Oak Oak

https://jsr.io/@oak/oak/doc
Admin
Oak is a middleware framework for handling HTTP requests across various JavaScript runtimes...
Tokens:179,943
Snippets:1,276
Trust Score:9.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Basic Oak Application Setup

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/Application

Demonstrates the fundamental setup of an Oak Application, including middleware registration and starting the server. This example is suitable for environments like Deno.

```typescript
import { Application } from "jsr:@oak/oak/application";

const app = new Application();

app.use((ctx, next) => {
  // called on each request with the context (`ctx`) of the request,
  // response, and other data.
  // `next()` is use to modify the flow control of the middleware stack.
});

app.listen({ port: 8080 });


```

--------------------------------

### Basic Oak Application Setup

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/Application

Demonstrates the fundamental setup of an Oak application. It initializes the application, registers a basic middleware function, and starts the server on a specified port. This is suitable for Deno environments.

```typescript
import { Application } from "jsr:@oak/oak/application";

const app = new Application();

app.use((ctx, next) => {
  // called on each request with the context (`ctx`) of the request,
  // response, and other data.
  // `next()` is use to modify the flow control of the middleware stack.
});

app.listen({ port: 8080 });




```

--------------------------------

### Basic Oak HTTP Server Setup

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router

Demonstrates the fundamental setup of an Oak application. It initializes an Application and a Router, defines a simple GET route for the root path, registers the router's middleware, and starts the server to listen for incoming requests. Dependencies include Application and Router from '@oak/oak'.

```typescript
import { Application } from "jsr:@oak/oak/application";
import { Router } from "jsr:@oak/oak/router";

const app = new Application();
const router = new Router();
router.get("/", (ctx) => {
  ctx.response.body = "hello world!";
});
app.use(router.routes());
app.use(router.allowedMethods());

app.listen();

```

--------------------------------

### Oak Application Setup and Middleware Registration

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve/~/ServeContext.prototype.%5BSymbol.for%28%22nodejs.util

Demonstrates the typical usage of creating an Oak application instance, registering middleware using the `.use()` method, and starting the server to listen for requests.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Register middleware
app.use(async (context) => {
  context.response.body = "Hello, Oak!";
});

// Start listening for requests
await app.listen({ port: 8000 });
console.log("Server listening on port 8000");
```

--------------------------------

### Oak Application: Basic Middleware Setup (Deno, Node.js, Bun)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/context/~/Context.prototype.%5BSymbol.for%28%22nodejs.util

Demonstrates the basic setup of an Oak application, including creating an instance, registering middleware using `.use()`, and starting to listen for requests using `.listen()`. This pattern is common across Deno, Node.js, and Bun runtimes.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Logger middleware
app.use(async (ctx, next) => {
  await next();
  const rt = ctx.response.headers.get("x-response-time");
  console.log(`${ctx.request.method} ${ctx.request.url.pathname} - ${rt}`);
});

// Response middleware
app.use(async (ctx) => {
  ctx.response.body = "Hello World!";
});

await app.listen({
  port: 8000,
});
```

--------------------------------

### Oak Application Setup and Middleware Registration (Deno, Node.js, Bun)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router/~/Router.prototype.%5BSymbol.for%28%22nodejs.util

Demonstrates how to create an Oak application instance, register middleware using the .use() method, and start listening for incoming requests. This is a fundamental pattern for building web applications with Oak.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Middleware to log requests
app.use(async (ctx, next) => {
  console.log(`Request: ${ctx.request.method} ${ctx.request.url}`);
  await next();
});

// Middleware to handle responses
app.use(async (ctx) => {
  ctx.response.body = "Hello, Oak!";
});

// Start the server
await app.listen({
  port: 8000,
});
console.log("Server running on http://localhost:8000");
```

--------------------------------

### Oak Application Class Example

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/isMiddlewareObject

Demonstrates the instantiation and basic usage of the Oak Application class, which is central to setting up middleware and handling incoming HTTP requests. It shows how to register middleware using `.use()` and start the server with `.listen()`.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Register middleware
app.use(async (ctx, next) => {
  console.log(`Received request: ${ctx.request.method} ${ctx.request.url}`);
  await next();
});

// Start listening for requests
const port = 8000;
console.log(`Server listening on port ${port}`);
await app.listen({ port });
```

--------------------------------

### Install Oak using npm/yarn/pnpm/bun

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/testing/~/createMockApp

Instructions for adding the Oak framework to your project using various package managers. This includes commands for npm, yarn, pnpm, and bun, demonstrating how to install from a JSR registry.

```bash
# Using npm
npm install jsr:@oak/oak

# Using yarn
yarn add jsr:@oak/oak

# Using pnpm
pnpm install jsr:@oak/oak

# Using bun
bun install jsr:@oak/oak
```

--------------------------------

### Create and Listen with Oak Application

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application

Demonstrates the typical usage of the Oak application. It involves creating an application instance, registering middleware to handle requests, and starting the server to listen for incoming HTTP requests on a specified port. This example uses the Application class from the '@oak/oak/application' module.

```typescript
import { Application } from "jsr:@oak/oak/application";

const app = new Application();
app.use((ctx) => {
  ctx.response.body = "hello world!";
});

app.listen({ port: 8080 });



```

--------------------------------

### Server.prototype.listen

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/http_server_node/~/Server

Starts the server and begins listening for incoming HTTP requests. This method returns a Promise that resolves with a Listener object.

```APIDOC
## Server.prototype.listen

### Description
Starts the server and begins listening for incoming HTTP requests. This method returns a Promise that resolves with a Listener object.

### Method
`Server.prototype.listen(): Promise<Listener>`

### Return Type
`Promise<Listener>`
```

--------------------------------

### Application Listening

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/Application

Start the Oak application server to listen for incoming HTTP/HTTPS requests.

```APIDOC
## Application Listening

### Description
Starts the Oak application server, enabling it to process incoming requests.

### Methods

#### `listen(addr: string): Promise<void>`
**Description**: 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.

#### `listen(options?: ListenOptions): Promise<void>`
**Description**: 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. Omitting options will default to `{ port: 0 }` which allows the operating system to select the port.

### Parameters

#### Query Parameters for `listen(options?: ListenOptions)`
- **options** (ListenOptions) - Optional - Options which can be specified when listening. Defaults to `{ port: 0 }`.
```

--------------------------------

### Create and Configure Oak Application

Source: https://context7.com/context7/jsr_io_oak_oak_doc/llms.txt

Demonstrates how to create a basic Oak application instance, add middleware for logging and simple responses, and start the HTTP server. It utilizes the `Application` class and its `use` and `listen` methods.

```typescript
import { Application } from "jsr:@oak/oak/application";

const app = new Application();

// Add middleware
app.use(async (ctx, next) => {
  console.log(`${ctx.request.method} ${ctx.request.url}`);
  await next();
});

// Basic response
app.use((ctx) => {
  ctx.response.body = "Hello World!";
});

// Listen with options
app.listen({ port: 8000, hostname: "0.0.0.0" });
```

--------------------------------

### Add Oak Package using pnpm

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/MiddlewareObject

Installs the Oak package using the 'pnpm install' command. Supports installation via JSR specifiers.

```bash
pnpm i jsr:@oak/oak

```

--------------------------------

### Start Listening for Requests - Oak Application

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/Application

The `listen` method starts the Oak application server. It can accept a port string or a `ListenOptions` object. If `secure` is true, TLS certificates must be provided. Omitting options defaults to `{ port: 0 }`.

```typescript
app.listen(80);
app.listen({
  port: 80,
  secure: true,
  certFile: "./cert.pem",
  keyFile: "./key.pem",
});

```

--------------------------------

### Create Oak Application Instance and Register Middleware

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/NativeRequest

Demonstrates the typical usage of creating an Oak application instance, registering middleware functions using `.use()`, and starting the server to listen for incoming requests.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Register middleware
app.use(async (ctx, next) => {
  console.log(`Request received: ${ctx.request.method} ${ctx.request.url}`);
  await next(); // Proceed to the next middleware
});

// Start listening for requests
const port = 8000;
console.log(`Server listening on http://localhost:${port}`);
await app.listen({ port });
```

--------------------------------

### Oak Application Creation and Usage

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve/~/route

Demonstrates the typical usage of an Oak application: creating an instance, registering middleware using `.use()`, and starting to listen for requests using `.listen()`.

```typescript
const app = new Application();

// Register middleware
app.use(async (ctx, next) => {
  console.log(`METHOD: ${ctx.request.method} URL: ${ctx.request.url}`);
  await next();
});

// Start listening for requests
await app.listen({ port: 8000 });
```

--------------------------------

### Application Class

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/http_server_bun/~/Server

The core class for managing middleware and handling incoming HTTP requests. Use `.use()` to register middleware and `.listen()` to start the server.

```APIDOC
## GET /api/users/{id}

### Description
Retrieves the details of a specific user identified by their unique ID. This endpoint is used to fetch user information.

### Method
GET

### Endpoint
/api/users/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the user to retrieve.

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the user.
- **username** (string) - The username of the user.
- **email** (string) - The email address of the user.

#### Response Example
```json
{
  "id": "user-12345",
  "username": "john_doe",
  "email": "john.doe@example.com"
}
```
```

--------------------------------

### Application API

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/context/~/ContextSendOptions

The core concept of Oak, the middleware application. This includes creating an application instance, registering middleware, and starting to listen for requests.

```APIDOC
## Application

Contains the core concept of oak, the middleware application. Typical usage is the creation of an application instance, registration of middleware, and then starting to listen for requests.

### Class: Application

A class which registers middleware (via `.use()`) and then processes inbound requests against that middleware (via `.listen()`).

#### Methods
- `addApplicationListener` (event: string, listener: Function): void
- `fetch` (request: Request, programId?: string): Promise<Response>
- `handle` (request: Request, programId?: string): Promise<Response>
- `listen` (options: ListenOptions | ListenOptionsBase | ListenOptionsTls): Promise<void>
- `proxy` (options: ListenOptions | ListenOptionsBase | ListenOptionsTls): Promise<void>
- `state` (state: State): State
- `use` (middleware: Middleware | Middleware[]): this

### Interface: ApplicationOptions

Available options that are used when creating a new instance of `Application`.

#### Properties
- `contextState` (object) - Optional - The initial state that will be associated with every context.
- `jsonBodyReplacer` (Function) - Optional - A function that transforms results, defaults to undefined.
- `jsonBodyReviver` (Function) - Optional - A function that transforms results, defaults to undefined.
- `keys` (string[]) - Optional - An array of strings used for signing and verifying cookie values.
- `logErrors` (boolean) - Optional - When true, errors will be logged to stderr.
- `proxy` (boolean) - Optional - If true, the `X-Forwarded-Proto` and `X-Forwarded-Host` headers will be trusted.
- `serverConstructor` (ServerConstructor) - Optional - The constructor for the server implementation to use.
- `state` (State) - Optional - The initial state that will be associated with every context.
```

--------------------------------

### Application Listen Methods

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/Application

Methods for starting the Oak application server to listen for incoming requests over HTTP or HTTPS.

```APIDOC
## POST /api/users

### Description
Starts 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.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Query Parameters
- **userId** (string) - Required - The ID of the user to retrieve.

### Request Example
```json
{
  "username": "john_doe",
  "email": "john.doe@example.com"
}
```

### Response
#### Success Response (200)
- **user_id** (string) - The unique identifier for the user.
- **status** (string) - The current status of the user.

#### Response Example
```json
{
  "user_id": "123e4567-e89b-12d3-a456-426614174000",
  "status": "active"
}
```
## POST /api/users

### Description
Starts 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. Omitting options will default to `{ port: 0 }` which allows the operating system to select the port.

### Method
POST

### Endpoint
/api/users

### Parameters
#### Query Parameters
- **userId** (string) - Required - The ID of the user to retrieve.

### Request Example
```json
{
  "username": "john_doe",
  "email": "john.doe@example.com"
}
```

### Response
#### Success Response (200)
- **user_id** (string) - The unique identifier for the user.
- **status** (string) - The current status of the user.

#### Response Example
```json
{
  "user_id": "123e4567-e89b-12d3-a456-426614174000",
  "status": "active"
}
```
```

--------------------------------

### Add Oak Package with bunx

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/body/~/Body.prototype.%5BSymbol

Installs the Oak package using bunx.

```shell
bunx jsr add @oak/oak
```

--------------------------------

### Add Oak Package using Yarn

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/MiddlewareObject

Installs the Oak package using the 'yarn add' command. Supports installation via JSR specifiers.

```bash
yarn add jsr:@oak/oak

```

--------------------------------

### Install Oak using Yarn

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve/~/serve

Installs the Oak package using the Yarn package manager. Supports both newer and older versions of Yarn.

```shell
yarn add jsr:@oak/oak
# or (using Yarn 4.8 or older)
yarn dlx jsr add @oak/oak
```

--------------------------------

### Oak Application Creation and Middleware Usage

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve/~/serve

Demonstrates how to create an Oak application instance, register middleware using `.use()`, and start listening for incoming requests using `.listen()`. This is the core pattern for building an Oak server.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Use middleware
app.use(async (context, next) => {
  context.response.body = "Hello, World!";
  await next();
});

// Start listening
await app.listen({ port: 8000 });
console.log("Server listening on port 8000");
```

--------------------------------

### Add Oak Package with Deno

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/body/~/Body.prototype.%5BSymbol

Installs the Oak package using the Deno package manager.

```shell
deno add jsr:@oak/oak
```

--------------------------------

### Install Oak using pnpm

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve/~/serve

Installs the Oak package using the pnpm package manager. Supports both newer and older versions of pnpm.

```shell
pnpm i jsr:@oak/oak
# or (using pnpm 10.8 or older)
pnpm dlx jsr add @oak/oak
```

--------------------------------

### Oak Application Creation and Listening (TypeScript)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/send

Demonstrates creating an Oak application instance, registering middleware using `.use()`, and starting to listen for requests using `.listen()`. This is the typical usage pattern for Oak applications. Configuration options are provided via `ApplicationOptions` and `ListenOptions`.

```typescript
import {
 	Application,
 	ApplicationOptions,
 	ListenOptions,
} from "@oak/oak";

// Example middleware
const logger = async (ctx: any, next: () => Promise<void>) => {
 	console.log(`${ctx.request.method} ${ctx.request.url}`);
 	await next();
};

// Application options
const appOptions: ApplicationOptions = {
 	state: {},
};

// Create application instance
const app = new Application(appOptions);

// Register middleware
app.use(logger);

// Listening options
const listenOptions: ListenOptions = {
 	port: 8000,
};

// Start listening for requests
app.listen(listenOptions);
console.log(`Server listening on http://localhost:${listenOptions.port}`);
```

--------------------------------

### Oak Application Middleware Handling

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/MiddlewareObject

Demonstrates the core functionality of an Oak application for registering and handling middleware. It shows how to create an application instance, use middleware, and start listening for requests. This is fundamental for building web servers with Oak.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Register middleware
app.use(async (context, next) => {
  console.log("Request received");
  await next(); // Process next middleware
  console.log("Response sent");
});

// Start listening for requests
await app.listen({ port: 8000 });
console.log("Server listening on http://localhost:8000");
```

--------------------------------

### Add Oak Package with vlt

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/ApplicationOptions

Instructions for installing the Oak package using the `vlt` package manager.

```bash
vlt install jsr:@oak/oak
```

```typescript
import { type ApplicationOptions } from "@oak/oak/application";
```

--------------------------------

### Application Core

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve/~/ServeContext

The core concept of Oak, the middleware application. This section covers the creation of application instances, registration of middleware, and starting to listen for requests.

```APIDOC
## Application

A class which registers middleware (via `.use()`) and then processes inbound requests against that middleware (via `.listen()`)

### Methods
- `addEventListener`
- `fetch`
- `handle`
- `keys`
- `listen`
- `proxy`
- `state`
- `use`

## ApplicationCloseEvent

An event that occurs when the application closes.

## ApplicationErrorEvent

An event that occurs when an application error occurs.
  * `context`

## ApplicationListenEvent

An event that occurs when the application starts listening for requests.
  * `hostname`
  * `listener`
  * `port`
  * `secure`
  * `serverType`

## ApplicationOptions

Available options that are used when creating a new instance of `Application`.
  * `contextState`
  * `jsonBodyReplacer`
  * `jsonBodyReviver`
  * `keys`
  * `logErrors`
  * `proxy`
  * `serverConstructor`
  * `state`

## ListenOptions

Options which can be specified when listening.

## ListenOptionsBase

Base interface for application listening options.
  * `hostname`
  * `port`
  * `secure`
  * `signal`

## ListenOptionsTls

Interface options when listening on TLS.

## State

The base type of state which is associated with an application or context.
```

--------------------------------

### Add Oak Package to Project

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/testing/~/createMockNext

Instructions for adding the Oak package to your project using different package managers like deno, pnpm, yarn, vlt, npx, and bunx. This allows you to start using Oak.js in your applications.

```bash
deno add jsr:@oak/oak
```

```bash
pnpm i jsr:@oak/oak
```

```bash
pnpm dlx jsr add @oak/oak
```

```bash
yarn add jsr:@oak/oak
```

```bash
yarn dlx jsr add @oak/oak
```

```bash
vlt install jsr:@oak/oak
```

```bash
npx jsr add @oak/oak
```

```bash
bunx jsr add @oak/oak
```

--------------------------------

### Import ListenOptions from Oak (npm/pnpm/yarn/vlt)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/ListenOptions

Example of importing the 'ListenOptions' type from the Oak package after it has been installed using package managers like npm, pnpm, yarn, or vlt. This demonstrates how to use installed types within your TypeScript code.

```typescript
import { type ListenOptions } from "@oak/oak";
```

--------------------------------

### Application API

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/Next

The core concept of Oak, the middleware application. This includes creating an application instance, registering middleware, and starting to listen for requests.

```APIDOC
## Application Class

### Description
A class which registers middleware (via `.use()`) and then processes inbound requests against that middleware (via `.listen()`)

### Methods
- **addEventListener**(type, listener) 
- **fetch**(request, options)
- **handle**(request, options)
- **keys**
- **listen**(options)
- **proxy**(options)
- **state**
- **use**(middleware)

### Request Body
(Not applicable for Application methods directly, but middleware can have request bodies)

### Response
(Not directly applicable, but responses are handled by middleware)

### Error Handling
- **ApplicationErrorEvent**: An event that occurs when an application error occurs.

### Event Types
- **ApplicationCloseEvent**: An event that occurs when the application closes.
- **ApplicationListenEvent**: An event that occurs when the application starts listening for requests.

### Options
- **ApplicationOptions**: Available options that are used when creating a new instance of `Application`.
  - **contextState** (any) - Optional - The initial state for the context.
  - **jsonBodyReplacer** (function) - Optional - A replacer function for JSON stringification.
  - **jsonBodyReviver** (function) - Optional - A reviver function for JSON parsing.
  - **keys** (Array<string>) - Optional - Secret keys for signed cookies.
  - **logErrors** (boolean) - Optional - Whether to log errors.
  - **proxy** (boolean) - Optional - Whether to trust proxy headers.
  - **serverConstructor** (ServerConstructor) - Optional - A custom server constructor.
  - **state** (any) - Optional - The initial state for the application.
```

--------------------------------

### Oak Middleware Example with Context

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/Context

Demonstrates how to use the Application and Context from the @oak/oak package within middleware functions. It shows how to access request, response, and cookie information. This example requires the @oak/oak package to be installed.

```typescript
import { Application, Context } from "jsr:@oak/oak/";

const app = new Application();

app.use((ctx) => {
  // information about the request is here:
  ctx.request;
  // information about the response is here:
  ctx.response;
  // the cookie store is here:
  ctx.cookies;
});

// Needs a type annotation because it cannot be inferred.
function mw(ctx: Context) {
  // process here...
}

app.use(mw);




```

--------------------------------

### Application API

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/testing

The `Application` class is the core of Oak. It registers middleware and processes incoming requests. Key methods include `use()` for registering middleware and `listen()` for starting the server.

```APIDOC
## Application Class

### Description
A class which registers middleware (via `.use()`) and then processes inbound requests against that middleware (via `.listen()`).

### Methods
- **`use(middleware: Middleware)`**: Registers a middleware function.
- **`listen()`**: Starts the server to listen for requests.
- **`handle(request: Request)`**: Handles a single incoming request.
- **`fetch(input: RequestInfo | URL, init?: RequestInit)`**: Similar to the Fetch API, but for the application.

### Properties
- **`keys: Key[]`**: For use with signed cookies.
- **`state: State`**: A mutable state object associated with the application.

### Events
- **`ApplicationCloseEvent`**: Fired when the application closes.
- **`ApplicationErrorEvent`**: Fired when an application error occurs.
- **`ApplicationListenEvent`**: Fired when the application starts listening.

### Example Usage
```typescript
import { Application } from "@oak/oak";

const app = new Application();

app.use(async (ctx, next) => {
  console.log(`Request: ${ctx.request.method} ${ctx.request.url}`);
  await next();
});

await app.listen({ port: 8000 });
```
```

--------------------------------

### Import from @oak/oak Package (pnpm)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/response

Example of importing a symbol from the @oak/oak package. This import statement is common across different installation methods.

```typescript
import * as mod from "@oak/oak/response";
```

--------------------------------

### Oak Body Class Example

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/isMiddlewareObject

Shows how to interact with the Oak Body class to access and process the request body in various formats. Examples include parsing JSON, getting text, or streaming the body content. The `.has()` method checks for the presence of a body.

```typescript
import { Context } from "@oak/oak";

// Example within middleware
app.use(async (ctx: Context, next) => {
  if (ctx.request.body.has('json')) {
    const jsonBody = await ctx.request.body.json();
    console.log('JSON Body:', jsonBody);
  } else if (ctx.request.body.has('text')) {
    const textBody = await ctx.request.body.text();
    console.log('Text Body:', textBody);
  }
  await next();
});

```

--------------------------------

### Import Symbols from @oak/oak with pnpm

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware

Example of importing symbols from the @oak/oak package after installation with pnpm. This demonstrates how to access the package's modules in your project.

```typescript
import * as mod from "@oak/oak/middleware";
```

--------------------------------

### Import Request Symbol with Deno

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/Request

Example of importing the 'Request' symbol from the Oak package in Deno. This demonstrates how to use the package after installation.

```typescript
import { Request } from "@oak/oak";
```

--------------------------------

### Server Implementations

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/ListenOptionsBase

Abstractions for handling requests and responses within different runtimes like Bun and Deno.

```APIDOC
## Server Implementations

### Bun Server

- **type**: "bun" - The server type identifier.
- **close**(): void - Closes the server.
- **listen**(): Promise<void> - Starts the server.

### Deno Native Server

- **type**: "native" - The server type identifier.
- **app**: Application - The associated application instance.
- **close**(): void - Closes the server.
- **closed**: boolean - Indicates if the server is closed.
- **listen**(): Promise<void> - Starts the server.
```

--------------------------------

### Server Abstractions (Bun and Native)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/ServerConstructor

Details on the server abstractions used by Oak for Bun and Deno runtimes.

```APIDOC
## HTTP Server Abstractions

### Bun Runtime (`@oak/http_server_bun`)

#### Class: Server

An implementation of the oak server abstraction for handling requests on Bun using the built in Bun http server.

#### Methods

- **close**(): void
- **listen**(port?: number, hostname?: string): void
- **type**: "native" | "node" | "bun"

### Deno Runtime (`@oak/http_server_native`)

#### Class: Server

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.

#### Properties

- **app**: Application
- **close**(): Promise<void>
- **closed**: boolean
- **listen**: (port?: number, hostname?: string) => Promise<void>
- **type**: "native" | "node" | "bun"
```

--------------------------------

### Application Class

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/ApplicationOptions

The core class for managing middleware and handling incoming HTTP requests. You create an instance of Application, register middleware using `.use()`, and then start listening for requests using `.listen()`.

```APIDOC
## Class: Application

### Description
A class which registers middleware (via `.use()`) and then processes inbound requests against that middleware (via `.listen()`).

### Methods
- **addEventListener(type: string, listener: EventListener | ((evt: ApplicationEvent) => void))**: Adds an event listener.
- **fetch(request: Request, signal?: AbortSignal)**: Handles a request.
- **handle(request: Request, signal?: AbortSignal)**: Handles a request.
- **keys**: Returns the keys for the application.
- **listen()**: Starts the application listening for requests.
- **proxy**: If `true`, the application will proxy requests.
- **state**: The state of the application.
- **use(middleware: Middleware | Array<Middleware>)**: Registers middleware.

### Events
- **"close"**: An event that occurs when the application closes.
- **"error"**: An event that occurs when an application error occurs.
- **"listen"**: An event that occurs when the application starts listening for requests.
```

--------------------------------

### Import Oak symbols using npm/yarn/pnpm/bun

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/testing/~/createMockApp

Examples of how to import specific symbols or the entire Oak library after installation using different package managers. Shows both direct import and import from the JSR specifier.

```typescript
// Import a specific symbol
import { createMockApp } from "@oak/oak/testing";

// Or using JSR specifier
import { createMockApp as createMockAppJSR } from "jsr:@oak/oak/testing";

console.log(createMockApp);
console.log(createMockAppJSR);
```

--------------------------------

### Import from @oak/oak Package with Deno

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/context

Imports symbols from the @oak/oak package. It shows two ways to import: using the scoped package name '@oak/oak' and directly using the JSR specifier 'jsr:@oak/oak'.

```typescript
import * as mod from "@oak/oak/context";

```

```typescript
import * as mod from "jsr:@oak/oak/context";

```

--------------------------------

### Server Abstractions

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/context/~/Context.prototype.%5BSymbol

Details about the server abstractions used by Oak for different runtimes like Bun and Deno.

```APIDOC
## Bun Server Abstraction (`http_server_bun`)

### Description
The abstraction that oak uses when dealing with requests and responses within the Bun runtime that leverages the built in HTTP server.

### Class: Server
- **close(): Promise<void>**
- **listen(options: ListenOptions | number): void**
- **type**: "bun"

## Deno Server Abstraction (`http_server_native`)

### Description
The abstraction that oak uses when dealing with requests and responses within the Deno runtime.

### Class: Server
- **app**: The application instance.
- **close(): Promise<void>**
- **closed**: Boolean indicating if the server is closed.
- **listen(options: ListenOptions | number): void**
- **type**: "native"

### Request Example (Conceptual - Bun)
```json
{
  "request": {
    "url": "/hello",
    "method": "GET"
  }
}
```

### Response Example (Conceptual - Deno)
```json
{
  "status": 200,
  "body": "OK"
}
```
```

--------------------------------

### Import ListenOptions from Oak (JSR specifier)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/ListenOptions

Example of importing the 'ListenOptions' type directly using a JSR specifier. This method allows for direct imports from the JSR registry without needing to install the package via a traditional package manager first, assuming your environment supports it.

```typescript
import { type ListenOptions } from "jsr:@oak/oak";
```

--------------------------------

### Bun Server Implementation

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router/~/RouterAllowedMethodsOptions

The `Server` implementation for handling requests and responses within the Bun runtime.

```APIDOC
## http_server_bun.Server

### Description
An implementation of the oak server abstraction for handling requests on Bun using the built in Bun http server.

### Methods
- **close**(): `void`
- **listen**(options: ListenOptions | ListenOptionsBase | ListenOptionsTls): `Promise<void>`

### Properties
- **type**: `'πος'`
```

--------------------------------

### Oak Application Middleware Handling (TypeScript)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/request/~/Request.prototype.%5BSymbol.for%28%22nodejs.util

Demonstrates the creation of an Oak application, registration of middleware, and starting the server to listen for requests. This is the core pattern for building web applications with Oak.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Register middleware
app.use(async (ctx, next) => {
  console.log(`=> ${ctx.request.method} ${ctx.request.url}`);
  await next();
});

app.use(async (ctx) => {
  ctx.response.body = "Hello World!";
});

console.log("Application starting...");
await app.listen({ port: 8000 });
```

--------------------------------

### ContextOptions

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/serve

Options that can be supplied when creating a `Context`.

```APIDOC
## ContextOptions

Options that can be supplied when creating a `Context`.

### Properties

- **jsonBodyReplacer**: Replacer function for JSON parsing.
- **jsonBodyReviver**: Reviver function for JSON parsing.
- **secure**: Boolean indicating if the connection is secure.
```

--------------------------------

### Server Implementations

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/ListenOptions

Details on the server abstractions used by Oak for different runtimes.

```APIDOC
## Server Abstractions

### Description
Oak utilizes different server abstractions depending on the runtime environment to handle HTTP requests and responses.

### `http_server_bun.Server`
An implementation of the oak server abstraction for handling requests on Bun using the built-in Bun http server.

#### Methods
- **close()**: Closes the server.
- **listen()**: Starts the server to listen for connections.

#### Properties
- **type** (`string`): The type of the server ('bun').

### `http_server_native.Server`
The oak abstraction of the Deno native HTTP server which is used internally for handling native HTTP requests.

#### Methods
- **close()**: Closes the server.
- **listen()**: Starts the server to listen for connections.

#### Properties
- **app** (`Application`): The application instance.
- **closed** (`boolean`): Indicates if the server is closed.
- **type** (`string`): The type of the server ('native').

### Usage
Users typically do not need to interact directly with these server classes as they are managed internally by the `Application` instance when `.listen()` is called.
```

--------------------------------

### ETag Get Entity

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router/~/RouterAllowedMethodsOptions

Utility function to get the entity from a Context for ETag calculation.

```APIDOC
## etag.getEntity

### Description
For a given Context, try to determine the response body entity that an ETag can be calculated from.

### Parameters
- **context** (Context): The context object.

### Returns
- `string | undefined` - The ETag entity or undefined if it cannot be determined.
```

--------------------------------

### Bun Server Implementation

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/application/~/ApplicationOptions

The Oak server abstraction implementation for the Bun runtime, leveraging Bun's built-in HTTP server.

```APIDOC
## Class: Server (http_server_bun)

### Description
An implementation of the oak server abstraction for handling requests on Bun using the built in Bun http server.

### Methods
- **close()**: Closes the server.
- **listen(port: number, hostname?: string)**: Starts the server listening on the specified port and hostname.
```

--------------------------------

### Application Options

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router/~/RouterAllowedMethodsOptions

Options available when creating a new instance of the `Application` class.

```APIDOC
## ApplicationOptions Interface

### Description
Available options that are used when creating a new instance of `Application`.

### Properties
- **contextState** (context: Context): `State` - Optional - The initial state for the context.
- **jsonBodyReplacer** (key: string, value: any): `any` - Optional - A replacer function for JSON stringification.
- **jsonBodyReviver** (key: string, value: any): `any` - Optional - A reviver function for JSON parsing.
- **keys** (string[] | CryptoKey[]): `string[] | CryptoKey[]` - Optional - Keys for signed cookies.
- **logErrors** (boolean): `boolean` - Optional - Whether to log errors.
- **proxy** (boolean): `boolean` - Optional - Enable proxy support.
- **serverConstructor** (ServerConstructor): `ServerConstructor` - Optional - The constructor for the server.
- **state**: `State` - Optional - The initial state for the application.
```

--------------------------------

### Server Implementations

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/testing/~/createMockNext

Documentation for server abstractions used by Oak in different runtimes.

```APIDOC
## Server Implementations

### Bun Runtime Server
#### Description
The abstraction that oak uses when dealing with requests and responses within the Bun runtime that leverages the built in HTTP server.

#### Class: Server
- **close**(): Promise<void>
- **listen**(hostname: string, port: number, signal?: AbortSignal): Promise<void>
- **type**: "native" | "websocket"

### Deno Runtime Server
#### Description
The abstraction that oak uses when dealing with requests and responses within the Deno runtime.

#### Class: Server
- **app**: Application
- **close**(): Promise<void>
- **closed**: boolean
- **listen**(options: ListenOptions | ListenOptionsBase): Promise<void>
- **type**: "native" | "websocket"
```

--------------------------------

### Get Entity for ETag Calculation in Oak

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router/~/Router.prototype.%5BSymbol

A utility function that attempts to determine the response body entity suitable for ETag calculation from a given Oak Context. This is crucial for implementing conditional GET requests.

```typescript
fgetEntity
For a given Context, try to determine the response body entity that an ETag can be calculated from.
```

--------------------------------

### Bun Server Implementation

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/router/~/Layer.prototype.%5BSymbol.for%28%22nodejs.util

Oak's server abstraction implementation for the Bun runtime.

```APIDOC
## http_server_bun.Server

### Description
An implementation of the oak server abstraction for handling requests on Bun using the built in Bun http server.

### Methods
- `close`
- `listen`

### Properties
- `type` (string) - Indicates the server type, e.g., 'bun'.
```

--------------------------------

### Add Oak Package using Yarn (older versions)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/MiddlewareObject

Installs the Oak package using 'yarn dlx jsr add' for Yarn versions 4.8 or older. This command facilitates direct installation from JSR.

```bash
yarn dlx jsr add @oak/oak

```

--------------------------------

### Add Oak Package using pnpm (older versions)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/MiddlewareObject

Installs the Oak package using 'pnpm dlx jsr add' for pnpm versions 10.8 or older. This command allows direct installation from JSR.

```bash
pnpm dlx jsr add @oak/oak

```

--------------------------------

### Install Oak Package using npm

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/proxy/~/ProxyOptions

This snippet demonstrates how to add the Oak package to a project using npm. It involves running the `npm add` command with the JSR specifier for the Oak package. This command fetches and installs the package, making its modules available for import.

```bash
npm add jsr:@oak/oak
```

--------------------------------

### Application Options

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/testing/~/createMockContext

Available options when creating a new `Application` instance.

```APIDOC
## ApplicationOptions

### Description
Available options that are used when creating a new instance of `Application`.

### Method
Interface

### Endpoint
N/A (Interface definition)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
import { Application } from "@oak/oak";

const app = new Application({
  state: { customData: "hello" }, // Example of custom state
  logErrors: true
});
```

### Response
#### Success Response (200)
N/A (Interface definition)

#### Response Example
```json
{
  "example": "// No specific example for interface"
}
```

### Fields
* `contextState` (any) - Optional - 
* `jsonBodyReplacer` (Function) - Optional - 
* `jsonBodyReviver` (Function) - Optional - 
* `keys` (Array<string>) - Optional - 
* `logErrors` (boolean) - Optional - 
* `proxy` (boolean) - Optional - 
* `serverConstructor` (Function) - Optional - 
* `state` (T) - Optional - 
```

--------------------------------

### Bun Server Integration

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/context/~/Context

Oak's server abstraction for the Bun runtime.

```APIDOC
## Bun Server

### Description
The abstraction that oak uses when dealing with requests and responses within the Bun runtime that leverages the built in HTTP server.

### Class: Server

#### Methods
- **close**(): void
- **listen**(hostname: string, port: number, https?: object): void

#### Properties
- **type**: "native" | "tls"
```

--------------------------------

### Oak Application: Basic Usage (Deno, Node.js, Bun, Cloudflare Workers)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/middleware/~/Next

Demonstrates the typical usage of an Oak application, including creating an instance, registering middleware, and listening for requests. This pattern is common across Deno CLI, Deno Deploy, Cloudflare Workers, Node.js, and Bun.

```typescript
import { Application } from "@oak/oak";

const app = new Application();

// Register middleware
app.use(async (ctx, next) => {
  console.log(`Request received: ${ctx.request.method} ${ctx.request.url}`);
  await next();
  console.log(`Response sent: ${ctx.response.status}`);
});

// Start listening for requests
const port = 8000;
console.log(`Server listening on http://localhost:${port}`);
await app.listen({ port });
```

--------------------------------

### Add Oak Package with npx

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/body/~/Body.prototype.%5BSymbol

Installs the Oak package using npx.

```shell
npx jsr add @oak/oak
```

--------------------------------

### Import Oak ContextSendOptions Type

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/~/ContextSendOptions

Example of importing the `ContextSendOptions` type from the Oak package.

```typescript
import { type ContextSendOptions } from "@oak/oak";
```

```typescript
import { type ContextSendOptions } from "jsr:@oak/oak";
```

--------------------------------

### ETag Get Entity

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/proxy/~/ProxyOptions

Attempts to determine the response body entity suitable for ETag calculation.

```APIDOC
## etag.getEntity

### Description
For a given Context, try to determine the response body entity that an ETag can be calculated from.

### Method
Utility function

### Endpoint
(N/A - Utility function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **entity** (any | null) - The determined entity for ETag calculation or null if not possible.

#### Response Example
```typescript
import { Context } from "@oak/oak";
import { etag } from "@oak/oak";

const entity = await etag.getEntity(ctx);
```
```

--------------------------------

### Server Abstraction (Bun)

Source: https://jsr.io/@oak/oak/doc/%40oak/oak/doc/context/~/ContextOptions

Details on the `Server` abstraction used by Oak when operating within the Bun runtime.

```APIDOC
## http_server_bun.Server

### Description
An implementation of the oak server abstraction for handling requests on Bun using the built in Bun http server.

### Methods
- **close**(): void
- **listen**(): void

### Properties
- **type** (string): The type of server (e.g., "bun").
```
Tokens:
Raw