import { Oak } from "https://deno.land/x/p5_commander@v1.2.1/deps.ts";
A class which registers middleware (via .use()
) and then processes
inbound requests against that middleware (via .listen()
).
The context.state
can be typed via passing a generic argument when
constructing an instance of Application
.
Constructors
Properties
Handle an individual server request, returning the server response. This
is similar to .listen()
, but opening the connection and retrieving
requests are not the responsibility of the application. If the generated
context gets set to not to respond, then the method resolves with
undefined
, otherwise it resolves with a request that is compatible with
std/http/server
.
A set of keys, or an instance of KeyStack
which will be used to sign
cookies read and set by the application to avoid tampering with the
cookies.
If true
, proxy headers will be trusted when processing requests. This
defaults to false
.
Generic state of the application, which can be specified by passing the generic argument when constructing:
const app = new Application<{ foo: string }>();
Or can be contextually inferred based on setting an initial state object:
const app = new Application({ state: { foo: "bar" } });
Methods
Add an event listener for an "error"
event which occurs when an
un-caught error occurs when processing the middleware or during processing
of the response.
Add an event listener for a "listen"
event which occurs when the server
has successfully opened but before any requests start being processed.
Start listening for requests, processing registered middleware on each
request. If the options .secure
is undefined or false
, the listening
will be over HTTP. If the options .secure
property is true
, a
.certFile
and a .keyFile
property need to be supplied and requests
will be processed over HTTPS.
Start listening for requests, processing registered middleware on each
request. If the options .secure
is undefined or false
, the listening
will be over HTTP. If the options .secure
property is true
, a
.certFile
and a .keyFile
property need to be supplied and requests
will be processed over HTTPS.
Register middleware to be used with the application. Middleware will
be processed in the order it is added, but middleware can control the flow
of execution via the use of the next()
function that the middleware
function will be called with. The context
object provides information
about the current state of the application.
Basic usage:
const import { Application } from "https://deno.land/x/oak/mod.ts";
const app = new Application();
app.use((ctx, next) => {
ctx.request; // contains request information
ctx.response; // setups up information to use in the response;
await next(); // manages the flow control of the middleware execution
});
await app.listen({ port: 80 });