@depup/msw 2.15.0-depup.9 → 3.0.0-depup.0

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

@@ -1,24 +1,24 @@
 import { observeResponseBodyStream } from './observe-response-body-stream'
 
-it('returns null for a response without a body', () => {
+test('returns null for a response without a body', () => {
   expect(observeResponseBodyStream(new Response(null))).toBeNull()
 })
 
-it('returns null for a response whose body is already used', async () => {
+test('returns null for a response whose body is already used', async () => {
   const response = new Response('hello')
   await response.text()
 
   expect(observeResponseBodyStream(response)).toBeNull()
 })
 
-it('returns null for a response whose body is locked', () => {
+test('returns null for a response whose body is locked', () => {
   const response = new Response('hello')
   response.body?.getReader()
 
   expect(observeResponseBodyStream(response)).toBeNull()
 })
 
-it('resolves "settled" when the response body is read to completion', async () => {
+test('resolves "settled" when the response body is read to completion', async () => {
   const observed = observeResponseBodyStream(new Response('hello'))
   expect(observed).not.toBeNull()
 
@@ -26,7 +26,7 @@ it('resolves "settled" when the response body is read to completion', async () =
   await expect(observed?.settled).resolves.toBeUndefined()
 })
 
-it('resolves "settled" when the response body errors', async () => {
+test('resolves "settled" when the response body errors', async () => {
   const stream = new ReadableStream({
     start(controller) {
       controller.error(new Error('stream error'))
@@ -39,7 +39,7 @@ it('resolves "settled" when the response body errors', async () => {
   await expect(observed?.settled).resolves.toBeUndefined()
 })
 
-it('resolves "settled" when the response body is canceled', async () => {
+test('resolves "settled" when the response body is canceled', async () => {
   const stream = new ReadableStream({
     pull(controller) {
       controller.enqueue(new TextEncoder().encode('ping'))
@@ -55,7 +55,7 @@ it('resolves "settled" when the response body is canceled', async () => {
   await expect(observed?.settled).resolves.toBeUndefined()
 })
 
-it('resolves "settled" when the response body is consumed via piping', async () => {
+test('resolves "settled" when the response body is consumed via piping', async () => {
   const observed = observeResponseBodyStream(new Response('hello'))
   expect(observed).not.toBeNull()
 

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

@@ -1,6 +1,5 @@
-import { DeferredPromise } from '@open-draft/deferred-promise'
 import { FetchResponse } from '@mswjs/interceptors'
-import { copyResponseOwnProperties } from '../HttpResponse/decorators'
+import { copyResponseOwnProperties } from '../response-decorators'
 
 export interface ObservedResponse {
   response: Response
@@ -25,7 +24,7 @@ export function observeResponseBodyStream(
     return null
   }
 
-  const settled = new DeferredPromise<void>()
+  const settled = Promise.withResolvers<void>()
   const reader = response.body.getReader()
 
   /**
@@ -72,6 +71,6 @@ export function observeResponseBodyStream(
 
   return {
     response: observedResponse,
-    settled,
+    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',
+    },
+  })
+})

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

@@ -0,0 +1,45 @@
+import { matchPattern } from '@msw/url'
+import { getCleanUrl } from '@mswjs/interceptors'
+import { normalizePath } from './normalize-path'
+
+export type Path = string | RegExp
+export type PathParams<KeyType extends keyof any = string> = {
+  [ParamName in KeyType]?: string | ReadonlyArray<string>
+}
+
+export interface Match {
+  matches: boolean
+  params?: PathParams
+}
+
+export function isPath(value: unknown): value is Path {
+  return typeof value === 'string' || value instanceof RegExp
+}
+
+/**
+ * Match the given URL against a path pattern.
+ */
+export function matchRequestUrl(
+  url: URL,
+  pattern: Path,
+  baseUrl?: string,
+): Match {
+  const cleanUrl = getCleanUrl(url)
+
+  if (pattern instanceof RegExp) {
+    const match = pattern.flags.includes('g')
+      ? [...cleanUrl.matchAll(pattern)].flat()
+      : cleanUrl.match(pattern)
+
+    return {
+      matches: match != null && match.length > 0,
+      params: Object.fromEntries(
+        (match ?? []).slice(1).map((value, index) => [index, value]),
+      ),
+    }
+  }
+
+  // Resolve potentially realive patterns against the baseUrl.
+  const normalizedPath = normalizePath(pattern, baseUrl)
+  return matchPattern(normalizedPath, cleanUrl)
+}

package/src/core/utils/matching/{normalizePath.node.test.ts → normalize-path.node.test.ts}

@@ -1,7 +1,5 @@
-/**
- * @vitest-environment node
- */
-import { normalizePath } from './normalizePath'
+// @vitest-environment node
+import { normalizePath } from './normalize-path'
 
 test('returns RegExp as-is', () => {
   const path = /s/

package/src/core/utils/matching/{normalizePath.test.ts → normalize-path.test.ts}

@@ -1,7 +1,5 @@
-/**
- * @vitest-environment jsdom
- */
-import { normalizePath } from './normalizePath'
+// @vitest-environment jsdom
+import { normalizePath } from './normalize-path'
 
 test('returns RegExp as-is', () => {
   const path = /\/user\/(.+?)\//

package/src/core/utils/matching/{normalizePath.ts → normalize-path.ts}

@@ -1,6 +1,6 @@
-import type { Path } from './matchRequestUrl'
-import { cleanUrl } from '../url/cleanUrl'
-import { getAbsoluteUrl } from '../url/getAbsoluteUrl'
+import type { Path } from './match-request-url'
+import { getCleanUrlString } from '#utils/get-clean-url-string'
+import { getAbsoluteUrl } from '../url/get-absolute-url'
 
 /**
  * Normalizes a given request handler path:
@@ -10,7 +10,10 @@ import { getAbsoluteUrl } from '../url/getAbsoluteUrl'
  * - Preserves relative URLs in Node.js, unless specified otherwise.
  * - Preserves optional path parameters.
  */
-export function normalizePath(path: Path, baseUrl?: string): Path {
+export function normalizePath<ThisPath extends Path>(
+  path: ThisPath,
+  baseUrl?: string,
+): ThisPath {
   // RegExp paths do not need normalization.
   if (path instanceof RegExp) {
     return path
@@ -18,5 +21,5 @@ export function normalizePath(path: Path, baseUrl?: string): Path {
 
   const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl)
 
-  return cleanUrl(maybeAbsoluteUrl)
+  return getCleanUrlString(maybeAbsoluteUrl) as ThisPath
 }

package/src/core/utils/request/{getAllAcceptedMimeTypes.test.ts → get-all-accepted-mime-types.test.ts}

@@ -1,45 +1,45 @@
-import { getAllAcceptedMimeTypes } from './getAllAcceptedMimeTypes'
+import { getAllAcceptedMimeTypes } from './get-all-accepted-mime-types'
 
-it('returns an empty array for null accept header', () => {
+test('returns an empty array for null accept header', () => {
   expect(getAllAcceptedMimeTypes(null)).toEqual([])
 })
 
-it('returns a single mime type as-is', () => {
+test('returns a single mime type as-is', () => {
   expect(getAllAcceptedMimeTypes('application/json')).toEqual([
     'application/json',
   ])
 })
 
-it('returns multiple mime types in order', () => {
+test('returns multiple mime types in order', () => {
   expect(getAllAcceptedMimeTypes('text/html, application/json')).toEqual([
     'text/html',
     'application/json',
   ])
 })
 
-it('sorts by quality value (q parameter)', () => {
+test('sorts by quality value (q parameter)', () => {
   expect(
     getAllAcceptedMimeTypes('text/plain;q=0.5, application/json;q=0.9'),
   ).toEqual(['application/json', 'text/plain'])
 })
 
-it('excludes types with q=0', () => {
+test('excludes types with q=0', () => {
   expect(getAllAcceptedMimeTypes('text/html, text/plain;q=0')).toEqual([
     'text/html',
   ])
 })
 
-it('returns an empty array when all types have q=0', () => {
+test('returns an empty array when all types have q=0', () => {
   expect(getAllAcceptedMimeTypes('text/html;q=0, text/plain;q=0')).toEqual([])
 })
 
-it('treats missing q as q=1 (default)', () => {
+test('treats missing q as q=1 (default)', () => {
   expect(getAllAcceptedMimeTypes('text/plain;q=0.5, application/json')).toEqual(
     ['application/json', 'text/plain'],
   )
 })
 
-it('sorts by specificity when quality is equal (type/subtype > type/* > */*)', () => {
+test('sorts by specificity when quality is equal (type/subtype > type/* > */*)', () => {
   expect(getAllAcceptedMimeTypes('*/*, text/*, text/html')).toEqual([
     'text/html',
     'text/*',
@@ -47,7 +47,7 @@ it('sorts by specificity when quality is equal (type/subtype > type/* > */*)', (
   ])
 })
 
-it('sorts by parameter count when quality and specificity are equal', () => {
+test('sorts by parameter count when quality and specificity are equal', () => {
   expect(
     getAllAcceptedMimeTypes(
       'text/plain;format=fixed;charset=utf-8, text/plain;charset=utf-8',
@@ -55,7 +55,7 @@ it('sorts by parameter count when quality and specificity are equal', () => {
   ).toEqual(['text/plain', 'text/plain'])
 })
 
-it('applies full precedence: quality > specificity > parameter count', () => {
+test('applies full precedence: quality > specificity > parameter count', () => {
   expect(
     getAllAcceptedMimeTypes(
       'text/*;q=0.8, application/json, text/html;q=0.8, */*;q=0.1',
@@ -63,13 +63,13 @@ it('applies full precedence: quality > specificity > parameter count', () => {
   ).toEqual(['application/json', 'text/html', 'text/*', '*/*'])
 })
 
-it('handles whitespace around values', () => {
+test('handles whitespace around values', () => {
   expect(
     getAllAcceptedMimeTypes('  text/html  ,  application/json ; q=0.9  '),
   ).toEqual(['text/html', 'application/json'])
 })
 
-it('handles a realistic browser accept header', () => {
+test('handles a realistic browser accept header', () => {
   expect(
     getAllAcceptedMimeTypes(
       'text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8',
@@ -77,7 +77,7 @@ it('handles a realistic browser accept header', () => {
   ).toEqual(['text/html', 'application/xhtml+xml', 'application/xml', '*/*'])
 })
 
-it('handles the graphql-over-http accept header', () => {
+test('handles the graphql-over-http accept header', () => {
   expect(
     getAllAcceptedMimeTypes(
       'application/graphql-response+json, application/json',

package/src/core/utils/request/get-request-cookies.ts

@@ -0,0 +1,76 @@
+import { parseCookie } from 'cookie'
+import { cookieStore } from '../cookie-store'
+
+function parseCookies(input: string): Record<string, string> {
+  const parsedCookies = parseCookie(input)
+  const cookies: Record<string, string> = {}
+
+  for (const cookieName in parsedCookies) {
+    if (typeof parsedCookies[cookieName] !== 'undefined') {
+      cookies[cookieName] = parsedCookies[cookieName]
+    }
+  }
+
+  return cookies
+}
+
+function getAllDocumentCookies() {
+  return parseCookies(document.cookie)
+}
+
+/**
+ * Returns whether the given request would carry cookies,
+ * based on its `credentials` mode.
+ */
+function includesCredentials(request: Request): boolean {
+  switch (request.credentials) {
+    case 'same-origin': {
+      // Include cookies only when requesting a resource
+      // from the same origin as the current document.
+      return (
+        typeof location !== 'undefined' &&
+        location.origin === new URL(request.url).origin
+      )
+    }
+
+    case 'include': {
+      return true
+    }
+
+    default: {
+      return false
+    }
+  }
+}
+
+function getDocumentCookies(): Record<string, string> {
+  if (typeof document === 'undefined') {
+    return {}
+  }
+
+  return getAllDocumentCookies()
+}
+
+export function getAllRequestCookies(request: Request): Record<string, string> {
+  const requestCookieHeader = request.headers.get('cookie')
+  const cookiesFromHeaders = requestCookieHeader
+    ? parseCookies(requestCookieHeader)
+    : {}
+
+  if (cookieStore === null || !includesCredentials(request)) {
+    return cookiesFromHeaders
+  }
+
+  const cookiesFromDocument = getDocumentCookies()
+
+  const cookiesFromStore = cookieStore.getCookies(request.url)
+  const storedCookiesObject = Object.fromEntries(
+    cookiesFromStore.map((cookie) => [cookie.key, cookie.value]),
+  )
+
+  return {
+    ...cookiesFromDocument,
+    ...storedCookiesObject,
+    ...cookiesFromHeaders,
+  }
+}

package/src/core/utils/request/store-response-cookies.ts

@@ -0,0 +1,15 @@
+import { cookieStore } from '../cookie-store'
+import { getRawSetCookie } from '../response-decorators'
+
+export async function storeResponseCookies(
+  request: Request,
+  response: Response,
+): Promise<void> {
+  if (cookieStore === null) {
+    return
+  }
+
+  for (const responseCookie of getRawSetCookie(response)) {
+    await cookieStore.setCookie(responseCookie, request.url)
+  }
+}