web #

fn filter(s string) string

filter Do not delete.
It used by vlib/v/gen/c/str_intp.v:130 for string interpolation inside web templates TODO: move it to template render

fn route_matches(url_words []string, route_words []string) ?[]string

route_matches returns wether a route matches

fn parse_query_from_url(url urllib.URL) map[string]string

Extracts query parameters from a URL.

pub fn run[T](global_app &T, port int)

run runs the app

fn handle_conn[T](mut conn net.TcpConn, mut app T, routes map[string]Route)

handle_conn handles a connection

fn parse_attrs(name string, attrs []string) !([]http.Method, string)

Parsing function attributes for methods and path.

fn parse_form_from_request(request http.Request) !(map[string]string, map[string][]http.FileData)

Extract form data from an HTTP request.

interface DbInterface {
	db voidptr
}

struct FileData {
pub:
	filename     string
	content_type string
	data         string
}

pub struct Context {
pub:
// HTTP Request
	req http.Request
// API key used when authenticating requests
	api_key string
// TODO Response
pub mut:
// TCP connection to client.
// But beware, do not store it for further use, after request processing web will close connection.
	conn &net.TcpConn = unsafe { nil }
// Gives access to a shared logger object
	logger shared log.Log
// Used to collect metrics on the web server
	collector &metrics.MetricsCollector
// time.ticks() from start of web connection handle.
// You can use it to determine how much time is spent on your request.
	page_gen_start i64
// REQUEST
	static_files      map[string]string
	static_mime_types map[string]string
// Map containing query params for the route.
// Example: `http://localhost:3000/index?q=vpm&order_by=desc => { 'q': 'vpm', 'order_by': 'desc' }
	query map[string]string
// Multipart-form fields.
	form map[string]string
// Files from multipart-form.
	files map[string][]http.FileData
// Allows reading the request body
	reader &io.BufferedReader = unsafe { nil }
// RESPONSE
	status       http.Status = http.Status.ok
	content_type string      = 'text/plain'
// response headers
	header http.Header
}

The Context struct represents the Context which hold the HTTP request and response.
It has fields for the query, form, files.

pub fn (ctx Context) before_request()

Defining this method is optional.
before_request is called before every request (aka middleware).
Probably you can use it for check user session cookie or add header.

pub fn (mut ctx Context) body(status http.Status, content_type string, body string) Result

body sends the given body as an HTTP response.

pub fn (mut ctx Context) file(f_path string) Result

file Response HTTP_OK with file as payload This function manually implements responses because it needs to stream the file contents

pub fn (ctx &Context) is_authenticated() bool

is_authenticated checks whether the request passes a correct API key.

pub fn (mut ctx Context) json[T](status http.Status, j T) Result

json[T] HTTP_OK with json_s as payload with content-type application/json

pub fn (mut ctx Context) ldebug(msg string)

ldebug create a log message with the debug level

pub fn (mut ctx Context) lerror(msg string)

lerror create a log message with the error level

pub fn (mut ctx Context) lfatal(msg string)

lfatal create a log message with the fatal level

pub fn (mut ctx Context) linfo(msg string)

linfo create a log message with the info level

pub fn (mut ctx Context) lwarn(msg string)

lwarn create a log message with the warn level

pub fn (mut ctx Context) redirect(url string) Result

redirect Redirect to an url

pub fn (mut ctx Context) send() bool

send is a convenience function for sending the HTTP response with an empty body.

fn (mut ctx Context) send_custom_response(resp &http.Response) !

send_custom_response sends the given http.Response to the client. It can be used to overwrite the Context object & send a completely custom http.Response instead.

fn (mut ctx Context) send_reader(mut reader io.Reader, size u64) !

send_reader reads at most size bytes from the given reader & writes them to the TCP connection socket. Internally, a 10KB buffer is used, to avoid having to store all bytes in memory at once.

pub fn (mut ctx Context) send_reader_response(mut reader io.Reader, size u64) bool

send_reader_response constructs the resulting HTTP response with the given body & streams the reader's contents to the client.

pub fn (mut ctx Context) send_response(res string) bool

send_response constructs the resulting HTTP response with the given body string & sends it to the client.

pub fn (mut ctx Context) send_response_header() !

send_response_header constructs a valid HTTP response with an empty body & sends it to the client.

fn (mut ctx Context) send_string(s string) !

send_string writes the given string to the TCP connection socket.

pub fn (mut ctx Context) server_error(ecode int) Result

server_error Response a server error

pub fn (mut ctx Context) status(status http.Status) Result

status responds with an empty textual response, essentially only returning the given status code.

struct Route {
	methods []http.Method
	path    string
}

[noinit]
pub struct Result {}

A dummy structure that returns from routes to indicate that you actually sent something to a user