Bump undici & TS (#9847)

* Bump undici & TS

* go back to ws

* Use Headers for casing

* fix callsite type

* remove .only()

* fix vitest pool dispatch

* fix comments

* Add better ts-expect-error comments

* set -> append

* changeset

* Address comments

Author: penalosa

.changeset/thin-ideas-stay.md

@@ -0,0 +1,8 @@
+---
+"@cloudflare/vite-plugin": patch
+"@cloudflare/vitest-pool-workers": patch
+"miniflare": patch
+"wrangler": patch
+---
+
+Upgrade Undici

fixtures/wildcard-modules/package.json

@@ -13,7 +13,7 @@
 	"devDependencies": {
 		"@cloudflare/workers-tsconfig": "workspace:*",
 		"@cloudflare/workers-types": "^4.20250712.0",
-		"undici": "^5.28.4",
+		"undici": "catalog:default",
 		"wrangler": "workspace:*"
 	},
 	"volta": {

packages/miniflare/src/http/fetch.ts

@@ -1,22 +1,15 @@
+import assert from "assert";
 import http from "http";
 import { IncomingRequestCfProperties } from "@cloudflare/workers-types/experimental";
 import * as undici from "undici";
+import { UndiciHeaders } from "undici/types/dispatcher";
 import NodeWebSocket from "ws";
 import { CoreHeaders, DeferredPromise } from "../workers";
 import { Request, RequestInfo, RequestInit } from "./request";
 import { Response } from "./response";
 import { coupleWebSocket, WebSocketPair } from "./websocket";
 
 const ignored = ["transfer-encoding", "connection", "keep-alive", "expect"];
-function headersFromIncomingRequest(req: http.IncomingMessage): undici.Headers {
-	const entries = Object.entries(req.headers).filter(
-		(pair): pair is [string, string | string[]] => {
-			const [name, value] = pair;
-			return !ignored.includes(name) && value !== undefined;
-		}
-	);
-	return new undici.Headers(Object.fromEntries(entries));
-}
 
 export async function fetch(
 	input: RequestInfo,
@@ -40,13 +33,13 @@ export async function fetch(
 
 		// Normalise request headers to a format ws understands, extracting the
 		// Sec-WebSocket-Protocol header as ws treats this differently
-		const headers: Record<string, string> = {};
+		const headers = new undici.Headers();
 		let protocols: string[] | undefined;
 		for (const [key, value] of request.headers.entries()) {
 			if (key.toLowerCase() === "sec-websocket-protocol") {
 				protocols = value.split(",").map((protocol) => protocol.trim());
 			} else {
-				headers[key] = value;
+				headers.append(key, value);
 			}
 		}
 
@@ -59,13 +52,13 @@ export async function fetch(
 		// Establish web socket connection
 		const ws = new NodeWebSocket(url, protocols, {
 			followRedirects: request.redirect === "follow",
-			headers,
+			headers: Object.fromEntries(headers.entries()),
 			...rejectUnauthorized,
 		});
 
 		const responsePromise = new DeferredPromise<Response>();
 		ws.once("upgrade", (req) => {
-			const headers = headersFromIncomingRequest(req);
+			const headers = convertUndiciHeadersToStandard(req.headers);
 			// Couple web socket with pair and resolve
 			const [worker, client] = Object.values(new WebSocketPair());
 			const couplePromise = coupleWebSocket(ws, client);
@@ -77,7 +70,7 @@ export async function fetch(
 			responsePromise.resolve(couplePromise.then(() => response));
 		});
 		ws.once("unexpected-response", (_, req) => {
-			const headers = headersFromIncomingRequest(req);
+			const headers = convertUndiciHeadersToStandard(req.headers);
 			const response = new Response(req, {
 				status: req.statusCode,
 				headers,
@@ -99,9 +92,74 @@ export type DispatchFetch = (
 ) => Promise<Response>;
 
 export type AnyHeaders = http.IncomingHttpHeaders | string[];
-function addHeader(/* mut */ headers: AnyHeaders, key: string, value: string) {
-	if (Array.isArray(headers)) headers.push(key, value);
-	else headers[key] = value;
+
+function isIterable(
+	headers: UndiciHeaders
+): headers is Iterable<[string, string | string[] | undefined]> {
+	return Symbol.iterator in Object(headers);
+}
+
+// See https://github.com/nodejs/undici/blob/main/docs/docs/api/Dispatcher.md?plain=1#L1151 for documentation
+function convertUndiciHeadersToStandard(
+	headers: NonNullable<UndiciHeaders>
+): undici.Headers {
+	// Array format: https://github.com/nodejs/undici/blob/main/docs/docs/api/Dispatcher.md?plain=1#L1157
+	if (Array.isArray(headers)) {
+		let name: string | undefined = undefined;
+		let value: string | undefined = undefined;
+		const standardHeaders = new undici.Headers();
+		for (const element of headers) {
+			if (name === undefined && value === undefined) {
+				name = element;
+			} else if (name !== undefined && value === undefined) {
+				value = element;
+			} else if (name !== undefined && value !== undefined) {
+				if (!ignored.includes(name)) {
+					standardHeaders.set(name, value);
+				}
+				name = undefined;
+				value = undefined;
+			}
+		}
+		// The string[] format for UndiciHeaders must have an even number of entries
+		// https://github.com/nodejs/undici/blob/main/docs/docs/api/Dispatcher.md?plain=1#L1157
+		assert(name === undefined && value === undefined);
+		return standardHeaders;
+	} else if (isIterable(headers)) {
+		const standardHeaders = new undici.Headers();
+		for (const [name, value] of headers) {
+			if (!ignored.includes(name)) {
+				if (!value) {
+					continue;
+				}
+				if (typeof value === "string") {
+					standardHeaders.append(name, value);
+				} else {
+					for (const v of value) {
+						standardHeaders.append(name, v);
+					}
+				}
+			}
+		}
+		return standardHeaders;
+	} else {
+		const standardHeaders = new undici.Headers();
+		for (const [name, value] of Object.entries(headers)) {
+			if (!ignored.includes(name)) {
+				if (!value) {
+					continue;
+				}
+				if (typeof value === "string") {
+					standardHeaders.append(name, value);
+				} else {
+					for (const v of value) {
+						standardHeaders.append(name, v);
+					}
+				}
+			}
+		}
+		return standardHeaders;
+	}
 }
 
 /**
@@ -135,22 +193,22 @@ export class DispatchFetchDispatcher extends undici.Dispatcher {
 	}
 
 	addHeaders(
-		/* mut */ headers: AnyHeaders,
+		/* mut */ headers: undici.Headers,
 		path: string // Including query parameters
 	) {
 		// Reconstruct URL using runtime origin specified with `dispatchFetch()`
 		const originalURL = this.userRuntimeOrigin + path;
-		addHeader(headers, CoreHeaders.ORIGINAL_URL, originalURL);
-		addHeader(headers, CoreHeaders.DISABLE_PRETTY_ERROR, "true");
+		headers.set(CoreHeaders.ORIGINAL_URL, originalURL);
+		headers.set(CoreHeaders.DISABLE_PRETTY_ERROR, "true");
 		if (this.cfBlobJson !== undefined) {
 			// Only add this header if a `cf` override was set
-			addHeader(headers, CoreHeaders.CF_BLOB, this.cfBlobJson);
+			headers.set(CoreHeaders.CF_BLOB, this.cfBlobJson);
 		}
 	}
 
 	dispatch(
 		/* mut */ options: undici.Dispatcher.DispatchOptions,
-		handler: undici.Dispatcher.DispatchHandlers
+		handler: undici.Dispatcher.DispatchHandler
 	): boolean {
 		let origin = String(options.origin);
 		// The first request in a redirect chain will always match the user origin
@@ -170,9 +228,11 @@ export class DispatchFetchDispatcher extends undici.Dispatcher {
 				path = url.pathname + url.search;
 			}
 
-			// ...and add special Miniflare headers for runtime requests
-			options.headers ??= {};
-			this.addHeaders(options.headers, path);
+			const headers = convertUndiciHeadersToStandard(options.headers ?? {});
+
+			this.addHeaders(headers, path);
+
+			options.headers = headers;
 
 			// Dispatch with runtime dispatcher to avoid certificate errors if using
 			// self-signed certificate

packages/miniflare/src/http/index.ts

@@ -5,7 +5,7 @@ export * from "./websocket";
 export * from "./server";
 export * from "./helpers";
 
-export { File, FormData, Headers } from "undici";
+export { FormData, Headers } from "undici";
 export type {
 	BodyInit,
 	HeadersInit,

packages/miniflare/src/plugins/core/proxy/types.ts

@@ -1,7 +1,7 @@
 import { Blob } from "buffer";
 import { arrayBuffer } from "stream/consumers";
 import { ReadableStream } from "stream/web";
-import { File, Headers } from "undici";
+import { Headers } from "undici";
 import { Request, RequestInit, Response } from "../../../http";
 import { PlatformImpl } from "../../../workers";
 import type {

packages/miniflare/test/http/fetch.spec.ts

@@ -107,7 +107,7 @@ test("fetch: includes headers from web socket upgrade response", async (t) => {
 		headers: { upgrade: "websocket" },
 	});
 	t.not(res.webSocket, undefined);
-	t.is(res.headers.get("set-cookie"), "key=value");
+	t.is(res.headers.getSetCookie()[0], "key=value");
 });
 const fetchDispatchCloseFlakyTest = flaky(async (t) => {
 	let clientCloses = 0;

packages/miniflare/test/plugins/core/proxy/client.spec.ts

@@ -8,7 +8,6 @@ import test, { ThrowsExpectation } from "ava";
 import {
 	DeferredPromise,
 	fetch,
-	File,
 	MessageEvent,
 	Miniflare,
 	ReplaceWorkersTypes,

packages/vitest-pool-workers/scripts/bundle.mjs

@@ -35,8 +35,8 @@ function map(specifier, target) {
 	return { [filePath]: targetPath };
 }
 const fetchMockPathMap = {
-	...map("undici/lib/client.js", "src/mock-agent/client.cjs"),
-	...map("undici/lib/pool.js", "src/mock-agent/pool.cjs"),
+	...map("undici/lib/dispatcher/client.js", "src/mock-agent/client.cjs"),
+	...map("undici/lib/dispatcher/pool.js", "src/mock-agent/pool.cjs"),
 	...map(
 		"undici/lib/mock/pending-interceptors-formatter.js",
 		"src/mock-agent/pending-interceptor-formatter.cjs"

packages/vitest-pool-workers/src/mock-agent/client.cjs

@@ -1,5 +1,5 @@
 const assert = require("node:assert");
-const DispatcherBase = require("undici/lib/dispatcher-base");
+const DispatcherBase = require("undici/lib/dispatcher/dispatcher-base");
 const { kDispatch, kClose, kDestroy } = require("undici/lib/core/symbols");
 const { getDispatcher } = require("./dispatcher.cjs");
 

packages/vitest-pool-workers/src/mock-agent/index.cjs

@@ -16,7 +16,7 @@ function resetMockAgent(agent) {
 
 	// Remove all pending interceptors
 	for (const mockClient of agent[kClients].values()) {
-		mockClient.deref()?.[kDispatches].splice(0);
+		mockClient.dispatcher?.[kDispatches].splice(0);
 	}
 	agent.assertNoPendingInterceptors();
 }