@whatwg-node/server 0.9.65 → 0.9.66-alpha-20250205000734-b48a2e64484147e8ccb74c205803bb5cd4b7e948

package/README.md

@@ -167,10 +167,15 @@ app.route({
   url: '/mypath',
   method: ['GET', 'POST', 'OPTIONS'],
   handler: async (req, reply) => {
-    const response = await myServerAdapter.handleNodeRequestAndResponse(req, reply, {
+    const response: Response = await myServerAdapter.handleNodeRequestAndResponse(req, reply, {
       req,
       reply
     })
+
+    if (!response) {
+      return reply.status(404).send('Not Found')
+    }
+
     response.headers.forEach((value, key) => {
       reply.header(key, value)
     })
@@ -200,7 +205,7 @@ import myServerAdapter from './myServerAdapter'
 const app = new Koa()
 
 app.use(async ctx => {
-  const response = await myServerAdapter.handleNodeRequest(ctx.req)
+  const response = await myServerAdapter.handleNodeRequestAndResponse(ctx.request, ctx.res, ctx)
 
   // Set status code
   ctx.status = response.status
@@ -258,9 +263,7 @@ as a first class citizen. So the configuration is really simple like any other J
 ```ts
 import myServerAdapter from './myServerAdapter'
 
-Bun.serve(myServerAdapter)
-
-const server = Bun.serve(yoga)
+const server = Bun.serve(myServerAdapter)
 
 console.info(`Server is running on ${server.hostname}`)
 ```
@@ -299,3 +302,305 @@ We'd recommend to use `fets` to handle routing and middleware approach. It uses
 `@whatwg-node/server` under the hood.
 
 > Learn more about `fets` [here](https://github.com/ardatan/fets)
+
+## Plugin System
+
+You can create your own plugins to extend the functionality of your server adapter.
+
+### `onRequest`
+
+This hook is invoked for ANY incoming HTTP request. Here you can manipulate the request or create a
+short circuit before the server adapter handles the request.
+
+For example, you can shortcut the manually handle an HTTP request, short-circuiting the HTTP
+handler:
+
+```ts
+import { createServerAdapter, type ServerAdapterPlugin } from '@whatwg-node/server'
+
+const myPlugin: ServerAdapterPlugin = {
+  onRequest({ request, endResponse, fetchAPI }) {
+    if (!request.headers.get('authorization')) {
+      endResponse(
+        new fetchAPI.Response(null, {
+          status: 401,
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        })
+      )
+    }
+  }
+}
+
+const myServerAdapter = createServerAdapter(
+  async request => {
+    return new Response(`Hello World!`, { status: 200 })
+  },
+  {
+    plugins: [myPlugin]
+  }
+)
+```
+
+Possible usage examples of this hook are:
+
+- Manipulate the request
+- Short circuit before the adapter handles the request
+
+| Payload field   | Description                                                                                                                                     |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `request`       | The incoming HTTP request as WHATWG `Request` object. [Learn more about the request](https://developer.mozilla.org/en-US/docs/Web/API/Request). |
+| `serverContext` | The early context object that is shared between all hooks and the entire execution. [Learn more about the context](/docs/features/context).     |
+| `fetchAPI`      | WHATWG Fetch API implementation. [Learn more about the fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).                  |
+| `url`           | WHATWG URL object of the incoming request. [Learn more about the URL object](https://developer.mozilla.org/en-US/docs/Web/API/URL).             |
+| `endResponse`   | A function that allows you to end the request early and send a response to the client.                                                          |
+
+### `onResponse`
+
+This hook is invoked after a HTTP request 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.
+
+```ts
+import { createServerAdapter, type ServerAdapterPlugin } from '@whatwg-node/server'
+
+const requestTimeMap = new WeakMap<Request, number>()
+
+const myPlugin: ServerAdapterPlugin = {
+  onRequest({ request }) {
+    requestTimeMap.set(request, Date.now())
+  },
+  onResponse({ request, serverContext, response }) {
+    console.log(`Request to ${request.url} has been processed with status ${response.status}`)
+    // Add some headers
+    response.headers.set('X-Server-Name', 'My Server')
+    console.log(`Request to ${request.url} took ${Date.now() - requestTimeMap.get(request)}ms`)
+  }
+}
+```
+
+**Example actions in this hook:**
+
+- Specify custom response format
+- Logging/Metrics
+
+| Field Name      | Description                                                                                                                                                   |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `request`       | The incoming HTTP request as WHATWG `Request` object. [Learn more about the request](https://developer.mozilla.org/en-US/docs/Web/API/Request).               |
+| `serverContext` | The final context object that is shared between all hooks and the execution. [Learn more about the context](/docs/features/context).                          |
+| `response`      | The outgoing HTTP response as WHATWG `Response` object. [Learn more about the response interface](https://developer.mozilla.org/en-US/docs/Web/API/Response). |
+
+### `onDispose`
+
+In order to clean up resources when the server is shut down, you can use `onDispose`,
+`Symbol.asyncDispose` or `Symbol.syncDispose` to clean up resources.
+
+```ts
+export const useMyPlugin = () => {
+  return {
+    async onDispose() {
+      // Clean up resources
+      await stopConnection()
+    }
+  }
+}
+```
+
+[You can learn more about Explicit Resource Management below](#explicit-resource-management)
+
+## `Request.signal` for awareness of client disconnection
+
+In the real world, a lot of HTTP requests are dropped or canceled. This can happen due to a flakey
+internet connection, navigation to a new view or page within a web or native app or the user simply
+closing the app. In this case, the server can stop processing the request and save resources.
+
+You can utilize `request.signal` to cancel pending asynchronous operations when the client
+disconnects.
+
+```ts
+import { createServerAdapter } from '@whatwg-node/server'
+
+const myServerAdapter = createServerAdapter(async request => {
+  const upstreamRes = await fetch('https://api.example.com/data', {
+    // When the client disconnects, the fetch request will be canceled
+    signal: request.signal
+  })
+  return Response.json({
+    data: await upstreamRes.json()
+  })
+})
+```
+
+The execution cancelation API is built on top of the AbortController and AbortSignal APIs.
+
+[Learn more about AbortController and AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortController)
+
+## Explicit Resource Management
+
+While implementing your server with `@whatwg-node/server`, you need to control over the lifecycle of
+your resources. This is especially important when you are dealing with resources that need to be
+cleaned up when they are no longer needed, or clean up the operations in a queue when the server is
+shutting down.
+
+### Dispose the Server Adapter
+
+The server adapter supports
+[Explicit Resource Management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management)
+approach that allows you to dispose of resources when they are no longer needed. This can be done in
+two ways shown below;
+
+#### `await using` syntax
+
+We use the `await using` syntax to create a new instance of `adapter` and dispose of it when the
+block is exited. Notice that we are using a block to limit the scope of `adapter` within `{ }`. So
+resources will be disposed of when the block is exited.
+
+```ts
+console.log('Adapter is starting')
+{
+  await using adapter = createServerAdapter(/* ... */)
+}
+console.log('Adapter is disposed')
+```
+
+#### `dispose` method
+
+We create a new instance of `adapter` and dispose of it using the `dispose` method.
+
+```ts
+console.log('Adapter is starting')
+const adapter = createServerAdapter(/* ... */)
+await adapter.dispose()
+console.log('Adapter is disposed')
+```
+
+In the first example, we use the `await using` syntax to create a new instance of `adapter` and
+dispose of it when the block is exited. In the second example,
+
+#### Dispose on Node.js
+
+When running your adapter on Node.js, you can use process event listeners or server's `close` event
+to trigger the adapter's disposal. Or you can configure the adapter to handle this automatically by
+listening `process` exit signals.
+
+##### Explicit disposal
+
+We can dispose of the adapter instance when the server is closed like below.
+
+```ts
+import { createServer } from 'http'
+import { createServerAdapter } from '@whatwg-node/server'
+
+const adapter = createServerAdapter(/* ... */)
+
+const server = createServer(adapter)
+server.listen(4000, () => {
+  console.info('Server is running on http://localhost:4000')
+})
+server.once('close', async () => {
+  await adapter.dispose()
+  console.info('Server is disposed so is adapter')
+})
+```
+
+##### Automatic disposal
+
+`disposeOnProcessTerminate` option will register an event listener for `process` termination in
+Node.js
+
+```ts
+import { createServer } from 'http'
+import { createServerAdapter } from '@whatwg-node/server'
+
+createServer(
+  createServerAdapter(/* ... */, {
+    disposeOnProcessTerminate: true,
+    plugins: [/* ... */]
+  })
+).listen(4000, () => {
+  console.info('Server is running on http://localhost:4000')
+})
+```
+
+### Plugin Disposal
+
+If you have plugins that need some internal resources to be disposed of, you can use the `onDispose`
+hook to dispose of them. This hook will be invoked when the adapter instance is disposed like above.
+
+```ts
+let dbConnection: Connection
+const plugin = {
+  onPluginInit: async () => {
+    dbConnection = await createConnection()
+  },
+  onDispose: async () => {
+    // Dispose of resources
+    await dbConnection.close()
+  }
+}
+```
+
+Or you can flush a queue of operations when the server is shutting down.
+
+```ts
+const backgroundJobs: Promise<void>[] = []
+
+const plugin = {
+  onRequest() {
+    backgroundJobs.push(
+      sendAnalytics({
+        /* ... */
+      })
+    )
+  },
+  onDispose: async () => {
+    // Flush the queue of background jobs
+    await Promise.all(backgroundJobs)
+  }
+}
+```
+
+But for this kind of purposes, `waitUntil` can be a better choice.
+
+### Background jobs
+
+If you have background jobs that need to be completed before the environment is shut down.
+`waitUntil` is better choice than `onDispose`. In this case, those jobs will keep running in the
+background but in case of disposal, they will be awaited. `waitUntil` works so similar to
+[Cloudflare Workers' `waitUntil` function](https://developers.cloudflare.com/workers/runtime-apis/handlers/fetch/#parameters).
+
+But the adapter handles `waitUntil` even if it is not provided by the environment.
+
+```ts
+const adapter = createServerAdapter(async (request, context) => {
+  const args = await request.json()
+  if (!args.name) {
+    return Response.json({ error: 'Name is required' }, { status: 400 })
+  }
+  // This does not block the response
+  context.waitUntil(
+    fetch('http://my-analytics.com/analytics', {
+      method: 'POST',
+      body: JSON.stringify({
+        name: args.name,
+        userAgent: request.headers.get('User-Agent')
+      })
+    })
+  )
+  return Response.json({ greetings: `Hello, ${args.name}` })
+})
+
+const res = await adapter.fetch('http://localhost:4000', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({ name: 'John' })
+})
+
+console.log(await res.json()) // { greetings: "Hello, John" }
+
+await adapter.dispose()
+// The fetch request for `analytics` will be awaited here
+```

package/cjs/createServerAdapter.js

@@ -201,7 +201,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         const serverContext = filteredCtxParts.length > 0
             ? (0, utils_js_1.completeAssign)(defaultServerContext, ...ctx)
             : defaultServerContext;
-        const signal = new utils_js_1.ServerAdapterRequestAbortSignal();
+        const controller = new AbortController();
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -210,16 +210,16 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         };
         const originalOnAborted = res.onAborted.bind(res);
         originalOnAborted(function () {
-            signal.sendAbort();
+            controller.abort();
         });
         res.onAborted = function (cb) {
-            signal.addEventListener('abort', cb);
+            controller.signal.addEventListener('abort', cb);
         };
         const request = (0, uwebsockets_js_1.getRequestFromUWSRequest)({
             req,
             res,
             fetchAPI,
-            signal,
+            controller,
         });
         let response$;
         try {
@@ -232,8 +232,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return response$
                 .catch((e) => (0, utils_js_1.handleErrorFromRequestHandler)(e, fetchAPI.Response))
                 .then(response => {
-                if (!signal.aborted && !resEnded) {
-                    return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, signal, fetchAPI);
+                if (!controller.signal.aborted && !resEnded) {
+                    return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, controller, fetchAPI);
                 }
             })
                 .catch(err => {
@@ -241,8 +241,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
         }
         try {
-            if (!signal.aborted && !resEnded) {
-                return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response$, signal, fetchAPI);
+            if (!controller.signal.aborted && !resEnded) {
+                return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response$, controller, fetchAPI);
             }
         }
         catch (err) {

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decompressedResponseMap = exports.nodeRequestResponseMap = exports.ServerAdapterRequestAbortSignal = void 0;
+exports.decompressedResponseMap = exports.nodeRequestResponseMap = void 0;
 exports.isAsyncIterable = isAsyncIterable;
 exports.normalizeNodeRequest = normalizeNodeRequest;
 exports.isReadable = isReadable;
@@ -69,40 +69,9 @@ function isRequestBody(body) {
     }
     return false;
 }
-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]);
-    }
-}
-exports.ServerAdapterRequestAbortSignal = ServerAdapterRequestAbortSignal;
 let bunNodeCompatModeWarned = false;
 exports.nodeRequestResponseMap = new WeakMap();
-function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
+function normalizeNodeRequest(nodeRequest, fetchAPI) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
@@ -112,7 +81,6 @@ function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
         }
         fullUrl = url.toString();
     }
-    let signal;
     const nodeResponse = exports.nodeRequestResponseMap.get(nodeRequest);
     exports.nodeRequestResponseMap.delete(nodeRequest);
     let normalizedHeaders = nodeRequest.headers;
@@ -124,24 +92,12 @@ 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.once('error', closeEventListener);
@@ -154,7 +110,7 @@ function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
         return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
-            signal,
+            signal: controller.signal,
         });
     }
     /**
@@ -167,16 +123,16 @@ 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');
@@ -221,16 +177,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,
     });
 }
 function isReadable(stream) {
@@ -276,13 +233,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);
@@ -343,15 +312,15 @@ 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) {

package/cjs/uwebsockets.js

@@ -9,7 +9,7 @@ const utils_js_1 = require("./utils.js");
 function isUWSResponse(res) {
     return !!res.onData;
 }
-function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
+function getRequestFromUWSRequest({ req, res, fetchAPI, controller, }) {
     const method = req.getMethod();
     let duplex;
     const chunks = [];
@@ -43,7 +43,7 @@ function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     let getReadableStream;
     if (method !== 'get' && method !== 'head') {
         duplex = 'half';
-        signal.addEventListener('abort', () => {
+        controller.signal.addEventListener('abort', () => {
             stop();
         });
         let readableStream;
@@ -97,7 +97,7 @@ 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,
@@ -171,14 +171,14 @@ function createWritableFromUWS(uwsResponse, fetchAPI) {
         },
     });
 }
-function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
+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(() => {
@@ -208,17 +208,17 @@ function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
     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);
         }
     });
     return fetchResponse.body
         .pipeTo(createWritableFromUWS(uwsResponse, fetchAPI), {
-        signal,
+        signal: controller.signal,
     })
         .catch(err => {
-        if (signal.aborted) {
+        if (controller.signal.aborted) {
             return;
         }
         throw err;

package/esm/createServerAdapter.js

@@ -1,6 +1,6 @@
 import { AsyncDisposableStack, DisposableSymbols } from '@whatwg-node/disposablestack';
 import * as DefaultFetchAPI from '@whatwg-node/fetch';
-import { completeAssign, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, ServerAdapterRequestAbortSignal, } from './utils.js';
+import { completeAssign, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, } from './utils.js';
 import { fakePromise, getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './uwebsockets.js';
 // Required for envs like nextjs edge runtime
 function isRequestAccessible(serverContext) {
@@ -197,7 +197,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         const serverContext = filteredCtxParts.length > 0
             ? completeAssign(defaultServerContext, ...ctx)
             : defaultServerContext;
-        const signal = new ServerAdapterRequestAbortSignal();
+        const controller = new AbortController();
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -206,16 +206,16 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         };
         const originalOnAborted = res.onAborted.bind(res);
         originalOnAborted(function () {
-            signal.sendAbort();
+            controller.abort();
         });
         res.onAborted = function (cb) {
-            signal.addEventListener('abort', cb);
+            controller.signal.addEventListener('abort', cb);
         };
         const request = getRequestFromUWSRequest({
             req,
             res,
             fetchAPI,
-            signal,
+            controller,
         });
         let response$;
         try {
@@ -228,8 +228,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return response$
                 .catch((e) => handleErrorFromRequestHandler(e, fetchAPI.Response))
                 .then(response => {
-                if (!signal.aborted && !resEnded) {
-                    return sendResponseToUwsOpts(res, response, signal, fetchAPI);
+                if (!controller.signal.aborted && !resEnded) {
+                    return sendResponseToUwsOpts(res, response, controller, fetchAPI);
                 }
             })
                 .catch(err => {
@@ -237,8 +237,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
         }
         try {
-            if (!signal.aborted && !resEnded) {
-                return sendResponseToUwsOpts(res, response$, signal, fetchAPI);
+            if (!controller.signal.aborted && !resEnded) {
+                return sendResponseToUwsOpts(res, response$, controller, fetchAPI);
             }
         }
         catch (err) {

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.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) {

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,7 +36,7 @@ export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     let getReadableStream;
     if (method !== 'get' && method !== 'head') {
         duplex = 'half';
-        signal.addEventListener('abort', () => {
+        controller.signal.addEventListener('abort', () => {
             stop();
         });
         let 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);
         }
     });
     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.9.65",
+  "version": "0.9.66-alpha-20250205000734-b48a2e64484147e8ccb74c205803bb5cd4b7e948",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {

package/typings/plugins/useErrorHandling.d.cts

@@ -8,5 +8,5 @@ export declare class HTTPError extends Error {
     name: string;
     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

@@ -8,5 +8,5 @@ export declare class HTTPError extends Error {
     name: string;
     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 {};