dx-server 0.12.1 → 0.13.0-alpha.1

package/README.md

@@ -10,7 +10,7 @@ A modern, unopinionated, and performant Node.js server framework built on AsyncL
 - 🎯 **Elegant API interface** - No need to pass req/res objects through middleware chains
 - 🔗 **Chainable middleware** - Elegant middleware composition with [jchain](https://www.npmjs.com/package/jchain)
 - 🚀 **Context-based architecture** - Access request/response from anywhere using AsyncLocalStorage
-- 🔄 **Express compatible** - Use existing Express middleware and applications
+- 🔄 **Express compatible** - Bridge Express/Connect middleware with a small adapter
 - 📦 **Zero dependencies** - No runtime dependencies, all functionality built-in
 - 🛡️ **Built-in body parsing** - JSON, text, URL-encoded, and raw body parsing with size limits
 - 🗂️ **Static file serving** - Efficient static file handling with ETag, Range, and Last-Modified support
@@ -127,9 +127,7 @@ new Server().on('request', (req, res) => chain(
 )()).listen(3000)
 ```
 
-### Production-Ready Server with Express Integration
-
-This example requires: `npm install express morgan helmet cors`
+### Production-Ready Server
 
 ```javascript
 import {Server} from 'node:http'
@@ -139,11 +137,9 @@ import dxServer, {
   getReq, getRes,
   getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery,
   setHtml, setJson, setText, setEmpty, setBuffer, setRedirect, setNodeStream, setWebStream, setFile,
-  router, connectMiddlewares, chainStatic, makeDxContext
+  router, chainStatic, makeDxContext
 } from 'dx-server'
-import {expressApp} from 'dx-server/express'
-import express from 'express'
-import morgan from 'morgan'
+import {resolve} from 'node:path'
 
 // it is best practice to create custom error class for non-system error
 class ServerError extends Error {
@@ -166,7 +162,6 @@ function requireAuth() {
 
 const serverChain = chain(
   next => {
-    // this is the difference between express and dx-server
     // req, res can be accessed from anywhere via context which uses NodeJS's AsyncLocalStorage under the hood
     getRes().setHeader('Cache-Control', 'no-cache')
     return next() // must return or await
@@ -182,15 +177,7 @@ const serverChain = chain(
       }
     }
   },
-  connectMiddlewares(
-    morgan('common'),
-    // cors(),
-  ),
-  await expressApp(app => {// any express feature can be used. This requires express installed, with for e.g., `yarn add express`
-    app.set('trust proxy', true)
-    if (process.env.NODE_ENV !== 'production') app.set('json spaces', 2)
-    app.use('/public', express.static('public'))
-  }),
+  chainStatic('/public/*', {root: resolve(import.meta.dirname, 'public')}),
   authContext.chain(), // chain context will set the context value to authContext.value in every request
   router.post('/api/*', async ({next}) => {// example of catching error for all /api/* routes
     try {
@@ -318,12 +305,12 @@ import dxServer, {
   setNodeStream, setWebStream, setFile,
   
   // Utilities
-  router, connectMiddlewares, chainStatic, makeDxContext
+  router, chainStatic, makeDxContext,
+  
+  // Logging
+  logger, logJson,
 } from 'dx-server'
 
-// Express integration (requires express installed)
-import {expressApp, expressRouter} from 'dx-server/express'
-
 // Low-level helpers
 import {
   setBufferBodyDefaultOptions,
@@ -384,7 +371,6 @@ Options:
   ```
 
 #### Middleware Utilities
-- **`connectMiddlewares(...middlewares)`** - Use Connect/Express middleware
 - **`chainStatic(pattern, options)`** - Serve static files
   ```javascript
   chainStatic('/public/*', {
@@ -453,30 +439,38 @@ router.get({
 
 ### Express Integration
 
-dx-server seamlessly integrates with Express applications and middleware:
+dx-server does not ship a built-in Express adapter, but Express apps and Connect-style middleware slot into a chain with a one-line adapter. A Connect/Express middleware has the signature `(req, res, next) => void`; jchain expects `next => void | Promise`. Bridge them inline:
 
 ```javascript
-import {expressApp, expressRouter} from 'dx-server/express'
+import chain from 'jchain'
+import {getReq, getRes} from 'dx-server'
 import express from 'express'
-import cors from 'cors'
+import morgan from 'morgan'
 import helmet from 'helmet'
+import cors from 'cors'
 
-chain(
-  // Use entire Express app
-  await expressApp(app => {
-    app.set('trust proxy', true)
-    app.set('json spaces', 2)
-    app.use(helmet())
-    app.use('/static', express.static('public'))
-  }),
-  
-  // Or use Express router
-  expressRouter(router => {
-    router.use(cors())
-    router.get('/legacy', (req, res) => {
-      res.json({message: 'Express route'})
-    })
+// Adapt one Connect/Express-style middleware (or a full Express app, which has the
+// same (req, res, next) shape) into a jchain step. Always calls next() so the rest of
+// the chain runs — dx-server handles the case where the response is already ended.
+const fromConnect = mw => next => new Promise((resolve, reject) => {
+  mw(getReq(), getRes(), err => {
+    if (err) return reject(err)
+    next().then(resolve, reject)
   })
+})
+
+const app = express()
+app.set('trust proxy', true)
+app.use('/public', express.static('public'))
+app.get('/legacy', (req, res) => res.json({message: 'Express route'}))
+
+chain(
+  fromConnect(app), // mount the entire Express app first
+  fromConnect(morgan('common')),
+  fromConnect(helmet()),
+  fromConnect(cors()),
+  // dx-server routes continue here
+  router.get('/', () => setHtml('ok')),
 )
 ```
 
@@ -560,20 +554,18 @@ router.post('/api/users', async () => {
 ```
 
 ### Security Headers
-Use security middleware:
+Use security middleware via the `fromConnect` adapter shown in [Express Integration](#express-integration):
 
 ```javascript
 import helmet from 'helmet'
 import cors from 'cors'
 
 chain(
-  connectMiddlewares(
-    helmet(),
-    cors({
-      origin: process.env.ALLOWED_ORIGINS?.split(','),
-      credentials: true
-    })
-  )
+  fromConnect(helmet()),
+  fromConnect(cors({
+    origin: process.env.ALLOWED_ORIGINS?.split(','),
+    credentials: true
+  })),
 )
 ```
 
@@ -611,16 +603,16 @@ server.on('upgrade', (request, socket, head) => {
 ```
 
 ### Rate Limiting
+Using the `fromConnect` adapter from [Express Integration](#express-integration):
+
 ```javascript
 import rateLimit from 'express-rate-limit'
 
 chain(
-  connectMiddlewares(
-    rateLimit({
-      windowMs: 15 * 60 * 1000, // 15 minutes
-      max: 100 // limit each IP to 100 requests per windowMs
-    })
-  )
+  fromConnect(rateLimit({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  })),
 )
 ```
 

package/{cjs → lib}/body.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type BufferBodyOptions } from './bodyHelpers.js';
-export declare const getBuffer: import("./dx.js").Context<Buffer | undefined, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
+export declare const getBuffer: import("./dx.js").Context<Buffer<ArrayBufferLike> | undefined, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
 export declare const getJson: import("./dx.js").Context<any, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
-export declare const getRaw: import("./dx.js").Context<Buffer | undefined, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
+export declare const getRaw: import("./dx.js").Context<Buffer<ArrayBufferLike> | undefined, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
 export declare const getText: import("./dx.js").Context<string | undefined, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
 export declare const getUrlEncoded: import("./dx.js").Context<any, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;
 export declare const getQuery: import("./dx.js").Context<any, [options?: Partial<BufferBodyOptions> | undefined], any, (...np: any[]) => any>;

package/lib/body.js

@@ -0,0 +1,10 @@
+import { getReq, makeDxContext } from './dx.js';
+import { bufferFromReq, jsonFromReq, queryFromReq, rawFromReq, textFromReq, urlEncodedFromReq } from './bodyHelpers.js';
+export const getBuffer = makeDxContext((options) => bufferFromReq(getReq(), options));
+export const getJson = makeDxContext((options) => jsonFromReq(getReq(), options));
+export const getRaw = makeDxContext((options) => rawFromReq(getReq(), options));
+export const getText = makeDxContext((options) => textFromReq(getReq(), options));
+export const getUrlEncoded = makeDxContext((options) => urlEncodedFromReq(getReq(), options));
+export const getQuery = makeDxContext((options) => queryFromReq(getReq(), options));
+// to getFile use busboy
+// https://github.com/mscdex/busboy

package/{esm → lib}/bodyHelpers.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { IncomingMessage } from 'node:http';
 export interface BufferBodyOptions {
     bodyLimit: number;
@@ -7,9 +5,9 @@ export interface BufferBodyOptions {
     queryParser?(search: string): any;
 }
 export declare function setBufferBodyDefaultOptions(options: Partial<BufferBodyOptions>): void;
-export declare function bufferFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<Buffer | undefined>;
+export declare function bufferFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<Buffer<ArrayBufferLike> | undefined>;
 export declare function jsonFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<any>;
-export declare function rawFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<Buffer | undefined>;
+export declare function rawFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<Buffer<ArrayBufferLike> | undefined>;
 export declare function textFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<string | undefined>;
 export declare function urlEncodedFromReq(req: IncomingMessage, options?: Partial<BufferBodyOptions>): Promise<any>;
 export declare function urlFromReq(req: IncomingMessage): URL;

package/lib/bodyHelpers.js

@@ -0,0 +1,89 @@
+import { getContentStream, readStream } from './stream.js';
+import { parseContentType } from './vendors/contentType.js';
+function defaultQueryParser(search) {
+    return Object.fromEntries(new URLSearchParams(search)); // support both leading ? and not
+}
+let bodyDefaultOptions = { bodyLimit: 100 << 10 }; // 100kb
+export function setBufferBodyDefaultOptions(options) {
+    bodyDefaultOptions = { ...bodyDefaultOptions, ...options };
+}
+export async function bufferFromReq(req, options) {
+    const { bodyLimit } = { ...bodyDefaultOptions, ...options };
+    /**
+     * Check if a request has a request body.
+     * A request with a body __must__ either have `transfer-encoding`
+     * or `content-length` headers set.
+     * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
+     */
+    // https://github.com/jshttp/type-is/blob/cdcfe23e9833872e425b0aaf71ca0311373b6116/index.js#L92
+    const contentLengthParsed = parseInt(req.headers['content-length'] ?? '', 10);
+    if (req.headers['transfer-encoding'] === undefined
+        && isNaN(contentLengthParsed))
+        return;
+    const contentLength = isNaN(contentLengthParsed) ? undefined : contentLengthParsed;
+    // read
+    const encoding = (req.headers['content-encoding'] ?? 'identity').toLowerCase();
+    const stream = getContentStream(req, encoding);
+    return await readStream(stream, {
+        length: encoding === 'identity' ? contentLength : undefined,
+        limit: bodyLimit,
+    });
+}
+// if content-type is not as expected, return undefined
+function forceGetContentTypeParams(req, expected) {
+    const contentTypeRaw = req.headers['content-type'];
+    if (!contentTypeRaw)
+        return;
+    const { mediaType, parameters } = parseContentType(contentTypeRaw);
+    if (mediaType !== expected)
+        return;
+    return parameters;
+}
+function forceGetCharset(req, expected) {
+    const parameters = forceGetContentTypeParams(req, expected);
+    if (!parameters)
+        return;
+    // assert charset per RFC 7159 sec 8.1
+    const charset = parameters.charset?.toLowerCase() || 'utf-8';
+    if (!charset.startsWith('utf-'))
+        throw new Error(`unsupported charset "${charset.toUpperCase()}"`);
+    return charset;
+}
+export async function jsonFromReq(req, options) {
+    const charset = forceGetCharset(req, 'application/json');
+    if (!charset)
+        return;
+    const buffer = await bufferFromReq(req, options);
+    if (buffer) {
+        const str = buffer.toString(charset);
+        return str ? JSON.parse(str) : undefined;
+    }
+}
+export async function rawFromReq(req, options) {
+    if (!forceGetContentTypeParams(req, 'application/octet-stream'))
+        return;
+    return await bufferFromReq(req, options);
+}
+export async function textFromReq(req, options) {
+    const charset = forceGetCharset(req, 'text/plain');
+    if (!charset)
+        return;
+    const buffer = await bufferFromReq(req, options);
+    if (buffer)
+        return buffer.toString(charset);
+}
+export async function urlEncodedFromReq(req, options) {
+    const charset = forceGetCharset(req, 'application/x-www-form-urlencoded');
+    if (!charset)
+        return;
+    const buffer = await bufferFromReq(req, options);
+    if (buffer) {
+        return (bodyDefaultOptions.urlEncodedParser ?? options?.urlEncodedParser ?? defaultQueryParser)(buffer.toString(charset));
+    }
+}
+export function urlFromReq(req) {
+    return new URL(req.url ?? '', 'https://example.com');
+}
+export function queryFromReq(req, options) {
+    return (bodyDefaultOptions.queryParser ?? options?.queryParser ?? defaultQueryParser)(urlFromReq(req).searchParams.toString());
+}

package/{esm → lib}/dx.d.ts

@@ -1,20 +1,17 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Readable } from 'node:stream';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { SendFileOptions } from './staticHelpers.js';
-export interface Chainable<P extends any[] = any[], R = any, Next = (...np: any[]) => any> {
-    (next: Next, ...p: P): R;
+export interface Chainable<R = any, Next = (...np: any[]) => any> {
+    (next: Next): R;
 }
-export interface Context<T, Params extends any[], R = any, Next = (...np: any[]) => any> {
+export interface Context<T, Params extends any[] = any[], R = any, Next = (...np: any[]) => any> {
     value: Awaited<T>;
     get(req: IncomingMessage): T;
     set(req: IncomingMessage, value: T): void;
     (...params: Params): Promise<T>;
-    chain(...params: Params): Chainable<Params, R, Next>;
+    chain(...params: Params): Chainable<R, Next>;
 }
-export declare function makeDxContext<T, Params extends any[], R = any, Next = (...np: any[]) => any>(maker: (...params: Params) => T | Promise<T>): Context<T, Params, R, Next>;
+export declare function makeDxContext<T, Params extends any[] = any[], R = any, Next = (...np: any[]) => any>(maker: (...params: Params) => T | Promise<T>): Context<T, Params, R, Next>;
 export declare function dxServer(req: IncomingMessage, res: ServerResponse, options?: {
     jsonBeautify?: boolean;
     disableEtag?: boolean;

package/lib/dx.js

@@ -0,0 +1,127 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { writeRes } from './dxHelpers.js';
+export function makeDxContext(maker) {
+    const promiseMap = new WeakMap();
+    const valueMap = new WeakMap();
+    const context = ((...params) => {
+        const req = getReq();
+        if (!promiseMap.has(req))
+            promiseMap.set(req, (async () => {
+                const value = await maker(...params);
+                valueMap.set(req, value);
+                return value;
+            })());
+        return promiseMap.get(req);
+    });
+    Object.defineProperty(context, 'value', {
+        get() { return valueMap.get(getReq()); },
+        set(value) {
+            const req = getReq();
+            promiseMap.set(req, Promise.resolve(value));
+            valueMap.set(req, value);
+        }
+    });
+    context.chain = ((...params) => (async (next) => {
+        await context(...params);
+        return next();
+    }));
+    context.set = (req, value) => {
+        promiseMap.set(req, Promise.resolve(value));
+        valueMap.set(req, value);
+    };
+    context.get = req => valueMap.get(req);
+    return context;
+}
+const requestStorage = new AsyncLocalStorage();
+const dxContext = makeDxContext(options => ({ ...options }));
+export function dxServer(req, res, options = {}) {
+    return async (next) => {
+        dxContext.set(req, { ...options });
+        const result = await requestStorage.run({ req, res }, next);
+        await writeRes(req, res, dxContext.get(req));
+        return result;
+    };
+}
+// method: verb
+// url: full url without server, protocol, port.
+// headers: if headers are repeated, they are joined by comma. Header names are lowercased.
+// rawHeaders: list of header name and value in a flat array. Case is preserved.
+export function getReq() { return requestStorage.getStore().req; }
+export function getRes() { return requestStorage.getStore().res; }
+export function setText(text, { status } = {}) {
+    const res = getRes();
+    const dx = dxContext.value;
+    if (status)
+        res.statusCode = status;
+    dx.data = text;
+    dx.type = 'text';
+}
+export function setEmpty({ status } = {}) {
+    const res = getRes();
+    const dx = dxContext.value;
+    if (status)
+        res.statusCode = status;
+    dx.data = undefined;
+    dx.type = 'empty';
+}
+export function setHtml(html, opts = {}) {
+    setText(html, opts);
+    const dx = dxContext.value;
+    dx.type = 'html';
+}
+export function setFile(filePath, options) {
+    const dx = dxContext.value;
+    dx.data = filePath;
+    dx.type = 'file';
+    dx.options = options;
+}
+export function setBuffer(buffer, { status } = {}) {
+    const res = getRes();
+    const dx = dxContext.value;
+    if (status)
+        res.statusCode = status;
+    dx.data = buffer;
+    dx.type = 'buffer';
+}
+export function setNodeStream(stream, { status } = {}) {
+    const res = getRes();
+    const dx = dxContext.value;
+    if (status)
+        res.statusCode = status;
+    dx.data = stream;
+    dx.type = 'nodeStream';
+}
+export function setWebStream(stream, { status } = {}) {
+    const res = getRes();
+    const dx = dxContext.value;
+    if (status)
+        res.statusCode = status;
+    dx.data = stream;
+    dx.type = 'webStream';
+}
+export function setJson(json, { status } = {}) {
+    const res = getRes();
+    if (status)
+        res.statusCode = status;
+    const dx = dxContext.value;
+    dx.data = json;
+    dx.type = 'json';
+}
+export function setRedirect(url, status) {
+    const res = getRes();
+    const dx = dxContext.value;
+    res.statusCode = status;
+    dx.data = url;
+    dx.type = 'redirect';
+}
+// for download, set content-disposition header
+// res.setHeader('Content-disposition', 'attachment; filename=my-movie.MOV')
+// res.setHeader('Content-type', 'video/quicktime')
+// fileStream.pipe(res)
+// or
+// send(req, filePath, options).pipe(res) // which will set content-type, content-length, and other cache related headers like staticHelpers.sendFile
+// implementing this require a strict validation for the type (attachment) and filename.
+// For example: express relies on this
+// https://github.com/jshttp/content-disposition/blob/1037e24e4790273da96645ad250061f39e77968c/index.js#L186
+// because in most applications, users can specify a simple filename which usually doesn't need to be validated.
+// we leave setDownload() implementation for users, for now.

package/{cjs → lib}/dxHelpers.d.ts

@@ -1,10 +1,6 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { Readable } from 'node:stream';
 import { type SendFileOptions } from './staticHelpers.js';
-import './polyfillWithResolvers.js';
 export type DxContext = {
     charset?: BufferEncoding;
     jsonBeautify?: boolean;

package/{esm → lib}/dxHelpers.js

@@ -2,7 +2,6 @@ import { Readable } from 'node:stream';
 import { promisify } from 'node:util';
 import { entityTag, isFreshETag } from './vendors/etag.js';
 import { sendFileTrusted } from './staticHelpers.js';
-import './polyfillWithResolvers.js';
 export async function writeRes(req, res, { type, data, charset, jsonBeautify, disableEtag, options }) {
     const setContentType = (contentType) => {
         if (res.headersSent || res.getHeader('content-type'))
@@ -116,4 +115,3 @@ export async function writeRes(req, res, { type, data, charset, jsonBeautify, di
         await promisify(res.end.bind(res))();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/{cjs → lib}/index.d.ts

@@ -2,7 +2,6 @@ export { getReq, getRes, setHtml, setNodeStream, setWebStream, setJson, setBuffe
 import { dxServer } from './dx.js';
 export { getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery, } from './body.js';
 export { router } from './router.js';
-export { connectMiddlewares } from './connect.js';
 export { chainStatic } from './static.js';
 export { logJson, default as logger } from './logger.js';
 export default dxServer;

package/{esm/index.d.ts → lib/index.js}

@@ -2,7 +2,6 @@ export { getReq, getRes, setHtml, setNodeStream, setWebStream, setJson, setBuffe
 import { dxServer } from './dx.js';
 export { getBuffer, getJson, getRaw, getText, getUrlEncoded, getQuery, } from './body.js';
 export { router } from './router.js';
-export { connectMiddlewares } from './connect.js';
 export { chainStatic } from './static.js';
 export { logJson, default as logger } from './logger.js';
 export default dxServer;

package/lib/logger.js

@@ -0,0 +1,56 @@
+import { getReq, getRes } from './dx.js';
+import { hrtime } from 'node:process';
+export function logJson(json) {
+    console.log(JSON.stringify(json));
+}
+let requestCount = 0;
+export default (log = logJson) => function logger(next) {
+    const res = getRes();
+    const req = getReq();
+    const logId = requestCount++;
+    const start = hrtime.bigint();
+    const now = new Date(Date.now() + 9 * 60 * 60 * 1000); // jst
+    log({
+        level: 'info',
+        id: logId,
+        timestamp: [
+            [
+                now.getUTCFullYear(),
+                String(now.getUTCMonth() + 1).padStart(2, '0'),
+                String(now.getUTCDate()).padStart(2, '0'),
+            ].join('-'),
+            [
+                String(now.getUTCHours()).padStart(2, '0'),
+                String(now.getUTCMinutes()).padStart(2, '0'),
+                [String(now.getUTCSeconds()).padStart(2, '0'), String(now.getUTCMilliseconds()).padStart(3, '0')].join('.'),
+            ].join(':'),
+        ].join('T'),
+        remoteAddress: req.socket.remoteAddress,
+        method: req.method,
+        url: req.url,
+        httpVersion: `HTTP/${req.httpVersion}`,
+        headers: process.env.NODE_ENV === 'production'
+            ? req.headers
+            : Object.fromEntries(Object.entries(req.headers).filter(([k]) => [
+                'host',
+                'referer',
+                'referrer',
+                'user-agent',
+                'x-forwarded-proto',
+                'x-forwarded-host',
+                'x-forwarded-for',
+            ].includes(k))),
+    });
+    res.once('finish', end).once('close', end).once('error', end);
+    return next();
+    function end() {
+        res.off('finish', end).off('close', end).off('error', end);
+        const durationNs = hrtime.bigint() - start;
+        log({
+            level: 'info',
+            id: logId,
+            duration: Number(durationNs) / 1e6, // ms
+            headers: res.getHeaders(),
+        });
+    }
+};

package/lib/router.d.ts

@@ -0,0 +1,42 @@
+import { type Chainable } from './dx.js';
+interface URLPatternOptions {
+}
+interface RouteContext {
+    matched: URLPatternResult;
+    next(): any;
+}
+interface Route {
+    (context: RouteContext): any;
+}
+interface Routes {
+    [k: string]: Route;
+}
+interface RouterOptions extends URLPatternOptions {
+    prefix?: string;
+}
+type Router = {
+    patch(routes: Routes, options?: RouterOptions): Chainable;
+    patch(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    trace(routes: Routes, options?: RouterOptions): Chainable;
+    trace(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    options(routes: Routes, options?: RouterOptions): Chainable;
+    options(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    connect(routes: Routes, options?: RouterOptions): Chainable;
+    connect(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    delete(routes: Routes, options?: RouterOptions): Chainable;
+    delete(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    put(routes: Routes, options?: RouterOptions): Chainable;
+    put(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    post(routes: Routes, options?: RouterOptions): Chainable;
+    post(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    head(routes: Routes, options?: RouterOptions): Chainable;
+    head(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    get(routes: Routes, options?: RouterOptions): Chainable;
+    get(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    all(routes: Routes, options?: RouterOptions): Chainable;
+    all(pattern: string, route: Route, options?: RouterOptions): Chainable;
+    method(method: string, routes: Routes, options?: RouterOptions): Chainable;
+    method(method: string, pattern: string, route: Route, options?: RouterOptions): Chainable;
+};
+export declare const router: Router;
+export {};