msw 2.14.7 → 3.0.0

package/src/core/utils/http-status-messages.ts

@@ -0,0 +1,69 @@
+/**
+ * Reason phrases of the known HTTP status codes.
+ * @see https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+ */
+export const httpStatusMessages: Record<number, string> = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  208: 'Already Reported',
+  226: 'IM Used',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  414: 'URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a Teapot",
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  425: 'Too Early',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates',
+  507: 'Insufficient Storage',
+  508: 'Loop Detected',
+  509: 'Bandwidth Limit Exceeded',
+  510: 'Not Extended',
+  511: 'Network Authentication Required',
+}

package/src/core/utils/internal/{attachSiblingHandlers.ts → attach-sibling-handlers.ts}

@@ -2,6 +2,7 @@ import { invariant } from 'outvariant'
 import type { AnyHandler } from '../../experimental/handlers-controller'
 
 const kSiblingHandlers = Symbol('kSiblingHandlers')
+const kIsSiblingHandler = Symbol('kIsSiblingHandler')
 
 export function attachSiblingHandlers<T extends AnyHandler>(
   owner: T,
@@ -20,9 +21,28 @@ export function attachSiblingHandlers<T extends AnyHandler>(
     configurable: false,
   })
 
+  // Mark the siblings so introspection (e.g. `.listHandlers()`) can tell
+  // explicitly registered handlers from their implementation details.
+  // Shared siblings can be attached to multiple owners, so skip the
+  // already-marked ones.
+  for (const sibling of siblings) {
+    if (!isSiblingHandler(sibling)) {
+      Object.defineProperty(sibling, kIsSiblingHandler, {
+        value: true,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+      })
+    }
+  }
+
   return owner
 }
 
 export function getSiblingHandlers(owner: AnyHandler): Array<AnyHandler> {
   return Reflect.get(owner, kSiblingHandlers) || []
 }
+
+export function isSiblingHandler(handler: AnyHandler): boolean {
+  return Reflect.get(handler, kIsSiblingHandler) === true
+}

package/src/core/utils/internal/{devUtils.test.ts → dev-utils.test.ts}

@@ -1,7 +1,7 @@
-import { InternalError } from './devUtils'
+import { InternalError } from './dev-utils'
 
 describe(InternalError, () => {
-  it('creates an InternalError instance', () => {
+  test('creates an InternalError instance', () => {
     const error = new InternalError('Message')
 
     expect(error.name).toBe('InternalError')
@@ -10,7 +10,7 @@ describe(InternalError, () => {
     expect(error.stack).toMatch(/\w+/)
   })
 
-  it('passes the identity check', () => {
+  test('passes the identity check', () => {
     const error = new InternalError('Message')
     expect(error instanceof InternalError).toBe(true)
     expect(error instanceof Error).toBe(true)

package/src/core/utils/internal/{Disposable.ts → disposable.ts}

@@ -1,4 +1,4 @@
-import { devUtils } from './devUtils'
+import { devUtils } from './dev-utils'
 
 export type DisposableSubscription = () => void
 

package/src/core/utils/internal/{getCallFrame.test.ts → get-call-frame.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment jsdom
  */
-import { getCallFrame } from './getCallFrame'
+import { getCallFrame } from './get-call-frame'
 
 class ErrorWithStack extends Error {
   constructor(stack: string[] | undefined | null) {

package/src/core/utils/internal/{getCallFrame.ts → get-call-frame.ts}

@@ -2,7 +2,7 @@
 const SOURCE_FRAME = /[/\\]msw[/\\]src[/\\](.+)/
 
 const BUILD_FRAME =
-  /(node_modules)?[/\\]lib[/\\](core|browser|node|native|iife)[/\\]|^[^/\\]*$/
+  /(node_modules)?[/\\]lib[/\\](core|browser|node|iife)[/\\]|^[^/\\]*$/
 
 /**
  * Return the stack trace frame of a function's invocation.

package/src/core/utils/internal/{hasRefCounted.test.ts → has-ref-counted.test.ts}

@@ -1,6 +1,6 @@
-import { hasRefCounted } from './hasRefCounted'
+import { hasRefCounted } from './has-ref-counted'
 
-it('returns true for objects with ref and unref methods', () => {
+test('returns true for objects with ref and unref methods', () => {
   expect(
     hasRefCounted({
       ref() {},
@@ -9,13 +9,13 @@ it('returns true for objects with ref and unref methods', () => {
   ).toBe(true)
 })
 
-it('returns false for a non-refcounted object', () => {
+test('returns false for a non-refcounted object', () => {
   expect(hasRefCounted({})).toBe(false)
   expect(hasRefCounted({ ref() {} })).toBe(false)
   expect(hasRefCounted({ unref() {} })).toBe(false)
 })
 
-it('returns false for non-object values', () => {
+test('returns false for non-object values', () => {
   expect(
     hasRefCounted(
       // @ts-expect-error Runtime value.

package/src/core/utils/internal/{hasRefCounted.ts → has-ref-counted.ts}

@@ -1,4 +1,4 @@
-import { isObject } from './isObject'
+import { isObject } from './is-object'
 
 export function hasRefCounted<T extends object>(
   value: T,

package/src/core/utils/internal/{isIterable.test.ts → is-iterable.test.ts}

@@ -1,4 +1,4 @@
-import { isIterable } from './isIterable'
+import { isIterable } from './is-iterable'
 
 test('returns true given an iterator', () => {
   expect(

package/src/core/utils/internal/is-iterable.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 → is-object.test.ts}

@@ -1,4 +1,4 @@
-import { isObject } from './isObject'
+import { isObject } from './is-object'
 
 test('returns true given an object', () => {
   expect(isObject({})).toBe(true)

package/src/core/utils/internal/{isStringEqual.test.ts → is-string-equal.test.ts}

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

package/src/core/utils/internal/{jsonParse.test.ts → json-parse.test.ts}

@@ -1,4 +1,4 @@
-import { jsonParse } from './jsonParse'
+import { jsonParse } from './json-parse'
 
 test('parses a given valid JSON string', () => {
   expect(jsonParse(`{"property":"value"}`)).toEqual({

package/src/core/utils/internal/observe-response-body-stream.test.ts

@@ -0,0 +1,64 @@
+import { observeResponseBodyStream } from './observe-response-body-stream'
+
+test('returns null for a response without a body', () => {
+  expect(observeResponseBodyStream(new Response(null))).toBeNull()
+})
+
+test('returns null for a response whose body is already used', async () => {
+  const response = new Response('hello')
+  await response.text()
+
+  expect(observeResponseBodyStream(response)).toBeNull()
+})
+
+test('returns null for a response whose body is locked', () => {
+  const response = new Response('hello')
+  response.body?.getReader()
+
+  expect(observeResponseBodyStream(response)).toBeNull()
+})
+
+test('resolves "settled" when the response body is read to completion', async () => {
+  const observed = observeResponseBodyStream(new Response('hello'))
+  expect(observed).not.toBeNull()
+
+  await expect(observed?.response.text()).resolves.toBe('hello')
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+test('resolves "settled" when the response body errors', async () => {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.error(new Error('stream error'))
+    },
+  })
+  const observed = observeResponseBodyStream(new Response(stream))
+  expect(observed).not.toBeNull()
+
+  await expect(observed?.response.text()).rejects.toThrow('stream error')
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+test('resolves "settled" when the response body is canceled', async () => {
+  const stream = new ReadableStream({
+    pull(controller) {
+      controller.enqueue(new TextEncoder().encode('ping'))
+    },
+  })
+  const observed = observeResponseBodyStream(new Response(stream))
+  const reader = observed?.response.body?.getReader()
+  expect(reader).toBeDefined()
+
+  await reader?.read()
+  await reader?.cancel(new Error('client disconnected'))
+
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+test('resolves "settled" when the response body is consumed via piping', async () => {
+  const observed = observeResponseBodyStream(new Response('hello'))
+  expect(observed).not.toBeNull()
+
+  await observed?.response.body?.pipeTo(new WritableStream())
+  await expect(observed?.settled).resolves.toBeUndefined()
+})

package/src/core/utils/internal/observe-response-body-stream.ts

@@ -0,0 +1,76 @@
+import { FetchResponse } from '@mswjs/interceptors'
+import { copyResponseOwnProperties } from '../response-decorators'
+
+export interface ObservedResponse {
+  response: Response
+  /**
+   * A promise that resolves once the response body stream has settled:
+   * it was closed, errored, or canceled, and will not be used anymore.
+   */
+  settled: Promise<void>
+}
+
+/**
+ * Observe the `ReadableStream` body of the given response.
+ * Returns a copy of that response whose body reports when it has
+ * settled (was read to completion, errored, or canceled by the consumer).
+ * Returns `null` for responses whose body cannot be observed
+ * (no body, already used, or locked).
+ */
+export function observeResponseBodyStream(
+  response: Response,
+): ObservedResponse | null {
+  if (response.body == null || response.bodyUsed || response.body.locked) {
+    return null
+  }
+
+  const settled = Promise.withResolvers<void>()
+  const reader = response.body.getReader()
+
+  /**
+   * @note Relay the body through a manual underlying source instead of
+   * `.pipeThrough(new TransformStream({ flush, cancel }))`. The `cancel`
+   * transformer callback is not implemented in Chromium, which loses
+   * the stream error/cancelation signals there entirely.
+   */
+  const observedStream = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const readResult = await reader.read()
+
+        if (readResult.done) {
+          settled.resolve()
+          controller.close()
+          return
+        }
+
+        controller.enqueue(readResult.value)
+      } catch (error) {
+        settled.resolve()
+        throw error
+      }
+    },
+    async cancel(reason) {
+      settled.resolve()
+      await reader.cancel(reason)
+    },
+  })
+
+  /**
+   * @note Reconstruct the response because the body of an existing
+   * response cannot be replaced. Use `FetchResponse` to support
+   * non-standard response status codes (e.g. 101).
+   */
+  const observedResponse = new FetchResponse(observedStream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  })
+
+  copyResponseOwnProperties(response, observedResponse)
+
+  return {
+    response: observedResponse,
+    settled: settled.promise,
+  }
+}

package/src/core/utils/internal/{parseMultipartData.test.ts → parse-multipart-data.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment jsdom
  */
-import { parseMultipartData } from './parseMultipartData'
+import { parseMultipartData } from './parse-multipart-data'
 
 test('parses a given valid multipart string', async () => {
   expect.assertions(3)

package/src/core/utils/internal/{parseMultipartData.ts → parse-multipart-data.ts}

@@ -1,5 +1,5 @@
 import { stringToHeaders } from 'headers-polyfill'
-import { type DefaultRequestMultipartBody } from '../../handlers/RequestHandler'
+import type { DefaultRequestMultipartBody } from '../../handlers/request-handler'
 
 interface ParsedContentHeaders {
   name: string

package/src/core/utils/internal/{toReadonlyArray.test.ts → to-readonly-array.test.ts}

@@ -1,10 +1,10 @@
-import { toReadonlyArray } from './toReadonlyArray'
+import { toReadonlyArray } from './to-readonly-array'
 
-it('creates a copy of an array', () => {
+test('creates a copy of an array', () => {
   expect(toReadonlyArray([1, 2, 3])).toEqual([1, 2, 3])
 })
 
-it('does not affect the source array', () => {
+test('does not affect the source array', () => {
   const source = ['a', 'b', 'c']
   toReadonlyArray(source)
 
@@ -12,7 +12,7 @@ it('does not affect the source array', () => {
   expect(source).toEqual(['a', 'b', 'c', 'd'])
 })
 
-it('forbids modifying the array copy', () => {
+test('forbids modifying the array copy', () => {
   const source = [1, 2, 3]
   const copy = toReadonlyArray(source)
 

package/src/core/utils/logging/colors.ts

@@ -0,0 +1,13 @@
+/**
+ * Colors for logging the direction of intercepted events.
+ *
+ * @note A standalone module so consumers interested only in the
+ * palette (e.g. `sse`, `msw/graphql` loggers) don't pull the entire
+ * WebSocket logger into their graph.
+ */
+export const colors = {
+  system: '#3b82f6',
+  outgoing: '#22c55e',
+  incoming: '#ef4444',
+  mocked: '#ff6a33',
+}

package/src/core/utils/logging/{getStatusCodeColor.test.ts → get-status-code-color.test.ts}

@@ -1,4 +1,4 @@
-import { getStatusCodeColor } from './getStatusCodeColor'
+import { getStatusCodeColor } from './get-status-code-color'
 
 test('returns a green color for status codes lower than 300', () => {
   expect(getStatusCodeColor(100)).toBe('#69AB32')

package/src/core/utils/logging/{getTimestamp.test.ts → get-timestamp.test.ts}

@@ -1,4 +1,4 @@
-import { getTimestamp } from './getTimestamp'
+import { getTimestamp } from './get-timestamp'
 
 beforeAll(() => {
   vi.useFakeTimers()

package/src/core/utils/logging/{serializeRequest.test.ts → serialize-request.test.ts}

@@ -1,5 +1,5 @@
 import { encodeBuffer } from '@mswjs/interceptors'
-import { serializeRequest } from './serializeRequest'
+import { serializeRequest } from './serialize-request'
 
 test('serializes given Request instance into a plain object', async () => {
   const request = await serializeRequest(

package/src/core/utils/logging/{serializeResponse.test.ts → serialize-response.test.ts}

@@ -1,10 +1,8 @@
-/**
- * @vitest-environment node
- */
+// @vitest-environment node
 import { encodeBuffer } from '@mswjs/interceptors'
-import { serializeResponse } from './serializeResponse'
+import { serializeResponse } from './serialize-response'
 
-it('serializes response without body', async () => {
+test('serializes response without body', async () => {
   const result = await serializeResponse(new Response(null))
 
   expect(result.status).toBe(200)
@@ -13,7 +11,7 @@ it('serializes response without body', async () => {
   expect(result.body).toBe('')
 })
 
-it('serializes a plain text response', async () => {
+test('serializes a plain text response', async () => {
   const result = await serializeResponse(
     new Response('hello world', {
       status: 201,
@@ -32,7 +30,7 @@ it('serializes a plain text response', async () => {
   expect(result.body).toBe('hello world')
 })
 
-it('serializes a JSON response', async () => {
+test('serializes a JSON response', async () => {
   const response = new Response(JSON.stringify({ users: ['John'] }), {
     headers: {
       'Content-Type': 'application/json',
@@ -46,7 +44,7 @@ it('serializes a JSON response', async () => {
   expect(result.body).toBe(JSON.stringify({ users: ['John'] }))
 })
 
-it('serializes a ArrayBuffer response', async () => {
+test('serializes a ArrayBuffer response', async () => {
   const data = encodeBuffer('hello world')
   const response = new Response(data)
   const result = await serializeResponse(response)
@@ -54,14 +52,14 @@ it('serializes a ArrayBuffer response', async () => {
   expect(result.body).toBe('hello world')
 })
 
-it('serializes a Blob response', async () => {
+test('serializes a Blob response', async () => {
   const response = new Response(new Blob(['hello world']))
   const result = await serializeResponse(response)
 
   expect(result.body).toBe('hello world')
 })
 
-it('serializes a FormData response', async () => {
+test('serializes a FormData response', async () => {
   const data = new FormData()
   data.set('firstName', 'Alice')
   data.set('age', '32')

package/src/core/utils/logging/{serializeResponse.ts → serialize-response.ts}

@@ -1,6 +1,4 @@
-import statuses from '../../../shims/statuses'
-
-const { message } = statuses
+import { httpStatusMessages } from '../http-status-messages'
 
 export interface SerializedResponse {
   status: number
@@ -20,7 +18,7 @@ export async function serializeResponse(
   // from status codes. This has no effect on the actual response instance.
   const responseStatus = responseClone.status || 200
   const responseStatusText =
-    responseClone.statusText || message[responseStatus] || 'OK'
+    responseClone.statusText || httpStatusMessages[responseStatus] || 'OK'
 
   return {
     status: responseStatus,

package/src/core/utils/matching/match-request-url.test.ts

@@ -0,0 +1,90 @@
+// @vitest-environment jsdom
+import { matchRequestUrl } from './match-request-url'
+
+test('returns true when matched against a string URL', () => {
+  expect(
+    matchRequestUrl(new URL('https://test.mswjs.io'), 'https://test.mswjs.io'),
+  ).toEqual({
+    matches: true,
+    params: {},
+  })
+})
+
+test('returns false when a string URL does not match', () => {
+  expect(
+    matchRequestUrl(new URL('https://test.mswjs.io'), 'https://google.com'),
+  ).toEqual({
+    matches: false,
+    params: {},
+  })
+})
+
+test('returns true when matched against a RegExp', () => {
+  expect(
+    matchRequestUrl(new URL('https://test.mswjs.io'), /test\.mswjs\.io/),
+  ).toEqual({
+    matches: true,
+    params: {},
+  })
+})
+
+test('returns false when a RegExp does not match', () => {
+  expect(matchRequestUrl(new URL('https://test.mswjs.io'), /foo\.bar/)).toEqual(
+    {
+      matches: false,
+      params: {},
+    },
+  )
+
+  expect(
+    matchRequestUrl(new URL('https://test.mswjs.io'), /foo\.bar/g),
+  ).toEqual({
+    matches: false,
+    params: {},
+  })
+
+  expect(matchRequestUrl(new URL('https://test.mswjs.io'), /foo(.+)/)).toEqual({
+    matches: false,
+    params: {},
+  })
+
+  expect(matchRequestUrl(new URL('https://test.mswjs.io'), /foo(.+)/g)).toEqual(
+    {
+      matches: false,
+      params: {},
+    },
+  )
+})
+
+test('ignores query parameters when matching against a RegExp', () => {
+  expect(
+    matchRequestUrl(new URL('https://test.mswjs.io/path?foo=bar'), /\/path$/),
+  ).toEqual({
+    matches: true,
+    params: {},
+  })
+})
+
+test('parses matching RegExp groups into index-based parameters', () => {
+  expect(
+    matchRequestUrl(new URL('https://test.mswjs.io/path'), /(.+)\.mswjs\.io/g),
+  ).toEqual({
+    matches: true,
+    params: {
+      0: 'https://test',
+    },
+  })
+
+  expect(
+    matchRequestUrl(
+      new URL('https://test.mswjs.io/path'),
+      /https:\/\/(.+)\.mswjs\.io\/(.+)/g,
+    ),
+  ).toEqual({
+    matches: true,
+    params: {
+      0: 'test',
+      1: 'path',
+    },
+  })
+})