@depup/mswjs__interceptors 0.41.3-depup.0

package/src/interceptors/ClientRequest/utils/parserUtils.ts

@@ -0,0 +1,48 @@
+import type { Socket } from 'node:net'
+import { HTTPParser } from '_http_common'
+
+/**
+ * @see https://github.com/nodejs/node/blob/f3adc11e37b8bfaaa026ea85c1cf22e3a0e29ae9/lib/_http_common.js#L180
+ */
+export function freeParser(parser: HTTPParser<any>, socket?: Socket): void {
+  if (parser._consumed) {
+    parser.unconsume()
+  }
+
+  parser._headers = []
+  parser._url = ''
+  parser.socket = null
+  parser.incoming = null
+  parser.outgoing = null
+  parser.maxHeaderPairs = 2000
+  parser._consumed = false
+  parser.onIncoming = null
+
+  parser[HTTPParser.kOnHeaders] = null
+  parser[HTTPParser.kOnHeadersComplete] = null
+  parser[HTTPParser.kOnMessageBegin] = null
+  parser[HTTPParser.kOnMessageComplete] = null
+  parser[HTTPParser.kOnBody] = null
+  parser[HTTPParser.kOnExecute] = null
+  parser[HTTPParser.kOnTimeout] = null
+
+  parser.remove()
+  parser.free()
+
+  if (socket) {
+    /**
+     * @note Unassigning the socket's parser will fail this assertion
+     * if there's still some data being processed on the socket:
+     * @see https://github.com/nodejs/node/blob/4e1f39b678b37017ac9baa0971e3aeecd3b67b51/lib/_http_client.js#L613
+     */
+    if (socket.destroyed) {
+      // @ts-expect-error Node.js internals.
+      socket.parser = null
+    } else {
+      socket.once('end', () => {
+        // @ts-expect-error Node.js internals.
+        socket.parser = null
+      })
+    }
+  }
+}

package/src/interceptors/ClientRequest/utils/recordRawHeaders.test.ts

@@ -0,0 +1,258 @@
+// @vitest-environment node
+import { it, expect, afterEach } from 'vitest'
+import {
+  recordRawFetchHeaders,
+  restoreHeadersPrototype,
+  getRawFetchHeaders,
+} from './recordRawHeaders'
+
+const url = 'http://localhost'
+
+afterEach(() => {
+  restoreHeadersPrototype()
+})
+
+it('returns an empty list if no headers were set', () => {
+  expect(getRawFetchHeaders(new Headers())).toEqual([])
+  expect(getRawFetchHeaders(new Headers(undefined))).toEqual([])
+  expect(getRawFetchHeaders(new Headers({}))).toEqual([])
+  expect(getRawFetchHeaders(new Headers([]))).toEqual([])
+  expect(getRawFetchHeaders(new Request(url).headers)).toEqual([])
+  expect(getRawFetchHeaders(new Response().headers)).toEqual([])
+})
+
+it('records raw headers (Headers / object as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers({
+    'Content-Type': 'application/json',
+    'X-My-Header': '1',
+  })
+
+  expect(getRawFetchHeaders(headers)).toEqual([
+    ['Content-Type', 'application/json'],
+    ['X-My-Header', '1'],
+  ])
+  expect(Object.fromEntries(headers)).toEqual({
+    'content-type': 'application/json',
+    'x-my-header': '1',
+  })
+})
+
+it('records raw headers (Headers / array as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+
+  expect(getRawFetchHeaders(headers)).toEqual([['X-My-Header', '1']])
+  expect(Object.fromEntries(headers)).toEqual({
+    'x-my-header': '1',
+  })
+})
+
+it('records raw headers (Headers / Headers as init', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+
+  expect(getRawFetchHeaders(new Headers(headers))).toEqual([
+    ['X-My-Header', '1'],
+  ])
+})
+
+it('records raw headers added via ".set()"', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  headers.set('X-Another-Header', '2')
+
+  expect(getRawFetchHeaders(headers)).toEqual([
+    ['X-My-Header', '1'],
+    ['X-Another-Header', '2'],
+  ])
+})
+
+it('records raw headers added via ".append()"', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  headers.append('X-My-Header', '2')
+
+  expect(getRawFetchHeaders(headers)).toEqual([
+    ['X-My-Header', '1'],
+    ['X-My-Header', '2'],
+  ])
+})
+
+it('deletes the header when called ".delete()"', () => {
+  const headers = new Headers([['X-My-Header', '1']])
+  headers.delete('X-My-Header')
+
+  expect(getRawFetchHeaders(headers)).toEqual([])
+})
+
+it('records raw headers (Request / object as init)', () => {
+  recordRawFetchHeaders()
+  const request = new Request(url, {
+    headers: {
+      'Content-Type': 'application/json',
+      'X-My-Header': '1',
+    },
+  })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([
+    ['Content-Type', 'application/json'],
+    ['X-My-Header', '1'],
+  ])
+})
+
+it('records raw headers (Request / array as init)', () => {
+  recordRawFetchHeaders()
+  const request = new Request(url, {
+    headers: [['X-My-Header', '1']],
+  })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('records raw headers (Request / Headers as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  const request = new Request(url, { headers })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('records raw headers (Request / Request as init)', () => {
+  recordRawFetchHeaders()
+  const init = new Request(url, { headers: [['X-My-Header', '1']] })
+  const request = new Request(init)
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('preserves headers instanceof (Request / Request as init)', () => {
+  recordRawFetchHeaders()
+  const init = new Request(url, { headers: [['X-My-Header', '1']] })
+  new Request(init)
+  expect(init.headers).toBeInstanceOf(Headers)
+})
+
+it('preserves headers instanceof (Request / Request with Headers as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  const init = new Request(url, { headers })
+  new Request(init)
+  expect(init.headers).toBeInstanceOf(Headers)
+})
+
+it('preserves headers instanceof (Response / Response with Headers as init)', () => {
+  recordRawFetchHeaders()
+  const init = { headers: new Headers([['X-My-Header', '1']]) }
+  new Response(url, init)
+  expect(init.headers).toBeInstanceOf(Headers)
+})
+
+it('records raw headers (Request / Request+Headers as init)', () => {
+  recordRawFetchHeaders()
+  const init = new Request(url, { headers: [['X-My-Header', '1']] })
+  expect(getRawFetchHeaders(init.headers)).toEqual([['X-My-Header', '1']])
+
+  const request = new Request(init, {
+    headers: new Headers([['X-Another-Header', '2']]),
+  })
+
+  // Must merge the raw headers from the request init
+  // and the request instance itself.
+  expect(getRawFetchHeaders(request.headers)).toEqual([
+    ['X-My-Header', '1'],
+    ['X-Another-Header', '2'],
+  ])
+})
+
+it('records raw headers (Response / object as init)', () => {
+  recordRawFetchHeaders()
+  const response = new Response(null, {
+    headers: {
+      'Content-Type': 'application/json',
+      'X-My-Header': '1',
+    },
+  })
+
+  expect(getRawFetchHeaders(response.headers)).toEqual([
+    ['Content-Type', 'application/json'],
+    ['X-My-Header', '1'],
+  ])
+})
+
+it('records raw headers (Response / array as init)', () => {
+  recordRawFetchHeaders()
+  const response = new Response(null, {
+    headers: [['X-My-Header', '1']],
+  })
+
+  expect(getRawFetchHeaders(response.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('records raw headers (Response / Headers as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  const response = new Response(null, { headers })
+
+  expect(getRawFetchHeaders(response.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('stops recording once the patches are restored', () => {
+  restoreHeadersPrototype()
+
+  const headers = new Headers({ 'X-My-Header': '1' })
+  // Must return the normalized headers (no access to raw headers).
+  expect(getRawFetchHeaders(headers)).toEqual([['x-my-header', '1']])
+})
+
+it('overrides an existing header when calling ".set()"', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['a', '1']])
+  expect(headers.get('a')).toBe('1')
+
+  headers.set('a', '2')
+  expect(headers.get('a')).toBe('2')
+
+  const headersClone = new Headers(headers)
+  expect(headersClone.get('a')).toBe('2')
+})
+
+it('overrides an existing multi-value header when calling ".set()"', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([
+    ['a', '1'],
+    ['a', '2'],
+  ])
+  expect(headers.get('a')).toBe('1, 2')
+
+  headers.set('a', '3')
+  expect(headers.get('a')).toBe('3')
+})
+
+it('does not throw on using Headers before recording', () => {
+  // If the consumer constructs a Headers instance before
+  // the interceptor is enabled, it will have no internal symbol set.
+  const headers = new Headers()
+  recordRawFetchHeaders()
+  const request = new Request(url, { headers })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([])
+
+  request.headers.set('X-My-Header', '1')
+  expect(getRawFetchHeaders(request.headers)).toEqual([['X-My-Header', '1']])
+})
+
+/**
+ * @see https://github.com/mswjs/interceptors/issues/681
+ */
+it('isolates headers between different headers instances', async () => {
+  recordRawFetchHeaders()
+  const original = new Headers()
+  const firstClone = new Headers(original)
+  firstClone.set('Content-Type', 'application/json')
+  const secondClone = new Headers(original)
+
+  expect(original.get('Content-Type')).toBeNull()
+  expect(firstClone.get('Content-Type')).toBe('application/json')
+  expect(secondClone.get('Content-Type')).toBeNull()
+})

package/src/interceptors/ClientRequest/utils/recordRawHeaders.ts

@@ -0,0 +1,262 @@
+type HeaderTuple = [string, string]
+type RawHeaders = Array<HeaderTuple>
+type SetHeaderBehavior = 'set' | 'append'
+
+const kRawHeaders = Symbol('kRawHeaders')
+const kRestorePatches = Symbol('kRestorePatches')
+
+function recordRawHeader(
+  headers: Headers,
+  args: HeaderTuple,
+  behavior: SetHeaderBehavior
+) {
+  ensureRawHeadersSymbol(headers, [])
+  const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders
+
+  if (behavior === 'set') {
+    // When recording a set header, ensure we remove any matching existing headers.
+    for (let index = rawHeaders.length - 1; index >= 0; index--) {
+      if (rawHeaders[index][0].toLowerCase() === args[0].toLowerCase()) {
+        rawHeaders.splice(index, 1)
+      }
+    }
+  }
+
+  rawHeaders.push(args)
+}
+
+/**
+ * Define the raw headers symbol on the given `Headers` instance.
+ * If the symbol already exists, this function does nothing.
+ */
+function ensureRawHeadersSymbol(
+  headers: Headers,
+  rawHeaders: RawHeaders
+): void {
+  if (Reflect.has(headers, kRawHeaders)) {
+    return
+  }
+
+  defineRawHeadersSymbol(headers, rawHeaders)
+}
+
+/**
+ * Define the raw headers symbol on the given `Headers` instance.
+ * If the symbol already exists, it gets overridden.
+ */
+function defineRawHeadersSymbol(headers: Headers, rawHeaders: RawHeaders) {
+  Object.defineProperty(headers, kRawHeaders, {
+    value: rawHeaders,
+    enumerable: false,
+    // Mark the symbol as configurable so its value can be overridden.
+    // Overrides happen when merging raw headers from multiple sources.
+    // E.g. new Request(new Request(url, { headers }), { headers })
+    configurable: true,
+  })
+}
+
+/**
+ * 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 {
+    Headers: OriginalHeaders,
+    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.Headers = OriginalHeaders
+
+      globalThis.Request = OriginalRequest
+      globalThis.Response = OriginalResponse
+
+      Reflect.deleteProperty(Headers, kRestorePatches)
+    },
+    enumerable: false,
+    /**
+     * @note Mark this property as configurable
+     * so we can delete it using `Reflect.delete` during cleanup.
+     */
+    configurable: true,
+  })
+
+  Object.defineProperty(globalThis, 'Headers', {
+    enumerable: true,
+    writable: true,
+    value: new Proxy(Headers, {
+      construct(target, args, newTarget) {
+        const headersInit = args[0] || []
+
+        if (
+          headersInit instanceof Headers &&
+          Reflect.has(headersInit, kRawHeaders)
+        ) {
+          const headers = Reflect.construct(
+            target,
+            [Reflect.get(headersInit, kRawHeaders)],
+            newTarget
+          )
+          ensureRawHeadersSymbol(headers, [
+            /**
+             * @note Spread the retrieved headers to clone them.
+             * This prevents multiple Headers instances from pointing
+             * at the same internal "rawHeaders" array.
+             */
+            ...Reflect.get(headersInit, kRawHeaders),
+          ])
+          return headers
+        }
+
+        const headers = Reflect.construct(target, args, newTarget)
+
+        // 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)) {
+          const rawHeadersInit = Array.isArray(headersInit)
+            ? headersInit
+            : Object.entries(headersInit)
+          ensureRawHeadersSymbol(headers, rawHeadersInit)
+        }
+
+        return headers
+      },
+    }),
+  })
+
+  Headers.prototype.set = new Proxy(Headers.prototype.set, {
+    apply(target, thisArg, args: HeaderTuple) {
+      recordRawHeader(thisArg, args, 'set')
+      return Reflect.apply(target, thisArg, args)
+    },
+  })
+
+  Headers.prototype.append = new Proxy(Headers.prototype.append, {
+    apply(target, thisArg, args: HeaderTuple) {
+      recordRawHeader(thisArg, args, 'append')
+      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)
+    },
+  })
+
+  Object.defineProperty(globalThis, 'Request', {
+    enumerable: true,
+    writable: true,
+    value: new Proxy(Request, {
+      construct(target, args, newTarget) {
+        const request = Reflect.construct(target, args, newTarget)
+        const inferredRawHeaders: RawHeaders = []
+
+        // Infer raw headers from a `Request` instance used as init.
+        if (typeof args[0] === 'object' && args[0].headers != null) {
+          inferredRawHeaders.push(...inferRawHeaders(args[0].headers))
+        }
+
+        // Infer raw headers from the "headers" init argument.
+        if (typeof args[1] === 'object' && args[1].headers != null) {
+          inferredRawHeaders.push(...inferRawHeaders(args[1].headers))
+        }
+
+        if (inferredRawHeaders.length > 0) {
+          ensureRawHeadersSymbol(request.headers, inferredRawHeaders)
+        }
+
+        return request
+      },
+    }),
+  })
+
+  Object.defineProperty(globalThis, 'Response', {
+    enumerable: true,
+    writable: true,
+    value: new Proxy(Response, {
+      construct(target, args, newTarget) {
+        const response = Reflect.construct(target, args, newTarget)
+
+        if (typeof args[1] === 'object' && args[1].headers != null) {
+          ensureRawHeadersSymbol(
+            response.headers,
+            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 {
+  // If the raw headers recording failed for some reason,
+  // use the normalized header entries instead.
+  if (!Reflect.has(headers, kRawHeaders)) {
+    return Array.from(headers.entries())
+  }
+
+  const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders
+  return rawHeaders.length > 0 ? rawHeaders : 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
+ * instance out of it.
+ */
+function inferRawHeaders(headers: HeadersInit): RawHeaders {
+  if (headers instanceof Headers) {
+    return Reflect.get(headers, kRawHeaders) || []
+  }
+
+  return Reflect.get(new Headers(headers), kRawHeaders)
+}