feat(toWebRequest): add request abort signal

src/utils/request.ts

@@ -352,6 +352,8 @@ export function getRequestURL(
  * **NOTE:** This function is not stable and might have edge cases that are not handled properly.
  */
 export function toWebRequest(event: H3Event) {
+  let abortSignal: AbortController | undefined;
+
   return (
     event.web?.request ||
     new Request(getRequestURL(event), {
@@ -360,6 +362,16 @@ export function toWebRequest(event: H3Event) {
       method: event.method,
       headers: event.headers,
       body: getRequestWebStream(event),
+      get signal() {
+        if (!abortSignal) {
+          abortSignal = new AbortController();
+
+          const abort = (err?: any) => abortSignal?.abort(err);
+          event.node.req.once("close", abort);
+          event.node.req.once("end", abort);
+        }
+        return abortSignal.signal;
+      },
     })
   );
 }

test/web.test.ts

@@ -1,11 +1,16 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { Server } from "node:http";
+import { Client } from "undici";
+import getPort from "get-port";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import {
   createApp,
   App,
   eventHandler,
   WebHandler,
   toWebHandler,
   readBody,
+  toWebRequest,
+  toNodeListener,
 } from "../src";
 
 describe("Web handler", () => {
@@ -66,3 +71,63 @@ describe("Web handler", () => {
     });
   });
 });
+
+describe("Web Request", () => {
+  let app: App;
+  let server: Server;
+  let client: Client;
+
+  beforeEach(async () => {
+    app = createApp({ debug: true });
+    server = new Server(toNodeListener(app));
+    const port = await getPort();
+    server.listen(port);
+    client = new Client(`http://localhost:${port}`);
+  });
+
+  afterEach(() => {
+    client.close();
+    server.close();
+  });
+
+  it("abort request", async () => {
+    let aborted = false;
+
+    app.use(
+      "/abort",
+      eventHandler(async (event) => {
+        const req = toWebRequest(event);
+        req.signal.addEventListener("abort", () => {
+          aborted = true;
+        });
+
+        return new ReadableStream({
+          async start(controller) {
+            while (!req.signal.aborted) {
+              controller.enqueue(
+                new TextEncoder().encode(new Date().toISOString() + "\n"),
+              );
+              await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            controller.close();
+          },
+        });
+      }),
+    );
+
+    const controller = new AbortController();
+    const response = await client.request({
+      path: "/abort",
+      method: "GET",
+      signal: controller.signal,
+    });
+    controller.abort();
+
+    expect(response.statusCode).toBe(200);
+    await expect(response.body.text()).rejects.toThrow("aborted");
+
+    // Node.js http1 variant needs a bit of time to process the abort
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(aborted).toBe(true);
+  });
+});