perf: drop undici from the Node network dispatcher (#870)

Author: harlan-zw

packages/script/package.json

@@ -142,7 +142,6 @@
 "std-env": "catalog:",
 "ufo": "catalog:",
 "ultrahtml": "catalog:",
-"undici": "catalog:",
 "unplugin": "catalog:",
 "unstorage": "catalog:",
 "valibot": "catalog:"

packages/script/src/runtime/server/utils/network-dispatcher.node.ts

@@ -1,23 +1,189 @@
+importtype{IncomingMessage,RequestOptions}from'node:http'
 importtype{CreateNetworkDispatcher,NetworkAddress}from'./network-host'
 import{lookup}from'node:dns'
-import{Agent,fetch}from'undici'
+import{AgentasHttpAgent,requestashttpRequest}from'node:http'
+import{AgentasHttpsAgent,requestashttpsRequest}from'node:https'
+import{Readable}from'node:stream'
+import{createBrotliDecompress,createGunzip,createInflate,constantsaszlibConstants}from'node:zlib'
+
+/**
+ * Node has no public API for a custom DNS lookup on `globalThis.fetch`, and the proxy
+ * needs one: the address is validated inside the socket connection, so a rebind between
+ * the check and the connect cannot slip past. So this is a fetch built on `node:http`,
+ * which does accept a lookup, rather than a fetch with an undici `Agent` bolted on.
+ * Keeping undici out saves roughly 1.6 MB from a traced Node server build.
+ */
+
+/** Statuses that must carry a null body, per fetch. */
+constNULL_BODY_STATUS=newSet([101,103,204,205,304])
+
+constACCEPTED_ENCODINGS='gzip, deflate, br'
+
+functiontoHeaderRecord(headers: HeadersInit|undefined): Record<string,string|string[]>{
+constrecord: Record<string,string|string[]>={}
+if(!headers)
+returnrecord
+constappend=(name: string,value: string)=>{
+constkey=name.toLowerCase()
+constexisting=record[key]
+if(existing===undefined)
+record[key]=value
+elseif(Array.isArray(existing))
+existing.push(value)
+else
+record[key]=[existing,value]
+}
+if(headersinstanceofHeaders){
+headers.forEach((value,name)=>append(name,value))
+}
+elseif(Array.isArray(headers)){
+for(const[name,value]ofheaders)append(name,value)
+}
+else{
+for(const[name,value]ofObject.entries(headers))append(name,String(value))
+}
+returnrecord
+}
+
+/** Node exposes duplicate response headers only through `rawHeaders`, and `set-cookie` needs them. */
+functiontoResponseHeaders(raw: string[]): Headers{
+constheaders=newHeaders()
+for(leti=0;i<raw.length;i+=2)
+headers.append(raw[i]!,raw[i+1]!)
+returnheaders
+}
+
+/**
+ * Decode the body the way fetch does, so callers see plain bytes and can keep treating
+ * `content-encoding` as a header to strip rather than a body format to handle.
+ */
+functiondecodeBody(response: IncomingMessage): Readable{
+constencodings=String(response.headers['content-encoding']||'')
+.split(',')
+.map(encoding=>encoding.trim().toLowerCase())
+.filter(Boolean)
+.reverse()
+
+// Tolerate an upstream that ends the stream without a proper trailer, the way fetch does.
+constflush={finishFlush: zlibConstants.Z_SYNC_FLUSH}
+letstream: Readable=response
+for(constencodingofencodings){
+if(encoding==='gzip'||encoding==='x-gzip')
+stream=stream.pipe(createGunzip(flush))
+elseif(encoding==='deflate'||encoding==='x-deflate')
+stream=stream.pipe(createInflate(flush))
+elseif(encoding==='br')
+stream=stream.pipe(createBrotliDecompress())
+else
+break// identity, or an encoding we do not decode; hand the bytes through untouched
+}
+returnstream
+}
+
+/** Byte length of a body fetch would send with a `content-length`, or null when it streams. */
+functionknownBodyLength(body: BodyInit|null|undefined): number|null{
+if(body===undefined||body===null)
+returnnull
+if(typeofbody==='string')
+returnBuffer.byteLength(body)
+if(bodyinstanceofURLSearchParams)
+returnBuffer.byteLength(body.toString())
+if(ArrayBuffer.isView(body))
+returnbody.byteLength
+if(bodyinstanceofArrayBuffer)
+returnbody.byteLength
+returnnull
+}
+
+functionwriteRequestBody(request: ReturnType<typeofhttpRequest>,body: BodyInit|null|undefined): void{
+if(body===undefined||body===null){
+request.end()
+return
+}
+if(typeofbody==='string'){
+request.end(body)
+return
+}
+if(bodyinstanceofReadableStream){
+Readable.fromWeb(bodyasParameters<typeofReadable.fromWeb>[0]).pipe(request)
+return
+}
+if(bodyinstanceofURLSearchParams){
+request.end(body.toString())
+return
+}
+if(ArrayBuffer.isView(body)){
+request.end(Buffer.from(body.buffer,body.byteOffset,body.byteLength))
+return
+}
+if(bodyinstanceofArrayBuffer){
+request.end(Buffer.from(body))
+return
+}
+request.destroy(newTypeError(`Unsupported proxy request body of type ${Object.prototype.toString.call(body)}`))
+}
+
+functionrequestThroughAgent(
+url: URL,
+init: RequestInit,
+agents: {http: HttpAgent,https: HttpsAgent},
+): Promise<Response>{
+constisSecure=url.protocol==='https:'
+constheaders=toHeaderRecord(init.headers)
+if(!('accept-encoding'inheaders))
+headers['accept-encoding']=ACCEPTED_ENCODINGS
+
+constmethod=(init.method||'GET').toUpperCase()
+if(headers['content-length']===undefined){
+constlength=knownBodyLength(init.body)
+if(length!==null)
+headers['content-length']=String(length)
+}
+
+constoptions: RequestOptions={
+ method,
+ headers,
+agent: isSecure ? agents.https : agents.http,
+signal: init.signal??undefined,
+}
+
+returnnewPromise<Response>((resolve,reject)=>{
+constrequest=(isSecure ? httpsRequest : httpRequest)(url,options,(response)=>{
+conststatus=response.statusCode??502
+constbody=NULL_BODY_STATUS.has(status)||method==='HEAD'
+ ? null
+ : Readable.toWeb(decodeBody(response))asReadableStream<Uint8Array>
+resolve(newResponse(body,{
+ status,
+statusText: response.statusMessage||'',
+headers: toResponseHeaders(response.rawHeaders),
+}))
+})
+request.on('error',reject)
+writeRequestBody(request,init.body)
+})
+}
 
 exportconstcreateNetworkDispatcher: CreateNetworkDispatcher=async(createLookup,resolveHostnameOverride)=>{
 constresolveHostname=resolveHostnameOverride||((hostname,callback)=>{
 lookup(hostname,{all: true,verbatim: true},(error,addresses)=>{
 callback(error,addressesasNetworkAddress[])
 })
 })
-constdispatcher=newAgent({
-connect:{
-lookup: createLookup(resolveHostname),
-},
-})
+constpinnedLookup=createLookup(resolveHostname)
+constagents={
+http: newHttpAgent({keepAlive: true,lookup: pinnedLookup}),
+https: newHttpsAgent({keepAlive: true,lookup: pinnedLookup}),
+}
 return{
-fetch: ((input,init)=>fetch(inputasstring|URL,{
- ...(initasunknownasNonNullable<Parameters<typeoffetch>[1]>),
- dispatcher,
-})asunknownasPromise<Response>)astypeofglobalThis.fetch,
-close: ()=>dispatcher.close(),
+fetch: ((input,init)=>requestThroughAgent(
+newURL(inputinstanceofRequest ? input.url : String(input)),
+init??{},
+agents,
+))astypeofglobalThis.fetch,
+close: async()=>{
+agents.http.destroy()
+agents.https.destroy()
+},
 }
 }

pnpm-lock.yaml

@@ -100,7 +100,6 @@ catalog:
 ufo: ^1.6.4
 ultrahtml: ^1.7.0
 unbuild: ^3.6.1
-undici: ^8.10.0
 unhead: ^3.3.1
 unimport: ^6.4.0
 unplugin: ^3.3.0