@depup/mswjs__interceptors 0.41.3-depup.0

package/src/utils/getUrlByRequestOptions.ts

@@ -0,0 +1,152 @@
+import { Agent } from 'http'
+import { RequestOptions, Agent as HttpsAgent } from 'https'
+import { Logger } from '@open-draft/logger'
+
+const logger = new Logger('utils getUrlByRequestOptions')
+
+// Request instance constructed by the "request" library
+// has a "self" property that has a "uri" field. This is
+// reproducible by performing a "XMLHttpRequest" request in JSDOM.
+export interface RequestSelf {
+  uri?: URL
+}
+
+export type ResolvedRequestOptions = RequestOptions & RequestSelf
+
+export const DEFAULT_PATH = '/'
+const DEFAULT_PROTOCOL = 'http:'
+const DEFAULT_HOSTNAME = 'localhost'
+const SSL_PORT = 443
+
+function getAgent(
+  options: ResolvedRequestOptions
+): Agent | HttpsAgent | undefined {
+  return options.agent instanceof Agent ? options.agent : undefined
+}
+
+function getProtocolByRequestOptions(options: ResolvedRequestOptions): string {
+  if (options.protocol) {
+    return options.protocol
+  }
+
+  const agent = getAgent(options)
+  const agentProtocol = (agent as RequestOptions)?.protocol
+
+  if (agentProtocol) {
+    return agentProtocol
+  }
+
+  const port = getPortByRequestOptions(options)
+  const isSecureRequest = options.cert || port === SSL_PORT
+
+  return isSecureRequest ? 'https:' : options.uri?.protocol || DEFAULT_PROTOCOL
+}
+
+function getPortByRequestOptions(
+  options: ResolvedRequestOptions
+): number | undefined {
+  // Use the explicitly provided port.
+  if (options.port) {
+    return Number(options.port)
+  }
+
+  // Otherwise, try to resolve port from the agent.
+  const agent = getAgent(options)
+
+  if ((agent as HttpsAgent)?.options.port) {
+    return Number((agent as HttpsAgent).options.port)
+  }
+
+  if ((agent as RequestOptions)?.defaultPort) {
+    return Number((agent as RequestOptions).defaultPort)
+  }
+
+  // Lastly, return undefined indicating that the port
+  // must inferred from the protocol. Do not infer it here.
+  return undefined
+}
+
+interface RequestAuth {
+  username: string
+  password: string
+}
+
+function getAuthByRequestOptions(
+  options: ResolvedRequestOptions
+): RequestAuth | undefined {
+  if (options.auth) {
+    const [username, password] = options.auth.split(':')
+    return { username, password }
+  }
+}
+
+/**
+ * Returns true if host looks like an IPv6 address without surrounding brackets
+ * It assumes any host containing `:` is definitely not IPv4 and probably IPv6,
+ * but note that this could include invalid IPv6 addresses as well.
+ */
+function isRawIPv6Address(host: string): boolean {
+  return host.includes(':') && !host.startsWith('[') && !host.endsWith(']')
+}
+
+function getHostname(options: ResolvedRequestOptions): string | undefined {
+  let host = options.hostname || options.host
+
+  if (host) {
+    if (isRawIPv6Address(host)) {
+       host = `[${host}]`
+    }
+
+    // Check the presence of the port, and if it's present,
+    // remove it from the host, returning a hostname.
+    return new URL(`http://${host}`).hostname
+  }
+
+  return DEFAULT_HOSTNAME
+}
+
+/**
+ * Creates a `URL` instance from a given `RequestOptions` object.
+ */
+export function getUrlByRequestOptions(options: ResolvedRequestOptions): URL {
+  logger.info('request options', options)
+
+  if (options.uri) {
+    logger.info(
+      'constructing url from explicitly provided "options.uri": %s',
+      options.uri
+    )
+    return new URL(options.uri.href)
+  }
+
+  logger.info('figuring out url from request options...')
+
+  const protocol = getProtocolByRequestOptions(options)
+  logger.info('protocol', protocol)
+
+  const port = getPortByRequestOptions(options)
+  logger.info('port', port)
+
+  const hostname = getHostname(options)
+  logger.info('hostname', hostname)
+
+  const path = options.path || DEFAULT_PATH
+  logger.info('path', path)
+
+  const credentials = getAuthByRequestOptions(options)
+  logger.info('credentials', credentials)
+
+  const authString = credentials
+    ? `${credentials.username}:${credentials.password}@`
+    : ''
+  logger.info('auth string:', authString)
+
+  const portString = typeof port !== 'undefined' ? `:${port}` : ''
+  const url = new URL(`${protocol}//${hostname}${portString}${path}`)
+  url.username = credentials?.username || ''
+  url.password = credentials?.password || ''
+
+  logger.info('created url:', url)
+
+  return url
+}

package/src/utils/getValueBySymbol.test.ts

@@ -0,0 +1,14 @@
+import { it, expect } from 'vitest'
+import { getValueBySymbol } from './getValueBySymbol'
+
+it('returns undefined given a non-existing symbol', () => {
+  expect(getValueBySymbol('non-existing', {})).toBeUndefined()
+})
+
+it('returns value behind the given symbol', () => {
+  const symbol = Symbol('kInternal')
+
+  expect(getValueBySymbol('kInternal', { [symbol]: null })).toBe(null)
+  expect(getValueBySymbol('kInternal', { [symbol]: true })).toBe(true)
+  expect(getValueBySymbol('kInternal', { [symbol]: 'value' })).toBe('value')
+})

package/src/utils/getValueBySymbol.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns the value behind the symbol with the given name.
+ */
+export function getValueBySymbol<T>(
+  symbolName: string,
+  source: object
+): T | undefined {
+  const ownSymbols = Object.getOwnPropertySymbols(source)
+
+  const symbol = ownSymbols.find((symbol) => {
+    return symbol.description === symbolName
+  })
+
+  if (symbol) {
+    return Reflect.get(source, symbol)
+  }
+
+  return
+}

package/src/utils/handleRequest.ts

@@ -0,0 +1,205 @@
+import type { Emitter } from 'strict-event-emitter'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { until } from '@open-draft/until'
+import type { HttpRequestEventMap } from '../glossary'
+import { emitAsync } from './emitAsync'
+import { RequestController } from '../RequestController'
+import {
+  createServerErrorResponse,
+  isResponseError,
+  isResponseLike,
+} from './responseUtils'
+import { InterceptorError } from '../InterceptorError'
+import { isNodeLikeError } from './isNodeLikeError'
+import { isObject } from './isObject'
+
+interface HandleRequestOptions {
+  requestId: string
+  request: Request
+  emitter: Emitter<HttpRequestEventMap>
+  controller: RequestController
+}
+
+export async function handleRequest(
+  options: HandleRequestOptions
+): Promise<void> {
+  const handleResponse = async (
+    response: Response | Error | Record<string, any>
+  ) => {
+    if (response instanceof Error) {
+      await options.controller.errorWith(response)
+      return true
+    }
+
+    // Handle "Response.error()" instances.
+    if (isResponseError(response)) {
+      await options.controller.respondWith(response)
+      return true
+    }
+
+    /**
+     * Handle normal responses or response-like objects.
+     * @note This must come before the arbitrary object check
+     * since Response instances are, in fact, objects.
+     */
+    if (isResponseLike(response)) {
+      await options.controller.respondWith(response)
+      return true
+    }
+
+    // Handle arbitrary objects provided to `.errorWith(reason)`.
+    if (isObject(response)) {
+      await options.controller.errorWith(response)
+      return true
+    }
+
+    return false
+  }
+
+  const handleResponseError = async (error: unknown): Promise<boolean> => {
+    // Forward the special interceptor error instances
+    // to the developer. These must not be handled in any way.
+    if (error instanceof InterceptorError) {
+      throw result.error
+    }
+
+    // Support mocking Node.js-like errors.
+    if (isNodeLikeError(error)) {
+      await options.controller.errorWith(error)
+      return true
+    }
+
+    // Handle thrown responses.
+    if (error instanceof Response) {
+      return await handleResponse(error)
+    }
+
+    return false
+  }
+
+  // Add the last "request" listener to check if the request
+  // has been handled in any way. If it hasn't, resolve the
+  // response promise with undefined.
+  // options.emitter.once('request', async ({ requestId: pendingRequestId }) => {
+  //   if (
+  //     pendingRequestId === options.requestId &&
+  //     options.controller.readyState === RequestController.PENDING
+  //   ) {
+  //     await options.controller.passthrough()
+  //   }
+  // })
+
+  const requestAbortPromise = new DeferredPromise<void, unknown>()
+
+  /**
+   * @note `signal` is not always defined in React Native.
+   */
+  if (options.request.signal) {
+    if (options.request.signal.aborted) {
+      await options.controller.errorWith(options.request.signal.reason)
+      return
+    }
+
+    options.request.signal.addEventListener(
+      'abort',
+      () => {
+        requestAbortPromise.reject(options.request.signal.reason)
+      },
+      { once: true }
+    )
+  }
+
+  const result = await until(async () => {
+    // Emit the "request" event and wait until all the listeners
+    // for that event are finished (e.g. async listeners awaited).
+    // By the end of this promise, the developer cannot affect the
+    // request anymore.
+    const requestListenersPromise = emitAsync(options.emitter, 'request', {
+      requestId: options.requestId,
+      request: options.request,
+      controller: options.controller,
+    })
+
+    await Promise.race([
+      // Short-circuit the request handling promise if the request gets aborted.
+      requestAbortPromise,
+      requestListenersPromise,
+      options.controller.handled,
+    ])
+  })
+
+  // Handle the request being aborted while waiting for the request listeners.
+  if (requestAbortPromise.state === 'rejected') {
+    await options.controller.errorWith(requestAbortPromise.rejectionReason)
+    return
+  }
+
+  if (result.error) {
+    // Handle the error during the request listener execution.
+    // These can be thrown responses or request errors.
+    if (await handleResponseError(result.error)) {
+      return
+    }
+
+    // If the developer has added "unhandledException" listeners,
+    // allow them to handle the error. They can translate it to a
+    // mocked response, network error, or forward it as-is.
+    if (options.emitter.listenerCount('unhandledException') > 0) {
+      // Create a new request controller just for the unhandled exception case.
+      // This is needed because the original controller might have been already
+      // interacted with (e.g. "respondWith" or "errorWith" called on it).
+      const unhandledExceptionController = new RequestController(
+        options.request,
+        {
+          /**
+           * @note Intentionally empty passthrough handle.
+           * This controller is created within another controller and we only need
+           * to know if `unhandledException` listeners handled the request.
+           */
+          passthrough() {},
+          async respondWith(response) {
+            await handleResponse(response)
+          },
+          async errorWith(reason) {
+            /**
+             * @note Handle the result of the unhandled controller
+             * in the same way as the original request controller.
+             * The exception here is that thrown errors within the
+             * "unhandledException" event do NOT result in another
+             * emit of the same event. They are forwarded as-is.
+             */
+            await options.controller.errorWith(reason)
+          },
+        }
+      )
+
+      await emitAsync(options.emitter, 'unhandledException', {
+        error: result.error,
+        request: options.request,
+        requestId: options.requestId,
+        controller: unhandledExceptionController,
+      })
+
+      // If all the "unhandledException" listeners have finished
+      // but have not handled the request in any way, passthrough.
+      if (
+        unhandledExceptionController.readyState !== RequestController.PENDING
+      ) {
+        return
+      }
+    }
+
+    // Otherwise, coerce unhandled exceptions to a 500 Internal Server Error response.
+    await options.controller.respondWith(
+      createServerErrorResponse(result.error)
+    )
+    return
+  }
+
+  // If the request hasn't been handled by this point, passthrough.
+  if (options.controller.readyState === RequestController.PENDING) {
+    return await options.controller.passthrough()
+  }
+
+  return options.controller.handled
+}

package/src/utils/hasConfigurableGlobal.test.ts

@@ -0,0 +1,83 @@
+import { vi, beforeAll, afterEach, afterAll, it, expect } from 'vitest'
+import { hasConfigurableGlobal } from './hasConfigurableGlobal'
+
+beforeAll(() => {
+  vi.spyOn(console, 'error').mockImplementation(() => {})
+})
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+afterAll(() => {
+  vi.restoreAllMocks()
+})
+
+it('returns true if the global property exists and is configurable', () => {
+  Object.defineProperty(global, '_existsAndConfigurable', {
+    value: 'something',
+    configurable: true,
+  })
+
+  expect(hasConfigurableGlobal('_existsAndConfigurable')).toBe(true)
+})
+
+it('returns false if the global property does not exist', () => {
+  expect(hasConfigurableGlobal('_non-existing')).toBe(false)
+})
+
+it('returns false for existing global with undefined as a value', () => {
+  Object.defineProperty(global, '_existsAndUndefined', {
+    value: undefined,
+    configurable: true,
+  })
+  expect(hasConfigurableGlobal('_existsAndUndefined')).toBe(false)
+})
+
+it('returns false for existing global with null as a value', () => {
+  Object.defineProperty(global, '_existsAndNull', {
+    value: null,
+    configurable: true,
+  })
+  expect(hasConfigurableGlobal('_existsAndNull')).toBe(false)
+})
+
+it('returns false for existing global with a getter that returns undefined', () => {
+  Object.defineProperty(global, '_existsGetterUndefined', {
+    get: () => undefined,
+    configurable: true,
+  })
+  expect(hasConfigurableGlobal('_existsGetterUndefined')).toBe(false)
+})
+
+it('returns false and prints an error for implicitly non-configurable global property', () => {
+  Object.defineProperty(global, '_implicitlyNonConfigurable', {
+    value: 'something',
+  })
+
+  expect(hasConfigurableGlobal('_implicitlyNonConfigurable')).toBe(false)
+  expect(console.error).toHaveBeenCalledWith(
+    '[MSW] Failed to apply interceptor: the global `_implicitlyNonConfigurable` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.'
+  )
+})
+
+it('returns false and prints an error for explicitly non-configurable global property', () => {
+  Object.defineProperty(global, '_explicitlyNonConfigurable', {
+    value: 'something',
+    configurable: false,
+  })
+
+  expect(hasConfigurableGlobal('_explicitlyNonConfigurable')).toBe(false)
+  expect(console.error).toHaveBeenCalledWith(
+    '[MSW] Failed to apply interceptor: the global `_explicitlyNonConfigurable` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.'
+  )
+})
+
+it('returns false and prints an error for global property that only has a getter', () => {
+  Object.defineProperty(global, '_onlyGetter', { get: () => 'something' })
+
+  expect(hasConfigurableGlobal('_onlyGetter')).toBe(false)
+  expect(console.error).toHaveBeenCalledWith(
+    '[MSW] Failed to apply interceptor: the global `_onlyGetter` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.'
+  )
+})

package/src/utils/hasConfigurableGlobal.ts

@@ -0,0 +1,34 @@
+/**
+ * Returns a boolean indicating whether the given global property
+ * is defined and is configurable.
+ */
+export function hasConfigurableGlobal(propertyName: string): boolean {
+  const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName)
+
+  // The property is not set at all.
+  if (typeof descriptor === 'undefined') {
+    return false
+  }
+
+  // The property is set to a getter that returns undefined.
+  if (
+    typeof descriptor.get === 'function' &&
+    typeof descriptor.get() === 'undefined'
+  ) {
+    return false
+  }
+
+  // The property is set to a value equal to undefined.
+  if (typeof descriptor.get === 'undefined' && descriptor.value == null) {
+    return false
+  }
+
+  if (typeof descriptor.set === 'undefined' && !descriptor.configurable) {
+    console.error(
+      `[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`
+    )
+    return false
+  }
+
+  return true
+}

package/src/utils/isNodeLikeError.ts

@@ -0,0 +1,13 @@
+export function isNodeLikeError(
+  error: unknown
+): error is NodeJS.ErrnoException {
+  if (error == null) {
+    return false
+  }
+
+  if (!(error instanceof Error)) {
+    return false
+  }
+
+  return 'code' in error && 'errno' in error
+}

package/src/utils/isObject.test.ts

@@ -0,0 +1,21 @@
+import { it, expect } from 'vitest'
+import { isObject } from './isObject'
+
+it('returns true given an object', () => {
+  expect(isObject({})).toBe(true)
+  expect(isObject({ a: 1 })).toBe(true)
+})
+
+it('returns false given an object-like instance', () => {
+  expect(isObject([1])).toBe(false)
+  expect(isObject(function () {})).toBe(false)
+  expect(isObject(new Response())).toBe(false)
+})
+
+it('returns false given a non-object instance', () => {
+  expect(isObject(null)).toBe(false)
+  expect(isObject(undefined)).toBe(false)
+  expect(isObject(false)).toBe(false)
+  expect(isObject(123)).toBe(false)
+  expect(isObject(Symbol('object Object'))).toBe(false)
+})

package/src/utils/isObject.ts

@@ -0,0 +1,8 @@
+/**
+ * Determines if a given value is an instance of object.
+ */
+export function isObject<T>(value: any, loose = false): value is T {
+  return loose
+    ? Object.prototype.toString.call(value).startsWith('[object ')
+    : Object.prototype.toString.call(value) === '[object Object]'
+}

package/src/utils/isPropertyAccessible.ts

@@ -0,0 +1,19 @@
+/**
+ * A function that validates if property access is possible on an object
+ * without throwing. It returns `true` if the property access is possible
+ * and `false` otherwise.
+ *
+ * Environments like miniflare will throw on property access on certain objects
+ * like Request and Response, for unimplemented properties.
+ */
+export function isPropertyAccessible<Obj extends Record<string, any>>(
+  obj: Obj,
+  key: keyof Obj
+) {
+  try {
+    obj[key]
+    return true
+  } catch {
+    return false
+  }
+}

package/src/utils/nextTick.ts

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

@@ -0,0 +1,39 @@
+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)
+}

package/src/utils/parseJson.test.ts

@@ -0,0 +1,10 @@
+import { it, expect } from 'vitest'
+import { parseJson } from './parseJson'
+
+it('parses a given string into JSON', () => {
+  expect(parseJson('{"id":1}')).toEqual({ id: 1 })
+})
+
+it('returns null given invalid JSON string', () => {
+  expect(parseJson('{"o:2\'')).toBeNull()
+})

package/src/utils/parseJson.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses a given string into JSON.
+ * Gracefully handles invalid JSON by returning `null`.
+ */
+export function parseJson(data: string): Record<string, unknown> | null {
+  try {
+    const json = JSON.parse(data)
+    return json
+  } catch (_) {
+    return null
+  }
+}