import * as mod from "https://dotland.deno.dev/x/oak@v14.1.0/mod.ts";
A middleware framework for handling HTTP with Deno.
oak works well on both Deno CLI and Deno deploy, and is inspired by koa. It works well with both the Deno CLI and Deno Deploy.
Example server
A minimal router server which responds with content on /
. With Deno CLI
this will listen on port 8080 and on Deploy, this will simply serve requests
received on the application.
import { Application, Router } from "https://deno.land/x/oak/mod.ts";
const router = new Router();
router.get("/", (ctx) => {
ctx.response.body = `<!DOCTYPE html>
<html>
<head><title>Hello oak!</title><head>
<body>
<h1>Hello oak!</h1>
</body>
</html>
`;
});
const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());
app.listen({ port: 8080 });
Namespaces
N etag | A collection of oak specific APIs for management of ETags. |
A collection of APIs to help assist in creating middleware. | |
A collection of utility APIs which can make testing of an oak application easier. |
Classes
A class which registers middleware (via | |
Provides context about the current request and response to middleware
functions, and the current instance being processed is the first argument
provided a {@link | |
Provides an way to manage cookies in a request and response on the server as a single iterable collection, as well as the ability to sign and verify cookies to prevent tampering. | |
The base class that all derivative HTTP extend, providing a | |
The oak abstraction of the Deno native HTTP server which is used internally for handling native HTTP requests. Generally users of oak do not need to worry about this class. | |
A class that takes a file (either a Deno.FsFile or Uint8Array) and bytes and streams the ranges as a multi-part encoded HTTP body. | |
An internal oak abstraction for handling a Deno native request. Most users of oak do not need to worry about this abstraction. | |
An interface which provides information about the current request. The
instance related to the current request is available on the
{@link | |
An interface to control what response will be sent when the middleware finishes processing the request. | |
The context associated with serve middleware requests on a router. | |
An interface for registering middleware that will run when certain HTTP methods and paths are requested, as well as provides a way to parameterize parts of the requested path. | |
The context associated when dealing with serve middleware requests on an application. | |
An event which contains information which will be sent to the remote
connection and be made available in an |
Variables
A namespace that contains each error constructor. Each error extends
| |
A symbol that indicates to | |
A record of all the status codes text. | |
Allows external parties to modify the context state. |
Functions
Compose multiple middleware functions into a single middleware function. | |
A factory function which provides a way to create errors. It takes up to 3
arguments, the error | |
Calculate an ETag for an entity. When the entity is a specific set of data it will be fingerprinted as a "strong" tag, otherwise if it is just file information, it will be calculated as a weak tag. | |
Create middleware that will attempt to decode the response.body into
something that can be used to generate an | |
For a given Context, try to determine the response body entity that an ETag can be calculated from. | |
A helper function that takes the value from the | |
A helper function that takes the value from the | |
Given a context, return the | |
Determine, by the value of an | |
A type guard that determines if the status code is an error. | |
A type guard that determines if the value is an HttpError or not. | |
A type guard that determines if the status code is a redirection. | |
Given a range header value and a current byte size of an asset, determine what ranges of bytes are being requested. | |
Middleware that provides a back-to-back proxy for requests. | |
f send | Asynchronously fulfill a response with a file from the local file system. |
Creates a mock of | |
Create a mock of | |
Creates a mock |
Interfaces
Available options that are used when creating a new instance of
{@link | |
A representation of range of bytes. | |
Options that can be supplied when using the | |
Options for {@link | |
Just the part of | |
Base interface for application listening options. | |
Interface options when listening on TLS. | |
Middleware are functions which are chained together to deal with requests. | |
Middleware objects allow encapsulation of middleware along with the ability to initialize the middleware upon listen. | |
Options which can be specified on the {@link | |
The internal abstraction of a route used by the oak {@link | |
Options which can be specified when calling the | |
The context passed router middleware. | |
The interface that {@link | |
Options which can be specified when creating a new instance of a
{@link | |
Middleware that will be called by the router when handling a specific parameter, which the middleware will be called when a request matches the route parameter. | |
Options which can be specified when using the {@link | |
The abstract constructor interface that custom servers need to adhere to
when using with an {@link | |
Options that can be set in a mock context. |
Type Aliases
An HTTP status that is an error (4XX and 5XX). | |
Options which can be specified when using {@link | |
A type representing string literals of each of the common HTTP method. | |
Options which can be specified when listening. | |
Type that represents {@link | |
T Next | A function for chaining middleware. |
An HTTP status that is a redirect (3XX). | |
A dynamic type which attempts to determine the route params based on matching the route string. | |
The base type of state which is associated with an application or context. |