fix(server): use ServerResponse's close event to catch request cancellation

.changeset/young-trees-call.md

@@ -0,0 +1,5 @@
+---
+"@whatwg-node/server": patch
+---
+
+Use ServerResponse's close event to catch request cancellation

packages/server/src/createServerAdapter.ts

@@ -26,6 +26,7 @@ import {
   isServerResponse,
   iterateAsyncVoid,
   NodeRequest,
+  nodeRequestResponseMap,
   NodeResponse,
   normalizeNodeRequest,
   sendNodeResponse,
@@ -198,6 +199,7 @@ function createServerAdapter<
         waitUntilPromises.push(cb.catch(err => console.error(err)));
       },
     };
+    nodeRequestResponseMap.set(nodeRequest, serverResponse);
     let response$: Response | Promise<Response> | undefined;
     try {
       response$ = handleNodeRequest(nodeRequest, defaultServerContext as any, ...ctx);

packages/server/src/utils.ts

@@ -116,6 +116,8 @@ export class ServerAdapterRequestAbortSignal extends EventTarget implements Abor
 
 let bunNodeCompatModeWarned = false;
 
+export const nodeRequestResponseMap = new WeakMap<NodeRequest, NodeResponse>();
+
 export function normalizeNodeRequest(
   nodeRequest: NodeRequest,
   RequestCtor: typeof Request,
@@ -130,30 +132,34 @@ export function normalizeNodeRequest(
     fullUrl = url.toString();
   }
 
-  let signal: AbortSignal;
+  let signal: AbortSignal | undefined;
 
-  // If ponyfilled
-  if (RequestCtor !== globalThis.Request) {
-    signal = new ServerAdapterRequestAbortSignal();
+  const nodeResponse = nodeRequestResponseMap.get(nodeRequest);
+  nodeRequestResponseMap.delete(nodeRequest);
+  if (nodeResponse?.once) {
+    let sendAbortSignal: VoidFunction;
 
-    if (rawRequest?.once) {
-      rawRequest.once('close', () => {
-        if (rawRequest.aborted) {
-          (signal as ServerAdapterRequestAbortSignal).sendAbort();
-        }
-      });
-    }
-  } else {
-    const controller = new AbortController();
-    signal = controller.signal;
-
-    if (rawRequest.once) {
-      rawRequest.once('close', () => {
-        if (rawRequest.aborted) {
-          controller.abort();
-        }
-      });
+    // If ponyfilled
+    if (RequestCtor !== globalThis.Request) {
+      signal = new ServerAdapterRequestAbortSignal();
+      sendAbortSignal = () => (signal as ServerAdapterRequestAbortSignal).sendAbort();
+    } else {
+      const controller = new AbortController();
+      signal = controller.signal;
+      sendAbortSignal = () => controller.abort();
     }
+
+    let responseFinished = false;
+
+    nodeResponse.once('finish', () => {
+      responseFinished = true;
+    });
+
+    nodeResponse.once('close', () => {
+      if (!responseFinished && signal && !signal.aborted) {
+        sendAbortSignal();
+      }
+    });
   }
 
   if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {

packages/server/test/node.spec.ts

@@ -162,18 +162,22 @@ describe('Node Specific Cases', () => {
         const serverAdapter = createServerAdapter(
           req =>
             new Promise(resolve => {
-              req.signal.onabort = () => {
+              req.signal.addEventListener('abort', () => {
                 abortListener();
                 resolve(new Response('Hello World', { status: 200 }));
-              };
+              });
             }),
         );
         testServer.addOnceHandler(serverAdapter);
         const controller = new AbortController();
-        setTimeout(() => controller.abort(), 1000);
-        const error = await fetch(testServer.url, { signal: controller.signal }).catch(e => e);
+        const error$ = fetch(testServer.url, { signal: controller.signal }).catch(e => e);
+        await sleep(100);
+        expect(abortListener).toHaveBeenCalledTimes(0);
+        controller.abort();
+        await sleep(100);
+        const error = await error$;
         expect(error.toString().toLowerCase()).toContain('abort');
-        await new Promise(resolve => setTimeout(resolve, 300));
+        await sleep(100);
         expect(abortListener).toHaveBeenCalledTimes(1);
       });