@whatwg-node/server 0.10.0-alpha-20241125144944-df106a17746126e3c8089afa16af852a4483c8b3 → 0.10.0-alpha-20250205002109-e61c2d65aed8aa582581368511e66b20e33632b8

package/esm/utils.js

@@ -47,39 +47,9 @@ function isRequestBody(body) {
     }
     return false;
 }
-export class ServerAdapterRequestAbortSignal extends EventTarget {
-    aborted = false;
-    _onabort = null;
-    reason;
-    throwIfAborted() {
-        if (this.aborted) {
-            throw this.reason;
-        }
-    }
-    sendAbort() {
-        this.reason = new DOMException('This operation was aborted', 'AbortError');
-        this.aborted = true;
-        this.dispatchEvent(new Event('abort'));
-    }
-    get onabort() {
-        return this._onabort;
-    }
-    set onabort(value) {
-        this._onabort = value;
-        if (value) {
-            this.addEventListener('abort', value);
-        }
-        else {
-            this.removeEventListener('abort', value);
-        }
-    }
-    any(signals) {
-        return AbortSignal.any([...signals]);
-    }
-}
 let bunNodeCompatModeWarned = false;
 export const nodeRequestResponseMap = new WeakMap();
-export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
+export function normalizeNodeRequest(nodeRequest, fetchAPI) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
@@ -89,7 +59,6 @@ export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
         }
         fullUrl = url.toString();
     }
-    let signal;
     const nodeResponse = nodeRequestResponseMap.get(nodeRequest);
     nodeRequestResponseMap.delete(nodeRequest);
     let normalizedHeaders = nodeRequest.headers;
@@ -101,24 +70,12 @@ export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
             }
         }
     }
+    const controller = new AbortController();
     if (nodeResponse?.once) {
-        let sendAbortSignal;
-        // If ponyfilled
-        if (fetchAPI.Request !== globalThis.Request) {
-            const newSignal = new ServerAdapterRequestAbortSignal();
-            registerSignal?.(newSignal);
-            signal = newSignal;
-            sendAbortSignal = () => signal.sendAbort();
-        }
-        else {
-            const controller = new AbortController();
-            signal = controller.signal;
-            sendAbortSignal = () => controller.abort();
-        }
         const closeEventListener = () => {
-            if (signal && !signal.aborted) {
-                rawRequest.aborted = true;
-                sendAbortSignal();
+            if (!controller.signal.aborted) {
+                Object.defineProperty(rawRequest, 'aborted', { value: true });
+                controller.abort(nodeResponse.errored ?? undefined);
             }
         };
         nodeResponse.once('error', closeEventListener);
@@ -131,7 +88,7 @@ export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
         return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
-            signal,
+            signal: controller.signal,
         });
     }
     /**
@@ -144,16 +101,16 @@ export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
     if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
         if (isRequestBody(maybeParsedBody)) {
             return new fetchAPI.Request(fullUrl, {
-                method: nodeRequest.method,
+                method: nodeRequest.method || 'GET',
                 headers: normalizedHeaders,
                 body: maybeParsedBody,
-                signal,
+                signal: controller.signal,
             });
         }
         const request = new fetchAPI.Request(fullUrl, {
-            method: nodeRequest.method,
+            method: nodeRequest.method || 'GET',
             headers: normalizedHeaders,
-            signal,
+            signal: controller.signal,
         });
         if (!request.headers.get('content-type')?.includes('json')) {
             request.headers.set('content-type', 'application/json; charset=utf-8');
@@ -198,16 +155,17 @@ It will affect your performance. Please check our Bun integration recipe, and av
                     rawRequest.destroy(e);
                 },
             }),
-            signal,
+            signal: controller.signal,
         });
     }
     // perf: instead of spreading the object, we can just pass it as is and it performs better
     return new fetchAPI.Request(fullUrl, {
         method: nodeRequest.method,
         headers: normalizedHeaders,
+        signal: controller.signal,
+        // @ts-expect-error - AsyncIterable is supported as body
         body: rawRequest,
         duplex: 'half',
-        signal,
     });
 }
 export function isReadable(stream) {
@@ -253,13 +211,25 @@ async function sendAsyncIterable(serverResponse, asyncIterable) {
         if (closed) {
             break;
         }
-        if (!serverResponse
-            // @ts-expect-error http and http2 writes are actually compatible
-            .write(chunk)) {
-            if (closed) {
-                break;
+        const shouldBreak = await new Promise(resolve => {
+            if (!serverResponse
+                // @ts-expect-error http and http2 writes are actually compatible
+                .write(chunk, err => {
+                if (err) {
+                    resolve(true);
+                }
+            })) {
+                if (closed) {
+                    resolve(true);
+                    return;
+                }
+                serverResponse.once('drain', () => {
+                    resolve(false);
+                });
             }
-            await new Promise(resolve => serverResponse.once('drain', resolve));
+        });
+        if (shouldBreak) {
+            break;
         }
     }
     endResponse(serverResponse);
@@ -320,15 +290,15 @@ export function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
         return;
     }
     if (isReadableStream(fetchBody)) {
-        return sendReadableStream(serverResponse, fetchBody);
+        return sendReadableStream(nodeRequest, serverResponse, fetchBody);
     }
     if (isAsyncIterable(fetchBody)) {
         return sendAsyncIterable(serverResponse, fetchBody);
     }
 }
-async function sendReadableStream(serverResponse, readableStream) {
+async function sendReadableStream(nodeRequest, serverResponse, readableStream) {
     const reader = readableStream.getReader();
-    serverResponse.req.once('error', err => {
+    nodeRequest?.once?.('error', err => {
         reader.cancel(err);
     });
     while (true) {
@@ -451,11 +421,14 @@ export function createDeferredPromise() {
     };
 }
 export function handleAbortSignalAndPromiseResponse(response$, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw abortSignal.reason;
+    }
     if (isPromise(response$) && abortSignal) {
         const deferred$ = createDeferredPromise();
         abortSignal.addEventListener('abort', function abortSignalFetchErrorHandler() {
             deferred$.reject(abortSignal.reason);
-        });
+        }, { once: true });
         response$
             .then(function fetchSuccessHandler(res) {
             deferred$.resolve(res);
@@ -524,7 +497,7 @@ export function handleResponseDecompression(response, fetchAPI) {
     }
     return decompressedResponse;
 }
-const terminateEvents = ['SIGINT', 'SIGTERM', 'exit'];
+const terminateEvents = ['SIGINT', 'exit', 'SIGTERM'];
 const disposableStacks = new Set();
 let eventListenerRegistered = false;
 function ensureEventListenerForDisposableStacks() {
@@ -534,10 +507,7 @@ function ensureEventListenerForDisposableStacks() {
     eventListenerRegistered = true;
     for (const event of terminateEvents) {
         globalThis.process.once(event, function terminateHandler() {
-            return Promise.allSettled([...disposableStacks].map(stack => !stack.disposed &&
-                stack.disposeAsync().catch(e => {
-                    console.error('Error while disposing:', e);
-                })));
+            return Promise.allSettled([...disposableStacks].map(stack => !stack.disposed && stack.disposeAsync()));
         });
     }
 }

package/esm/uwebsockets.js

@@ -2,7 +2,7 @@ import { isPromise } from './utils.js';
 export function isUWSResponse(res) {
     return !!res.onData;
 }
-export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
+export function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }) {
     const method = req.getMethod();
     let duplex;
     const chunks = [];
@@ -36,9 +36,9 @@ export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     let getReadableStream;
     if (method !== 'get' && method !== 'head') {
         duplex = 'half';
-        signal.addEventListener('abort', () => {
+        controller.signal.addEventListener('abort', () => {
             stop();
-        });
+        }, { once: true });
         let readableStream;
         getReadableStream = () => {
             if (!readableStream) {
@@ -90,7 +90,7 @@ export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
         get body() {
             return getBody();
         },
-        signal,
+        signal: controller.signal,
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore - not in the TS types yet
         duplex,
@@ -164,14 +164,14 @@ export function createWritableFromUWS(uwsResponse, fetchAPI) {
         },
     });
 }
-export function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
+export function sendResponseToUwsOpts(uwsResponse, fetchResponse, controller, fetchAPI) {
     if (!fetchResponse) {
         uwsResponse.writeStatus('404 Not Found');
         uwsResponse.end();
         return;
     }
     const bufferOfRes = fetchResponse._buffer;
-    if (signal.aborted) {
+    if (controller.signal.aborted) {
         return;
     }
     uwsResponse.cork(() => {
@@ -201,17 +201,17 @@ export function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchA
     if (bufferOfRes || !fetchResponse.body) {
         return;
     }
-    signal.addEventListener('abort', () => {
+    controller.signal.addEventListener('abort', () => {
         if (!fetchResponse.body?.locked) {
-            fetchResponse.body?.cancel(signal.reason);
+            fetchResponse.body?.cancel(controller.signal.reason);
         }
-    });
+    }, { once: true });
     return fetchResponse.body
         .pipeTo(createWritableFromUWS(uwsResponse, fetchAPI), {
-        signal,
+        signal: controller.signal,
     })
         .catch(err => {
-        if (signal.aborted) {
+        if (controller.signal.aborted) {
             return;
         }
         throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.10.0-alpha-20241125144944-df106a17746126e3c8089afa16af852a4483c8b3",
+  "version": "0.10.0-alpha-20250205002109-e61c2d65aed8aa582581368511e66b20e33632b8",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {

package/typings/createServerAdapter.d.cts

@@ -3,6 +3,14 @@ import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestH
 export interface ServerAdapterOptions<TServerContext> {
     plugins?: ServerAdapterPlugin<TServerContext>[];
     fetchAPI?: Partial<FetchAPI>;
+    /**
+     * Node.js only!
+     *
+     * If true, the server adapter will dispose itself when the process is terminated.
+     * If false, you have to dispose the server adapter by using the `dispose` method,
+     * or [Explicit Resource Management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html)
+     */
+    disposeOnProcessTerminate?: boolean;
 }
 declare function createServerAdapter<TServerContext = {}, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>>(serverAdapterRequestHandler: THandleRequest, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, ServerAdapterBaseObject<TServerContext, THandleRequest>>;
 declare function createServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>>(serverAdapterBaseObject: TBaseObject, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, TBaseObject>;

package/typings/createServerAdapter.d.ts

@@ -3,6 +3,14 @@ import { FetchAPI, ServerAdapter, ServerAdapterBaseObject, ServerAdapterRequestH
 export interface ServerAdapterOptions<TServerContext> {
     plugins?: ServerAdapterPlugin<TServerContext>[];
     fetchAPI?: Partial<FetchAPI>;
+    /**
+     * Node.js only!
+     *
+     * If true, the server adapter will dispose itself when the process is terminated.
+     * If false, you have to dispose the server adapter by using the `dispose` method,
+     * or [Explicit Resource Management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html)
+     */
+    disposeOnProcessTerminate?: boolean;
 }
 declare function createServerAdapter<TServerContext = {}, THandleRequest extends ServerAdapterRequestHandler<TServerContext> = ServerAdapterRequestHandler<TServerContext>>(serverAdapterRequestHandler: THandleRequest, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, ServerAdapterBaseObject<TServerContext, THandleRequest>>;
 declare function createServerAdapter<TServerContext, TBaseObject extends ServerAdapterBaseObject<TServerContext>>(serverAdapterBaseObject: TBaseObject, options?: ServerAdapterOptions<TServerContext>): ServerAdapter<TServerContext, TBaseObject>;

package/typings/index.d.cts

@@ -7,3 +7,4 @@ export * from './plugins/useErrorHandling.cjs';
 export * from './plugins/useContentEncoding.cjs';
 export * from './uwebsockets.cjs';
 export { Response } from '@whatwg-node/fetch';
+export { DisposableSymbols } from '@whatwg-node/disposablestack';

package/typings/index.d.ts

@@ -7,3 +7,4 @@ export * from './plugins/useErrorHandling.js';
 export * from './plugins/useContentEncoding.js';
 export * from './uwebsockets.js';
 export { Response } from '@whatwg-node/fetch';
+export { DisposableSymbols } from '@whatwg-node/disposablestack';

package/typings/plugins/types.d.cts

@@ -1,10 +1,43 @@
 import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.cjs';
-export type ServerAdapterPlugin<TServerContext = {}> = {
+export interface ServerAdapterPlugin<TServerContext = {}> {
+    /**
+     * This hook is invoked for ANY incoming HTTP request. Here you can manipulate the request,
+     * create a short circuit before the request handler takes it over.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
     onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked after a HTTP request (both GraphQL and NON GraphQL) has been processed
+     * and after the response has been forwarded to the client. Here you can perform any cleanup
+     * or logging operations, or you can manipulate the outgoing response object.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
     onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
     [Symbol.dispose]?: () => void;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
     [Symbol.asyncDispose]?: () => PromiseLike<void> | void;
-} | undefined;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    onDispose?: () => PromiseLike<void> | void;
+}
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;

package/typings/plugins/types.d.ts

@@ -1,10 +1,43 @@
 import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.js';
-export type ServerAdapterPlugin<TServerContext = {}> = {
+export interface ServerAdapterPlugin<TServerContext = {}> {
+    /**
+     * This hook is invoked for ANY incoming HTTP request. Here you can manipulate the request,
+     * create a short circuit before the request handler takes it over.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
     onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked after a HTTP request (both GraphQL and NON GraphQL) has been processed
+     * and after the response has been forwarded to the client. Here you can perform any cleanup
+     * or logging operations, or you can manipulate the outgoing response object.
+     *
+     * Warning: Exceptions thrown by this hook are not caught.
+     * This means they will buble up to the HTTP server underlying implementation.
+     * For example, the `node:http` server crashes the entire process on uncaught exceptions.
+     */
     onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
     [Symbol.dispose]?: () => void;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
     [Symbol.asyncDispose]?: () => PromiseLike<void> | void;
-} | undefined;
+    /**
+     * This hook is invoked when the server is being disposed.
+     * The server disposal is triggered either by the process termination or the explicit server disposal.
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html
+     */
+    onDispose?: () => PromiseLike<void> | void;
+}
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;

package/typings/plugins/useErrorHandling.d.cts

@@ -4,9 +4,9 @@ export declare class HTTPError extends Error {
     status: number;
     message: string;
     headers: HeadersInit;
-    details?: any;
+    details?: any | undefined;
     name: string;
-    constructor(status: number | undefined, message: string, headers?: HeadersInit, details?: any);
+    constructor(status: number | undefined, message: string, headers?: HeadersInit, details?: any | undefined);
 }
-export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response>;
+export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response> | void;
 export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/typings/plugins/useErrorHandling.d.ts

@@ -4,9 +4,9 @@ export declare class HTTPError extends Error {
     status: number;
     message: string;
     headers: HeadersInit;
-    details?: any;
+    details?: any | undefined;
     name: string;
-    constructor(status: number | undefined, message: string, headers?: HeadersInit, details?: any);
+    constructor(status: number | undefined, message: string, headers?: HeadersInit, details?: any | undefined);
 }
-export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response>;
+export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response> | void;
 export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/typings/types.d.cts

@@ -1,4 +1,4 @@
-import type { RequestListener } from 'http';
+import type { RequestListener } from 'node:http';
 import type { NodeRequest, NodeResponse } from './utils.cjs';
 import { UWSHandler, UWSRequest, UWSResponse } from './uwebsockets.cjs';
 export interface FetchEvent extends Event {

package/typings/types.d.ts

@@ -1,4 +1,4 @@
-import type { RequestListener } from 'http';
+import type { RequestListener } from 'node:http';
 import type { NodeRequest, NodeResponse } from './utils.js';
 import { UWSHandler, UWSRequest, UWSResponse } from './uwebsockets.js';
 export interface FetchEvent extends Event {

package/typings/utils.d.cts

@@ -1,37 +1,27 @@
-import type { IncomingMessage, ServerResponse } from 'http';
-import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
-import type { Socket } from 'net';
-import type { Readable } from 'stream';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
 import type { FetchAPI, FetchEvent } from './types.cjs';
 export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
 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;
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    body?: any | undefined;
+    url?: string | undefined;
+    originalUrl?: string | undefined;
+    method?: string | undefined;
+    headers?: any | undefined;
+    req?: IncomingMessage | Http2ServerRequest | undefined;
+    raw?: IncomingMessage | Http2ServerRequest | undefined;
+    socket?: Socket | undefined;
+    query?: any | undefined;
     once?(event: string, listener: (...args: any[]) => void): void;
-    aborted?: boolean;
+    aborted?: boolean | undefined;
 }
 export type NodeResponse = ServerResponse | Http2ServerResponse;
-export declare class ServerAdapterRequestAbortSignal extends EventTarget implements AbortSignal {
-    aborted: boolean;
-    private _onabort;
-    reason: any;
-    throwIfAborted(): void;
-    sendAbort(): void;
-    get onabort(): ((this: AbortSignal, ev: Event) => any) | null;
-    set onabort(value: ((this: AbortSignal, ev: Event) => any) | null);
-    any(signals: Iterable<AbortSignal>): AbortSignal;
-}
 export declare const nodeRequestResponseMap: WeakMap<NodeRequest, NodeResponse>;
-export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI, registerSignal?: (signal: ServerAdapterRequestAbortSignal) => void): Request;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI): Request;
 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;

package/typings/utils.d.ts

@@ -1,37 +1,27 @@
-import type { IncomingMessage, ServerResponse } from 'http';
-import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
-import type { Socket } from 'net';
-import type { Readable } from 'stream';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Socket } from 'node:net';
+import type { Readable } from 'node:stream';
 import type { FetchAPI, FetchEvent } from './types.js';
 export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
 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;
+    protocol?: string | undefined;
+    hostname?: string | undefined;
+    body?: any | undefined;
+    url?: string | undefined;
+    originalUrl?: string | undefined;
+    method?: string | undefined;
+    headers?: any | undefined;
+    req?: IncomingMessage | Http2ServerRequest | undefined;
+    raw?: IncomingMessage | Http2ServerRequest | undefined;
+    socket?: Socket | undefined;
+    query?: any | undefined;
     once?(event: string, listener: (...args: any[]) => void): void;
-    aborted?: boolean;
+    aborted?: boolean | undefined;
 }
 export type NodeResponse = ServerResponse | Http2ServerResponse;
-export declare class ServerAdapterRequestAbortSignal extends EventTarget implements AbortSignal {
-    aborted: boolean;
-    private _onabort;
-    reason: any;
-    throwIfAborted(): void;
-    sendAbort(): void;
-    get onabort(): ((this: AbortSignal, ev: Event) => any) | null;
-    set onabort(value: ((this: AbortSignal, ev: Event) => any) | null);
-    any(signals: Iterable<AbortSignal>): AbortSignal;
-}
 export declare const nodeRequestResponseMap: WeakMap<NodeRequest, NodeResponse>;
-export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI, registerSignal?: (signal: ServerAdapterRequestAbortSignal) => void): Request;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI): Request;
 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;

package/typings/uwebsockets.d.cts

@@ -1,5 +1,4 @@
 import type { FetchAPI } from './types.cjs';
-import { ServerAdapterRequestAbortSignal } from './utils.cjs';
 export interface UWSRequest {
     getMethod(): string;
     forEach(callback: (key: string, value: string) => void): void;
@@ -24,10 +23,10 @@ interface GetRequestFromUWSOpts {
     req: UWSRequest;
     res: UWSResponse;
     fetchAPI: FetchAPI;
-    signal: AbortSignal;
+    controller: AbortController;
 }
-export declare function getRequestFromUWSRequest({ req, res, fetchAPI, signal }: GetRequestFromUWSOpts): Request;
+export declare function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }: GetRequestFromUWSOpts): Request;
 export declare function createWritableFromUWS(uwsResponse: UWSResponse, fetchAPI: FetchAPI): WritableStream<any>;
-export declare function sendResponseToUwsOpts(uwsResponse: UWSResponse, fetchResponse: Response, signal: ServerAdapterRequestAbortSignal, fetchAPI: FetchAPI): Promise<void> | undefined;
+export declare function sendResponseToUwsOpts(uwsResponse: UWSResponse, fetchResponse: Response, controller: AbortController, fetchAPI: FetchAPI): Promise<void> | undefined;
 export declare function fakePromise<T>(value: T): Promise<T>;
 export {};

package/typings/uwebsockets.d.ts

@@ -1,5 +1,4 @@
 import type { FetchAPI } from './types.js';
-import { ServerAdapterRequestAbortSignal } from './utils.js';
 export interface UWSRequest {
     getMethod(): string;
     forEach(callback: (key: string, value: string) => void): void;
@@ -24,10 +23,10 @@ interface GetRequestFromUWSOpts {
     req: UWSRequest;
     res: UWSResponse;
     fetchAPI: FetchAPI;
-    signal: AbortSignal;
+    controller: AbortController;
 }
-export declare function getRequestFromUWSRequest({ req, res, fetchAPI, signal }: GetRequestFromUWSOpts): Request;
+export declare function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }: GetRequestFromUWSOpts): Request;
 export declare function createWritableFromUWS(uwsResponse: UWSResponse, fetchAPI: FetchAPI): WritableStream<any>;
-export declare function sendResponseToUwsOpts(uwsResponse: UWSResponse, fetchResponse: Response, signal: ServerAdapterRequestAbortSignal, fetchAPI: FetchAPI): Promise<void> | undefined;
+export declare function sendResponseToUwsOpts(uwsResponse: UWSResponse, fetchResponse: Response, controller: AbortController, fetchAPI: FetchAPI): Promise<void> | undefined;
 export declare function fakePromise<T>(value: T): Promise<T>;
 export {};