msw 2.0.12 → 2.0.13

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

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

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/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,12 @@
+/**
+ * Determines if the given function is an iterator.
+ */
+export function isIterable<IteratorType>(
+  fn: any,
+): fn is Generator<IteratorType, IteratorType, IteratorType> {
+  if (!fn) {
+    return false
+  }
+
+  return typeof (fn as Generator<unknown>)[Symbol.iterator] == 'function'
+}

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): boolean {
+  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 (error) {
+    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,27 @@
+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))
+}

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

@@ -0,0 +1,99 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { encodeBuffer } from '@mswjs/interceptors'
+import { OperationTypeNode } from 'graphql'
+import {
+  ParsedGraphQLRequest,
+  parseGraphQLRequest,
+} from './parseGraphQLRequest'
+
+test('returns true given a GraphQL-compatible request', async () => {
+  const getRequest = new Request(
+    new URL(
+      'http://localhost:8080/graphql?query=mutation Login { user { id } }',
+    ),
+  )
+  expect(await parseGraphQLRequest(getRequest)).toEqual<
+    ParsedGraphQLRequest<any>
+  >({
+    operationType: OperationTypeNode.MUTATION,
+    operationName: 'Login',
+    query: `mutation Login { user { id } }`,
+    variables: undefined,
+  })
+
+  const postRequest = new Request(new URL('http://localhost:8080/graphql'), {
+    method: 'POST',
+    headers: new Headers({ 'Content-Type': 'application/json' }),
+    body: encodeBuffer(
+      JSON.stringify({
+        query: `query GetUser { user { firstName } }`,
+      }),
+    ),
+  })
+
+  expect(await parseGraphQLRequest(postRequest)).toEqual<
+    ParsedGraphQLRequest<any>
+  >({
+    operationType: OperationTypeNode.QUERY,
+    operationName: 'GetUser',
+    query: `query GetUser { user { firstName } }`,
+    variables: undefined,
+  })
+})
+
+test('throws an exception given an invalid GraphQL request', async () => {
+  const getRequest = new Request(
+    new URL('http://localhost:8080/graphql?query=mutation Login() { user { {}'),
+  )
+
+  await expect(parseGraphQLRequest(getRequest)).rejects.toThrowError(
+    '[MSW] Failed to intercept a GraphQL request to "GET http://localhost:8080/graphql": cannot parse query. See the error message from the parser below.',
+  )
+
+  const postRequest = new Request(new URL('http://localhost:8080/graphql'), {
+    method: 'POST',
+    headers: new Headers({ 'Content-Type': 'application/json' }),
+    body: encodeBuffer(
+      JSON.stringify({
+        query: `query GetUser() { user {{}`,
+      }),
+    ),
+  })
+
+  await expect(parseGraphQLRequest(postRequest)).rejects.toThrowError(
+    '[MSW] Failed to intercept a GraphQL request to "POST http://localhost:8080/graphql": cannot parse query. See the error message from the parser below.\n\nSyntax Error: Expected "$", found ")".',
+  )
+})
+
+test('returns false given a GraphQL-incompatible request', async () => {
+  const getRequest = new Request(new URL('http://localhost:8080/graphql'), {
+    headers: new Headers({ 'Content-Type': 'application/json' }),
+  })
+  expect(await parseGraphQLRequest(getRequest)).toBeUndefined()
+
+  const postRequest = new Request(new URL('http://localhost:8080/graphql'), {
+    method: 'POST',
+    headers: new Headers({ 'Content-Type': 'application/json' }),
+    body: encodeBuffer(
+      JSON.stringify({
+        queryUser: true,
+      }),
+    ),
+  })
+  expect(await parseGraphQLRequest(postRequest)).toBeUndefined()
+})
+
+test('does not read the original request body', async () => {
+  const request = new Request(new URL('http://localhost/api'), {
+    method: 'POST',
+    body: JSON.stringify({ payload: 'value' }),
+  })
+
+  await parseGraphQLRequest(request)
+
+  // Must not read the original request body because GraphQL parsing
+  // is an internal operation that must not lock the body stream.
+  expect(request.bodyUsed).toBe(false)
+})