http

Grammar to parse a cookie header to a series of keys and values.

(cookies nextmw)

Parses cookies into the table under :cookies key

(download url dest &keys opts)

Download an HTTP resource to a destination path, file, buffer, or sink.
Supports automatic redirect following, chunked transfer encoding,
and incremental chunk streaming without buffering entire responses.

Arguments:
* `url` - The URL to download
* `dest` - Target file path (string), buffer, core/file or stream, or sink function (fn [chunk])

Options:
* `:headers` - Table of HTTP headers
* `:max-redirects` - Maximum redirects to follow (default 10)
* `:stream-factory` - Custom stream factory function
* `:stream-opts` - Options passed to stream-factory

(logger nextmw)

Creates a logging middleware. The logger middleware prints URL route, return status, and elapsed request time.

(make-response-stream conn head &opt url method)

Create a streaming HTTP response object from a connection and parsed header.

(middleware x)

Coerce any type to http middleware

(open-stream url &keys {:headers headers :stream-opts stream-opts :max-redirects max-redirects :body body :method method :stream-factory stream-factory})

Open an HTTP request and return an open response stream.
The stream implements :status, :message, :headers, :url, :head-size,
:read, :blocks, :lines, and :close.
Automatically follows HTTP 3xx redirects up to :max-redirects (default 10).

Options:
* `:method` - HTTP method string (default "GET")
* `:body` - Request body content
* `:headers` - Request headers table
* `:stream-factory` - Function to create connection stream. Defaults to net/connect.
* `:stream-opts` - Options table passed to stream-factory
* `:max-redirects` - Maximum number of 3xx redirects to follow (default 10)

Grammar that parses a query string (sans url path and ? character) and returns a table.

(read-body req &opt sink)

Given a request/response table, read the HTTP body from the connection.
If sink is provided (or (in req :sink)), streams chunks to sink (function,
file, buffer, or stream). Otherwise returns the body as a buffer. If the request
has no body, returns nil.

(read-request conn buf &opt no-query)

Read an HTTP request header from a connection. Returns a table with the following keys:
* `:headers` - table mapping header names to header values. Header names are lowercase.
* `:connection` - the connection stream for the header.
* `:buffer` - the buffer instance that may contain extra bytes.
* `:head-size` - the number of bytes used by the header.
* `:method` - the HTTP method used.
* `:path` - the path of the resource requested.

The following keys are also present, but omitted if the user passes a truthy parameter to `no-query`.
* `:route` - path of the resource requested without query string.
* `:query-string` - segment of HTTP path after first ? character.
* `:query` - the query string parsed into a table. Supports a single string value
 for every string key, and any query parameters that aren't given a value are mapped to true.

Note that data is read in chunks and any data after the header terminator is
stored in `:buffer`.

(read-response conn buf)

Read an HTTP response header from a connection. Returns a table with the following keys:
* `:headers` - table mapping header names to header values. Header names are lowercase.
* `:connection` - the connection stream for the header.
* `:buffer` - the buffer instance that may contain extra bytes.
* `:head-size` - the number of bytes used by the header.
* `:status` - the HTTP status code.
* `:message` - the HTTP status message.

Note that data is read in chunks and any data after the header terminator is
stored in `:buffer`.

(request method url &keys opts)

Make an HTTP request to a server.
Returns a table containing response information:
* `:head-size` - number of bytes in the http header
* `:headers` - table mapping header names to header values. Header names are lowercase.
* `:connection` - the connection stream for the header.
* `:buffer` - the buffer instance that may contain extra bytes.
* `:status` - HTTP status code as an integer.
* `:message` - HTTP status message.
* `:url` - final resolved URL.
* `:body` - Bytes of the response body (nil if streaming to custom sink or method is HEAD).

Options:
* `:body` - Request body content
* `:headers` - Request headers table
* `:stream-factory` - Function to create connection stream. Defaults to net/connect.
 Signature: (stream-factory host port stream-opts)
* `:stream-opts` - Options table passed to stream-factory
* `:sink` - Target to stream response body into (function, file, or buffer)
* `:stream` - If true, returns the open response stream directly without consuming body
* `:max-redirects` - Maximum number of 3xx redirects to follow (default 0)

PEG for parsing HTTP requests

(resolve-url base-url location)

Resolve a redirect location against a base URL per RFC 9110.

PEG for parsing HTTP responses

(router routes)

Creates a router middleware. A router will dispatch to different routes based on the URL path.

(send-response conn response &opt buf)

Send an HTTP response over a connection. Will automatically use chunked
encoding if body is not a byte sequence. `response` should be a table
with the following keys:

* `:headers` - optional headers to write
* `:status` - integer status code to write
* `:body` - optional byte sequence or iterable (for chunked body)
 for returning contents. The iterable can be lazy, i.e. for streaming
 data.

(server handler &opt host port)

Makes a simple http server. By default it binds to 0.0.0.0:8000, returns a new server stream. Simply wraps http/server-handler with a net/server.

(server-handler conn handler)

A simple connection handler for an HTTP server.
When a connection is accepted. Call this with a handler
function to handle the connect. The handler will be called
with one argument, the request table, which will contain the
following keys:
* `:head-size` - number of bytes in the http header.
* `:headers` - table mapping header names to header values.
* `:connection` - the connection stream for the header.
* `:buffer` - the buffer instance that may contain extra bytes.
* `:path` - HTTP path.
* `:method` - HTTP method, as a string.

Mapping of HTTP status codes to their status message.

Grammar to parse a URL into scheme, domain, port, and path. Supports both http:// and https:// protocols. Returns [scheme host port path].