@whatwg-node/server 0.9.56 → 0.9.57-alpha-20241125145154-b2c748560e2a94065f9a25e55132e073f78bea40

package/cjs/createServerAdapter.js

@@ -3,12 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServerAdapter = createServerAdapter;
 const tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/ban-types */
+const disposablestack_1 = require("@whatwg-node/disposablestack");
 const DefaultFetchAPI = tslib_1.__importStar(require("@whatwg-node/fetch"));
 const utils_js_1 = require("./utils.js");
 const uwebsockets_js_1 = require("./uwebsockets.js");
-async function handleWaitUntils(waitUntilPromises) {
-    await Promise.allSettled(waitUntilPromises);
-}
 // Required for envs like nextjs edge runtime
 function isRequestAccessible(serverContext) {
     try {
@@ -29,13 +27,55 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         : serverAdapterBaseObject.handle;
     const onRequestHooks = [];
     const onResponseHooks = [];
+    const waitUntilPromises = new Set();
+    const disposableStack = new disposablestack_1.AsyncDisposableStack();
+    const signals = new Set();
+    function registerSignal(signal) {
+        signals.add(signal);
+        signal.addEventListener('abort', () => {
+            signals.delete(signal);
+        });
+    }
+    disposableStack.defer(() => {
+        for (const signal of signals) {
+            signal.sendAbort();
+        }
+    });
+    disposableStack.defer(() => {
+        if (waitUntilPromises.size > 0) {
+            return Promise.allSettled(waitUntilPromises).then(() => {
+                waitUntilPromises.clear();
+            }, () => {
+                waitUntilPromises.clear();
+            });
+        }
+    });
+    function waitUntil(promiseLike) {
+        // If it is a Node.js environment, we should register the disposable stack to handle process termination events
+        if (globalThis.process) {
+            (0, utils_js_1.ensureDisposableStackRegisteredForTerminateEvents)(disposableStack);
+        }
+        waitUntilPromises.add(promiseLike);
+        promiseLike.then(() => {
+            waitUntilPromises.delete(promiseLike);
+        }, err => {
+            console.error(`Unexpected error while waiting: ${err.message || err}`);
+            waitUntilPromises.delete(promiseLike);
+        });
+    }
     if (options?.plugins != null) {
         for (const plugin of options.plugins) {
-            if (plugin.onRequest) {
-                onRequestHooks.push(plugin.onRequest);
-            }
-            if (plugin.onResponse) {
-                onResponseHooks.push(plugin.onResponse);
+            if (plugin != null) {
+                if (plugin.onRequest) {
+                    onRequestHooks.push(plugin.onRequest);
+                }
+                if (plugin.onResponse) {
+                    onResponseHooks.push(plugin.onResponse);
+                }
+                const disposeFn = plugin[disposablestack_1.DisposableSymbols.asyncDispose] || plugin[disposablestack_1.DisposableSymbols.dispose];
+                if (disposeFn != null) {
+                    disposableStack.defer(disposeFn);
+                }
             }
         }
     }
@@ -46,12 +86,13 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             if (onRequestHooks.length === 0) {
                 return handleEarlyResponse();
             }
-            let url = new Proxy(EMPTY_OBJECT, {
-                get(_target, prop, _receiver) {
-                    url = new fetchAPI.URL(request.url, 'http://localhost');
-                    return Reflect.get(url, prop, url);
-                },
-            });
+            let url = request['parsedUrl'] ||
+                new Proxy(EMPTY_OBJECT, {
+                    get(_target, prop, _receiver) {
+                        url = new fetchAPI.URL(request.url, 'http://localhost');
+                        return Reflect.get(url, prop, url);
+                    },
+                });
             const onRequestHooksIteration$ = (0, utils_js_1.iterateAsyncVoid)(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
                 request,
                 setRequest(newRequest) {
@@ -109,7 +150,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     // TODO: Remove this on the next major version
     function handleNodeRequest(nodeRequest, ...ctx) {
         const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};
-        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI);
+        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI, registerSignal);
         return handleRequest(request, serverContext);
     }
     function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
@@ -118,13 +159,10 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         return handleNodeRequest(nodeRequest, ...ctx);
     }
     function requestListener(nodeRequest, nodeResponse, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             req: nodeRequest,
             res: nodeResponse,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         let response$;
         try {
@@ -149,19 +187,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
     }
     function handleUWS(res, req, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             res,
             req,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
         const serverContext = filteredCtxParts.length > 0
             ? (0, utils_js_1.completeAssign)(defaultServerContext, ...ctx)
             : defaultServerContext;
         const signal = new utils_js_1.ServerAdapterRequestAbortSignal();
+        registerSignal(signal);
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -222,17 +258,12 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     }
     function handleRequestWithWaitUntil(request, ...ctx) {
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
-        let waitUntilPromises;
         const serverContext = filteredCtxParts.length > 1
             ? (0, utils_js_1.completeAssign)({}, ...filteredCtxParts)
             : (0, utils_js_1.isolateObject)(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null
-                ? (waitUntilPromises = [])
+                ? waitUntil
                 : undefined);
-        const response$ = handleRequest(request, serverContext);
-        if (waitUntilPromises?.length) {
-            return handleWaitUntils(waitUntilPromises).then(() => response$);
-        }
-        return response$;
+        return handleRequest(request, serverContext);
     }
     const fetchFn = (input, ...maybeCtx) => {
         if (typeof input === 'string' || 'href' in input) {
@@ -285,6 +316,19 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         handleEvent,
         handleUWS,
         handle: genericRequestHandler,
+        disposableStack,
+        [disposablestack_1.DisposableSymbols.asyncDispose]() {
+            if (!disposableStack.disposed) {
+                return disposableStack.disposeAsync();
+            }
+            return (0, uwebsockets_js_1.fakePromise)(undefined);
+        },
+        dispose() {
+            if (!disposableStack.disposed) {
+                return disposableStack.disposeAsync();
+            }
+            return (0, uwebsockets_js_1.fakePromise)(undefined);
+        },
     };
     const serverAdapter = new Proxy(genericRequestHandler, {
         // It should have all the attributes of the handler function and the server instance

package/cjs/plugins/useContentEncoding.js

@@ -47,7 +47,6 @@ function useContentEncoding() {
             }
         },
         onResponse({ request, response, setResponse, fetchAPI, serverContext }) {
-            const waitUntil = serverContext.waitUntil?.bind(serverContext) || (() => { });
             // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
             if (response['bodyInit'] || response.body) {
                 const encodings = encodingMap.get(request);
@@ -61,8 +60,10 @@ function useContentEncoding() {
                             const bufOfRes = response._buffer;
                             if (bufOfRes) {
                                 const writer = compressionStream.writable.getWriter();
-                                waitUntil(writer.write(bufOfRes));
-                                waitUntil(writer.close());
+                                const write$ = writer.write(bufOfRes);
+                                serverContext.waitUntil?.(write$);
+                                const close$ = writer.close();
+                                serverContext.waitUntil?.(close$);
                                 const uint8Arrays$ = (0, utils_js_1.isReadable)(compressionStream.readable['readable'])
                                     ? collectReadableValues(compressionStream.readable['readable'])
                                     : (0, utils_js_1.isAsyncIterable)(compressionStream.readable)
@@ -80,7 +81,8 @@ function useContentEncoding() {
                                     });
                                     utils_js_1.decompressedResponseMap.set(compressedResponse, response);
                                     setResponse(compressedResponse);
-                                    waitUntil(compressionStream.writable.close());
+                                    const close$ = compressionStream.writable.close();
+                                    serverContext.waitUntil?.(close$);
                                 });
                             }
                         }

package/cjs/utils.js

@@ -19,6 +19,7 @@ exports.createDeferredPromise = createDeferredPromise;
 exports.handleAbortSignalAndPromiseResponse = handleAbortSignalAndPromiseResponse;
 exports.getSupportedEncodings = getSupportedEncodings;
 exports.handleResponseDecompression = handleResponseDecompression;
+exports.ensureDisposableStackRegisteredForTerminateEvents = ensureDisposableStackRegisteredForTerminateEvents;
 function isAsyncIterable(body) {
     return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
 }
@@ -101,7 +102,7 @@ class ServerAdapterRequestAbortSignal extends EventTarget {
 exports.ServerAdapterRequestAbortSignal = ServerAdapterRequestAbortSignal;
 let bunNodeCompatModeWarned = false;
 exports.nodeRequestResponseMap = new WeakMap();
-function normalizeNodeRequest(nodeRequest, fetchAPI) {
+function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
@@ -127,7 +128,9 @@ function normalizeNodeRequest(nodeRequest, fetchAPI) {
         let sendAbortSignal;
         // If ponyfilled
         if (fetchAPI.Request !== globalThis.Request) {
-            signal = new ServerAdapterRequestAbortSignal();
+            const newSignal = new ServerAdapterRequestAbortSignal();
+            registerSignal?.(newSignal);
+            signal = newSignal;
             sendAbortSignal = () => signal.sendAbort();
         }
         else {
@@ -440,21 +443,17 @@ function handleErrorFromRequestHandler(error, ResponseCtor) {
         status: error.status || 500,
     });
 }
-function isolateObject(originalCtx, waitUntilPromises) {
+function isolateObject(originalCtx, waitUntilFn) {
     if (originalCtx == null) {
-        if (waitUntilPromises == null) {
+        if (waitUntilFn == null) {
             return {};
         }
         return {
-            waitUntil(promise) {
-                waitUntilPromises.push(promise.catch(err => console.error(err)));
-            },
+            waitUntil: waitUntilFn,
         };
     }
     return completeAssign(Object.create(originalCtx), {
-        waitUntil(promise) {
-            waitUntilPromises?.push(promise.catch(err => console.error(err)));
-        },
+        waitUntil: waitUntilFn,
     }, originalCtx);
 }
 function createDeferredPromise() {
@@ -548,3 +547,31 @@ function handleResponseDecompression(response, fetchAPI) {
     }
     return decompressedResponse;
 }
+const terminateEvents = ['SIGINT', 'SIGTERM', 'exit'];
+const disposableStacks = new Set();
+let eventListenerRegistered = false;
+function ensureEventListenerForDisposableStacks() {
+    if (eventListenerRegistered) {
+        return;
+    }
+    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);
+                })));
+        });
+    }
+}
+function ensureDisposableStackRegisteredForTerminateEvents(disposableStack) {
+    if (globalThis.process) {
+        ensureEventListenerForDisposableStacks();
+        if (!disposableStacks.has(disposableStack)) {
+            disposableStacks.add(disposableStack);
+            disposableStack.defer(() => {
+                disposableStacks.delete(disposableStack);
+            });
+        }
+    }
+}

package/esm/createServerAdapter.js

@@ -1,10 +1,8 @@
 /* eslint-disable @typescript-eslint/ban-types */
+import { AsyncDisposableStack, DisposableSymbols } from '@whatwg-node/disposablestack';
 import * as DefaultFetchAPI from '@whatwg-node/fetch';
-import { completeAssign, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, ServerAdapterRequestAbortSignal, } from './utils.js';
-import { getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './uwebsockets.js';
-async function handleWaitUntils(waitUntilPromises) {
-    await Promise.allSettled(waitUntilPromises);
-}
+import { completeAssign, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, ServerAdapterRequestAbortSignal, } from './utils.js';
+import { fakePromise, getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './uwebsockets.js';
 // Required for envs like nextjs edge runtime
 function isRequestAccessible(serverContext) {
     try {
@@ -25,13 +23,55 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         : serverAdapterBaseObject.handle;
     const onRequestHooks = [];
     const onResponseHooks = [];
+    const waitUntilPromises = new Set();
+    const disposableStack = new AsyncDisposableStack();
+    const signals = new Set();
+    function registerSignal(signal) {
+        signals.add(signal);
+        signal.addEventListener('abort', () => {
+            signals.delete(signal);
+        });
+    }
+    disposableStack.defer(() => {
+        for (const signal of signals) {
+            signal.sendAbort();
+        }
+    });
+    disposableStack.defer(() => {
+        if (waitUntilPromises.size > 0) {
+            return Promise.allSettled(waitUntilPromises).then(() => {
+                waitUntilPromises.clear();
+            }, () => {
+                waitUntilPromises.clear();
+            });
+        }
+    });
+    function waitUntil(promiseLike) {
+        // If it is a Node.js environment, we should register the disposable stack to handle process termination events
+        if (globalThis.process) {
+            ensureDisposableStackRegisteredForTerminateEvents(disposableStack);
+        }
+        waitUntilPromises.add(promiseLike);
+        promiseLike.then(() => {
+            waitUntilPromises.delete(promiseLike);
+        }, err => {
+            console.error(`Unexpected error while waiting: ${err.message || err}`);
+            waitUntilPromises.delete(promiseLike);
+        });
+    }
     if (options?.plugins != null) {
         for (const plugin of options.plugins) {
-            if (plugin.onRequest) {
-                onRequestHooks.push(plugin.onRequest);
-            }
-            if (plugin.onResponse) {
-                onResponseHooks.push(plugin.onResponse);
+            if (plugin != null) {
+                if (plugin.onRequest) {
+                    onRequestHooks.push(plugin.onRequest);
+                }
+                if (plugin.onResponse) {
+                    onResponseHooks.push(plugin.onResponse);
+                }
+                const disposeFn = plugin[DisposableSymbols.asyncDispose] || plugin[DisposableSymbols.dispose];
+                if (disposeFn != null) {
+                    disposableStack.defer(disposeFn);
+                }
             }
         }
     }
@@ -42,12 +82,13 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             if (onRequestHooks.length === 0) {
                 return handleEarlyResponse();
             }
-            let url = new Proxy(EMPTY_OBJECT, {
-                get(_target, prop, _receiver) {
-                    url = new fetchAPI.URL(request.url, 'http://localhost');
-                    return Reflect.get(url, prop, url);
-                },
-            });
+            let url = request['parsedUrl'] ||
+                new Proxy(EMPTY_OBJECT, {
+                    get(_target, prop, _receiver) {
+                        url = new fetchAPI.URL(request.url, 'http://localhost');
+                        return Reflect.get(url, prop, url);
+                    },
+                });
             const onRequestHooksIteration$ = iterateAsyncVoid(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
                 request,
                 setRequest(newRequest) {
@@ -105,7 +146,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     // TODO: Remove this on the next major version
     function handleNodeRequest(nodeRequest, ...ctx) {
         const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};
-        const request = normalizeNodeRequest(nodeRequest, fetchAPI);
+        const request = normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal);
         return handleRequest(request, serverContext);
     }
     function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
@@ -114,13 +155,10 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         return handleNodeRequest(nodeRequest, ...ctx);
     }
     function requestListener(nodeRequest, nodeResponse, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             req: nodeRequest,
             res: nodeResponse,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         let response$;
         try {
@@ -145,19 +183,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
     }
     function handleUWS(res, req, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             res,
             req,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
         const serverContext = filteredCtxParts.length > 0
             ? completeAssign(defaultServerContext, ...ctx)
             : defaultServerContext;
         const signal = new ServerAdapterRequestAbortSignal();
+        registerSignal(signal);
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -218,17 +254,12 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     }
     function handleRequestWithWaitUntil(request, ...ctx) {
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
-        let waitUntilPromises;
         const serverContext = filteredCtxParts.length > 1
             ? completeAssign({}, ...filteredCtxParts)
             : isolateObject(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null
-                ? (waitUntilPromises = [])
+                ? waitUntil
                 : undefined);
-        const response$ = handleRequest(request, serverContext);
-        if (waitUntilPromises?.length) {
-            return handleWaitUntils(waitUntilPromises).then(() => response$);
-        }
-        return response$;
+        return handleRequest(request, serverContext);
     }
     const fetchFn = (input, ...maybeCtx) => {
         if (typeof input === 'string' || 'href' in input) {
@@ -281,6 +312,19 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         handleEvent,
         handleUWS,
         handle: genericRequestHandler,
+        disposableStack,
+        [DisposableSymbols.asyncDispose]() {
+            if (!disposableStack.disposed) {
+                return disposableStack.disposeAsync();
+            }
+            return fakePromise(undefined);
+        },
+        dispose() {
+            if (!disposableStack.disposed) {
+                return disposableStack.disposeAsync();
+            }
+            return fakePromise(undefined);
+        },
     };
     const serverAdapter = new Proxy(genericRequestHandler, {
         // It should have all the attributes of the handler function and the server instance

package/esm/plugins/useContentEncoding.js

@@ -44,7 +44,6 @@ export function useContentEncoding() {
             }
         },
         onResponse({ request, response, setResponse, fetchAPI, serverContext }) {
-            const waitUntil = serverContext.waitUntil?.bind(serverContext) || (() => { });
             // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
             if (response['bodyInit'] || response.body) {
                 const encodings = encodingMap.get(request);
@@ -58,8 +57,10 @@ export function useContentEncoding() {
                             const bufOfRes = response._buffer;
                             if (bufOfRes) {
                                 const writer = compressionStream.writable.getWriter();
-                                waitUntil(writer.write(bufOfRes));
-                                waitUntil(writer.close());
+                                const write$ = writer.write(bufOfRes);
+                                serverContext.waitUntil?.(write$);
+                                const close$ = writer.close();
+                                serverContext.waitUntil?.(close$);
                                 const uint8Arrays$ = isReadable(compressionStream.readable['readable'])
                                     ? collectReadableValues(compressionStream.readable['readable'])
                                     : isAsyncIterable(compressionStream.readable)
@@ -77,7 +78,8 @@ export function useContentEncoding() {
                                     });
                                     decompressedResponseMap.set(compressedResponse, response);
                                     setResponse(compressedResponse);
-                                    waitUntil(compressionStream.writable.close());
+                                    const close$ = compressionStream.writable.close();
+                                    serverContext.waitUntil?.(close$);
                                 });
                             }
                         }

package/esm/utils.js

@@ -79,7 +79,7 @@ export class ServerAdapterRequestAbortSignal extends EventTarget {
 }
 let bunNodeCompatModeWarned = false;
 export const nodeRequestResponseMap = new WeakMap();
-export function normalizeNodeRequest(nodeRequest, fetchAPI) {
+export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
@@ -105,7 +105,9 @@ export function normalizeNodeRequest(nodeRequest, fetchAPI) {
         let sendAbortSignal;
         // If ponyfilled
         if (fetchAPI.Request !== globalThis.Request) {
-            signal = new ServerAdapterRequestAbortSignal();
+            const newSignal = new ServerAdapterRequestAbortSignal();
+            registerSignal?.(newSignal);
+            signal = newSignal;
             sendAbortSignal = () => signal.sendAbort();
         }
         else {
@@ -418,21 +420,17 @@ export function handleErrorFromRequestHandler(error, ResponseCtor) {
         status: error.status || 500,
     });
 }
-export function isolateObject(originalCtx, waitUntilPromises) {
+export function isolateObject(originalCtx, waitUntilFn) {
     if (originalCtx == null) {
-        if (waitUntilPromises == null) {
+        if (waitUntilFn == null) {
             return {};
         }
         return {
-            waitUntil(promise) {
-                waitUntilPromises.push(promise.catch(err => console.error(err)));
-            },
+            waitUntil: waitUntilFn,
         };
     }
     return completeAssign(Object.create(originalCtx), {
-        waitUntil(promise) {
-            waitUntilPromises?.push(promise.catch(err => console.error(err)));
-        },
+        waitUntil: waitUntilFn,
     }, originalCtx);
 }
 export function createDeferredPromise() {
@@ -526,3 +524,31 @@ export function handleResponseDecompression(response, fetchAPI) {
     }
     return decompressedResponse;
 }
+const terminateEvents = ['SIGINT', 'SIGTERM', 'exit'];
+const disposableStacks = new Set();
+let eventListenerRegistered = false;
+function ensureEventListenerForDisposableStacks() {
+    if (eventListenerRegistered) {
+        return;
+    }
+    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);
+                })));
+        });
+    }
+}
+export function ensureDisposableStackRegisteredForTerminateEvents(disposableStack) {
+    if (globalThis.process) {
+        ensureEventListenerForDisposableStacks();
+        if (!disposableStacks.has(disposableStack)) {
+            disposableStacks.add(disposableStack);
+            disposableStack.defer(() => {
+                disposableStacks.delete(disposableStack);
+            });
+        }
+    }
+}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.9.56",
+  "version": "0.9.57-alpha-20241125145154-b2c748560e2a94065f9a25e55132e073f78bea40",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {
+    "@whatwg-node/disposablestack": "^0.0.5",
     "@whatwg-node/fetch": "^0.10.0",
     "tslib": "^2.6.3"
   },

package/typings/plugins/types.d.cts

@@ -1,8 +1,10 @@
 import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.cjs';
-export interface ServerAdapterPlugin<TServerContext = {}> {
+export type ServerAdapterPlugin<TServerContext = {}> = {
     onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
     onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
-}
+    [Symbol.dispose]?: () => void;
+    [Symbol.asyncDispose]?: () => PromiseLike<void> | void;
+} | undefined;
 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,10 @@
 import { FetchAPI, ServerAdapterRequestHandler, type ServerAdapterInitialContext } from '../types.js';
-export interface ServerAdapterPlugin<TServerContext = {}> {
+export type ServerAdapterPlugin<TServerContext = {}> = {
     onRequest?: OnRequestHook<TServerContext & ServerAdapterInitialContext>;
     onResponse?: OnResponseHook<TServerContext & ServerAdapterInitialContext>;
-}
+    [Symbol.dispose]?: () => void;
+    [Symbol.asyncDispose]?: () => PromiseLike<void> | void;
+} | undefined;
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;

package/typings/types.d.cts

@@ -13,7 +13,7 @@ export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends
      */
     handle: THandleRequest;
 }
-export interface ServerAdapterObject<TServerContext> extends EventListenerObject {
+export interface ServerAdapterObject<TServerContext> extends EventListenerObject, AsyncDisposable {
     /**
      * A basic request listener that takes a `Request` with the server context and returns a `Response`.
      */
@@ -56,6 +56,8 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     handle(container: {
         request: Request;
     } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
+    disposableStack: AsyncDisposableStack;
+    dispose(): Promise<void> | void;
 }
 export interface RequestLike {
     url: string;

package/typings/types.d.ts

@@ -13,7 +13,7 @@ export interface ServerAdapterBaseObject<TServerContext, THandleRequest extends
      */
     handle: THandleRequest;
 }
-export interface ServerAdapterObject<TServerContext> extends EventListenerObject {
+export interface ServerAdapterObject<TServerContext> extends EventListenerObject, AsyncDisposable {
     /**
      * A basic request listener that takes a `Request` with the server context and returns a `Response`.
      */
@@ -56,6 +56,8 @@ export interface ServerAdapterObject<TServerContext> extends EventListenerObject
     handle(container: {
         request: Request;
     } & Partial<TServerContext & ServerAdapterInitialContext>, ...ctx: Partial<TServerContext & ServerAdapterInitialContext>[]): Promise<Response> | Response;
+    disposableStack: AsyncDisposableStack;
+    dispose(): Promise<void> | void;
 }
 export interface RequestLike {
     url: string;

package/typings/utils.d.cts

@@ -31,7 +31,7 @@ export declare class ServerAdapterRequestAbortSignal extends EventTarget impleme
     any(signals: Iterable<AbortSignal>): AbortSignal;
 }
 export declare const nodeRequestResponseMap: WeakMap<NodeRequest, NodeResponse>;
-export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI): Request;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI, registerSignal?: (signal: ServerAdapterRequestAbortSignal) => void): 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;
@@ -43,7 +43,7 @@ export declare function completeAssign(...args: any[]): any;
 export declare function isPromise<T>(val: T | Promise<T>): val is Promise<T>;
 export declare function iterateAsyncVoid<TInput>(iterable: Iterable<TInput>, callback: (input: TInput, stopEarly: () => void) => Promise<void> | void): Promise<void> | void;
 export declare function handleErrorFromRequestHandler(error: any, ResponseCtor: typeof Response): Response;
-export declare function isolateObject<TIsolatedObject extends object>(originalCtx: TIsolatedObject, waitUntilPromises?: Promise<unknown>[]): TIsolatedObject;
+export declare function isolateObject<TIsolatedObject extends object>(originalCtx: TIsolatedObject, waitUntilFn?: (promiseLike: PromiseLike<unknown>) => void): TIsolatedObject;
 export interface DeferredPromise<T = void> {
     promise: Promise<T>;
     resolve: (value: T) => void;
@@ -54,3 +54,4 @@ export declare function handleAbortSignalAndPromiseResponse(response$: Promise<R
 export declare const decompressedResponseMap: WeakMap<Response, Response>;
 export declare function getSupportedEncodings(fetchAPI: FetchAPI): CompressionFormat[];
 export declare function handleResponseDecompression(response: Response, fetchAPI: FetchAPI): Response;
+export declare function ensureDisposableStackRegisteredForTerminateEvents(disposableStack: AsyncDisposableStack): void;

package/typings/utils.d.ts

@@ -31,7 +31,7 @@ export declare class ServerAdapterRequestAbortSignal extends EventTarget impleme
     any(signals: Iterable<AbortSignal>): AbortSignal;
 }
 export declare const nodeRequestResponseMap: WeakMap<NodeRequest, NodeResponse>;
-export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI): Request;
+export declare function normalizeNodeRequest(nodeRequest: NodeRequest, fetchAPI: FetchAPI, registerSignal?: (signal: ServerAdapterRequestAbortSignal) => void): 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;
@@ -43,7 +43,7 @@ export declare function completeAssign(...args: any[]): any;
 export declare function isPromise<T>(val: T | Promise<T>): val is Promise<T>;
 export declare function iterateAsyncVoid<TInput>(iterable: Iterable<TInput>, callback: (input: TInput, stopEarly: () => void) => Promise<void> | void): Promise<void> | void;
 export declare function handleErrorFromRequestHandler(error: any, ResponseCtor: typeof Response): Response;
-export declare function isolateObject<TIsolatedObject extends object>(originalCtx: TIsolatedObject, waitUntilPromises?: Promise<unknown>[]): TIsolatedObject;
+export declare function isolateObject<TIsolatedObject extends object>(originalCtx: TIsolatedObject, waitUntilFn?: (promiseLike: PromiseLike<unknown>) => void): TIsolatedObject;
 export interface DeferredPromise<T = void> {
     promise: Promise<T>;
     resolve: (value: T) => void;
@@ -54,3 +54,4 @@ export declare function handleAbortSignalAndPromiseResponse(response$: Promise<R
 export declare const decompressedResponseMap: WeakMap<Response, Response>;
 export declare function getSupportedEncodings(fetchAPI: FetchAPI): CompressionFormat[];
 export declare function handleResponseDecompression(response: Response, fetchAPI: FetchAPI): Response;
+export declare function ensureDisposableStackRegisteredForTerminateEvents(disposableStack: AsyncDisposableStack): void;