@mswjs/interceptors 0.41.9 → 0.42.0

package/src/interceptors/Socket/utils/normalizeSocketWriteArgs.test.ts

@@ -1,52 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { it, expect } from 'vitest'
-import { normalizeSocketWriteArgs } from './normalizeSocketWriteArgs'
-
-it('normalizes .write()', () => {
-  expect(normalizeSocketWriteArgs([undefined])).toEqual([
-    undefined,
-    undefined,
-    undefined,
-  ])
-  expect(normalizeSocketWriteArgs([null])).toEqual([null, undefined, undefined])
-})
-
-it('normalizes .write(chunk)', () => {
-  expect(normalizeSocketWriteArgs([Buffer.from('hello')])).toEqual([
-    Buffer.from('hello'),
-    undefined,
-    undefined,
-  ])
-  expect(normalizeSocketWriteArgs(['hello'])).toEqual([
-    'hello',
-    undefined,
-    undefined,
-  ])
-  expect(normalizeSocketWriteArgs([null])).toEqual([null, undefined, undefined])
-})
-
-it('normalizes .write(chunk, encoding)', () => {
-  expect(normalizeSocketWriteArgs([Buffer.from('hello'), 'utf8'])).toEqual([
-    Buffer.from('hello'),
-    'utf8',
-    undefined,
-  ])
-})
-
-it('normalizes .write(chunk, callback)', () => {
-  const callback = () => {}
-  expect(normalizeSocketWriteArgs([Buffer.from('hello'), callback])).toEqual([
-    Buffer.from('hello'),
-    undefined,
-    callback,
-  ])
-})
-
-it('normalizes .write(chunk, encoding, callback)', () => {
-  const callback = () => {}
-  expect(
-    normalizeSocketWriteArgs([Buffer.from('hello'), 'utf8', callback])
-  ).toEqual([Buffer.from('hello'), 'utf8', callback])
-})

package/src/interceptors/Socket/utils/normalizeSocketWriteArgs.ts

@@ -1,33 +0,0 @@
-export type WriteCallback = (error?: Error | null) => void
-
-export type WriteArgs =
-  | [chunk: unknown, callback?: WriteCallback]
-  | [chunk: unknown, encoding: BufferEncoding, callback?: WriteCallback]
-
-export type NormalizedSocketWriteArgs = [
-  chunk: any,
-  encoding?: BufferEncoding,
-  callback?: WriteCallback,
-]
-
-/**
- * Normalizes the arguments provided to the `Writable.prototype.write()`
- * and `Writable.prototype.end()`.
- */
-export function normalizeSocketWriteArgs(
-  args: WriteArgs
-): NormalizedSocketWriteArgs {
-  const normalized: NormalizedSocketWriteArgs = [args[0], undefined, undefined]
-
-  if (typeof args[1] === 'string') {
-    normalized[1] = args[1]
-  } else if (typeof args[1] === 'function') {
-    normalized[2] = args[1]
-  }
-
-  if (typeof args[2] === 'function') {
-    normalized[2] = args[2]
-  }
-
-  return normalized
-}

package/src/interceptors/XMLHttpRequest/index.ts

@@ -1,40 +0,0 @@
-import { Emitter } from 'strict-event-emitter'
-import { HttpRequestEventMap } from '../../glossary'
-import { Interceptor } from '../../Interceptor'
-import { createXMLHttpRequestProxy } from './XMLHttpRequestProxy'
-import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
-import { patchesRegistry } from '../../utils/patchesRegistry'
-
-export type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>
-
-export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
-  static symbol = Symbol.for('xhr-interceptor')
-
-  constructor() {
-    super(XMLHttpRequestInterceptor.symbol)
-  }
-
-  protected checkEnvironment() {
-    return hasConfigurableGlobal('XMLHttpRequest')
-  }
-
-  protected setup() {
-    const logger = this.logger.extend('setup')
-
-    logger.info('patching global XMLHttpRequest...')
-
-    this.subscriptions.push(
-      patchesRegistry.applyPatch(globalThis, 'XMLHttpRequest', () => {
-        return createXMLHttpRequestProxy({
-          emitter: this.emitter,
-          logger: this.logger,
-        })
-      })
-    )
-
-    logger.info(
-      'global XMLHttpRequest patched!',
-      globalThis.XMLHttpRequest.name
-    )
-  }
-}

package/src/interceptors/fetch/index.ts

@@ -1,203 +0,0 @@
-import { until } from '@open-draft/until'
-import { DeferredPromise } from '@open-draft/deferred-promise'
-import { HttpRequestEventMap } from '../../glossary'
-import { Interceptor } from '../../Interceptor'
-import { RequestController } from '../../RequestController'
-import { emitAsync } from '../../utils/emitAsync'
-import { handleRequest } from '../../utils/handleRequest'
-import { canParseUrl } from '../../utils/canParseUrl'
-import { createRequestId } from '../../createRequestId'
-import { createNetworkError } from './utils/createNetworkError'
-import { followFetchRedirect } from './utils/followRedirect'
-import { decompressResponse } from './utils/decompression'
-import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
-import { FetchRequest, FetchResponse } from '../../utils/fetchUtils'
-import { setRawRequest } from '../../getRawRequest'
-import { isResponseError } from '../../utils/responseUtils'
-import { patchesRegistry } from '../../utils/patchesRegistry'
-
-export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
-  static symbol = Symbol.for('fetch-interceptor')
-
-  constructor() {
-    super(FetchInterceptor.symbol)
-  }
-
-  protected checkEnvironment() {
-    return hasConfigurableGlobal('fetch')
-  }
-
-  protected async setup() {
-    const logger = this.logger.extend('setup')
-
-    const pureFetch = globalThis.fetch
-
-    const fetchProxy: typeof fetch = async (input, init) => {
-      const requestId = createRequestId()
-
-      /**
-       * @note Resolve potentially relative request URL
-       * against the present `location`. This is mainly
-       * for native `fetch` in JSDOM.
-       * @see https://github.com/mswjs/msw/issues/1625
-       */
-      const resolvedInput =
-        typeof input === 'string' &&
-        typeof location !== 'undefined' &&
-        !canParseUrl(input)
-          ? new URL(input, location.href)
-          : input
-
-      const request = new FetchRequest(resolvedInput, init)
-
-      /**
-       * @note Set the raw request only if a Request instance was provided to fetch.
-       */
-      if (input instanceof Request) {
-        setRawRequest(request, input)
-      }
-
-      const responsePromise = new DeferredPromise<Response>()
-
-      const controller = new RequestController(request, {
-        passthrough: async () => {
-          this.logger.info('request has not been handled, passthrough...')
-
-          /**
-           * @note Clone the request instance right before performing it.
-           * This preserves any modifications made to the intercepted request
-           * in the "request" listener. This also allows the user to read the
-           * request body in the "response" listener (otherwise "unusable").
-           */
-          const requestCloneForResponseEvent = request.clone()
-
-          // Perform the intercepted request as-is.
-          const { error: responseError, data: originalResponse } = await until(
-            () => pureFetch(request)
-          )
-
-          if (responseError) {
-            return responsePromise.reject(responseError)
-          }
-
-          this.logger.info('original fetch performed', originalResponse)
-
-          if (this.emitter.listenerCount('response') > 0) {
-            this.logger.info('emitting the "response" event...')
-
-            const responseClone = FetchResponse.clone(originalResponse)
-            await emitAsync(this.emitter, 'response', {
-              response: responseClone,
-              isMockedResponse: false,
-              request: requestCloneForResponseEvent,
-              requestId,
-            })
-          }
-
-          // Resolve the response promise with the original response
-          // since the `fetch()` return this internal promise.
-          responsePromise.resolve(originalResponse)
-        },
-        respondWith: async (rawResponse) => {
-          // Handle mocked `Response.error()` (i.e. request errors).
-          if (isResponseError(rawResponse)) {
-            this.logger.info('request has errored!', { response: rawResponse })
-            responsePromise.reject(createNetworkError(rawResponse))
-            return
-          }
-
-          this.logger.info('received mocked response!', {
-            rawResponse,
-          })
-
-          // Decompress the mocked response body, if applicable.
-          const decompressedStream = decompressResponse(rawResponse)
-          const response = new FetchResponse(
-            decompressedStream || rawResponse.body,
-            {
-              url: request.url,
-              status: rawResponse.status,
-              statusText: rawResponse.statusText,
-              headers: rawResponse.headers,
-            }
-          )
-
-          /**
-           * Undici's handling of following redirect responses.
-           * Treat the "manual" redirect mode as a regular mocked response.
-           * This way, the client can manually follow the redirect it receives.
-           * @see https://github.com/nodejs/undici/blob/a6dac3149c505b58d2e6d068b97f4dc993da55f0/lib/web/fetch/index.js#L1173
-           */
-          if (FetchResponse.isRedirectResponse(response.status)) {
-            // Reject the request promise if its `redirect` is set to `error`
-            // and it receives a mocked redirect response.
-            if (request.redirect === 'error') {
-              responsePromise.reject(createNetworkError('unexpected redirect'))
-              return
-            }
-
-            if (request.redirect === 'follow') {
-              followFetchRedirect(request, response).then(
-                (response) => {
-                  responsePromise.resolve(response)
-                },
-                (reason) => {
-                  responsePromise.reject(reason)
-                }
-              )
-              return
-            }
-          }
-
-          if (this.emitter.listenerCount('response') > 0) {
-            this.logger.info('emitting the "response" event...')
-
-            // Await the response listeners to finish before resolving
-            // the response promise. This ensures all your logic finishes
-            // before the interceptor resolves the pending response.
-            await emitAsync(this.emitter, 'response', {
-              // Clone the mocked response for the "response" event listener.
-              // This way, the listener can read the response and not lock its body
-              // for the actual fetch consumer.
-              response: FetchResponse.clone(response),
-              isMockedResponse: true,
-              request,
-              requestId,
-            })
-          }
-
-          responsePromise.resolve(response)
-        },
-        errorWith: (reason) => {
-          this.logger.info('request has been aborted!', { reason })
-          responsePromise.reject(reason)
-        },
-      })
-
-      this.logger.info('[%s] %s', request.method, request.url)
-      this.logger.info('awaiting for the mocked response...')
-
-      this.logger.info(
-        'emitting the "request" event for %s listener(s)...',
-        this.emitter.listenerCount('request')
-      )
-
-      await handleRequest({
-        request,
-        requestId,
-        emitter: this.emitter,
-        controller,
-      })
-
-      return responsePromise
-    }
-
-    logger.info('patching global fetch...')
-
-    this.subscriptions.push(
-      patchesRegistry.applyPatch(globalThis, 'fetch', () => fetchProxy)
-    )
-
-    logger.info('global fetch patched!', globalThis.fetch.name)
-  }
-}

package/src/utils/bufferUtils.ts

@@ -1,22 +0,0 @@
-const encoder = new TextEncoder()
-
-export function encodeBuffer(text: string): Uint8Array {
-  return encoder.encode(text)
-}
-
-export function decodeBuffer(buffer: ArrayBuffer, 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 {
-  return array.buffer.slice(
-    array.byteOffset,
-    array.byteOffset + array.byteLength
-  )
-}

package/src/utils/canParseUrl.ts

@@ -1,13 +0,0 @@
-/**
- * Returns a boolean indicating whether the given URL string
- * can be parsed into a `URL` instance.
- * A substitute for `URL.canParse()` for Node.js 18.
- */
-export function canParseUrl(url: string): boolean {
-  try {
-    new URL(url)
-    return true
-  } catch (_error) {
-    return false
-  }
-}

package/src/utils/emitAsync.ts

@@ -1,25 +0,0 @@
-import { Emitter, EventMap } from 'strict-event-emitter'
-
-/**
- * Emits an event on the given emitter but executes
- * the listeners sequentially. This accounts for asynchronous
- * listeners (e.g. those having "sleep" and handling the request).
- */
-export async function emitAsync<
-  Events extends EventMap,
-  EventName extends keyof Events
->(
-  emitter: Emitter<Events>,
-  eventName: EventName,
-  ...data: Events[EventName]
-): Promise<void> {
-  const listeners = emitter.listeners(eventName)
-
-  if (listeners.length === 0) {
-    return
-  }
-
-  for (const listener of listeners) {
-    await listener.apply(emitter, data)
-  }
-}

package/src/utils/nextTick.ts

@@ -1,11 +0,0 @@
-export function nextTick(callback: () => void) {
-  setTimeout(callback, 0)
-}
-
-export function nextTickAsync(callback: () => void) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(callback())
-    }, 0)
-  })
-}

package/src/utils/node/index.ts

@@ -1,39 +0,0 @@
-import { ClientRequest } from 'node:http'
-import { Readable } from 'node:stream'
-import { invariant } from 'outvariant'
-import { getRawRequest } from '../../getRawRequest'
-
-const kRawRequestBodyStream = Symbol('kRawRequestBodyStream')
-
-/**
- * Returns the request body stream of the given request.
- * @note This is only relevant in the context of `http.ClientRequest`.
- * This function will throw if the given `request` wasn't created based on
- * the `http.ClientRequest` instance.
- * You must rely on the web stream consumers for other request clients.
- */
-export function getClientRequestBodyStream(request: Request): Readable {
-  const rawRequest = getRawRequest(request)
-
-  invariant(
-    rawRequest instanceof ClientRequest,
-    `Failed to retrieve raw request body stream: request is not an instance of "http.ClientRequest". Note that you can only use the "getClientRequestBodyStream" function with the requests issued by "http.clientRequest".`
-  )
-
-  const requestBodyStream = Reflect.get(request, kRawRequestBodyStream)
-
-  invariant(
-    requestBodyStream instanceof Readable,
-    'Failed to retrieve raw request body stream: corrupted stream (%s)',
-    typeof requestBodyStream
-  )
-
-  return requestBodyStream
-}
-
-export function setRawRequestBodyStream(
-  request: Request,
-  stream: Readable
-): void {
-  Reflect.set(request, kRawRequestBodyStream, stream)
-}