@depup/msw 2.12.13-depup.0

package/src/core/utils/internal/checkGlobals.ts

@@ -0,0 +1,17 @@
+import { invariant } from 'outvariant'
+import { devUtils } from './devUtils'
+
+export function checkGlobals() {
+  /**
+   * MSW expects the "URL" constructor to be defined.
+   * It's not present in React Native so suggest a polyfill
+   * instead of failing silently.
+   * @see https://github.com/mswjs/msw/issues/1408
+   */
+  invariant(
+    typeof URL !== 'undefined',
+    devUtils.formatMessage(
+      `Global "URL" class is not defined. This likely means that you're running MSW in an environment that doesn't support all Node.js standard API (e.g. React Native). If that's the case, please use an appropriate polyfill for the "URL" class, like "react-native-url-polyfill".`,
+    ),
+  )
+}

package/src/core/utils/internal/devUtils.test.ts

@@ -0,0 +1,21 @@
+import { InternalError } from './devUtils'
+
+describe(InternalError, () => {
+  it('creates an InternalError instance', () => {
+    const error = new InternalError('Message')
+
+    expect(error.name).toBe('InternalError')
+    expect(error.message).toBe('Message')
+    expect(error.toString()).toBe('InternalError: Message')
+    expect(error.stack).toMatch(/\w+/)
+  })
+
+  it('passes the identity check', () => {
+    const error = new InternalError('Message')
+    expect(error instanceof InternalError).toBe(true)
+    expect(error instanceof Error).toBe(true)
+
+    const extraneousError = new Error('Message')
+    expect(extraneousError).not.toBeInstanceOf(InternalError)
+  })
+})

package/src/core/utils/internal/devUtils.ts

@@ -0,0 +1,44 @@
+import { format } from 'outvariant'
+
+const LIBRARY_PREFIX = '[MSW]'
+
+/**
+ * Formats a given message by appending the library's prefix string.
+ */
+function formatMessage(message: string, ...positionals: any[]): string {
+  const interpolatedMessage = format(message, ...positionals)
+  return `${LIBRARY_PREFIX} ${interpolatedMessage}`
+}
+
+/**
+ * Prints a library-specific warning.
+ */
+function warn(message: string, ...positionals: any[]): void {
+  console.warn(formatMessage(message, ...positionals))
+}
+
+/**
+ * Prints a library-specific error.
+ */
+function error(message: string, ...positionals: any[]): void {
+  console.error(formatMessage(message, ...positionals))
+}
+
+export const devUtils = {
+  formatMessage,
+  warn,
+  error,
+}
+
+/**
+ * Internal error instance.
+ * Used to differentiate the library errors that must be forwarded
+ * to the user from the unhandled exceptions. Use this if you don't
+ * wish for the error to be coerced to a 500 fallback response.
+ */
+export class InternalError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'InternalError'
+  }
+}

package/src/core/utils/internal/getCallFrame.test.ts

@@ -0,0 +1,154 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { getCallFrame } from './getCallFrame'
+
+class ErrorWithStack extends Error {
+  constructor(stack: string[] | undefined | null) {
+    super('')
+    this.stack = stack?.join('\n')
+  }
+}
+
+test('supports Node.js (Linux, MacOS) error stack', () => {
+  const linuxError = new ErrorWithStack([
+    'Error: ',
+    '    at getCallFrame (/Users/mock/github/msw/lib/node/index.js:3735:22)',
+    '    at Object.get (/Users/mock/github/msw/lib/node/index.js:3776:29)',
+    '    at Object.<anonymous> (/Users/mock/github/msw/test/msw-api/setup-server/listHandlers.test.ts:13:8)', // <-- this one
+    '    at Runtime._execModule (/Users/mock/github/msw/node_modules/jest-runtime/build/index.js:1299:24)',
+    '    at Runtime._loadModule (/Users/mock/github/msw/node_modules/jest-runtime/build/index.js:898:12)',
+    '    at Runtime.requireModule (/Users/mock/github/msw/node_modules/jest-runtime/build/index.js:746:10)',
+    '    at jasmine2 (/Users/mock/github/msw/node_modules/jest-jasmine2/build/index.js:230:13)',
+    '    at runTestInternal (/Users/mock/github/msw/node_modules/jest-runner/build/runTest.js:380:22)',
+    '    at runTest (/Users/mock/github/msw/node_modules/jest-runner/build/runTest.js:472:34)',
+  ])
+  expect(getCallFrame(linuxError)).toEqual(
+    '/Users/mock/github/msw/test/msw-api/setup-server/listHandlers.test.ts:13:8',
+  )
+
+  const macOsError = new ErrorWithStack([
+    'Error: ',
+    '    at getCallFrame (/Users/mock/git/msw/lib/node/index.js:3735:22)',
+    '    at graphQLRequestHandler (/Users/mock/git/msw/lib/node/index.js:7071:25)',
+    '    at Object.query (/Users/mock/git/msw/lib/node/index.js:7182:18)',
+    '    at Object.<anonymous> (/Users/mock/git/msw/test/msw-api/setup-server/listHandlers.test.ts:14:11)', // <-- this one
+    '    at Runtime._execModule (/Users/mock/git/msw/node_modules/jest-runtime/build/index.js:1299:24)',
+    '    at Runtime._loadModule (/Users/mock/git/msw/node_modules/jest-runtime/build/index.js:898:12)',
+    '    at Runtime.requireModule (/Users/mock/git/msw/node_modules/jest-runtime/build/index.js:746:10)',
+    '    at jasmine2 (/Users/mock/git/msw/node_modules/jest-jasmine2/build/index.js:230:13)',
+    '    at runTestInternal (/Users/mock/git/msw/node_modules/jest-runner/build/runTest.js:380:22)',
+    '    at runTest (/Users/mock/git/msw/node_modules/jest-runner/build/runTest.js:472:34)',
+  ])
+
+  expect(getCallFrame(macOsError)).toEqual(
+    '/Users/mock/git/msw/test/msw-api/setup-server/listHandlers.test.ts:14:11',
+  )
+})
+
+test('supports Node.js (Windows) error stack', () => {
+  const error = new ErrorWithStack([
+    'Error: ',
+    '    at getCallFrame (C:\\Users\\mock\\git\\msw\\lib\\node\\index.js:3735:22)',
+    '    at graphQLRequestHandler (C:\\Users\\mock\\git\\msw\\lib\\node\\index.js:7071:25)',
+    '    at Object.query (C:\\Users\\mock\\git\\msw\\lib\\node\\index.js:7182:18)',
+    '    at Object.<anonymous> (C:\\Users\\mock\\git\\msw\\test\\msw-api\\setup-server\\listHandlers.test.ts:75:13)', // <-- this one
+    '    at Object.asyncJestTest (C:\\Users\\mock\\git\\msw\\node_modules\\jest-jasmine2\\build\\jasmineAsyncInstall.js:106:37)',
+    '    at C:\\Users\\mock\\git\\msw\\node_modules\\jest-jasmine2\\build\\queueRunner.js:45:12',
+    '    at new Promise (<anonymous>)',
+    '    at mapper (C:\\Users\\mock\\git\\msw\\node_modules\\jest-jasmine2\\build\\queueRunner.js:28:19)',
+    '    at C:\\Users\\mock\\git\\msw\\node_modules\\jest-jasmine2\\build\\queueRunner.js:75:41',
+  ])
+
+  expect(getCallFrame(error)).toBe(
+    'C:\\Users\\mock\\git\\msw\\test\\msw-api\\setup-server\\listHandlers.test.ts:75:13',
+  )
+})
+
+test('supports Chrome and Edge error stack', () => {
+  const error = new ErrorWithStack([
+    'Error',
+    '    at getCallFrame (webpack:///./lib/browser/getCallFrame-deps.js?:272:20)',
+    '    at Object.eval [as get] (webpack:///./lib/browser/rest-deps.js?:1402:90)',
+    '    at eval (webpack:///./test/msw-api/setup-worker/listHandlers.mocks.ts?:6:113)', // <-- this one
+    '    at Module../test/msw-api/setup-worker/listHandlers.mocks.ts (http://localhost:59464/main.js:1376:1)',
+    '    at __webpack_require__ (http://localhost:59464/main.js:790:30)',
+    '    at fn (http://localhost:59464/main.js:101:20)',
+    '    at eval (webpack:///multi_(webpack)-dev-server/client?:4:18)',
+    '    at Object.0 (http://localhost:59464/main.js:1399:1)',
+    '    at __webpack_require__ (http://localhost:59464/main.js:790:30)',
+    '    at http://localhost:59464/main.js:857:37',
+  ])
+
+  expect(getCallFrame(error)).toBe(
+    'webpack:///./test/msw-api/setup-worker/listHandlers.mocks.ts?:6:113',
+  )
+})
+
+test('supports Firefox (MacOS, Windows) error stack', () => {
+  const error = new ErrorWithStack([
+    'getCallFrame@webpack:///./lib/browser/getCallFrame-deps.js?:272:20',
+    'createRestHandler/<@webpack:///./lib/browser/rest-deps.js?:1402:90',
+    '@webpack:///./test/msw-api/setup-worker/listHandlers.mocks.ts?:6:113', // <-- this one
+    './test/msw-api/setup-worker/listHandlers.mocks.ts@http://localhost:59464/main.js:1376:1',
+    '__webpack_require__@http://localhost:59464/main.js:790:30',
+    'fn@http://localhost:59464/main.js:101:20',
+    '@webpack:///multi_(webpack)-dev-server/client?:4:18',
+    '0@http://localhost:59464/main.js:1399:1',
+    '__webpack_require__@http://localhost:59464/main.js:790:30',
+    '@http://localhost:59464/main.js:857:37',
+  ])
+
+  expect(getCallFrame(error)).toBe(
+    'webpack:///./test/msw-api/setup-worker/listHandlers.mocks.ts?:6:113',
+  )
+})
+
+test('supports Safari (MacOS) error stack', () => {
+  const errorOne = new ErrorWithStack([
+    'getCallFrame',
+    '',
+    'eval code',
+    'eval@[native code]',
+    './test/msw-api/setup-worker/listHandlers.mocks.ts@http://localhost:59464/main.js:1376:5', // <-- this one
+    '__webpack_require__@http://localhost:59464/main.js:790:34',
+    'fn@http://localhost:59464/main.js:101:39',
+    'eval code',
+    'eval@[native code]',
+    'http://localhost:59464/main.js:1399:5',
+    '__webpack_require__@http://localhost:59464/main.js:790:34',
+    'http://localhost:59464/main.js:857:37',
+    'global code@http://localhost:59464/main.js:858:12',
+  ])
+
+  expect(getCallFrame(errorOne)).toBe(
+    './test/msw-api/setup-worker/listHandlers.mocks.ts@http://localhost:59464/main.js:1376:5',
+  )
+
+  const errorTwo = new ErrorWithStack([
+    'getCallFrame',
+    'graphQLRequestHandler',
+    'eval code',
+    'eval@[native code]',
+    './test/msw-api/setup-worker/listHandlers.mocks.ts@http://localhost:56460/main.js:1376:5', // <-- this one
+    '__webpack_require__@http://localhost:56460/main.js:790:34',
+    'fn@http://localhost:56460/main.js:101:39',
+    'eval code',
+    'eval@[native code]',
+    'http://localhost:56460/main.js:1399:5',
+    '__webpack_require__@http://localhost:56460/main.js:790:34',
+    'http://localhost:56460/main.js:857:37',
+    'global code@http://localhost:56460/main.js:858:12',
+  ])
+
+  expect(getCallFrame(errorTwo)).toBe(
+    './test/msw-api/setup-worker/listHandlers.mocks.ts@http://localhost:56460/main.js:1376:5',
+  )
+})
+
+test('handles the undefined stack trace', () => {
+  expect(() => getCallFrame(new ErrorWithStack(undefined))).not.toThrow(
+    TypeError,
+  )
+  expect(() => getCallFrame(new ErrorWithStack(null))).not.toThrow(TypeError)
+})

package/src/core/utils/internal/getCallFrame.ts

@@ -0,0 +1,35 @@
+// Ignore the source files traces for local testing.
+const SOURCE_FRAME = /[/\\]msw[/\\]src[/\\](.+)/
+
+const BUILD_FRAME =
+  /(node_modules)?[/\\]lib[/\\](core|browser|node|native|iife)[/\\]|^[^/\\]*$/
+
+/**
+ * Return the stack trace frame of a function's invocation.
+ */
+export function getCallFrame(error: Error) {
+  // In <IE11, new Error may return an undefined stack
+  const stack = error.stack
+
+  if (!stack) {
+    return
+  }
+
+  const frames: string[] = stack.split('\n').slice(1)
+
+  // Get the first frame that doesn't reference the library's internal trace.
+  // Assume that frame is the invocation frame.
+  const declarationFrame = frames.find((frame) => {
+    return !(SOURCE_FRAME.test(frame) || BUILD_FRAME.test(frame))
+  })
+
+  if (!declarationFrame) {
+    return
+  }
+
+  // Extract file reference from the stack frame.
+  const declarationPath = declarationFrame
+    .replace(/\s*at [^()]*\(([^)]+)\)/, '$1')
+    .replace(/^@/, '')
+  return declarationPath
+}

package/src/core/utils/internal/hasRefCounted.test.ts

@@ -0,0 +1,16 @@
+import { hasRefCounted } from './hasRefCounted'
+
+it('returns true for objects with ref and unref methods', () => {
+  expect(
+    hasRefCounted({
+      ref() {},
+      unref() {},
+    }),
+  ).toBe(true)
+})
+
+it('returns false for a non-refcounted object', () => {
+  expect(hasRefCounted({})).toBe(false)
+  expect(hasRefCounted({ ref() {} })).toBe(false)
+  expect(hasRefCounted({ unref() {} })).toBe(false)
+})

package/src/core/utils/internal/hasRefCounted.ts

@@ -0,0 +1,8 @@
+export function hasRefCounted<T extends object>(
+  value: T,
+): value is T & NodeJS.RefCounted {
+  return (
+    typeof Reflect.get(value, 'ref') === 'function' &&
+    typeof Reflect.get(value, 'unref') === 'function'
+  )
+}

package/src/core/utils/internal/isHandlerKind.test.ts

@@ -0,0 +1,64 @@
+import { GraphQLHandler } from '../../handlers/GraphQLHandler'
+import { HttpHandler } from '../../handlers/HttpHandler'
+import { RequestHandler } from '../../handlers/RequestHandler'
+import { WebSocketHandler } from '../../handlers/WebSocketHandler'
+import { isHandlerKind } from './isHandlerKind'
+
+it('returns true if expected a request handler and given a request handler', () => {
+  expect(
+    isHandlerKind('RequestHandler')(new HttpHandler('*', '*', () => {})),
+  ).toBe(true)
+
+  expect(
+    isHandlerKind('RequestHandler')(
+      new GraphQLHandler('all', '*', '*', () => {}),
+    ),
+  ).toBe(true)
+})
+
+it('returns true if expected a request handler and given a custom request handler', () => {
+  class MyHandler extends RequestHandler {
+    constructor() {
+      super({ info: { header: '*' }, resolver: () => {} })
+    }
+    predicate = () => false
+    log() {}
+  }
+
+  expect(isHandlerKind('RequestHandler')(new MyHandler())).toBe(true)
+})
+
+it('returns false if expected a request handler but given event handler', () => {
+  expect(isHandlerKind('RequestHandler')(new WebSocketHandler('*'))).toBe(false)
+})
+
+it('returns false if expected a request handler but given arbitrary object', () => {
+  expect(isHandlerKind('RequestHandler')(undefined)).toBe(false)
+  expect(isHandlerKind('RequestHandler')(null)).toBe(false)
+  expect(isHandlerKind('RequestHandler')({})).toBe(false)
+  expect(isHandlerKind('RequestHandler')([])).toBe(false)
+  expect(isHandlerKind('RequestHandler')(123)).toBe(false)
+  expect(isHandlerKind('RequestHandler')('hello')).toBe(false)
+})
+
+it('returns true if expected an event handler and given an event handler', () => {
+  expect(isHandlerKind('EventHandler')(new WebSocketHandler('*'))).toBe(true)
+})
+
+it('returns true if expected an event handler and given a custom event handler', () => {
+  class MyEventHandler extends WebSocketHandler {
+    constructor() {
+      super('*')
+    }
+  }
+  expect(isHandlerKind('EventHandler')(new MyEventHandler())).toBe(true)
+})
+
+it('returns false if expected an event handler but given arbitrary object', () => {
+  expect(isHandlerKind('EventHandler')(undefined)).toBe(false)
+  expect(isHandlerKind('EventHandler')(null)).toBe(false)
+  expect(isHandlerKind('EventHandler')({})).toBe(false)
+  expect(isHandlerKind('EventHandler')([])).toBe(false)
+  expect(isHandlerKind('EventHandler')(123)).toBe(false)
+  expect(isHandlerKind('EventHandler')('hello')).toBe(false)
+})

package/src/core/utils/internal/isHandlerKind.ts

@@ -0,0 +1,21 @@
+import type { HandlerKind } from '../../handlers/common'
+import type { RequestHandler } from '../../handlers/RequestHandler'
+import type { WebSocketHandler } from '../../handlers/WebSocketHandler'
+
+/**
+ * A filter function that ensures that the provided argument
+ * is a handler of the given kind. This helps differentiate
+ * between different kinds of handlers, e.g. request and event handlers.
+ */
+export function isHandlerKind<K extends HandlerKind>(kind: K) {
+  return (
+    input: unknown,
+  ): input is K extends 'EventHandler' ? WebSocketHandler : RequestHandler => {
+    return (
+      input != null &&
+      typeof input === 'object' &&
+      '__kind' in input &&
+      input.__kind === kind
+    )
+  }
+}

package/src/core/utils/internal/isIterable.test.ts

@@ -0,0 +1,23 @@
+import { isIterable } from './isIterable'
+
+test('returns true given an iterator', () => {
+  expect(
+    isIterable(
+      (function* () {
+        yield 2
+      })(),
+    ),
+  ).toEqual(true)
+})
+
+test('returns false given a regular function', () => {
+  expect(
+    isIterable(
+      (function () {
+        return null
+      })(),
+    ),
+  ).toEqual(false)
+
+  expect(isIterable((() => null)())).toEqual(false)
+})

package/src/core/utils/internal/isIterable.ts

@@ -0,0 +1,32 @@
+/**
+ * This is the same as TypeScript's `Iterable`, but with all three type parameters.
+ * @todo Remove once TypeScript 5.6 is the minimum.
+ */
+export interface Iterable<T, TReturn, TNext> {
+  [Symbol.iterator](): Iterator<T, TReturn, TNext>
+}
+
+/**
+ * This is the same as TypeScript's `AsyncIterable`, but with all three type parameters.
+ * @todo Remove once TypeScript 5.6 is the minimum.
+ */
+export interface AsyncIterable<T, TReturn, TNext> {
+  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>
+}
+
+/**
+ * Determines if the given function is an iterator.
+ */
+export function isIterable<IteratorType>(
+  fn: any,
+): fn is
+  | Iterable<IteratorType, IteratorType, IteratorType>
+  | AsyncIterable<IteratorType, IteratorType, IteratorType> {
+  if (!fn) {
+    return false
+  }
+
+  return (
+    Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator)
+  )
+}

package/src/core/utils/internal/isObject.test.ts

@@ -0,0 +1,20 @@
+import { isObject } from './isObject'
+
+test('returns true given an object', () => {
+  expect(isObject({})).toBe(true)
+  expect(isObject({ a: 1 })).toBe(true)
+})
+
+test('returns false given a non-object value', () => {
+  expect(isObject(1)).toBe(false)
+  expect(isObject('string')).toBe(false)
+  expect(isObject([])).toBe(false)
+  expect(
+    isObject(function () {
+      return 2
+    }),
+  ).toBe(false)
+  expect(isObject(false)).toBe(false)
+  expect(isObject(undefined)).toBe(false)
+  expect(isObject(null)).toBe(false)
+})

package/src/core/utils/internal/isObject.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines if the given value is an object.
+ */
+export function isObject(value: any): value is Record<string, any> {
+  return value != null && typeof value === 'object' && !Array.isArray(value)
+}

package/src/core/utils/internal/isStringEqual.test.ts

@@ -0,0 +1,45 @@
+import { isStringEqual } from './isStringEqual'
+
+describe('isStringEqual', () => {
+  describe('given two uppercase strings', () => {
+    describe('and the strings are equal', () => {
+      it('should return true', () => {
+        expect(isStringEqual('GET', 'GET')).toBe(true)
+      })
+    })
+
+    describe('and the strings are not equal', () => {
+      it('should return false', () => {
+        expect(isStringEqual('GET', 'POST')).toBe(false)
+      })
+    })
+  })
+
+  describe('given two lowercase strings', () => {
+    describe('and the strings are equal', () => {
+      it('should return true', () => {
+        expect(isStringEqual('get', 'get')).toBe(true)
+      })
+    })
+
+    describe('and the strings are not equal', () => {
+      it('should return false', () => {
+        expect(isStringEqual('get', 'post')).toBe(false)
+      })
+    })
+  })
+
+  describe('given two strings cased differently', () => {
+    describe('and the strings are equal', () => {
+      it('should return true', () => {
+        expect(isStringEqual('get', 'GET')).toBe(true)
+      })
+    })
+
+    describe('and the strings are not equal', () => {
+      it('should return false', () => {
+        expect(isStringEqual('get', 'POST')).toBe(false)
+      })
+    })
+  })
+})

package/src/core/utils/internal/isStringEqual.ts

@@ -0,0 +1,6 @@
+/**
+ * Performs a case-insensitive comparison of two given strings.
+ */
+export function isStringEqual(actual: string, expected: string): boolean {
+  return actual.toLowerCase() === expected.toLowerCase()
+}

package/src/core/utils/internal/jsonParse.test.ts

@@ -0,0 +1,13 @@
+import { jsonParse } from './jsonParse'
+
+test('parses a given valid JSON string', () => {
+  expect(jsonParse(`{"property":"value"}`)).toEqual({
+    property: 'value',
+  })
+})
+
+test('returns undefined without an error given an invalid JSON string', () => {
+  const parse = () => jsonParse(`{"property:val"ue$}`)
+  expect(parse).not.toThrow()
+  expect(parse()).toBeUndefined()
+})

package/src/core/utils/internal/jsonParse.ts

@@ -0,0 +1,13 @@
+/**
+ * Parses a given value into a JSON.
+ * Does not throw an exception on an invalid JSON string.
+ */
+export function jsonParse<ValueType extends Record<string, any>>(
+  value: any,
+): ValueType | undefined {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return undefined
+  }
+}

package/src/core/utils/internal/mergeRight.test.ts

@@ -0,0 +1,43 @@
+import { mergeRight } from './mergeRight'
+
+test('shallowly merges two given objects', () => {
+  expect(mergeRight({ a: 1, b: 2 }, { b: 3, c: 4 })).toEqual({
+    a: 1,
+    b: 3,
+    c: 4,
+  })
+})
+
+test('deeply merges two given objects', () => {
+  expect(
+    mergeRight(
+      {
+        a: 'string',
+        b: [1, 2],
+        c: {
+          d: 2,
+        },
+      },
+      {
+        a: 'another-string',
+        b: [3],
+        c: {
+          e: 'five',
+          f: {
+            g: true,
+          },
+        },
+      },
+    ),
+  ).toEqual({
+    a: 'another-string',
+    b: [1, 2, 3],
+    c: {
+      d: 2,
+      e: 'five',
+      f: {
+        g: true,
+      },
+    },
+  })
+})

package/src/core/utils/internal/mergeRight.ts

@@ -0,0 +1,30 @@
+import { isObject } from './isObject'
+
+/**
+ * Deeply merges two given objects with the right one
+ * having a priority during property assignment.
+ */
+export function mergeRight(
+  left: Record<string, any>,
+  right: Record<string, any>,
+) {
+  return Object.entries(right).reduce(
+    (result, [key, rightValue]) => {
+      const leftValue = result[key]
+
+      if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
+        result[key] = leftValue.concat(rightValue)
+        return result
+      }
+
+      if (isObject(leftValue) && isObject(rightValue)) {
+        result[key] = mergeRight(leftValue, rightValue)
+        return result
+      }
+
+      result[key] = rightValue
+      return result
+    },
+    Object.assign({}, left),
+  )
+}