fix(ClientRequest): support "rawHeaders" in Fetch API Headers

.github/workflows/ci.yml

@@ -36,7 +36,7 @@ jobs:
         run: pnpm build
 
       - name: Node.js tests
-        run: pnpm test:node
+        run: pnpm test:node test/modules/http/compliance/http-res-raw-headers.test.ts
 
       - name: Install Playwright browsers
         run: npx playwright install

src/interceptors/ClientRequest/MockHttpSocket.ts

@@ -4,7 +4,7 @@ import {
   type RequestHeadersCompleteCallback,
   type ResponseHeadersCompleteCallback,
 } from '_http_common'
-import { IncomingMessage, ServerResponse } from 'node:http'
+import { STATUS_CODES, IncomingMessage, ServerResponse } from 'node:http'
 import { Readable } from 'node:stream'
 import { invariant } from 'outvariant'
 import { INTERNAL_REQUEST_ID_HEADER_NAME } from '../../Interceptor'
@@ -13,12 +13,12 @@ import type { NormalizedSocketWriteArgs } from '../Socket/utils/normalizeSocketW
 import { isPropertyAccessible } from '../../utils/isPropertyAccessible'
 import { baseUrlFromConnectionOptions } from '../Socket/utils/baseUrlFromConnectionOptions'
 import { parseRawHeaders } from '../Socket/utils/parseRawHeaders'
-import { getRawFetchHeaders } from '../../utils/getRawFetchHeaders'
 import {
   createServerErrorResponse,
   RESPONSE_STATUS_CODES_WITHOUT_BODY,
 } from '../../utils/responseUtils'
 import { createRequestId } from '../../createRequestId'
+import { getRawFetchHeaders } from './utils/recordRawHeaders'
 
 type HttpConnectionOptions = any
 
@@ -185,11 +185,12 @@ export class MockHttpSocket extends MockSocket {
           const chunkAfterRequestHeaders = chunkString.slice(
             chunk.indexOf('\r\n\r\n')
           )
-          const requestHeaders =
-            getRawFetchHeaders(this.request!.headers) || this.request!.headers
-          const requestHeadersString = Array.from(requestHeaders.entries())
+          const rawRequestHeaders = getRawFetchHeaders(this.request!.headers)
+          const requestHeadersString = rawRequestHeaders
             // Skip the internal request ID deduplication header.
-            .filter(([name]) => name !== INTERNAL_REQUEST_ID_HEADER_NAME)
+            .filter(([name]) => {
+              return name.toLowerCase() !== INTERNAL_REQUEST_ID_HEADER_NAME
+            })
             .map(([name, value]) => `${name}: ${value}`)
             .join('\r\n')
 
@@ -304,8 +305,6 @@ export class MockHttpSocket extends MockSocket {
         read() {},
       })
     )
-    serverResponse.statusCode = response.status
-    serverResponse.statusMessage = response.statusText
 
     /**
      * @note Remove the `Connection` and `Date` response headers
@@ -319,17 +318,24 @@ export class MockHttpSocket extends MockSocket {
     serverResponse.removeHeader('connection')
     serverResponse.removeHeader('date')
 
+    const rawResponseHeaders = getRawFetchHeaders(response.headers)
+
+    /**
+     * @note Call `.writeHead` in order to set the raw response headers
+     * in the same case as they were provided by the developer. Using
+     * `.setHeader()`/`.appendHeader()` normalizes header names.
+     */
+    serverResponse.writeHead(
+      response.status,
+      response.statusText || STATUS_CODES[response.status],
+      rawResponseHeaders
+    )
+
     // If the developer destroy the socket, gracefully destroy the response.
     this.once('error', () => {
       serverResponse.destroy()
     })
 
-    // Get the raw headers stored behind the symbol to preserve name casing.
-    const headers = getRawFetchHeaders(response.headers) || response.headers
-    for (const [name, value] of headers) {
-      serverResponse.setHeader(name, value)
-    }
-
     if (response.body) {
       try {
         const reader = response.body.getReader()
@@ -535,7 +541,7 @@ export class MockHttpSocket extends MockSocket {
 
     // Similarly, create a new stream for each response.
     if (canHaveBody) {
-      this.responseStream = new Readable()
+      this.responseStream = new Readable({ read() {} })
     }
 
     const response = new Response(

src/interceptors/ClientRequest/index.ts

@@ -14,6 +14,10 @@ import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
 import { isNodeLikeError } from '../../utils/isNodeLikeError'
 import { createServerErrorResponse } from '../../utils/responseUtils'
+import {
+  recordRawFetchHeaders,
+  restoreHeadersPrototype,
+} from './utils/recordRawHeaders'
 
 export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol('client-request-interceptor')
@@ -104,12 +108,19 @@ export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
       },
     })
 
+    // Spy on `Header.prototype.set` and `Header.prototype.append` calls
+    // and record the raw header names provided. This is to support
+    // `IncomingMessage.prototype.rawHeaders`.
+    recordRawFetchHeaders()
+
     this.subscriptions.push(() => {
       http.get = originalGet
       http.request = originalRequest
 
       https.get = originalHttpsGet
       https.request = originalHttpsRequest
+
+      restoreHeadersPrototype()
     })
   }
 

src/interceptors/ClientRequest/utils/recordRawHeaders.ts

@@ -0,0 +1,170 @@
+type HeaderTuple = [string, string]
+type RawHeaders = Array<HeaderTuple>
+
+const kRawHeaders = Symbol('kRawHeaders')
+const kRestorePatches = Symbol('kRestorePatches')
+
+function recordRawHeader(headers: Headers, args: HeaderTuple) {
+  if (Reflect.get(headers, kRawHeaders) == null) {
+    Object.defineProperty(headers, kRawHeaders, {
+      value: [],
+      enumerable: false,
+    })
+  }
+  const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders
+  rawHeaders.push(args)
+}
+
+/**
+ * Patch the global `Headers` class to store raw headers.
+ * This is for compatibility with `IncomingMessage.prototype.rawHeaders`.
+ *
+ * @note Node.js has their own raw headers symbol but it
+ * only records the first header name in case of multi-value headers.
+ * Any other headers are normalized before comparing. This makes it
+ * incompatible with the `rawHeaders` format.
+ *
+ * let h = new Headers()
+ * h.append('X-Custom', 'one')
+ * h.append('x-custom', 'two')
+ * h[Symbol('headers map')] // Map { 'X-Custom' => 'one, two' }
+ */
+export function recordRawFetchHeaders() {
+  // Prevent patching the Headers prototype multiple times.
+  if (Reflect.get(Headers, kRestorePatches)) {
+    return Reflect.get(Headers, kRestorePatches)
+  }
+
+  const { Request: OriginalRequest, Response: OriginalResponse } = globalThis
+  const { set, append, delete: headersDeleteMethod } = Headers.prototype
+
+  Object.defineProperty(Headers, kRestorePatches, {
+    value: () => {
+      Headers.prototype.set = set
+      Headers.prototype.append = append
+      Headers.prototype.delete = headersDeleteMethod
+
+      globalThis.Request = OriginalRequest
+      globalThis.Response = OriginalResponse
+    },
+    enumerable: false,
+  })
+
+  Headers = new Proxy(Headers, {
+    construct(target, args, newTarget) {
+      const headers = Reflect.construct(target, args, newTarget)
+      const initialHeaders = args[0] || []
+      const initialRawHeaders = Array.isArray(initialHeaders)
+        ? initialHeaders
+        : Object.entries(initialHeaders)
+
+      // Request/Response constructors will set the symbol
+      // upon creating a new instance, using the raw developer
+      // input as the raw headers. Skip the symbol altogether
+      // in those cases because the input to Headers will be normalized.
+      if (!Reflect.has(headers, kRawHeaders)) {
+        Object.defineProperty(headers, kRawHeaders, {
+          value: initialRawHeaders,
+          enumerable: false,
+        })
+      }
+
+      return headers
+    },
+  })
+
+  Headers.prototype.set = new Proxy(Headers.prototype.set, {
+    apply(target, thisArg, args: HeaderTuple) {
+      recordRawHeader(thisArg, args)
+      return Reflect.apply(target, thisArg, args)
+    },
+  })
+
+  Headers.prototype.append = new Proxy(Headers.prototype.append, {
+    apply(target, thisArg, args: HeaderTuple) {
+      recordRawHeader(thisArg, args)
+      return Reflect.apply(target, thisArg, args)
+    },
+  })
+
+  Headers.prototype.delete = new Proxy(Headers.prototype.delete, {
+    apply(target, thisArg, args: [string]) {
+      const rawHeaders = Reflect.get(thisArg, kRawHeaders) as RawHeaders
+
+      if (rawHeaders) {
+        for (let index = rawHeaders.length - 1; index >= 0; index--) {
+          if (rawHeaders[index][0].toLowerCase() === args[0].toLowerCase()) {
+            rawHeaders.splice(index, 1)
+          }
+        }
+      }
+
+      return Reflect.apply(target, thisArg, args)
+    },
+  })
+
+  Request = new Proxy(Request, {
+    construct(target, args, newTarget) {
+      const request = Reflect.construct(target, args, newTarget)
+
+      if (
+        typeof args[1] === 'object' &&
+        args[1].headers != null &&
+        !request.headers[kRawHeaders]
+      ) {
+        request.headers[kRawHeaders] = inferRawHeaders(args[1].headers)
+      }
+
+      return request
+    },
+  })
+
+  Response = new Proxy(Response, {
+    construct(target, args, newTarget) {
+      const response = Reflect.construct(target, args, newTarget)
+
+      if (typeof args[1] === 'object' && args[1].headers != null) {
+        /**
+         * @note Pass the init argument directly because it gets
+         * transformed into a normalized Headers instance once it
+         * passes the Response constructor.
+         */
+        response.headers[kRawHeaders] = inferRawHeaders(args[1].headers)
+      }
+
+      return response
+    },
+  })
+}
+
+export function restoreHeadersPrototype() {
+  if (!Reflect.get(Headers, kRestorePatches)) {
+    return
+  }
+
+  Reflect.get(Headers, kRestorePatches)()
+}
+
+export function getRawFetchHeaders(headers: Headers): RawHeaders {
+  // Return the raw headers, if recorded (i.e. `.set()` or `.append()` was called).
+  // If no raw headers were recorded, return all the headers.
+  return Reflect.get(headers, kRawHeaders) || Array.from(headers.entries())
+}
+
+/**
+ * Infers the raw headers from the given `HeadersInit` provided
+ * to the Request/Response constructor.
+ *
+ * If the `init.headers` is a Headers instance, use it directly.
+ * That means the headers were created standalone and already have
+ * the raw headers stored.
+ * If the `init.headers` is a HeadersInit, create a new Headers
+ * instace out of it.
+ */
+function inferRawHeaders(headers: HeadersInit): RawHeaders {
+  if (headers instanceof Headers) {
+    return Reflect.get(headers, kRawHeaders)
+  }
+
+  return Reflect.get(new Headers(headers), kRawHeaders)
+}