fix: add getRawRequest utility (#719)

Author: kettanaito

src/getRawRequest.ts

@@ -0,0 +1,17 @@
+export const kRawRequest = Symbol('kRawRequest')
+
+/**
+ * Returns a raw request instance associated with this request.
+ *
+ * @example
+ * interceptor.on('request', ({ request }) => {
+ *   const rawRequest = getRawRequest(request)
+ *
+ *   if (rawRequest instanceof http.ClientRequest) {
+ *     console.log(rawRequest.rawHeaders)
+ *   }
+ * })
+ */
+export function getRawRequest(request: Request): unknown | undefined {
+  return Reflect.get(request, kRawRequest)
+}

src/index.ts

@@ -7,3 +7,4 @@ export { createRequestId } from './createRequestId'
 export { getCleanUrl } from './utils/getCleanUrl'
 export { encodeBuffer, decodeBuffer } from './utils/bufferUtils'
 export { FetchResponse } from './utils/fetchUtils'
+export { getRawRequest } from './getRawRequest'

src/interceptors/ClientRequest/MockHttpSocket.ts

@@ -16,6 +16,7 @@ import { createServerErrorResponse } from '../../utils/responseUtils'
 import { createRequestId } from '../../createRequestId'
 import { getRawFetchHeaders } from './utils/recordRawHeaders'
 import { FetchResponse } from '../../utils/fetchUtils'
+import { kRawRequest } from '../../getRawRequest'
 
 type HttpConnectionOptions = any
 
@@ -514,6 +515,7 @@ export class MockHttpSocket extends MockSocket {
     })
 
     Reflect.set(this.request, kRequestId, requestId)
+    Reflect.set(this.request, kRawRequest, Reflect.get(this, '_httpMessage'))
 
     // Skip handling the request that's already being handled
     // by another (parent) interceptor. For example, XMLHttpRequest

src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts

@@ -15,6 +15,7 @@ import { createResponse } from './utils/createResponse'
 import { INTERNAL_REQUEST_ID_HEADER_NAME } from '../../Interceptor'
 import { createRequestId } from '../../createRequestId'
 import { getBodyByteLength } from './utils/getBodyByteLength'
+import { kRawRequest } from '../../getRawRequest'
 
 const kIsRequestHandled = Symbol('kIsRequestHandled')
 const IS_NODE = isNodeProcess()
@@ -698,6 +699,7 @@ export class XMLHttpRequestController {
       },
     })
     define(fetchRequest, 'headers', proxyHeaders)
+    Reflect.set(fetchRequest, kRawRequest, this.request)
 
     this.logger.info('converted request to a Fetch API Request!', fetchRequest)
 

src/interceptors/fetch/index.ts

@@ -12,6 +12,7 @@ import { followFetchRedirect } from './utils/followRedirect'
 import { decompressResponse } from './utils/decompression'
 import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
 import { FetchResponse } from '../../utils/fetchUtils'
+import { kRawRequest } from '../../getRawRequest'
 
 export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol('fetch')
@@ -45,13 +46,18 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
         typeof input === 'string' &&
         typeof location !== 'undefined' &&
         !canParseUrl(input)
-          ? new URL(
-              input,
-              location.href
-            )
+          ? new URL(input, location.href)
           : input
 
       const request = new Request(resolvedInput, init)
+
+      /**
+       * @note Set the raw request only if a Request instance was provided to fetch.
+       */
+      if (input instanceof Request) {
+        Reflect.set(request, kRawRequest, input)
+      }
+
       const responsePromise = new DeferredPromise<Response>()
       const controller = new RequestController(request)
 

test/features/get-raw-request.test.ts

@@ -0,0 +1,132 @@
+// @vitest-environment jsdom
+import { it, expect, afterAll, afterEach, beforeAll } from 'vitest'
+import http from 'node:http'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { BatchInterceptor, getRawRequest } from '../../src'
+import { ClientRequestInterceptor } from '../../src/interceptors/ClientRequest'
+import { XMLHttpRequestInterceptor } from '../../src/interceptors/XMLHttpRequest'
+import { FetchInterceptor } from '../../src/interceptors/fetch'
+import { createXMLHttpRequest } from '../helpers'
+
+const interceptor = new BatchInterceptor({
+  name: 'batch-interceptor',
+  interceptors: [
+    new ClientRequestInterceptor(),
+    new XMLHttpRequestInterceptor(),
+    new FetchInterceptor(),
+  ],
+})
+
+beforeAll(() => {
+  interceptor.apply()
+})
+
+afterEach(() => {
+  interceptor.removeAllListeners()
+})
+
+afterAll(() => {
+  interceptor.dispose()
+})
+
+it('returns a reference to a raw http.ClientRequest instance', async () => {
+  const rawRequestPromise = new DeferredPromise<http.ClientRequest>()
+
+  interceptor.on('request', ({ request, controller }) => {
+    const rawRequest = getRawRequest(request)
+    if (rawRequest instanceof http.ClientRequest) {
+      rawRequestPromise.resolve(rawRequest)
+    } else {
+      console.error(rawRequest)
+      rawRequestPromise.reject(
+        new Error('Expected rawRequest to be an instance of http.ClientRequest')
+      )
+    }
+
+    controller.respondWith(new Response())
+  })
+
+  http
+    .request('http://localhost', {
+      headers: {
+        'X-CustoM-HeadeR-NamE': 'value',
+      },
+    })
+    .end()
+
+  const rawRequest = await rawRequestPromise
+  expect(rawRequest).toBeInstanceOf(http.ClientRequest)
+  expect(rawRequest.getRawHeaderNames()).toContain('X-CustoM-HeadeR-NamE')
+})
+
+it('returns a reference to a raw XMLHttpRequest instance', async () => {
+  const rawRequestPromise = new DeferredPromise<XMLHttpRequest>()
+  interceptor.on('request', ({ request, controller }) => {
+    const rawRequest = getRawRequest(request)
+
+    if (rawRequest instanceof XMLHttpRequest) {
+      rawRequestPromise.resolve(rawRequest)
+    } else {
+      console.error(rawRequest)
+      rawRequestPromise.reject(
+        new Error('Expected rawRequest to be an instance of XMLHttpRequest')
+      )
+    }
+
+    controller.respondWith(new Response('hello world'))
+  })
+
+  await createXMLHttpRequest((request) => {
+    request.open('GET', 'http://localhost:3000')
+    request.withCredentials = true
+    request.send()
+  })
+
+  const rawRequest = await rawRequestPromise
+  expect(rawRequest).toBeInstanceOf(XMLHttpRequest)
+  expect(rawRequest.withCredentials).toBe(true)
+  expect(rawRequest.responseText).toBe('hello world')
+})
+
+it('returns a reference to a raw Request instance (fetch)', async () => {
+  const rawRequestPromise = new DeferredPromise<Request>()
+  interceptor.on('request', ({ request, controller }) => {
+    const rawRequest = getRawRequest(request)
+
+    if (rawRequest instanceof Request) {
+      rawRequestPromise.resolve(rawRequest)
+    } else {
+      console.error(rawRequest)
+      rawRequestPromise.reject(
+        new Error('Expected rawRequest to be an instance of XMLHttpRequest')
+      )
+    }
+
+    controller.respondWith(new Response('hello world'))
+  })
+
+  const request = new Request('http://localhost:3000')
+  await fetch(request)
+
+  const rawRequest = await rawRequestPromise
+  expect(rawRequest).toEqual(request)
+})
+
+it('returns undefined for a non-Request input (fetch)', async () => {
+  const rawRequestPromise = new DeferredPromise<undefined>()
+  interceptor.on('request', ({ request, controller }) => {
+    const rawRequest = getRawRequest(request)
+
+    if (typeof rawRequest === 'undefined') {
+      rawRequestPromise.resolve(rawRequest)
+    } else {
+      console.error(rawRequest)
+      rawRequestPromise.reject(new Error('Expected rawRequest to be undefined'))
+    }
+
+    controller.respondWith(new Response('hello world'))
+  })
+
+  await fetch('http://localhost:3000')
+  await expect(rawRequestPromise).resolves.toBeUndefined()
+})