From cf8926db2384e5248a2b8976cb97af563122359c Mon Sep 17 00:00:00 2001 From: "Alexis H. Munsayac" Date: Tue, 13 Oct 2026 10:19:28 +0800 Subject: [PATCH] fix(1.x): abort event.request.signal when the client disconnects On Node, vinxi builds the web request without a signal tied to the connection, so event.request.signal never aborted and API routes kept running after the client went away. - Wrap the request with a signal that aborts when the response closes before it was fully sent, or with the request error if the request failed. - Combine it with the original signal using AbortSignal.any, so the platform signal on web runtimes still applies. - Store the wrapped request on event.web, since it takes over the body and later getWebRequest calls must return the same request. Fixes #1753. Co-Authored-By: Claude Opus 5.5 --- .changeset/request-abort-signal.md | 5 ++ packages/start/src/server/fetchEvent.spec.ts | 73 ++++++++++++++++++++ packages/start/src/server/fetchEvent.ts | 34 ++++++++- 3 files changed, 111 insertions(+), 1 deletion(-) create mode 100644 .changeset/request-abort-signal.md diff --git a/.changeset/request-abort-signal.md b/.changeset/request-abort-signal.md new file mode 100644 index 000000000..3f51779fc --- /dev/null +++ b/.changeset/request-abort-signal.md @@ -0,0 +1,5 @@ +--- +"@solidjs/start": patch +--- + +Make `event.request.signal` abort when the client disconnects on Node. The request was built without a signal tied to the connection, so it never aborted and API routes kept running after the client went away. On web runtimes the platform signal still applies. diff --git a/packages/start/src/server/fetchEvent.spec.ts b/packages/start/src/server/fetchEvent.spec.ts index c67245e98..1c7cfec60 100644 --- a/packages/start/src/server/fetchEvent.spec.ts +++ b/packages/start/src/server/fetchEvent.spec.ts @@ -1,3 +1,4 @@ +import { EventEmitter } from "node:events"; import { H3Event } from "vinxi/http"; import { beforeEach, describe, expect, it, vi } from "vitest"; import { cloneEvent, createFetchEvent, getFetchEvent, mergeResponseHeaders } from "./fetchEvent"; @@ -319,3 +320,75 @@ describe("fetchEvent", () => { }); }); }); + +describe("request abort signal", () => { + const createNodeEvent = (request: Request) => { + const res = Object.assign(new EventEmitter(), { writableEnded: false }); + const req = { errored: null as Error | null }; + const event = { + node: { req, res }, + context: {}, + web: { request } + } as unknown as H3Event; + mockedVinxiHttp.getWebRequest.mockReturnValue(request); + return { event, req, res }; + }; + + beforeEach(() => { + vi.clearAllMocks(); + }); + + it("aborts when the response closes before it was sent", () => { + const { event, res } = createNodeEvent(new Request("http://localhost/api")); + const { request } = createFetchEvent(event); + expect(request.signal.aborted).toBe(false); + + res.emit("close"); + + expect(request.signal.aborted).toBe(true); + }); + + it("does not abort when the response closes after it was sent", () => { + const { event, res } = createNodeEvent(new Request("http://localhost/api")); + const { request } = createFetchEvent(event); + + res.writableEnded = true; + res.emit("close"); + + expect(request.signal.aborted).toBe(false); + }); + + it("aborts with the request error when the request failed", () => { + const { event, req, res } = createNodeEvent(new Request("http://localhost/api")); + const { request } = createFetchEvent(event); + const error = new Error("socket hang up"); + + req.errored = error; + res.emit("close"); + + expect(request.signal.aborted).toBe(true); + expect(request.signal.reason).toBe(error); + }); + + it("keeps the abort signal of the platform request", () => { + const controller = new AbortController(); + const { event } = createNodeEvent( + new Request("http://localhost/api", { signal: controller.signal }) + ); + const { request } = createFetchEvent(event); + + controller.abort(); + + expect(request.signal.aborted).toBe(true); + }); + + it("gives later readers the same request, with its body", async () => { + const { event } = createNodeEvent( + new Request("http://localhost/api", { method: "POST", body: "hello" }) + ); + const { request } = createFetchEvent(event); + + expect(event.web!.request).toBe(request); + expect(await request.text()).toBe("hello"); + }); +}); diff --git a/packages/start/src/server/fetchEvent.ts b/packages/start/src/server/fetchEvent.ts index 5cce3982f..e77bd65be 100644 --- a/packages/start/src/server/fetchEvent.ts +++ b/packages/start/src/server/fetchEvent.ts @@ -15,9 +15,41 @@ import type { FetchEvent, ResponseStub } from "./types"; const fetchEventContext = "solidFetchEvent"; +/** + * On Node, the web request vinxi builds has a signal that never aborts, so a + * handler cannot tell when the client goes away. This wires the signal to the + * response closing before it was fully sent. On web runtimes the platform + * request already has a working signal, and it is kept. + */ +function createWebRequest(event: H3Event): Request { + const request = getWebRequest(event); + const res = event.node?.res; + if (!res || typeof res.once !== "function") { + return request; + } + const controller = new AbortController(); + res.once("close", () => { + const error = event.node.req.errored; + if (error) { + controller.abort(error); + } else if (!res.writableEnded) { + controller.abort(); + } + }); + const wrapped = new Request(request, { + signal: AbortSignal.any([request.signal, controller.signal]) + }); + // The wrapped request takes over the body of the original one, so later + // calls to getWebRequest must get the wrapped request too. + if (event.web) { + event.web.request = wrapped; + } + return wrapped; +} + export function createFetchEvent(event: H3Event): FetchEvent { return { - request: getWebRequest(event), + request: createWebRequest(event), response: createResponseStub(event), clientAddress: getRequestIP(event), locals: {},