Api

serve(; middleware::Vector=[], handler=stream_handler, host="127.0.0.1", port=8080, async=false, parallel=false, serialize=true, catch_errors=true, docs=true, metrics=true, show_errors=true, show_banner=true, docs_path="/docs", schema_path="/schema", kwargs...)

Start the webserver with your own custom request handler

serveparallel(; middleware::Vector=[], handler=stream_handler, host="127.0.0.1", port=8080, serialize=true, async=false, catch_errors=true, docs=true, metrics=true, kwargs...)

@get(path::String, func::Function)

Used to register a function to a specific endpoint to handle GET requests

@post(path::String, func::Function)

Used to register a function to a specific endpoint to handle POST requests

@put(path::String, func::Function)

Used to register a function to a specific endpoint to handle PUT requests

@patch(path::String, func::Function)

Used to register a function to a specific endpoint to handle PATCH requests

@delete(path::String, func::Function)

Used to register a function to a specific endpoint to handle DELETE requests

@route(methods::Array{String}, path::String, func::Function)

Used to register a function to a specific endpoint to handle mulitiple request types

@staticfiles(folder::String, mountdir::String, headers::Vector{Pair{String,String}}=[])

Mount all files inside the /static folder (or user defined mount point)

@dynamicfiles(folder::String, mountdir::String, headers::Vector{Pair{String,String}}=[])

Mount all files inside the /static folder (or user defined mount point), but files are re-read on each request

staticfiles(folder::String, mountdir::String; headers::Vector{Pair{String,String}}=[], loadfile::Union{Function,Nothing}=nothing)

Mount all files inside the /static folder (or user defined mount point). The headers array will get applied to all mounted files

dynamicfiles(folder::String, mountdir::String; headers::Vector{Pair{String,String}}=[], loadfile::Union{Function,Nothing}=nothing)

Mount all files inside the /static folder (or user defined mount point), but files are re-read on each request. The headers array will get applied to all mounted files

configdocs(docspath::String = "/docs", schemapath::String = "/schema")

Configure the default docs and schema endpoints

mergeschema(route::String, customschema::Dict)

Merge the schema of a specific route

setschema(customschema::Dict)

Overwrites the entire internal schema

getschema()

Return the current internal schema for this app

queryparams(request::HTTP.Request)

Parse's the query parameters from the Requests URL and return them as a Dict

formdata(request::HTTP.Request)

Read the html form data from the body of a HTTP.Request

formdata(request::HTTP.Response)

Read the html form data from the body of a HTTP.Response

html(content::String; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a String that should be interpreted as HTML

text(request::HTTP.Request)

Read the body of a HTTP.Request as a String

text(response::HTTP.Response)

Read the body of a HTTP.Response as a String

text(content::String; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a String that should be interpreted as plain text

file(filepath::String; loadfile=nothing, status = 200, headers = []) :: HTTP.Response

Reads a file and returns a HTTP.Response. The file is read as binary. If the file does not exist, an ArgumentError is thrown. The MIME type and the size of the file are added to the headers.

Arguments

• filepath: The path to the file to be read.
• loadfile: An optional function to load the file. If not provided, the file is read using the open function.
• status: The HTTP status code to be used in the response. Defaults to 200.
• headers: Any additional headers to be included in the response. Defaults to an empty array.

Returns

• A HTTP response.

xml(content::String; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a String that should be interpreted as XML

js(content::String; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a String that should be interpreted as JavaScript

json(request::HTTP.Request; keyword_arguments...)

Read the body of a HTTP.Request as JSON with additional arguments for the read/serializer.

json(request::HTTP.Request, classtype; keyword_arguments...)

Read the body of a HTTP.Request as JSON with additional arguments for the read/serializer into a custom struct.

json(response::HTTP.Response; keyword_arguments)

Read the body of a HTTP.Response as JSON with additional keyword arguments

json(response::HTTP.Response, classtype; keyword_arguments)

Read the body of a HTTP.Response as JSON with additional keyword arguments and serialize it into a custom struct

json(content::Any; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a String that should be interpreted as JSON

json(content::Vector{UInt8}; status::Int, headers::Vector{Pair}) :: HTTP.Response

A helper function that can be passed binary data that should be interpreted as JSON. No conversion is done on the content since it's already in binary format.

css(content::String; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a String that should be interpreted as CSS

binary(request::HTTP.Request)

Read the body of a HTTP.Request as a Vector{UInt8}

binary(content::Vector{UInt8}; status::Int, headers::Vector{Pair}) :: HTTP.Response

A convenience function to return a Vector of UInt8 that should be interpreted as binary data

@cron(expression::String, func::Function)

Registers a function with a cron expression. This will extract either the function name or the random Id julia assigns to each lambda function.

@cron(expression::String, name::String, func::Function)

This variation provides way manually "name" a registered function. This information is used by the server on startup to log out all cron jobs.

starttasks()

Start all background repeat tasks

stoptasks()

Stop all background repeat tasks

cleartasks(ct::Context)

Clear any stored repeat task definitions

startcronjobs()

Start all the cron cronjobs within their own async task. Each individual task will loop conintually and sleep untill the next time it's suppost to

stopcronjobs()

Stop each background task by toggling a global reference that all cron jobs reference

Clears all cron job defintions

internalrequest(req::HTTP.Request; middleware::Vector=[], serialize::Bool=true, catch_errors::Bool=true)

Directly call one of our other endpoints registered with the router, using your own middleware and bypassing any globally defined middleware

redirect(path::String; code = 308)

return a redirect response

terminate(ctx)

stops the webserver immediately

resetstate()

Reset all the internal state variables