@whatwg-node/server 0.9.1 → 0.9.2-alpha-20230702143635-7d0af11

package/esm/internal-plugins/useNodeAdapter.js

@@ -0,0 +1,227 @@
+import { URL } from '@whatwg-node/fetch';
+import { completeAssign, isAsyncIterable } from '../utils';
+export function useNodeAdapter() {
+    const nodeResponseMap = new WeakMap();
+    return {
+        onRequestAdapt({ args: [req, res, ...restOfCtx], setRequest, setServerContext, fetchAPI }) {
+            if (isNodeRequest(req)) {
+                const defaultServerContext = {
+                    req,
+                };
+                const request = normalizeNodeRequest(req, fetchAPI.Request);
+                setRequest(request);
+                let ctxParams = restOfCtx;
+                if (isServerResponse(res)) {
+                    defaultServerContext.res = res;
+                    nodeResponseMap.set(request, res);
+                }
+                else {
+                    ctxParams = [res, ...restOfCtx];
+                }
+                const serverContext = ctxParams.length > 0 ? completeAssign(...ctxParams) : defaultServerContext;
+                setServerContext(serverContext);
+            }
+        },
+        onResponse({ request, response }) {
+            const nodeResponse = nodeResponseMap.get(request);
+            if (nodeResponse) {
+                return sendNodeResponse(response, nodeResponse);
+            }
+        },
+    };
+}
+export function isReadable(stream) {
+    return stream.read != null;
+}
+export function isNodeRequest(request) {
+    return isReadable(request);
+}
+export function isServerResponse(stream) {
+    // Check all used functions are defined
+    return (stream != null &&
+        stream.setHeader != null &&
+        stream.end != null &&
+        stream.once != null &&
+        stream.write != null);
+}
+function getPort(nodeRequest) {
+    if (nodeRequest.socket?.localPort) {
+        return nodeRequest.socket?.localPort;
+    }
+    const hostInHeader = nodeRequest.headers?.[':authority'] || nodeRequest.headers?.host;
+    const portInHeader = hostInHeader?.split(':')?.[1];
+    if (portInHeader) {
+        return portInHeader;
+    }
+    return 80;
+}
+function getHostnameWithPort(nodeRequest) {
+    if (nodeRequest.headers?.[':authority']) {
+        return nodeRequest.headers?.[':authority'];
+    }
+    if (nodeRequest.headers?.host) {
+        return nodeRequest.headers?.host;
+    }
+    const port = getPort(nodeRequest);
+    if (nodeRequest.hostname) {
+        return nodeRequest.hostname + ':' + port;
+    }
+    const localIp = nodeRequest.socket?.localAddress;
+    if (localIp && !localIp?.includes('::') && !localIp?.includes('ffff')) {
+        return `${localIp}:${port}`;
+    }
+    return 'localhost';
+}
+function buildFullUrl(nodeRequest) {
+    const hostnameWithPort = getHostnameWithPort(nodeRequest);
+    const protocol = nodeRequest.protocol || 'http';
+    const endpoint = nodeRequest.originalUrl || nodeRequest.url || '/graphql';
+    return `${protocol}://${hostnameWithPort}${endpoint}`;
+}
+function isRequestBody(body) {
+    const stringTag = body[Symbol.toStringTag];
+    if (typeof body === 'string' ||
+        stringTag === 'Uint8Array' ||
+        stringTag === 'Blob' ||
+        stringTag === 'FormData' ||
+        stringTag === 'URLSearchParams' ||
+        isAsyncIterable(body)) {
+        return true;
+    }
+    return false;
+}
+export function normalizeNodeRequest(nodeRequest, RequestCtor) {
+    const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
+    let fullUrl = buildFullUrl(rawRequest);
+    if (nodeRequest.query) {
+        const url = new URL(fullUrl);
+        for (const key in nodeRequest.query) {
+            url.searchParams.set(key, nodeRequest.query[key]);
+        }
+        fullUrl = url.toString();
+    }
+    if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
+        return new RequestCtor(fullUrl, {
+            method: nodeRequest.method,
+            headers: nodeRequest.headers,
+        });
+    }
+    /**
+     * Some Node server frameworks like Serverless Express sends a dummy object with body but as a Buffer not string
+     * so we do those checks to see is there something we can use directly as BodyInit
+     * because the presence of body means the request stream is already consumed and,
+     * rawRequest cannot be used as BodyInit/ReadableStream by Fetch API in this case.
+     */
+    const maybeParsedBody = nodeRequest.body;
+    if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
+        if (isRequestBody(maybeParsedBody)) {
+            return new RequestCtor(fullUrl, {
+                method: nodeRequest.method,
+                headers: nodeRequest.headers,
+                body: maybeParsedBody,
+            });
+        }
+        const request = new RequestCtor(fullUrl, {
+            method: nodeRequest.method,
+            headers: nodeRequest.headers,
+        });
+        if (!request.headers.get('content-type')?.includes('json')) {
+            request.headers.set('content-type', 'application/json; charset=utf-8');
+        }
+        return new Proxy(request, {
+            get: (target, prop, receiver) => {
+                switch (prop) {
+                    case 'json':
+                        return async () => maybeParsedBody;
+                    case 'text':
+                        return async () => JSON.stringify(maybeParsedBody);
+                    default:
+                        return Reflect.get(target, prop, receiver);
+                }
+            },
+        });
+    }
+    // perf: instead of spreading the object, we can just pass it as is and it performs better
+    return new RequestCtor(fullUrl, {
+        method: nodeRequest.method,
+        headers: nodeRequest.headers,
+        body: rawRequest,
+    });
+}
+function configureSocket(rawRequest) {
+    rawRequest?.socket?.setTimeout?.(0);
+    rawRequest?.socket?.setNoDelay?.(true);
+    rawRequest?.socket?.setKeepAlive?.(true);
+}
+function endResponse(serverResponse) {
+    // @ts-expect-error Avoid arguments adaptor trampoline https://v8.dev/blog/adaptor-frame
+    serverResponse.end(null, null, null);
+}
+function getHeaderPairs(headers) {
+    const headerPairs = new Map();
+    headers.forEach((value, key) => {
+        let headerValues = headerPairs.get(key);
+        if (headerValues === undefined) {
+            headerValues = [];
+            headerPairs.set(key, headerValues);
+        }
+        if (key === 'set-cookie') {
+            const setCookies = headers.getSetCookie?.();
+            if (setCookies) {
+                setCookies.forEach(setCookie => {
+                    headerValues.push(setCookie);
+                });
+                return;
+            }
+        }
+        headerValues.push(value);
+    });
+    return headerPairs;
+}
+async function sendAsyncIterable(serverResponse, asyncIterable) {
+    for await (const chunk of asyncIterable) {
+        if (!serverResponse
+            // @ts-expect-error http and http2 writes are actually compatible
+            .write(chunk)) {
+            break;
+        }
+    }
+    endResponse(serverResponse);
+}
+export function sendNodeResponse(fetchResponse, serverResponse) {
+    const headerPairs = getHeaderPairs(fetchResponse.headers);
+    serverResponse.writeHead(fetchResponse.status, fetchResponse.statusText, Object.fromEntries(headerPairs.entries()));
+    // Optimizations for node-fetch
+    if (fetchResponse.bodyType === 'Buffer' ||
+        fetchResponse.bodyType === 'String' ||
+        fetchResponse.bodyType === 'Uint8Array') {
+        // @ts-expect-error http and http2 writes are actually compatible
+        serverResponse.write(fetchResponse.bodyInit);
+        endResponse(serverResponse);
+        return;
+    }
+    // Other fetch implementations
+    const fetchBody = fetchResponse.body;
+    if (fetchBody == null) {
+        endResponse(serverResponse);
+        return;
+    }
+    if (fetchBody[Symbol.toStringTag] === 'Uint8Array') {
+        serverResponse
+            // @ts-expect-error http and http2 writes are actually compatible
+            .write(fetchBody);
+        endResponse(serverResponse);
+        return;
+    }
+    configureSocket(serverResponse.req);
+    if (isReadable(fetchBody)) {
+        serverResponse.once('close', () => {
+            fetchBody.destroy();
+        });
+        fetchBody.pipe(serverResponse);
+        return;
+    }
+    if (isAsyncIterable(fetchBody)) {
+        return sendAsyncIterable(serverResponse, fetchBody);
+    }
+}

package/esm/{uwebsockets.js → internal-plugins/useUWSAdapter.js}

@@ -1,3 +1,35 @@
+import { completeAssign } from '../utils.js';
+export function useUWSAdapter() {
+    const uwsResponseMap = new WeakMap();
+    return {
+        onRequestAdapt({ args: [res, req, ...restOfCtx], setRequest, setServerContext, fetchAPI }) {
+            if (isUWSResponse(res)) {
+                const request = getRequestFromUWSRequest({
+                    req: req,
+                    res,
+                    fetchAPI,
+                });
+                uwsResponseMap.set(request, res);
+                setRequest(request);
+                const defaultServerContext = {
+                    req,
+                    res,
+                };
+                const serverContext = restOfCtx.length > 0 ? completeAssign(...restOfCtx) : defaultServerContext;
+                setServerContext(serverContext);
+            }
+        },
+        onResponse({ request, response }) {
+            const res = uwsResponseMap.get(request);
+            if (res) {
+                sendResponseToUwsOpts({
+                    res,
+                    response,
+                });
+            }
+        },
+    };
+}
 export function isUWSResponse(res) {
     return !!res.onData;
 }

package/esm/utils.js

@@ -1,208 +1,9 @@
-import { URL } from '@whatwg-node/fetch';
 export function isAsyncIterable(body) {
     return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
 }
-function getPort(nodeRequest) {
-    if (nodeRequest.socket?.localPort) {
-        return nodeRequest.socket?.localPort;
-    }
-    const hostInHeader = nodeRequest.headers?.[':authority'] || nodeRequest.headers?.host;
-    const portInHeader = hostInHeader?.split(':')?.[1];
-    if (portInHeader) {
-        return portInHeader;
-    }
-    return 80;
-}
-function getHostnameWithPort(nodeRequest) {
-    if (nodeRequest.headers?.[':authority']) {
-        return nodeRequest.headers?.[':authority'];
-    }
-    if (nodeRequest.headers?.host) {
-        return nodeRequest.headers?.host;
-    }
-    const port = getPort(nodeRequest);
-    if (nodeRequest.hostname) {
-        return nodeRequest.hostname + ':' + port;
-    }
-    const localIp = nodeRequest.socket?.localAddress;
-    if (localIp && !localIp?.includes('::') && !localIp?.includes('ffff')) {
-        return `${localIp}:${port}`;
-    }
-    return 'localhost';
-}
-function buildFullUrl(nodeRequest) {
-    const hostnameWithPort = getHostnameWithPort(nodeRequest);
-    const protocol = nodeRequest.protocol || 'http';
-    const endpoint = nodeRequest.originalUrl || nodeRequest.url || '/graphql';
-    return `${protocol}://${hostnameWithPort}${endpoint}`;
-}
-function isRequestBody(body) {
-    const stringTag = body[Symbol.toStringTag];
-    if (typeof body === 'string' ||
-        stringTag === 'Uint8Array' ||
-        stringTag === 'Blob' ||
-        stringTag === 'FormData' ||
-        stringTag === 'URLSearchParams' ||
-        isAsyncIterable(body)) {
-        return true;
-    }
-    return false;
-}
-export function normalizeNodeRequest(nodeRequest, RequestCtor) {
-    const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
-    let fullUrl = buildFullUrl(rawRequest);
-    if (nodeRequest.query) {
-        const url = new URL(fullUrl);
-        for (const key in nodeRequest.query) {
-            url.searchParams.set(key, nodeRequest.query[key]);
-        }
-        fullUrl = url.toString();
-    }
-    if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
-        return new RequestCtor(fullUrl, {
-            method: nodeRequest.method,
-            headers: nodeRequest.headers,
-        });
-    }
-    /**
-     * Some Node server frameworks like Serverless Express sends a dummy object with body but as a Buffer not string
-     * so we do those checks to see is there something we can use directly as BodyInit
-     * because the presence of body means the request stream is already consumed and,
-     * rawRequest cannot be used as BodyInit/ReadableStream by Fetch API in this case.
-     */
-    const maybeParsedBody = nodeRequest.body;
-    if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
-        if (isRequestBody(maybeParsedBody)) {
-            return new RequestCtor(fullUrl, {
-                method: nodeRequest.method,
-                headers: nodeRequest.headers,
-                body: maybeParsedBody,
-            });
-        }
-        const request = new RequestCtor(fullUrl, {
-            method: nodeRequest.method,
-            headers: nodeRequest.headers,
-        });
-        if (!request.headers.get('content-type')?.includes('json')) {
-            request.headers.set('content-type', 'application/json; charset=utf-8');
-        }
-        return new Proxy(request, {
-            get: (target, prop, receiver) => {
-                switch (prop) {
-                    case 'json':
-                        return async () => maybeParsedBody;
-                    case 'text':
-                        return async () => JSON.stringify(maybeParsedBody);
-                    default:
-                        return Reflect.get(target, prop, receiver);
-                }
-            },
-        });
-    }
-    // perf: instead of spreading the object, we can just pass it as is and it performs better
-    return new RequestCtor(fullUrl, {
-        method: nodeRequest.method,
-        headers: nodeRequest.headers,
-        body: rawRequest,
-    });
-}
-export function isReadable(stream) {
-    return stream.read != null;
-}
-export function isNodeRequest(request) {
-    return isReadable(request);
-}
-export function isServerResponse(stream) {
-    // Check all used functions are defined
-    return (stream != null &&
-        stream.setHeader != null &&
-        stream.end != null &&
-        stream.once != null &&
-        stream.write != null);
-}
 export function isReadableStream(stream) {
     return stream != null && stream.getReader != null;
 }
-export function isFetchEvent(event) {
-    return event != null && event.request != null && event.respondWith != null;
-}
-function configureSocket(rawRequest) {
-    rawRequest?.socket?.setTimeout?.(0);
-    rawRequest?.socket?.setNoDelay?.(true);
-    rawRequest?.socket?.setKeepAlive?.(true);
-}
-function endResponse(serverResponse) {
-    // @ts-expect-error Avoid arguments adaptor trampoline https://v8.dev/blog/adaptor-frame
-    serverResponse.end(null, null, null);
-}
-function getHeaderPairs(headers) {
-    const headerPairs = new Map();
-    headers.forEach((value, key) => {
-        let headerValues = headerPairs.get(key);
-        if (headerValues === undefined) {
-            headerValues = [];
-            headerPairs.set(key, headerValues);
-        }
-        if (key === 'set-cookie') {
-            const setCookies = headers.getSetCookie?.();
-            if (setCookies) {
-                setCookies.forEach(setCookie => {
-                    headerValues.push(setCookie);
-                });
-                return;
-            }
-        }
-        headerValues.push(value);
-    });
-    return headerPairs;
-}
-async function sendAsyncIterable(serverResponse, asyncIterable) {
-    for await (const chunk of asyncIterable) {
-        if (!serverResponse
-            // @ts-expect-error http and http2 writes are actually compatible
-            .write(chunk)) {
-            break;
-        }
-    }
-    endResponse(serverResponse);
-}
-export function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
-    const headerPairs = getHeaderPairs(fetchResponse.headers);
-    serverResponse.writeHead(fetchResponse.status, fetchResponse.statusText, Object.fromEntries(headerPairs.entries()));
-    // Optimizations for node-fetch
-    if (fetchResponse.bodyType === 'Buffer' ||
-        fetchResponse.bodyType === 'String' ||
-        fetchResponse.bodyType === 'Uint8Array') {
-        // @ts-expect-error http and http2 writes are actually compatible
-        serverResponse.write(fetchResponse.bodyInit);
-        endResponse(serverResponse);
-        return;
-    }
-    // Other fetch implementations
-    const fetchBody = fetchResponse.body;
-    if (fetchBody == null) {
-        endResponse(serverResponse);
-        return;
-    }
-    if (fetchBody[Symbol.toStringTag] === 'Uint8Array') {
-        serverResponse
-            // @ts-expect-error http and http2 writes are actually compatible
-            .write(fetchBody);
-        endResponse(serverResponse);
-        return;
-    }
-    configureSocket(nodeRequest);
-    if (isReadable(fetchBody)) {
-        serverResponse.once('close', () => {
-            fetchBody.destroy();
-        });
-        fetchBody.pipe(serverResponse);
-        return;
-    }
-    if (isAsyncIterable(fetchBody)) {
-        return sendAsyncIterable(serverResponse, fetchBody);
-    }
-}
 export function isRequestInit(val) {
     return (val != null &&
         typeof val === 'object' &&
@@ -241,3 +42,10 @@ export function completeAssign(...args) {
     });
     return target;
 }
+export function addWaitUntil(serverContext, waitUntilPromises) {
+    serverContext['waitUntil'] = function (promise) {
+        if (promise != null) {
+            waitUntilPromises.push(promise);
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.9.1",
+  "version": "0.9.2-alpha-20230702143635-7d0af11",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {

package/typings/index.d.cts

@@ -4,5 +4,7 @@ export * from './utils.cjs';
 export * from './plugins/types.cjs';
 export * from './plugins/useCors.cjs';
 export * from './plugins/useErrorHandling.cjs';
-export * from './uwebsockets.cjs';
+export * from './internal-plugins/useFetchEvent.cjs';
+export * from './internal-plugins/useNodeAdapter.cjs';
+export * from './internal-plugins/useUWSAdapter.cjs';
 export { Response } from '@whatwg-node/fetch';

package/typings/index.d.ts

@@ -4,5 +4,7 @@ export * from './utils.js';
 export * from './plugins/types.js';
 export * from './plugins/useCors.js';
 export * from './plugins/useErrorHandling.js';
-export * from './uwebsockets.js';
+export * from './internal-plugins/useFetchEvent.js';
+export * from './internal-plugins/useNodeAdapter.js';
+export * from './internal-plugins/useUWSAdapter.js';
 export { Response } from '@whatwg-node/fetch';

package/typings/internal-plugins/useFetchEvent.d.cts

@@ -0,0 +1,4 @@
+import { ServerAdapterPlugin } from '../plugins/types';
+import { FetchEvent } from '../types';
+export declare function isFetchEvent(event: any): event is FetchEvent;
+export declare function useFetchEvent(): ServerAdapterPlugin<FetchEvent>;

package/typings/internal-plugins/useFetchEvent.d.ts

@@ -0,0 +1,4 @@
+import { ServerAdapterPlugin } from '../plugins/types';
+import { FetchEvent } from '../types';
+export declare function isFetchEvent(event: any): event is FetchEvent;
+export declare function useFetchEvent(): ServerAdapterPlugin<FetchEvent>;

package/typings/internal-plugins/useNodeAdapter.d.cts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
+import { ServerAdapterPlugin } from '../plugins/types';
+interface NodeServerContext {
+    req: NodeRequest;
+    res?: NodeResponse;
+}
+export declare function useNodeAdapter(): ServerAdapterPlugin<NodeServerContext>;
+export interface NodeRequest {
+    protocol?: string;
+    hostname?: string;
+    body?: any;
+    url?: string;
+    originalUrl?: string;
+    method?: string;
+    headers?: any;
+    req?: IncomingMessage | Http2ServerRequest;
+    raw?: IncomingMessage | Http2ServerRequest;
+    socket?: Socket;
+    query?: any;
+}
+export type NodeResponse = ServerResponse | Http2ServerResponse;
+export declare function isReadable(stream: any): stream is Readable;
+export declare function isNodeRequest(request: any): request is NodeRequest;
+export declare function isServerResponse(stream: any): stream is NodeResponse;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, RequestCtor: typeof Request): Request;
+export declare function sendNodeResponse(fetchResponse: Response, serverResponse: NodeResponse): Promise<void> | undefined;
+export {};

package/typings/internal-plugins/useNodeAdapter.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
+import { ServerAdapterPlugin } from '../plugins/types';
+interface NodeServerContext {
+    req: NodeRequest;
+    res?: NodeResponse;
+}
+export declare function useNodeAdapter(): ServerAdapterPlugin<NodeServerContext>;
+export interface NodeRequest {
+    protocol?: string;
+    hostname?: string;
+    body?: any;
+    url?: string;
+    originalUrl?: string;
+    method?: string;
+    headers?: any;
+    req?: IncomingMessage | Http2ServerRequest;
+    raw?: IncomingMessage | Http2ServerRequest;
+    socket?: Socket;
+    query?: any;
+}
+export type NodeResponse = ServerResponse | Http2ServerResponse;
+export declare function isReadable(stream: any): stream is Readable;
+export declare function isNodeRequest(request: any): request is NodeRequest;
+export declare function isServerResponse(stream: any): stream is NodeResponse;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, RequestCtor: typeof Request): Request;
+export declare function sendNodeResponse(fetchResponse: Response, serverResponse: NodeResponse): Promise<void> | undefined;
+export {};

package/typings/{uwebsockets.d.ts → internal-plugins/useUWSAdapter.d.cts}

@@ -1,4 +1,10 @@
-import type { FetchAPI } from './types.js';
+import { ServerAdapterPlugin } from '../plugins/types.cjs';
+import type { FetchAPI } from '../types.cjs';
+interface UWSServerContext {
+    req: UWSRequest;
+    res: UWSResponse;
+}
+export declare function useUWSAdapter(): ServerAdapterPlugin<UWSServerContext>;
 export interface UWSRequest {
     getMethod(): string;
     forEach(callback: (key: string, value: string) => void): void;

package/typings/{uwebsockets.d.cts → internal-plugins/useUWSAdapter.d.ts}

@@ -1,4 +1,10 @@
-import type { FetchAPI } from './types.cjs';
+import { ServerAdapterPlugin } from '../plugins/types.js';
+import type { FetchAPI } from '../types.js';
+interface UWSServerContext {
+    req: UWSRequest;
+    res: UWSResponse;
+}
+export declare function useUWSAdapter(): ServerAdapterPlugin<UWSServerContext>;
 export interface UWSRequest {
     getMethod(): string;
     forEach(callback: (key: string, value: string) => void): void;

package/typings/plugins/types.d.cts

@@ -1,8 +1,21 @@
 import { FetchAPI, ServerAdapterRequestHandler } from '../types.cjs';
 export interface ServerAdapterPlugin<TServerContext = {}> {
+    onRequestAdapt?: OnRequestAdapt<TServerContext>;
     onRequest?: OnRequestHook<TServerContext>;
     onResponse?: OnResponseHook<TServerContext>;
 }
+export type OnRequestAdapt<TServerContext> = (payload: OnRequestAdaptEventPayload<TServerContext>) => Promise<void> | void;
+export interface RequestAdapterResult<TServerContext> {
+    serverContext: TServerContext;
+    request: Request;
+}
+export type RequestAdapter<TServerContext> = () => RequestAdapterResult<TServerContext>;
+export interface OnRequestAdaptEventPayload<TServerContext> {
+    args: unknown[];
+    setRequest(request: Request): void;
+    setServerContext(serverContext: TServerContext): void;
+    fetchAPI: FetchAPI;
+}
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;

package/typings/plugins/types.d.ts

@@ -1,8 +1,21 @@
 import { FetchAPI, ServerAdapterRequestHandler } from '../types.js';
 export interface ServerAdapterPlugin<TServerContext = {}> {
+    onRequestAdapt?: OnRequestAdapt<TServerContext>;
     onRequest?: OnRequestHook<TServerContext>;
     onResponse?: OnResponseHook<TServerContext>;
 }
+export type OnRequestAdapt<TServerContext> = (payload: OnRequestAdaptEventPayload<TServerContext>) => Promise<void> | void;
+export interface RequestAdapterResult<TServerContext> {
+    serverContext: TServerContext;
+    request: Request;
+}
+export type RequestAdapter<TServerContext> = () => RequestAdapterResult<TServerContext>;
+export interface OnRequestAdaptEventPayload<TServerContext> {
+    args: unknown[];
+    setRequest(request: Request): void;
+    setServerContext(serverContext: TServerContext): void;
+    fetchAPI: FetchAPI;
+}
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;