http #

fn cleanup_multipart_form(form &MultipartForm)

cleanup_multipart_form removes all temporary files from a form

fn cleanup_uploaded_file(file &UploadedFile)

cleanup_uploaded_file removes the temporary file

fn cookie(name string, value string) Cookie

Cookie builder helpers

fn error_page(status_code int, message string) string

error_page generates a simple HTML error page

fn http_status_text(code int) string

http_status_text returns the standard HTTP status text for a code

fn new_context(raw &Request) Context

Create context from V request

fn new_context_with_db(raw &Request, renderer &templates.Renderer, db &vareldb.DB) Context

Create context with template renderer and database connection

fn new_context_with_renderer(raw &Request, renderer &templates.Renderer) Context

Create context with template renderer

fn new_multipart_form() MultipartForm

Create a new empty multipart form

fn new_request(raw &Request) Request

new_request creates Request from V's http.Request

fn new_response() Response

Constructors

fn ok(body string) Response

fn parse_cookies(header_value string) map[string]string

Parse cookies from request header Simple parser for Cookie header format: "name1=value1; name2=value2"

fn parse_multipart(req &Request, config UploadConfig) !MultipartForm

Parse multipart/form-data from request body

fn save_uploaded_file(file &UploadedFile, dest_path string) !

save_uploaded_file moves an uploaded file to a permanent location

fn status_from_int(code int) Status

fn status_text(status Status) string

Status helpers

type HandlerFunc = fn (mut ctx Context) Response

HandlerFunc is the function signature for route handlers Takes a mutable Context and returns a Response

type Status = vhttp.Status

Re-export V's Status enum for convenience

struct Context {
pub mut:
	req      Request
	resp     Response
	params   map[string]string // Route parameters from router
	values   map[string]string // Middleware data storage
	session  &session.Session    = unsafe { nil } // Session data (set by session middleware)
	renderer &templates.Renderer = unsafe { nil } // Template renderer (optional)
	db       &vareldb.DB         = unsafe { nil } // Database connection (worker-specific)
}

Context unifies Request and Response for handlers

fn (ctx &Context) asset_path(file_path string) string

asset_path generates a path to a static asset in the public directory

ctx.asset_path('css/main.css') -> '/public/css/main.css'

ctx.asset_path('images/logo.png') -> '/public/images/logo.png'

fn (mut ctx Context) bad_request(message string) Response

fn (ctx &Context) cookie(name string) string

fn (mut ctx Context) created[T](data T) Response

fn (ctx &Context) current_email() string

Get current authenticated user's email

fn (ctx &Context) current_user_id() ?int

Get current authenticated user's ID

fn (ctx &Context) current_username() string

Get current authenticated user's username

fn (mut ctx Context) file(field_name string) ?UploadedFile

file returns the first uploaded file for a field name

fn (mut ctx Context) files(field_name string) []UploadedFile

files returns all uploaded files for a field name

fn (mut ctx Context) forbidden(message string) Response

fn (mut ctx Context) form(key string) string

fn (mut ctx Context) form_all(key string) []string

fn (ctx &Context) full_url(path string) string

full_url generates a complete URL including scheme, host, and path

ctx.full_url('/users/123') -> 'http://localhost:8080/users/123'

fn (ctx &Context) get(key string) string

fn (ctx &Context) has(key string) bool

fn (ctx &Context) has_cookie(name string) bool

fn (ctx &Context) has_current_user() bool

Check if current user is authenticated (alternative to is_authenticated)

fn (ctx &Context) has_file(field_name string) bool

has_file checks if a file was uploaded for a field

fn (ctx &Context) has_param(key string) bool

fn (ctx &Context) has_query(key string) bool

fn (ctx &Context) has_session() bool

Session helper methods (require session middleware)

fn (ctx &Context) header(key string) string

fn (mut ctx Context) html(status_code int, body string) Response

fn (mut ctx Context) internal_error(message string) Response

fn (ctx &Context) is_authenticated() bool

fn (ctx &Context) is_delete() bool

fn (ctx &Context) is_get() bool

fn (ctx &Context) is_json() bool

fn (ctx &Context) is_post() bool

fn (ctx &Context) is_put() bool

fn (ctx &Context) json[T]() !T

fn (mut ctx Context) json_response[T](status_code int, data T) Response

fn (ctx &Context) method() string

fn (mut ctx Context) no_content() Response

fn (mut ctx Context) not_found(message string) Response

fn (mut ctx Context) ok(body string) Response

fn (ctx &Context) param(key string) string

fn (mut ctx Context) parse_multipart_form(config UploadConfig) !MultipartForm

parse_multipart_form parses multipart form data from request

fn (ctx &Context) path() string

fn (ctx &Context) query(key string) string

Request convenience methods

fn (ctx &Context) query_all(key string) []string

fn (mut ctx Context) redirect(url string, status_code int) Response

fn (mut ctx Context) redirect_permanent(url string) Response

fn (mut ctx Context) redirect_temporary(url string) Response

fn (mut ctx Context) regenerate_session() !

fn (mut ctx Context) render(template_path string, data map[string]string) Response

render renders a template file with layout and returns HTML response

fn (mut ctx Context) render_data(template_path string, data map[string]vm.Any) Response

render_data renders a template with structured data (arrays, objects, etc.) This method accepts map[string]vm.Any to support passing complex data to templates

fn (mut ctx Context) render_string(template string, data map[string]string) Response

render_string renders a template string and returns HTML response

fn (mut ctx Context) render_with_status(status_code int, template_path string, data map[string]string) Response

render_with_status renders a template with custom status code

fn (mut ctx Context) session_clear()

fn (mut ctx Context) session_delete(key string)

fn (ctx &Context) session_get(key string) ?string

fn (mut ctx Context) session_set(key string, value string)

fn (mut ctx Context) set(key string, value string)

Middleware data storage

fn (mut ctx Context) set_cookie(cookie Cookie)

Set response cookie

fn (mut ctx Context) set_user(user_id int)

fn (mut ctx Context) status(code int) Response

Response convenience methods

fn (mut ctx Context) text(status_code int, body string) Response

fn (mut ctx Context) unauthorized(message string) Response

fn (ctx &Context) url_for(path string, query_params ...map[string]string) string

url_for generates a URL for a given path with optional query parameters

ctx.url_for('/users/123') -> '/users/123'

ctx.url_for('/search', {'q': 'varel', 'page': '2'}) -> '/search?q=varel&page=2'

fn (ctx &Context) user_id() ?int

struct Cookie {
pub:
	name      string
	value     string
	path      string = '/'
	domain    string
	expires   string
	max_age   int
	secure    bool
	http_only bool
	same_site string
}

Cookie represents an HTTP cookie

fn (c Cookie) make_http_only() Cookie

fn (c Cookie) make_secure() Cookie

fn (c Cookie) with_domain(d string) Cookie

fn (c Cookie) with_expires(expires string) Cookie

fn (c Cookie) with_max_age(seconds int) Cookie

fn (c Cookie) with_path(p string) Cookie

fn (c Cookie) with_same_site(same_site string) Cookie

struct FileValidator {
pub:
	max_size      i64
	allowed_types []string
	allowed_exts  []string
}

Validate file upload

fn (v &FileValidator) validate(file &UploadedFile) !

validate checks if an uploaded file meets requirements

struct FormFile {
pub:
	name         string
	filename     string
	content_type string
	data         []u8
}

FormFile represents an uploaded file

struct MultipartForm {
pub mut:
	fields map[string][]string       // Regular form fields (name -> values)
	files  map[string][]UploadedFile // File uploads (field name -> files)
}

MultipartForm contains parsed multipart/form-data

struct Request {
pub mut:
	raw     &vhttp.Request // Access to underlying V request
	method  string
	path    string
	query   urllib.Values // Leverage V's Values type for query params
	headers vhttp.Header
	body    string
	cookies map[string]string
	// Lazy-loaded caches
	form_parsed      bool
	form_values      map[string][]string
	multipart_parsed bool
	multipart_files  map[string][]FormFile
}

Request wraps V's http.Request with server-focused API

fn (req &Request) query_param(key string) string

Query parameter access (leveraging urllib.Values)

fn (req &Request) query_params(key string) []string

fn (req &Request) has_query(key string) bool

fn (mut req Request) parse_form() !

Form parsing (urlencoded) with multi-value support

fn (mut req Request) form_value(key string) string

fn (mut req Request) form_values(key string) []string

fn (mut req Request) parse_multipart_form() !

Multipart form parsing (leverage V's parser)

fn (mut req Request) file(key string) ?FormFile

fn (req &Request) json[T]() !T

JSON parsing

fn (req &Request) is_json() bool

fn (req &Request) header(key string) string

Header helpers

fn (req &Request) content_type() string

fn (req &Request) user_agent() string

fn (req &Request) accept() string

fn (req &Request) cookie(name string) string

Cookie access

fn (req &Request) has_cookie(name string) bool

fn (req &Request) is_get() bool

Request type checks

fn (req &Request) is_post() bool

fn (req &Request) is_put() bool

fn (req &Request) is_delete() bool

fn (req &Request) is_patch() bool

struct Response {
pub mut:
	status_code int = 200
	headers     vhttp.Header
	body        string
	cookies     []Cookie
}

Response builder with chainable API

fn (mut resp Response) status(code int) Response

Status setters (chainable)

fn (mut resp Response) ok() Response

fn (mut resp Response) created() Response

fn (mut resp Response) accepted() Response

fn (mut resp Response) no_content() Response

fn (mut resp Response) moved_permanently() Response

fn (mut resp Response) found() Response

fn (mut resp Response) see_other() Response

fn (mut resp Response) temporary_redirect() Response

fn (mut resp Response) permanent_redirect() Response

fn (mut resp Response) bad_request() Response

fn (mut resp Response) unauthorized() Response

fn (mut resp Response) forbidden() Response

fn (mut resp Response) not_found() Response

fn (mut resp Response) method_not_allowed() Response

fn (mut resp Response) conflict() Response

fn (mut resp Response) unprocessable_entity() Response

fn (mut resp Response) internal_error() Response

fn (mut resp Response) not_implemented() Response

fn (mut resp Response) bad_gateway() Response

fn (mut resp Response) service_unavailable() Response

fn (mut resp Response) set_body(body string) Response

Body setters (chainable)

fn (mut resp Response) text(body string) Response

fn (mut resp Response) html(body string) Response

fn (mut resp Response) json[T](data T) Response

fn (mut resp Response) xml(body string) Response

fn (mut resp Response) header(key string, value string) Response

Header setters (chainable)

fn (mut resp Response) content_type(ct string) Response

fn (mut resp Response) location(url string) Response

fn (mut resp Response) cookie(cookie Cookie) Response

Cookie setter

fn (resp &Response) to_vhttp() Response

Convert to V's Response

struct UploadConfig {
pub:
	max_file_size   i64 = 10 * 1024 * 1024 // 10MB default
	max_memory      i64 = 5 * 1024 * 1024  // 5MB in memory, rest on disk
	allowed_types   []string // Empty = allow all
	temp_dir        string = '/tmp' // Temporary upload directory
	keep_extensions bool   = true   // Preserve original file extensions
}

UploadConfig configures file upload behavior

struct UploadedFile {
pub:
	field_name   string            // Form field name
	filename     string            // Original filename from client
	content_type string            // MIME type
	size         i64               // File size in bytes
	headers      map[string]string // Part headers
pub mut:
	temp_path string // Temporary file path on disk
}

UploadedFile represents a file uploaded via multipart/form-data