msw 2.0.12 → 2.0.14

package/src/core/utils/handleRequest.ts

@@ -0,0 +1,132 @@
+import { until } from '@open-draft/until'
+import { Emitter } from 'strict-event-emitter'
+import { RequestHandler } from '../handlers/RequestHandler'
+import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
+import { RequiredDeep } from '../typeUtils'
+import { ResponseLookupResult, getResponse } from './getResponse'
+import { onUnhandledRequest } from './request/onUnhandledRequest'
+import { readResponseCookies } from './request/readResponseCookies'
+
+export interface HandleRequestOptions {
+  /**
+   * `resolutionContext` is not part of the general public api
+   * but is exposed to aid in creating extensions like
+   * `@mswjs/http-middleware`.
+   */
+  resolutionContext?: {
+    /**
+     * A base url to use when resolving relative urls.
+     * @note This is primarily used by the `@mswjs/http-middleware`
+     * to resolve relative urls in the context of the running server
+     */
+    baseUrl?: string
+  }
+
+  /**
+   * Transforms a `MockedResponse` instance returned from a handler
+   * to a response instance supported by the lower tooling (i.e. interceptors).
+   */
+  transformResponse?(response: Response): Response
+
+  /**
+   * Invoked whenever a request is performed as-is.
+   */
+  onPassthroughResponse?(request: Request): void
+
+  /**
+   * Invoked when the mocked response is ready to be sent.
+   */
+  onMockedResponse?(
+    response: Response,
+    handler: RequiredDeep<ResponseLookupResult>,
+  ): void
+}
+
+export async function handleRequest(
+  request: Request,
+  requestId: string,
+  handlers: Array<RequestHandler>,
+  options: RequiredDeep<SharedOptions>,
+  emitter: Emitter<LifeCycleEventsMap>,
+  handleRequestOptions?: HandleRequestOptions,
+): Promise<Response | undefined> {
+  emitter.emit('request:start', { request, requestId })
+
+  // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
+  if (request.headers.get('x-msw-intention') === 'bypass') {
+    emitter.emit('request:end', { request, requestId })
+    handleRequestOptions?.onPassthroughResponse?.(request)
+    return
+  }
+
+  // Resolve a mocked response from the list of request handlers.
+  const lookupResult = await until(() => {
+    return getResponse(
+      request,
+      handlers,
+      handleRequestOptions?.resolutionContext,
+    )
+  })
+
+  if (lookupResult.error) {
+    // Allow developers to react to unhandled exceptions in request handlers.
+    emitter.emit('unhandledException', {
+      error: lookupResult.error,
+      request,
+      requestId,
+    })
+    throw lookupResult.error
+  }
+
+  // If the handler lookup returned nothing, no request handler was found
+  // matching this request. Report the request as unhandled.
+  if (!lookupResult.data) {
+    await onUnhandledRequest(request, handlers, options.onUnhandledRequest)
+    emitter.emit('request:unhandled', { request, requestId })
+    emitter.emit('request:end', { request, requestId })
+    handleRequestOptions?.onPassthroughResponse?.(request)
+    return
+  }
+
+  const { response } = lookupResult.data
+
+  // When the handled request returned no mocked response, warn the developer,
+  // as it may be an oversight on their part. Perform the request as-is.
+  if (!response) {
+    emitter.emit('request:end', { request, requestId })
+    handleRequestOptions?.onPassthroughResponse?.(request)
+    return
+  }
+
+  // Perform the request as-is when the developer explicitly returned "req.passthrough()".
+  // This produces no warning as the request was handled.
+  if (
+    response.status === 302 &&
+    response.headers.get('x-msw-intention') === 'passthrough'
+  ) {
+    emitter.emit('request:end', { request, requestId })
+    handleRequestOptions?.onPassthroughResponse?.(request)
+    return
+  }
+
+  // Store all the received response cookies in the virtual cookie store.
+  readResponseCookies(request, response)
+
+  emitter.emit('request:match', { request, requestId })
+
+  const requiredLookupResult =
+    lookupResult.data as RequiredDeep<ResponseLookupResult>
+
+  const transformedResponse =
+    handleRequestOptions?.transformResponse?.(response) ||
+    (response as any as Response)
+
+  handleRequestOptions?.onMockedResponse?.(
+    transformedResponse,
+    requiredLookupResult,
+  )
+
+  emitter.emit('request:end', { request, requestId })
+
+  return transformedResponse
+}

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

@@ -0,0 +1,9 @@
+export type DisposableSubscription = () => Promise<void> | void
+
+export class Disposable {
+  protected subscriptions: Array<DisposableSubscription> = []
+
+  public async dispose() {
+    await Promise.all(this.subscriptions.map((subscription) => subscription()))
+  }
+}

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.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))
+}