v/vlib/vweb/README.md

132 lines
3.4 KiB
Markdown
Raw Normal View History

2019-07-29 19:46:26 +02:00
This is pre-alpha software.
## Features
- Very fast: performance of C on the web.
- Small binary: hello world website is <100 KB.
- Easy to deploy: just one binary file that also includes all templates.
No need to install any dependencies.
- Templates are precompiled, all errors are visible at compilation time,
not at runtime.
2019-07-29 19:46:26 +02:00
Lots of things are broken and not implemented yet in V and vweb.
There's no documentation yet, have a look at a simple example:
2019-07-29 18:50:25 +02:00
https://github.com/vlang/v/tree/master/examples/vweb/vweb_example.v
2019-07-30 21:15:17 +02:00
There's also the V forum: https://github.com/vlang/vorum
2019-07-30 21:15:17 +02:00
`vorum.v` contains all GET and POST actions.
2019-07-29 18:50:25 +02:00
```v ignore
2019-07-29 18:50:25 +02:00
pub fn (app mut App) index() {
posts := app.find_all_posts()
$vweb.html()
}
// TODO ['/post/:id/:title']
// TODO `fn (app App) post(id int)`
2019-07-29 18:50:25 +02:00
pub fn (app App) post() {
id := app.get_post_id()
2019-07-29 18:50:25 +02:00
post := app.retrieve_post(id) or {
2020-12-31 17:47:20 +01:00
app.redirect('/')
return
2019-07-29 18:50:25 +02:00
}
comments := app.find_comments(id)
show_form := true
2019-07-29 18:50:25 +02:00
$vweb.html()
}
```
`index.html` is an example of the V template language:
2019-07-29 19:46:26 +02:00
```html
@for post in posts
2019-07-29 18:50:25 +02:00
<div class=post>
<a class=topic href="@post.url">@post.title</a>
<img class=comment-img>
<span class=nr-comments>@post.nr_comments</span>
2019-07-29 18:50:25 +02:00
<span class=time>@post.time</span>
</div>
@end
```
2020-12-31 17:47:20 +01:00
`$vweb.html()` compiles an HTML template into V during compilation,
and embeds the resulting code in current action.
2019-07-29 18:50:25 +02:00
2019-09-14 22:54:14 +02:00
That means that the template automatically has access to that action's entire environment.
2019-07-29 19:46:26 +02:00
### Deploying vweb apps
Everything, including HTML templates, is in one binary file. That's all you need to deploy.
## Getting Started
To start with vweb, you have to import the module `vweb`.
After the import, define a struct to hold vweb.Context
(and any other variables your program will need).
The web server can be started by calling `vweb.run<App>(port)`.
**Example:**
```v ignore
import vweb
struct App {
vweb.Context
}
fn main() {
vweb.run<App>(8080)
}
```
### Defining endpoints
To add endpoints to your web server, you have to extend the `App` struct.
For routing you can either use auto-mapping of function names or specify the path as an attribute.
The function expects a response of the type `vweb.Result`.
**Example:**
```v ignore
// This endpoint can be accessed via http://localhost:port/hello
fn (mut app App) hello() vweb.Result {
return app.text('Hello')
}
// This endpoint can be accessed via http://localhost:port/foo
["/foo"]
fn (mut app App) world() vweb.Result {
return app.text('World')
}
```
To create an HTTP POST endpoint, you simply add a `[post]` attribute before the function definition.
**Example:**
```v ignore
[post]
fn (mut app App) world() vweb.Result {
return app.text('World')
}
```
To pass a parameter to an endpoint, you simply define it inside
an attribute, e. g. `['/hello/:user]`.
After it is defined in the attribute, you have to add it as a function parameter.
**Example:**
```v ignore
['/hello/:user']
fn (mut app App) hello_user(user string) vweb.Result {
return app.text('Hello $user')
}
```
You have access to the raw request data such as headers
or the request body by accessing `app` (which is `vweb.Context`).
If you want to read the request body, you can do that by calling `app.req.data`.
To read the request headers, you just call `app.req.header` and access the header you want,
e.g. `app.req.header.get(.content_type)`. See `struct Header` for all
available methods (`v doc net.http Header`).