From b3710520dfa3f993ff293d0cc841b38c52756511 Mon Sep 17 00:00:00 2001 From: Brenley Dueck Date: Wed, 18 Nov 2026 17:09:49 -0600 Subject: [PATCH] fix(start): send single-flight cookies as one semicolon-joined header --- .changeset/single-flight-cookie-header.md | 5 +++ packages/start/src/fns/handler.spec.ts | 40 ++++++++++++++++++----- packages/start/src/fns/handler.ts | 24 ++++++-------- 3 files changed, 47 insertions(+), 22 deletions(-) create mode 100644 .changeset/single-flight-cookie-header.md diff --git a/.changeset/single-flight-cookie-header.md b/.changeset/single-flight-cookie-header.md new file mode 100644 index 000000000..16e7b61e1 --- /dev/null +++ b/.changeset/single-flight-cookie-header.md @@ -0,0 +1,5 @@ +--- +"@solidjs/start": patch +--- + +Send the single-flight re-run request a single `; `-separated Cookie header with values kept as the browser sent them, so cookie parsers on Cloudflare Workers no longer read every cookie as one. diff --git a/packages/start/src/fns/handler.spec.ts b/packages/start/src/fns/handler.spec.ts index 2ef873fbe..24912ffec 100644 --- a/packages/start/src/fns/handler.spec.ts +++ b/packages/start/src/fns/handler.spec.ts @@ -1,13 +1,8 @@ import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"; -import { parseCookies } from "h3"; import type { FetchEvent } from "../server/types.ts"; import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent.ts"; import { getServerFunction } from "./registration.ts"; -vi.mock("h3", () => ({ - parseCookies: vi.fn(() => ({})), -})); - vi.mock("solid-js/web", () => ({ renderToString: vi.fn(), })); @@ -69,7 +64,6 @@ describe("createSingleFlightHeaders", () => { beforeEach(async () => { vi.clearAllMocks(); - vi.mocked(parseCookies).mockReturnValue({}); const module = await import("./handler.ts"); createSingleFlightHeaders = module.createSingleFlightHeaders; }); @@ -137,7 +131,6 @@ describe("createSingleFlightHeaders", () => { }); it("should let response cookies win over ones already on the request", () => { - vi.mocked(parseCookies).mockReturnValue({ session: "old" }); const sourceEvent = createMockFetchEvent({ cookie: "session=old" }); const redirect = new Response(null, { status: 302, @@ -150,7 +143,6 @@ describe("createSingleFlightHeaders", () => { }); it("should remove cookies cleared by the response", () => { - vi.mocked(parseCookies).mockReturnValue({ session: "abc123" }); const sourceEvent = createMockFetchEvent({ cookie: "session=abc123" }); const redirect = new Response(null, { status: 302, @@ -162,6 +154,38 @@ describe("createSingleFlightHeaders", () => { expect(result.get("cookie")).toBe(null); }); + it("should join multiple cookies into a single semicolon-separated header", () => { + const sourceEvent = createMockFetchEvent({ cookie: "theme=dark; session=abc" }, [ + "val=1234; Path=/", + ]); + + const append = vi.spyOn(Headers.prototype, "append"); + + const result = createSingleFlightHeaders(sourceEvent); + + expect(append).not.toHaveBeenCalledWith("cookie", expect.anything()); + expect(result.get("cookie")).toBe("theme=dark; session=abc; val=1234"); + append.mockRestore(); + }); + + it("should keep cookie values encoded as they were sent", () => { + const sourceEvent = createMockFetchEvent({ cookie: "token=a%2Bb%3D%3D; other=x" }, [ + "data=c%3Bd; Path=/", + ]); + + const result = createSingleFlightHeaders(sourceEvent); + + expect(result.get("cookie")).toBe("token=a%2Bb%3D%3D; other=x; data=c%3Bd"); + }); + + it("should send a nameless response cookie as its bare value", () => { + const sourceEvent = createMockFetchEvent({ cookie: "a=1" }, ["abc"]); + + const result = createSingleFlightHeaders(sourceEvent); + + expect(result.get("cookie")).toBe("a=1; abc"); + }); + it("should not copy non-cookie response headers onto the request", () => { const sourceEvent = createMockFetchEvent(); const redirect = new Response(null, { diff --git a/packages/start/src/fns/handler.ts b/packages/start/src/fns/handler.ts index 19892db88..74025d3ae 100644 --- a/packages/start/src/fns/handler.ts +++ b/packages/start/src/fns/handler.ts @@ -1,5 +1,5 @@ -import { parseSetCookie } from "cookie-es"; -import { type H3Event, parseCookies } from "h3"; +import { parseCookie, parseSetCookie } from "cookie-es"; +import type { H3Event } from "h3"; import { sharedConfig } from "solid-js"; import { renderToString } from "solid-js/web"; import { provideRequestEvent } from "solid-js/web/storage"; @@ -431,7 +431,8 @@ export function createSingleFlightHeaders(sourceEvent: FetchEvent, result?: unkn // update request headers on the underlying H3 event. const headers = new Headers(sourceEvent.request.headers); - const cookies = parseCookies(sourceEvent.nativeEvent); + // keep values encoded: a decoded `%3B` or `%25` would split or re-decode differently + const cookies = parseCookie(headers.get("cookie") ?? "", { decode: value => value }); const SetCookies = sourceEvent.response.headers.getSetCookie(); // cookies attached to the returned/thrown response (eg. `redirect(to, { headers })`) // haven't been merged onto the event response yet, but a browser round trip would @@ -439,16 +440,11 @@ export function createSingleFlightHeaders(sourceEvent: FetchEvent, result?: unkn // the ones on the event response, so they win on conflict. if (result instanceof Response) SetCookies.push(...result.headers.getSetCookie()); headers.delete("cookie"); - // let useH3Internals = false; - // if (sourceEvent.nativeEvent.node?.req) { - // useH3Internals = true; - // sourceEvent.nativeEvent.node.req.headers.cookie = ""; - // } SetCookies.forEach(cookie => { if (!cookie) return; // `parseSetCookie` returns undefined for forbidden cookie names and for // cookies with an empty name and value. - const parsed = parseSetCookie(cookie); + const parsed = parseSetCookie(cookie, { decode: false }); if (!parsed) return; const { maxAge, expires, name, value } = parsed; if (maxAge != null && maxAge <= 0) { @@ -461,11 +457,11 @@ export function createSingleFlightHeaders(sourceEvent: FetchEvent, result?: unkn } cookies[name] = value; }); - Object.entries(cookies).forEach(([key, value]) => { - headers.append("cookie", `${key}=${value}`); - // useH3Internals && - // (sourceEvent.nativeEvent.node.req.headers.cookie += `${key}=${value};`); - }); + // a single header: repeated `append` joins with ", " outside Node, which parsers read as one cookie + const cookie = Object.entries(cookies) + .map(([key, value]) => (key ? `${key}=${value}` : value)) + .join("; "); + if (cookie) headers.set("cookie", cookie); return headers; }