@mswjs/interceptors 0.41.8 → 0.42.0

package/src/{RemoteHttpInterceptor.ts → remote-http-interceptor.ts}

@@ -1,14 +1,15 @@
-import { ChildProcess } from 'child_process'
-import { HttpRequestEventMap } from './glossary'
-import { Interceptor } from './Interceptor'
-import { BatchInterceptor } from './BatchInterceptor'
+import type { ChildProcess } from 'node:child_process'
+import { type HttpRequestEventMap, HttpResponseEvent } from './events/http'
+import { Interceptor } from './interceptor'
+import { BatchInterceptor } from './batch-interceptor'
 import { ClientRequestInterceptor } from './interceptors/ClientRequest'
-import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
-import { FetchInterceptor } from './interceptors/fetch'
-import { handleRequest } from './utils/handleRequest'
-import { RequestController } from './RequestController'
-import { FetchRequest, FetchResponse } from './utils/fetchUtils'
-import { isResponseError } from './utils/responseUtils'
+import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest/node'
+import { FetchInterceptor } from './interceptors/fetch/node'
+import { handleRequest } from './utils/handle-request'
+import { RequestController } from './request-controller'
+import { FetchRequest, FetchResponse } from './utils/fetch-utils'
+import { isResponseError } from './utils/response-utils'
+import { createLogger } from './utils/logger'
 
 export interface SerializedRequest {
   id: string
@@ -16,7 +17,7 @@ export interface SerializedRequest {
   method: string
   headers: Array<[string, string]>
   credentials: RequestCredentials
-  body: string
+  body: string | null
 }
 
 interface RevivedRequest extends Omit<SerializedRequest, 'url' | 'headers'> {
@@ -28,9 +29,11 @@ export interface SerializedResponse {
   status: number
   statusText: string
   headers: Array<[string, string]>
-  body: string
+  body: string | null
 }
 
+const logger = createLogger('remote-http')
+
 export class RemoteHttpInterceptor extends BatchInterceptor<
   [ClientRequestInterceptor, XMLHttpRequestInterceptor, FetchInterceptor]
 > {
@@ -62,10 +65,10 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
         body: ['GET', 'HEAD'].includes(request.method)
           ? null
           : await request.text(),
-      } as SerializedRequest)
+      } satisfies SerializedRequest)
 
-      this.logger.info(
-        'sent serialized request to the child:',
+      logger.verbose(
+        'sent serialized request to child: %s',
         serializedRequest
       )
 
@@ -108,7 +111,7 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
       })
 
       // Listen for the mocked response message from the parent.
-      this.logger.info(
+      logger.verbose(
         'add "message" listener to the parent process',
         handleParentMessage
       )
@@ -141,22 +144,24 @@ export interface RemoveResolverOptions {
 }
 
 export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
-  static symbol = Symbol('remote-resolver')
+  static symbol = Symbol.for('remote-http-resolver')
   private process: ChildProcess
 
   constructor(options: RemoveResolverOptions) {
-    super(RemoteHttpResolver.symbol)
+    super()
     this.process = options.process
   }
 
-  protected setup() {
-    const logger = this.logger.extend('setup')
+  protected predicate(): boolean {
+    return true
+  }
 
+  protected setup() {
     const handleChildMessage: NodeJS.MessageListener = async (message) => {
-      logger.info('received message from child!', message)
+      logger.verbose('received message from child %o', message)
 
       if (typeof message !== 'string' || !message.startsWith('request:')) {
-        logger.info('unknown message, ignoring...')
+        logger.verbose('unknown message, ignoring')
         return
       }
 
@@ -168,9 +173,9 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
       const requestJson = JSON.parse(
         serializedRequest,
         requestReviver
-      ) as RevivedRequest
+      ) satisfies RevivedRequest
 
-      logger.info('parsed intercepted request', requestJson)
+      logger.verbose('parsed intercepted request %o', requestJson)
 
       const request = new FetchRequest(requestJson.url, {
         method: requestJson.method,
@@ -180,69 +185,77 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
       })
 
       const controller = new RequestController(request, {
-        passthrough: () => {},
+        passthrough: () => {
+          // Intentionally empty.
+        },
         respondWith: async (response) => {
           if (isResponseError(response)) {
-            this.logger.info('received a network error!', { response })
+            logger.verbose('received a network error %o', { response })
             throw new Error('Not implemented')
           }
 
-          this.logger.info('received mocked response!', { response })
-
           const responseClone = FetchResponse.clone(response)
           const responseText = await responseClone.text()
 
-          // // Send the mocked response to the child process.
+          // Send the mocked response to the child process.
           const serializedResponse = JSON.stringify({
             status: response.status,
             statusText: response.statusText,
             headers: Array.from(response.headers.entries()),
             body: responseText,
-          } as SerializedResponse)
+          } satisfies SerializedResponse)
 
           this.process.send(
             `response:${requestJson.id}:${serializedResponse}`,
-            (error) => {
+            async (error) => {
               if (error) {
                 return
               }
 
               // Emit an optimistic "response" event at this point,
               // not to rely on the back-and-forth signaling for the sake of the event.
-              this.emitter.emit('response', {
-                request,
-                requestId: requestJson.id,
-                response: responseClone,
-                isMockedResponse: true,
-              })
+              await this.emitter.emitAsPromise(
+                new HttpResponseEvent({
+                  initiator: null,
+                  request,
+                  requestId: requestJson.id,
+                  response: responseClone,
+                  responseType: 'mock',
+                })
+              )
             }
           )
 
-          logger.info(
-            'sent serialized mocked response to the parent:',
+          logger.verbose(
+            'sent serialized mocked response to parent: %s',
             serializedResponse
           )
         },
         errorWith: (reason) => {
-          this.logger.info('request has errored!', { error: reason })
+          logger.verbose('request errored %o', { error: reason })
           throw new Error('Not implemented')
         },
+      }, {
+        logger,
+        requestId: requestJson.id,
       })
 
       await handleRequest({
+        initiator: null,
         request,
         requestId: requestJson.id,
         controller,
         emitter: this.emitter,
+        logger,
       })
     }
 
     this.subscriptions.push(() => {
       this.process.removeListener('message', handleChildMessage)
-      logger.info('removed the "message" listener from the child process!')
+      logger.verbose('removed "message" listener from child process')
     })
 
-    logger.info('adding a "message" listener to the child process')
+    logger.verbose('adding "message" listener to child process')
     this.process.addListener('message', handleChildMessage)
 
     this.process.once('error', () => this.dispose())

package/src/request-context.ts

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import type { Logger } from './utils/logger'
+
+interface RequestContext {
+  initiator: unknown
+  logger?: Logger
+  transformRequest?: (request: Request) => Request
+}
+
+export const requestContext = new AsyncLocalStorage<RequestContext>()
+
+export function runInRequestContext<T>(callback: () => T, logger?: Logger): T {
+  /**
+   * @note Never shadow an existing request context. Nested calls
+   * (e.g. a patched entry point re-entered synchronously, or a request
+   * made within the fetch/XMLHttpRequest interceptor context) must run
+   * within the parent context so the sockets they create capture it.
+   */
+  if (requestContext.getStore()) {
+    return callback()
+  }
+
+  /**
+   * @note The initiator is the callback's return value (e.g. the
+   * "ClientRequest" instance), so it cannot be known before running
+   * the callback. The context is mutated in place once the callback
+   * returns; readers hold the context object by reference and sample
+   * "initiator" only after the request has been written.
+   */
+  const context: RequestContext = {
+    initiator: undefined,
+    logger,
+  }
+
+  return requestContext.run(context, () => {
+    const initiator = callback()
+    context.initiator = initiator
+    return initiator
+  })
+}

package/src/{RequestController.test.ts → request-controller.test.ts}

@@ -1,9 +1,9 @@
-import { vi, it, expect } from 'vitest'
 import {
   RequestController,
   type RequestControllerSource,
-} from './RequestController'
-import { InterceptorError } from './InterceptorError'
+} from './request-controller'
+import { InterceptorError } from './interceptor-error'
+import type { Logger } from './utils/logger'
 
 const defaultSource = {
   passthrough() {},
@@ -41,6 +41,40 @@ it('handles a request when calling ".respondWith()" with a mocked response', asy
   await expect(response.text()).resolves.toBe('hello world')
 })
 
+it('logs a mocked resolution and response as a single message', async () => {
+  const info = vi.fn<Logger['info']>()
+  const logger = {
+    info,
+    verbose: vi.fn<Logger['verbose']>(),
+    isEnabled() {
+      return true
+    },
+  } satisfies Logger
+  const controller = new RequestController(
+    new Request('http://localhost'),
+    defaultSource,
+    { logger, requestId: 'request-id' }
+  )
+
+  controller.respondWith(
+    new Response(null, {
+      status: 201,
+      statusText: 'Created',
+      headers: {
+        'x-example': 'yes',
+      },
+    })
+  )
+
+  await vi.waitFor(() => {
+    expect(info).toHaveBeenCalledWith(
+      '[%s] mocked %s',
+      'request-id',
+      ['HTTP 201 Created', 'x-example: yes', '', ''].join('\n')
+    )
+  })
+})
+
 it('handles the request when calling ".errorWith()" with an error', async () => {
   const errorWith = vi.fn<RequestControllerSource['errorWith']>()
   const controller = new RequestController(new Request('http://localhost'), {

package/src/{RequestController.ts → request-controller.ts}

@@ -1,11 +1,16 @@
-import { DeferredPromise } from '@open-draft/deferred-promise'
 import { invariant } from 'outvariant'
-import { InterceptorError } from './InterceptorError'
+import { InterceptorError } from './interceptor-error'
+import { formatResponse, type Logger } from './utils/logger'
 
 export interface RequestControllerSource {
-  passthrough(): void
-  respondWith(response: Response): void
-  errorWith(reason?: unknown): void
+  passthrough(): void | Promise<void>
+  respondWith(response: Response): void | Promise<void>
+  errorWith(reason?: unknown): void | Promise<void>
+}
+
+interface RequestControllerOptions {
+  logger: Logger
+  requestId: string
 }
 
 export class RequestController {
@@ -22,16 +27,16 @@ export class RequestController {
    */
   public handled: Promise<void>
 
+  readonly #handled: PromiseWithResolvers<void>
+
   constructor(
     protected readonly request: Request,
-    protected readonly source: RequestControllerSource
+    protected readonly source: RequestControllerSource,
+    protected readonly options?: RequestControllerOptions
   ) {
     this.readyState = RequestController.PENDING
-    this.handled = new DeferredPromise<void>()
-  }
-
-  get #handled() {
-    return this.handled as DeferredPromise<void>
+    this.#handled = Promise.withResolvers<void>()
+    this.handled = this.#handled.promise
   }
 
   /**
@@ -47,6 +52,9 @@ export class RequestController {
     )
 
     this.readyState = RequestController.PASSTHROUGH
+    if (this.options) {
+      this.options.logger.info('[%s] passthrough', this.options.requestId)
+    }
     await this.source.passthrough()
     this.#handled.resolve()
   }
@@ -72,6 +80,13 @@ export class RequestController {
     )
 
     this.readyState = RequestController.RESPONSE
+    if (this.options?.logger.isEnabled('default')) {
+      const { logger, requestId } = this.options
+
+      void formatResponse(response).then((message) => {
+        logger.info('[%s] mocked %s', requestId, message)
+      })
+    }
     this.#handled.resolve()
 
     /**
@@ -103,6 +118,13 @@ export class RequestController {
     )
 
     this.readyState = RequestController.ERROR
+    if (this.options) {
+      this.options.logger.info(
+        '[%s] error %o',
+        this.options.requestId,
+        reason
+      )
+    }
     this.source.errorWith(reason)
     this.#handled.resolve()
   }

package/src/utils/{bufferUtils.test.ts → buffer-utils.test.ts}

@@ -1,5 +1,4 @@
-import { it, expect } from 'vitest'
-import { decodeBuffer, encodeBuffer } from './bufferUtils'
+import { decodeBuffer, encodeBuffer } from './buffer-utils'
 
 it('encodes utf-8 string', () => {
   const encoded = encodeBuffer('😁')

package/src/utils/buffer-utils.ts

@@ -0,0 +1,37 @@
+const encoder = new TextEncoder()
+
+export function encodeBuffer(text: string) {
+  return encoder.encode(text)
+}
+
+export function decodeBuffer(buffer: AllowSharedBufferSource, encoding?: string): string {
+  const decoder = new TextDecoder(encoding)
+  return decoder.decode(buffer)
+}
+
+/**
+ * Create an `ArrayBuffer` from the given `Uint8Array`.
+ * Takes the byte offset into account to produce the right buffer
+ * in the case when the buffer is bigger than the data view.
+ */
+export function toArrayBuffer(array: Uint8Array<ArrayBuffer>): ArrayBuffer {
+  return array.buffer.slice(
+    array.byteOffset,
+    array.byteOffset + array.byteLength
+  )
+}
+
+export function toBuffer(
+  data: string | Buffer | Uint8Array<ArrayBufferLike>,
+  encoding?: BufferEncoding
+): Buffer {
+  if (Buffer.isBuffer(data)) {
+    return data
+  }
+
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data.buffer)
+  }
+
+  return Buffer.from(data, encoding)
+}

package/src/utils/{cloneObject.test.ts → clone-object.test.ts}

@@ -1,5 +1,4 @@
-import { it, expect } from 'vitest'
-import { cloneObject } from './cloneObject'
+import { cloneObject } from './clone-object'
 
 it('clones a shallow object', () => {
   const original = { a: 1, b: 2, c: [1, 2, 3] }

package/src/utils/{cloneObject.ts → clone-object.ts}

@@ -1,27 +1,27 @@
-import { Logger } from '@open-draft/logger'
+import { createLogger } from './logger'
 
-const logger = new Logger('cloneObject')
+const logger = createLogger('clone-object')
 
 function isPlainObject(obj?: Record<string, any>): boolean {
-  logger.info('is plain object?', obj)
+  logger.verbose('is plain object? %o', obj)
 
   if (obj == null || !obj.constructor?.name) {
-    logger.info('given object is undefined, not a plain object...')
+    logger.verbose('given object is undefined, not a plain object')
     return false
   }
 
-  logger.info('checking the object constructor:', obj.constructor.name)
+  logger.verbose('checking object constructor: %s', obj.constructor.name)
   return obj.constructor.name === 'Object'
 }
 
 export function cloneObject<ObjectType extends Record<string, any>>(
   obj: ObjectType
 ): ObjectType {
-  logger.info('cloning object:', obj)
+  logger.verbose('cloning object %o', obj)
 
   const enumerableProperties = Object.entries(obj).reduce<Record<string, any>>(
     (acc, [key, value]) => {
-      logger.info('analyzing key-value pair:', key, value)
+      logger.verbose('analyzing key-value pair: %s %o', key, value)
 
       // Recursively clone only plain objects, omitting class instances.
       acc[key] = isPlainObject(value) ? cloneObject(value) : value
@@ -31,6 +31,6 @@ export function cloneObject<ObjectType extends Record<string, any>>(
   )
 
   return isPlainObject(obj)
-    ? enumerableProperties
+    ? (enumerableProperties as ObjectType)
     : Object.assign(Object.getPrototypeOf(obj), enumerableProperties)
 }

package/src/utils/{createProxy.test.ts → create-proxy.test.ts}

@@ -1,5 +1,4 @@
-import { vi, it, expect } from 'vitest'
-import { createProxy } from './createProxy'
+import { createProxy } from './create-proxy'
 
 it('does not interfere with default constructors', () => {
   const ProxyClass = createProxy(
@@ -59,7 +58,7 @@ it('does not interfere with existing descriptors', () => {
 
 it('infer prototype descriptors', () => {
   class Child {
-    ok: boolean
+    ok!: boolean
 
     set status(nextStatus: number) {
       this.ok = nextStatus >= 200 && nextStatus < 300
@@ -86,7 +85,10 @@ it('infer prototype descriptors', () => {
 
 it('spies on the constructor', () => {
   const OriginalClass = class {
-    constructor(public name: string, public age: number) {}
+    constructor(
+      public name: string,
+      public age: number
+    ) {}
   }
 
   const constructorCall = vi.fn<

package/src/utils/{createProxy.ts → create-proxy.ts}

@@ -1,4 +1,4 @@
-import { findPropertySource } from './findPropertySource'
+import { findPropertySource } from './find-property-source'
 
 export interface ProxyOptions<Target extends Record<string, any>> {
   constructorCall?(args: Array<unknown>, next: NextFunction<Target>): Target

package/src/utils/{fetchUtils.test.ts → fetch-utils.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { FetchRequest, FetchResponse } from './fetchUtils'
+import { FetchRequest, FetchResponse } from './fetch-utils'
 
 describe('FetchRequest', () => {
   const URL = 'https://example.com/'

package/src/utils/{fetchUtils.ts → fetch-utils.ts}

@@ -1,5 +1,6 @@
-import { canParseUrl } from './canParseUrl'
-import { getValueBySymbol } from './getValueBySymbol'
+import { copyRawHeaders } from '../interceptors/ClientRequest/utils/record-raw-headers'
+import { getValueBySymbol } from './get-value-by-symbol'
+import { isResponseError } from './response-utils'
 
 interface UndiciRequestState extends RequestInit {}
 
@@ -164,6 +165,27 @@ const kStatus = Symbol('kStatus')
 const kUrl = Symbol('kUrl')
 
 export class FetchResponse extends Response {
+  static from(response: Response, init?: FetchResponseInit): FetchResponse {
+    if (response instanceof FetchResponse) {
+      return response
+    }
+
+    if (isResponseError(response)) {
+      return response
+    }
+
+    const fetchResponse = new FetchResponse(response.body, {
+      url: init?.url ?? response.url,
+      status: init?.status || response.status,
+      statusText: init?.statusText ?? response.statusText,
+      headers: init?.headers ?? response.headers,
+    })
+
+    copyRawHeaders(response.headers, fetchResponse.headers)
+
+    return fetchResponse
+  }
+
   /**
    * Response status codes for responses that cannot have body.
    * @see https://fetch.spec.whatwg.org/#statuses
@@ -216,7 +238,7 @@ export class FetchResponse extends Response {
   }
 
   static setUrl(url: string | undefined, response: Response): void {
-    if (!url || url === 'about:' || !canParseUrl(url)) {
+    if (!url || url === 'about:' || !URL.canParse(url)) {
       return
     }
 
@@ -283,6 +305,9 @@ export class FetchResponse extends Response {
     }
   }
 
+  #status?: number
+  #url?: string
+
   constructor(body?: BodyInit | null, init: FetchResponseInit = {}) {
     const status = init.status ?? 200
     const safeStatus = FetchResponse.isConfigurableStatusCode(status)

package/src/utils/{findPropertySource.test.ts → find-property-source.test.ts}

@@ -1,5 +1,4 @@
-import { it, expect } from 'vitest'
-import { findPropertySource } from './findPropertySource'
+import { findPropertySource } from './find-property-source'
 
 it('returns the source for objects without prototypes', () => {
   const obj = Object.create(null)

package/src/utils/{getCleanUrl.test.ts → get-clean-url.test.ts}

@@ -1,5 +1,4 @@
-import { describe, it, expect } from 'vitest'
-import { getCleanUrl } from './getCleanUrl'
+import { getCleanUrl } from './get-clean-url'
 
 describe('getCleanUrl', () => {
   describe('given a URL without query parameters', () => {

package/src/utils/{getUrlByRequestOptions.test.ts → get-url-by-request-options.test.ts}

@@ -1,7 +1,6 @@
-import { it, expect } from 'vitest'
-import { Agent as HttpAgent } from 'http'
-import { RequestOptions, Agent as HttpsAgent } from 'https'
-import { getUrlByRequestOptions } from './getUrlByRequestOptions'
+import { Agent as HttpAgent } from 'node:http'
+import { RequestOptions, Agent as HttpsAgent } from 'node:https'
+import { getUrlByRequestOptions } from './get-url-by-request-options'
 
 it('returns a URL based on the basic RequestOptions', () => {
   expect(
@@ -130,9 +129,7 @@ it('use "hostname" if both "hostname" and "host" are specified', () => {
     path: '/resource',
   }
 
-  expect(getUrlByRequestOptions(options).href).toBe(
-    'https://hostname/resource'
-  )
+  expect(getUrlByRequestOptions(options).href).toBe('https://hostname/resource')
 })
 
 it('parses "host" in IPv6', () => {
@@ -149,7 +146,6 @@ it('parses "host" in IPv6', () => {
       path: '/resource',
     }).href
   ).toBe('http://[::1]/resource')
-
 })
 
 it('parses "host" and "port" in IPv6', () => {