@depup/msw 2.12.13-depup.0

package/src/core/utils/logging/getTimestamp.test.ts

@@ -0,0 +1,32 @@
+import { getTimestamp } from './getTimestamp'
+
+beforeAll(() => {
+  vi.useFakeTimers()
+})
+
+afterAll(() => {
+  vi.useRealTimers()
+})
+
+test('returns a timestamp string of the invocation time', () => {
+  vi.setSystemTime(new Date('2024-01-01 12:4:8'))
+  const timestamp = getTimestamp()
+  expect(timestamp).toBe('12:04:08')
+})
+
+test('returns a timestamp with milliseconds', () => {
+  vi.setSystemTime(new Date('2024-01-01 12:4:8'))
+  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.000')
+
+  vi.setSystemTime(new Date('2024-01-01 12:4:8.000'))
+  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.000')
+
+  vi.setSystemTime(new Date('2024-01-01 12:4:8.4'))
+  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.400')
+
+  vi.setSystemTime(new Date('2024-01-01 12:4:8.123'))
+  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.123')
+
+  vi.setSystemTime(new Date('2024-01-01 12:00:00'))
+  expect(getTimestamp({ milliseconds: true })).toBe('12:00:00.000')
+})

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

@@ -0,0 +1,17 @@
+interface GetTimestampOptions {
+  milliseconds?: boolean
+}
+
+/**
+ * Returns a timestamp string in a "HH:MM:SS" format.
+ */
+export function getTimestamp(options?: GetTimestampOptions): string {
+  const now = new Date()
+  const timestamp = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`
+
+  if (options?.milliseconds) {
+    return `${timestamp}.${now.getMilliseconds().toString().padStart(3, '0')}`
+  }
+
+  return timestamp
+}

package/src/core/utils/logging/serializeRequest.test.ts

@@ -0,0 +1,23 @@
+import { encodeBuffer } from '@mswjs/interceptors'
+import { serializeRequest } from './serializeRequest'
+
+test('serializes given Request instance into a plain object', async () => {
+  const request = await serializeRequest(
+    new Request(new URL('http://test.mswjs.io/user'), {
+      method: 'POST',
+      headers: new Headers({
+        'Content-Type': 'text/plain',
+        'X-Header': 'secret',
+      }),
+      body: encodeBuffer('text-body'),
+    }),
+  )
+
+  expect(request.method).toBe('POST')
+  expect(request.url.href).toBe('http://test.mswjs.io/user')
+  expect(request.headers).toEqual({
+    'content-type': 'text/plain',
+    'x-header': 'secret',
+  })
+  expect(request.body).toBe('text-body')
+})

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

@@ -0,0 +1,23 @@
+export interface LoggedRequest {
+  url: URL
+  method: string
+  headers: Record<string, string>
+  body: string
+}
+
+/**
+ * Formats a mocked request for introspection in browser's console.
+ */
+export async function serializeRequest(
+  request: Request,
+): Promise<LoggedRequest> {
+  const requestClone = request.clone()
+  const requestText = await requestClone.text()
+
+  return {
+    url: new URL(request.url),
+    method: request.method,
+    headers: Object.fromEntries(request.headers.entries()),
+    body: requestText,
+  }
+}

package/src/core/utils/logging/serializeResponse.test.ts

@@ -0,0 +1,77 @@
+/**
+ * @vitest-environment node
+ */
+import { encodeBuffer } from '@mswjs/interceptors'
+import { serializeResponse } from './serializeResponse'
+
+it('serializes response without body', async () => {
+  const result = await serializeResponse(new Response(null))
+
+  expect(result.status).toBe(200)
+  expect(result.statusText).toBe('OK')
+  expect(result.headers).toEqual({})
+  expect(result.body).toBe('')
+})
+
+it('serializes a plain text response', async () => {
+  const result = await serializeResponse(
+    new Response('hello world', {
+      status: 201,
+      statusText: 'Created',
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    }),
+  )
+
+  expect(result.status).toBe(201)
+  expect(result.statusText).toBe('Created')
+  expect(result.headers).toEqual({
+    'content-type': 'text/plain',
+  })
+  expect(result.body).toBe('hello world')
+})
+
+it('serializes a JSON response', async () => {
+  const response = new Response(JSON.stringify({ users: ['John'] }), {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  })
+  const result = await serializeResponse(response)
+
+  expect(result.headers).toEqual({
+    'content-type': 'application/json',
+  })
+  expect(result.body).toBe(JSON.stringify({ users: ['John'] }))
+})
+
+it('serializes a ArrayBuffer response', async () => {
+  const data = encodeBuffer('hello world')
+  const response = new Response(data)
+  const result = await serializeResponse(response)
+
+  expect(result.body).toBe('hello world')
+})
+
+it('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 () => {
+  const data = new FormData()
+  data.set('firstName', 'Alice')
+  data.set('age', '32')
+  const response = new Response(data)
+  const result = await serializeResponse(response)
+
+  expect(result.body).toContain(
+    `Content-Disposition: form-data; name="firstName"\r\n\r\nAlice`,
+  )
+  expect(result.body).toContain(
+    `Content-Disposition: form-data; name="age"\r\n\r\n32`,
+  )
+})

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

@@ -0,0 +1,31 @@
+import statuses from '../../../shims/statuses'
+
+const { message } = statuses
+
+export interface SerializedResponse {
+  status: number
+  statusText: string
+  headers: Record<string, any>
+  body: string
+}
+
+export async function serializeResponse(
+  response: Response,
+): Promise<SerializedResponse> {
+  const responseClone = response.clone()
+  const responseText = await responseClone.text()
+
+  // Normalize the response status and status text when logging
+  // since the default Response instance doesn't infer status texts
+  // from status codes. This has no effect on the actual response instance.
+  const responseStatus = responseClone.status || 200
+  const responseStatusText =
+    responseClone.statusText || message[responseStatus] || 'OK'
+
+  return {
+    status: responseStatus,
+    statusText: responseStatusText,
+    headers: Object.fromEntries(responseClone.headers.entries()),
+    body: responseText,
+  }
+}

package/src/core/utils/matching/matchRequestUrl.test.ts

@@ -0,0 +1,183 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { coercePath, matchRequestUrl } from './matchRequestUrl'
+
+describe('matchRequestUrl', () => {
+  test('returns true when matches against an exact URL', () => {
+    expect(
+      matchRequestUrl(
+        new URL('https://test.mswjs.io'),
+        'https://test.mswjs.io',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {},
+    })
+  })
+
+  test('returns true when matched against a wildcard', () => {
+    expect(matchRequestUrl(new URL('https://test.mswjs.io'), '*')).toEqual({
+      matches: true,
+      params: {
+        '0': 'https://test.mswjs.io/',
+      },
+    })
+  })
+
+  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 path parameters when matched', () => {
+    expect(
+      matchRequestUrl(
+        new URL('https://test.mswjs.io/user/abc-123'),
+        'https://test.mswjs.io/user/:userId',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        userId: 'abc-123',
+      },
+    })
+  })
+
+  test('decodes path parameters', () => {
+    const url = 'http://example.com:5001/example'
+
+    expect(
+      matchRequestUrl(
+        new URL(`https://test.mswjs.io/reflect-url/${encodeURIComponent(url)}`),
+        'https://test.mswjs.io/reflect-url/:url',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        url,
+      },
+    })
+  })
+
+  test('returns false when does not match against the request URL', () => {
+    expect(
+      matchRequestUrl(new URL('https://test.mswjs.io'), 'https://google.com'),
+    ).toEqual({
+      matches: false,
+      params: {},
+    })
+  })
+
+  test('returns true when matching optional path parameters', () => {
+    expect(
+      matchRequestUrl(
+        new URL('https://test.mswjs.io/user/123'),
+        'https://test.mswjs.io/user/:userId?',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        userId: '123',
+      },
+    })
+  })
+
+  test('returns true for matching WebSocket URL', () => {
+    expect(
+      matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://test.mswjs.io'),
+    ).toEqual({
+      matches: true,
+      params: {},
+    })
+    expect(
+      matchRequestUrl(new URL('wss://test.mswjs.io'), 'wss://test.mswjs.io'),
+    ).toEqual({
+      matches: true,
+      params: {},
+    })
+  })
+
+  test('returns false for non-matching WebSocket URL', () => {
+    expect(
+      matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://foo.mswjs.io'),
+    ).toEqual({
+      matches: false,
+      params: {},
+    })
+    expect(
+      matchRequestUrl(new URL('wss://test.mswjs.io'), 'wss://completely.diff'),
+    ).toEqual({
+      matches: false,
+      params: {},
+    })
+  })
+
+  test('returns path parameters when matched a WebSocket URL', () => {
+    expect(
+      matchRequestUrl(
+        new URL('wss://test.mswjs.io'),
+        'wss://:service.mswjs.io',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        service: 'test',
+      },
+    })
+  })
+})
+
+describe('coercePath', () => {
+  test('escapes the colon in protocol', () => {
+    expect(coercePath('https://example.com')).toEqual('https\\://example.com')
+    expect(coercePath('https://example.com/:userId')).toEqual(
+      'https\\://example.com/:userId',
+    )
+    expect(coercePath('http://localhost:3000')).toEqual(
+      'http\\://localhost\\:3000',
+    )
+  })
+
+  test('escapes the colon before the port number', () => {
+    expect(coercePath('localhost:8080')).toEqual('localhost\\:8080')
+    expect(coercePath('http://127.0.0.1:8080')).toEqual(
+      'http\\://127.0.0.1\\:8080',
+    )
+    expect(coercePath('https://example.com:1234')).toEqual(
+      'https\\://example.com\\:1234',
+    )
+
+    expect(coercePath('localhost:8080/:5678')).toEqual('localhost\\:8080/:5678')
+    expect(coercePath('https://example.com:8080/:5678')).toEqual(
+      'https\\://example.com\\:8080/:5678',
+    )
+  })
+
+  test('replaces wildcard with an unnnamed capturing group', () => {
+    expect(coercePath('*')).toEqual('(.*)')
+    expect(coercePath('**')).toEqual('(.*)')
+    expect(coercePath('/us*')).toEqual('/us(.*)')
+    expect(coercePath('/user/*')).toEqual('/user/(.*)')
+    expect(coercePath('https://example.com/user/*')).toEqual(
+      'https\\://example.com/user/(.*)',
+    )
+    expect(coercePath('https://example.com/us*')).toEqual(
+      'https\\://example.com/us(.*)',
+    )
+  })
+
+  test('preserves path parameter modifiers', () => {
+    expect(coercePath(':name*')).toEqual(':name*')
+    expect(coercePath('/foo/:name*')).toEqual('/foo/:name*')
+    expect(coercePath('/foo/**:name*')).toEqual('/foo/(.*):name*')
+    expect(coercePath('**/foo/*/:name*')).toEqual('(.*)/foo/(.*)/:name*')
+    expect(coercePath('/foo/:first/bar/:second*/*')).toEqual(
+      '/foo/:first/bar/:second*/(.*)',
+    )
+  })
+})

package/src/core/utils/matching/matchRequestUrl.ts

@@ -0,0 +1,77 @@
+import { match } from 'path-to-regexp'
+import { getCleanUrl } from '@mswjs/interceptors'
+import { normalizePath } from './normalizePath'
+
+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
+}
+
+/**
+ * Coerce a path supported by MSW into a path
+ * supported by "path-to-regexp".
+ */
+export function coercePath(path: string): string {
+  return (
+    path
+      /**
+       * Replace wildcards ("*") with unnamed capturing groups
+       * because "path-to-regexp" doesn't support wildcards.
+       * Ignore path parameter' modifiers (i.e. ":name*").
+       */
+      .replace(
+        /([:a-zA-Z_-]*)(\*{1,2})+/g,
+        (_, parameterName: string | undefined, wildcard: string) => {
+          const expression = '(.*)'
+
+          if (!parameterName) {
+            return expression
+          }
+
+          return parameterName.startsWith(':')
+            ? `${parameterName}${wildcard}`
+            : `${parameterName}${expression}`
+        },
+      )
+      /**
+       * Escape the port so that "path-to-regexp" can match
+       * absolute URLs including port numbers.
+       */
+      .replace(/([^/])(:)(?=\d+)/, '$1\\$2')
+      /**
+       * Escape the protocol so that "path-to-regexp" could match
+       * absolute URL.
+       * @see https://github.com/pillarjs/path-to-regexp/issues/259
+       */
+      .replace(/^([^/]+)(:)(?=\/\/)/, '$1\\$2')
+  )
+}
+
+/**
+ * Returns the result of matching given request URL against a mask.
+ */
+export function matchRequestUrl(url: URL, path: Path, baseUrl?: string): Match {
+  const normalizedPath = normalizePath(path, baseUrl)
+  const cleanPath =
+    typeof normalizedPath === 'string'
+      ? coercePath(normalizedPath)
+      : normalizedPath
+
+  const cleanUrl = getCleanUrl(url)
+  const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl)
+  const params = (result && (result.params as PathParams)) || {}
+
+  return {
+    matches: result !== false,
+    params,
+  }
+}
+
+export function isPath(value: unknown): value is Path {
+  return typeof value === 'string' || value instanceof RegExp
+}

package/src/core/utils/matching/normalizePath.node.test.ts

@@ -0,0 +1,44 @@
+/**
+ * @vitest-environment node
+ */
+import { normalizePath } from './normalizePath'
+
+test('returns RegExp as-is', () => {
+  const path = /s/
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('returns a clean absolute URL as-is', () => {
+  const path = 'https://test.mswjs.io/path'
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('returns a relative URL as-is given a string path', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('rebases a relative URL against a custom base URL', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path, 'https://test.mswjs.io')).toEqual(
+    'https://test.mswjs.io/relative/url',
+  )
+})
+
+test('removes query parameters and hashes from an absolute URL', () => {
+  expect(normalizePath('https://test.mswjs.io/user?query=123')).toEqual(
+    'https://test.mswjs.io/user',
+  )
+  expect(normalizePath('https://test.mswjs.io/user#some')).toEqual(
+    'https://test.mswjs.io/user',
+  )
+  expect(normalizePath('https://test.mswjs.io/user?query=123#some')).toEqual(
+    'https://test.mswjs.io/user',
+  )
+})
+
+test('removes query parameters and hashes from a relative URL', () => {
+  expect(normalizePath('/user?query=123')).toEqual('/user')
+  expect(normalizePath('/user#some')).toEqual('/user')
+  expect(normalizePath('/user?query=123#some')).toEqual('/user')
+})

package/src/core/utils/matching/normalizePath.test.ts

@@ -0,0 +1,56 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { normalizePath } from './normalizePath'
+
+test('returns RegExp as-is', () => {
+  const path = /\/user\/(.+?)\//
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('returns a clean absolute URL as-is', () => {
+  const path = 'https://test.mswjs.io/user'
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('rebases a relative URL against the current location', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path)).toBe(`${location.origin}/relative/url`)
+})
+
+test('rebases a relative URL against a custom base URL', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path, 'https://test.mswjs.io')).toEqual(
+    'https://test.mswjs.io/relative/url',
+  )
+})
+
+test('removes query parameters and hashes from an absolute URL', () => {
+  const path = 'https://test.mswjs.io/user?query=123#some'
+  expect(normalizePath(path)).toEqual('https://test.mswjs.io/user')
+})
+
+test('removes query parameters and hashes from a relative URL', () => {
+  expect(normalizePath('/user?query=123')).toEqual(`${location.origin}/user`)
+  expect(normalizePath('/user#some')).toEqual(`${location.origin}/user`)
+  expect(normalizePath('/user?query=123#some')).toEqual(
+    `${location.origin}/user`,
+  )
+})
+
+test('returns a path pattern string as-is', () => {
+  expect(normalizePath(':api/user')).toEqual('http://localhost/:api/user')
+  expect(normalizePath('*/resource/*')).toEqual('*/resource/*')
+})
+
+test('removes query parameters and hashes from a path pattern string', () => {
+  expect(normalizePath(':api/user?query=123#some')).toEqual(
+    'http://localhost/:api/user',
+  )
+})
+
+test('preserves optional path parameters', () => {
+  expect(normalizePath('/user/:userId?')).toEqual(
+    'http://localhost/user/:userId?',
+  )
+})

package/src/core/utils/matching/normalizePath.ts

@@ -0,0 +1,22 @@
+import type { Path } from './matchRequestUrl'
+import { cleanUrl } from '../url/cleanUrl'
+import { getAbsoluteUrl } from '../url/getAbsoluteUrl'
+
+/**
+ * Normalizes a given request handler path:
+ * - Preserves RegExp.
+ * - Removes query parameters and hashes.
+ * - Rebases relative URLs against the "baseUrl" or the current location.
+ * - Preserves relative URLs in Node.js, unless specified otherwise.
+ * - Preserves optional path parameters.
+ */
+export function normalizePath(path: Path, baseUrl?: string): Path {
+  // RegExp paths do not need normalization.
+  if (path instanceof RegExp) {
+    return path
+  }
+
+  const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl)
+
+  return cleanUrl(maybeAbsoluteUrl)
+}

package/src/core/utils/request/getAllAcceptedMimeTypes.test.ts

@@ -0,0 +1,86 @@
+import { getAllAcceptedMimeTypes } from './getAllAcceptedMimeTypes'
+
+it('returns an empty array for null accept header', () => {
+  expect(getAllAcceptedMimeTypes(null)).toEqual([])
+})
+
+it('returns a single mime type as-is', () => {
+  expect(getAllAcceptedMimeTypes('application/json')).toEqual([
+    'application/json',
+  ])
+})
+
+it('returns multiple mime types in order', () => {
+  expect(getAllAcceptedMimeTypes('text/html, application/json')).toEqual([
+    'text/html',
+    'application/json',
+  ])
+})
+
+it('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', () => {
+  expect(getAllAcceptedMimeTypes('text/html, text/plain;q=0')).toEqual([
+    'text/html',
+  ])
+})
+
+it('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)', () => {
+  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/* > */*)', () => {
+  expect(getAllAcceptedMimeTypes('*/*, text/*, text/html')).toEqual([
+    'text/html',
+    'text/*',
+    '*/*',
+  ])
+})
+
+it('sorts by parameter count when quality and specificity are equal', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'text/plain;format=fixed;charset=utf-8, text/plain;charset=utf-8',
+    ),
+  ).toEqual(['text/plain', 'text/plain'])
+})
+
+it('applies full precedence: quality > specificity > parameter count', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'text/*;q=0.8, application/json, text/html;q=0.8, */*;q=0.1',
+    ),
+  ).toEqual(['application/json', 'text/html', 'text/*', '*/*'])
+})
+
+it('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', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8',
+    ),
+  ).toEqual(['text/html', 'application/xhtml+xml', 'application/xml', '*/*'])
+})
+
+it('handles the graphql-over-http accept header', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'application/graphql-response+json, application/json',
+    ),
+  ).toEqual(['application/graphql-response+json', 'application/json'])
+})