@depup/mswjs__interceptors 0.41.3-depup.0

package/src/interceptors/fetch/index.ts

@@ -0,0 +1,214 @@
+import { invariant } from 'outvariant'
+import { until } from '@open-draft/until'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { HttpRequestEventMap, IS_PATCHED_MODULE } 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 { FetchResponse } from '../../utils/fetchUtils'
+import { setRawRequest } from '../../getRawRequest'
+import { isResponseError } from '../../utils/responseUtils'
+
+export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol = Symbol('fetch')
+
+  constructor() {
+    super(FetchInterceptor.symbol)
+  }
+
+  protected checkEnvironment() {
+    return hasConfigurableGlobal('fetch')
+  }
+
+  protected async setup() {
+    const pureFetch = globalThis.fetch
+
+    invariant(
+      !(pureFetch as any)[IS_PATCHED_MODULE],
+      'Failed to patch the "fetch" module: already patched.'
+    )
+
+    globalThis.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 Request(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 = originalResponse.clone()
+            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 =
+            decompressedStream === null
+              ? rawResponse
+              : new FetchResponse(decompressedStream, rawResponse)
+
+          FetchResponse.setUrl(request.url, response)
+
+          /**
+           * 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: response.clone(),
+              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
+    }
+
+    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
+      enumerable: true,
+      configurable: true,
+      value: true,
+    })
+
+    this.subscriptions.push(() => {
+      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {
+        value: undefined,
+      })
+
+      globalThis.fetch = pureFetch
+
+      this.logger.info(
+        'restored native "globalThis.fetch"!',
+        globalThis.fetch.name
+      )
+    })
+  }
+}

package/src/interceptors/fetch/utils/brotli-decompress.browser.ts

@@ -0,0 +1,14 @@
+export class BrotliDecompressionStream extends TransformStream {
+  constructor() {
+    console.warn(
+      '[Interceptors]: Brotli decompression of response streams is not supported in the browser'
+    )
+
+    super({
+      transform(chunk, controller) {
+        // Keep the stream as passthrough, it does nothing.
+        controller.enqueue(chunk)
+      },
+    })
+  }
+}

package/src/interceptors/fetch/utils/brotli-decompress.ts

@@ -0,0 +1,31 @@
+import zlib from 'node:zlib'
+
+export class BrotliDecompressionStream extends TransformStream {
+  constructor() {
+    const decompress = zlib.createBrotliDecompress({
+      flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+      finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH,
+    })
+
+    super({
+      async transform(chunk, controller) {
+        const buffer = Buffer.from(chunk)
+
+        const decompressed = await new Promise<Buffer>((resolve, reject) => {
+          decompress.write(buffer, (error) => {
+            if (error) reject(error)
+          })
+
+          decompress.flush()
+          decompress.once('data', (data) => resolve(data))
+          decompress.once('error', (error) => reject(error))
+          decompress.once('end', () => controller.terminate())
+        }).catch((error) => {
+          controller.error(error)
+        })
+
+        controller.enqueue(decompressed)
+      },
+    })
+  }
+}

package/src/interceptors/fetch/utils/createNetworkError.ts

@@ -0,0 +1,5 @@
+export function createNetworkError(cause?: unknown) {
+  return Object.assign(new TypeError('Failed to fetch'), {
+    cause,
+  })
+}

package/src/interceptors/fetch/utils/decompression.ts

@@ -0,0 +1,85 @@
+// Import from an internal alias that resolves to different modules
+// depending on the environment. This way, we can keep the fetch interceptor
+// intact while using different strategies for Brotli decompression.
+import { BrotliDecompressionStream } from 'internal:brotli-decompress'
+
+class PipelineStream extends TransformStream {
+  constructor(
+    transformStreams: Array<TransformStream>,
+    ...strategies: Array<QueuingStrategy>
+  ) {
+    super({}, ...strategies)
+
+    const readable = [super.readable as any, ...transformStreams].reduce(
+      (readable, transform) => readable.pipeThrough(transform)
+    )
+
+    Object.defineProperty(this, 'readable', {
+      get() {
+        return readable
+      },
+    })
+  }
+}
+
+export function parseContentEncoding(contentEncoding: string): Array<string> {
+  return contentEncoding
+    .toLowerCase()
+    .split(',')
+    .map((coding) => coding.trim())
+}
+
+function createDecompressionStream(
+  contentEncoding: string
+): TransformStream | null {
+  if (contentEncoding === '') {
+    return null
+  }
+
+  const codings = parseContentEncoding(contentEncoding)
+
+  if (codings.length === 0) {
+    return null
+  }
+
+  const transformers = codings.reduceRight<Array<TransformStream>>(
+    (transformers, coding) => {
+      if (coding === 'gzip' || coding === 'x-gzip') {
+        return transformers.concat(new DecompressionStream('gzip'))
+      } else if (coding === 'deflate') {
+        return transformers.concat(new DecompressionStream('deflate'))
+      } else if (coding === 'br') {
+        return transformers.concat(new BrotliDecompressionStream())
+      } else {
+        transformers.length = 0
+      }
+
+      return transformers
+    },
+    []
+  )
+
+  return new PipelineStream(transformers)
+}
+
+export function decompressResponse(
+  response: Response
+): ReadableStream<any> | null {
+  if (response.body === null) {
+    return null
+  }
+
+  const decompressionStream = createDecompressionStream(
+    response.headers.get('content-encoding') || ''
+  )
+
+  if (!decompressionStream) {
+    return null
+  }
+
+  // Use `pipeTo` and return the decompression stream's readable
+  // instead of `pipeThrough` because that will lock the original
+  // response stream, making it unusable as the input to Response.
+  response.body.pipeTo(decompressionStream.writable)
+  return decompressionStream.readable
+}

package/src/interceptors/fetch/utils/followRedirect.ts

@@ -0,0 +1,114 @@
+import { createNetworkError } from './createNetworkError'
+
+const REQUEST_BODY_HEADERS = [
+  'content-encoding',
+  'content-language',
+  'content-location',
+  'content-type',
+  'content-length',
+]
+
+const kRedirectCount = Symbol('kRedirectCount')
+
+/**
+ * @see https://github.com/nodejs/undici/blob/a6dac3149c505b58d2e6d068b97f4dc993da55f0/lib/web/fetch/index.js#L1210
+ */
+export async function followFetchRedirect(
+  request: Request,
+  response: Response
+): Promise<Response> {
+  if (response.status !== 303 && request.body != null) {
+    return Promise.reject(createNetworkError())
+  }
+
+  const requestUrl = new URL(request.url)
+
+  let locationUrl: URL
+  try {
+    // If the location is a relative URL, use the request URL as the base URL.
+    locationUrl = new URL(response.headers.get('location')!, request.url) 
+  } catch (error) {
+    return Promise.reject(createNetworkError(error))
+  }
+
+  if (
+    !(locationUrl.protocol === 'http:' || locationUrl.protocol === 'https:')
+  ) {
+    return Promise.reject(
+      createNetworkError('URL scheme must be a HTTP(S) scheme')
+    )
+  }
+
+  if (Reflect.get(request, kRedirectCount) > 20) {
+    return Promise.reject(createNetworkError('redirect count exceeded'))
+  }
+
+  Object.defineProperty(request, kRedirectCount, {
+    value: (Reflect.get(request, kRedirectCount) || 0) + 1,
+  })
+
+  if (
+    request.mode === 'cors' &&
+    (locationUrl.username || locationUrl.password) &&
+    !sameOrigin(requestUrl, locationUrl)
+  ) {
+    return Promise.reject(
+      createNetworkError('cross origin not allowed for request mode "cors"')
+    )
+  }
+
+  const requestInit: RequestInit = {}
+
+  if (
+    ([301, 302].includes(response.status) && request.method === 'POST') ||
+    (response.status === 303 && !['HEAD', 'GET'].includes(request.method))
+  ) {
+    requestInit.method = 'GET'
+    requestInit.body = null
+
+    REQUEST_BODY_HEADERS.forEach((headerName) => {
+      request.headers.delete(headerName)
+    })
+  }
+
+  if (!sameOrigin(requestUrl, locationUrl)) {
+    request.headers.delete('authorization')
+    request.headers.delete('proxy-authorization')
+    request.headers.delete('cookie')
+    request.headers.delete('host')
+  }
+
+  /**
+   * @note Undici "safely" extracts the request body.
+   * I suspect we cannot dispatch this request again
+   * since its body has been read and the stream is locked.
+   */
+
+  requestInit.headers = request.headers
+  const finalResponse = await fetch(new Request(locationUrl, requestInit))
+  Object.defineProperty(finalResponse, 'redirected', {
+    value: true,
+    configurable: true,
+  })
+
+  return finalResponse
+}
+
+/**
+ * @see https://github.com/nodejs/undici/blob/a6dac3149c505b58d2e6d068b97f4dc993da55f0/lib/web/fetch/util.js#L761
+ */
+function sameOrigin(left: URL, right: URL): boolean {
+  if (left.origin === right.origin && left.origin === 'null') {
+    return true
+  }
+
+  if (
+    left.protocol === right.protocol &&
+    left.hostname === right.hostname &&
+    left.port === right.port
+  ) {
+    return true
+  }
+
+  return false
+}

package/src/presets/browser.ts

@@ -0,0 +1,11 @@
+import { FetchInterceptor } from '../interceptors/fetch'
+import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest'
+
+/**
+ * The default preset provisions the interception of requests
+ * regardless of their type (fetch/XMLHttpRequest).
+ */
+export default [
+  new FetchInterceptor(),
+  new XMLHttpRequestInterceptor(),
+] as const

package/src/presets/node.ts

@@ -0,0 +1,13 @@
+import { ClientRequestInterceptor } from '../interceptors/ClientRequest'
+import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest'
+import { FetchInterceptor } from '../interceptors/fetch'
+
+/**
+ * The default preset provisions the interception of requests
+ * regardless of their type (http/https/XMLHttpRequest).
+ */
+export default [
+  new ClientRequestInterceptor(),
+  new XMLHttpRequestInterceptor(),
+  new FetchInterceptor(),
+] as const

package/src/utils/bufferUtils.test.ts

@@ -0,0 +1,21 @@
+import { it, expect } from 'vitest'
+import { decodeBuffer, encodeBuffer } from './bufferUtils'
+
+it('encodes utf-8 string', () => {
+  const encoded = encodeBuffer('😁')
+  expect(new Uint8Array(encoded)).toEqual(new Uint8Array([240, 159, 152, 129]))
+})
+
+it('decodes utf-8 string', () => {
+  const array = new Uint8Array([240, 159, 152, 129])
+  const decoded = decodeBuffer(array.buffer)
+  expect(decoded).toEqual('😁')
+})
+
+it('decodes string with custom encoding', () => {
+  const array = new Uint8Array([
+    207, 240, 232, 226, 229, 242, 44, 32, 236, 232, 240, 33,
+  ])
+  const decoded = decodeBuffer(array.buffer, 'windows-1251')
+  expect(decoded).toEqual('Привет, мир!')
+})

package/src/utils/bufferUtils.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,13 @@
+/**
+ * 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/cloneObject.test.ts

@@ -0,0 +1,94 @@
+import { it, expect } from 'vitest'
+import { cloneObject } from './cloneObject'
+
+it('clones a shallow object', () => {
+  const original = { a: 1, b: 2, c: [1, 2, 3] }
+  const clone = cloneObject(original)
+
+  expect(clone).toEqual(original)
+
+  clone.a = 5
+  clone.b = 6
+  clone.c = [5, 6, 7]
+
+  expect(clone).toHaveProperty('a', 5)
+  expect(clone).toHaveProperty('b', 6)
+  expect(clone).toHaveProperty('c', [5, 6, 7])
+  expect(original).toHaveProperty('a', 1)
+  expect(original).toHaveProperty('b', 2)
+  expect(original).toHaveProperty('c', [1, 2, 3])
+})
+
+it('clones a nested object', () => {
+  const original = { a: { b: 1 }, c: { d: { e: 2 } } }
+  const clone = cloneObject(original)
+
+  expect(clone).toEqual(original)
+
+  clone.a.b = 10
+  clone.c.d.e = 20
+
+  expect(clone).toHaveProperty(['a', 'b'], 10)
+  expect(clone).toHaveProperty(['c', 'd', 'e'], 20)
+  expect(original).toHaveProperty(['a', 'b'], 1)
+  expect(original).toHaveProperty(['c', 'd', 'e'], 2)
+})
+
+it('clones a class instance', () => {
+  class Car {
+    public manufacturer: string
+    constructor() {
+      this.manufacturer = 'Audi'
+    }
+    getManufacturer() {
+      return this.manufacturer
+    }
+  }
+
+  const car = new Car()
+  const clone = cloneObject(car)
+
+  expect(clone).toHaveProperty('manufacturer', 'Audi')
+  expect(clone).toHaveProperty('getManufacturer')
+  expect(clone.getManufacturer).toBeInstanceOf(Function)
+  expect(clone.getManufacturer()).toEqual('Audi')
+})
+
+it('ignores nested class instances', () => {
+  class Car {
+    name: string
+    constructor(name: string) {
+      this.name = name
+    }
+    getName() {
+      return this.name
+    }
+  }
+  const original = {
+    a: 1,
+    car: new Car('Audi'),
+  }
+  const clone = cloneObject(original)
+
+  expect(clone).toEqual(original)
+  expect(clone.car).toBeInstanceOf(Car)
+  expect(clone.car.getName()).toEqual('Audi')
+
+  clone.car = new Car('BMW')
+
+  expect(clone.car).toBeInstanceOf(Car)
+  expect(clone.car.getName()).toEqual('BMW')
+  expect(original.car).toBeInstanceOf(Car)
+  expect(original.car.getName()).toEqual('Audi')
+})
+
+it('clones an object with null prototype', () => {
+  const original = {
+    key: Object.create(null),
+  }
+  const clone = cloneObject(original)
+
+  expect(clone).toEqual({
+    key: {},
+  })
+})

package/src/utils/cloneObject.ts

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