@depup/msw 2.12.13-depup.0

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

@@ -0,0 +1,70 @@
+/**
+ * Returns all accepted mime types, ordered by precedence as defined
+ * in [RFC 7231 Section 5.3.2](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2).
+ *
+ * Precedence rules (highest to lowest):
+ * 1. Quality value (`q` parameter, default 1).
+ * 2. Specificity: `type/subtype` > `type/*` > `*\/*`.
+ * 3. Number of media type parameters (more = more specific).
+ *
+ * Types with `q=0` are excluded (explicitly not acceptable).
+ */
+export function getAllAcceptedMimeTypes(
+  acceptHeader: string | null,
+): Array<string> {
+  if (acceptHeader == null) {
+    return []
+  }
+
+  const accepted: Array<{
+    type: string
+    quality: number
+    specificity: number
+    parameterCount: number
+  }> = []
+
+  for (const part of acceptHeader.split(',')) {
+    const [type, ...params] = part.split(';').map((v) => v.trim())
+
+    let quality = 1
+    let parameterCount = 0
+
+    for (const param of params) {
+      const [key, value] = param.split('=').map((v) => v.trim())
+
+      if (key === 'q') {
+        quality = Number(value)
+      } else {
+        parameterCount++
+      }
+    }
+
+    // RFC 7231: a quality value of 0 indicates "not acceptable".
+    if (quality === 0) {
+      continue
+    }
+
+    const [mediaType, mediaSubtype] = type.split('/')
+    const specificity = mediaType === '*' ? 0 : mediaSubtype === '*' ? 1 : 2
+
+    accepted.push({ type, quality, specificity, parameterCount })
+  }
+
+  if (!accepted.length) {
+    return []
+  }
+
+  return accepted
+    .sort((left, right) => {
+      if (right.quality !== left.quality) {
+        return right.quality - left.quality
+      }
+
+      if (right.specificity !== left.specificity) {
+        return right.specificity - left.specificity
+      }
+
+      return right.parameterCount - left.parameterCount
+    })
+    .map((entry) => entry.type)
+}

package/src/core/utils/request/getRequestCookies.ts

@@ -0,0 +1,88 @@
+import {
+  parse as parseCookie,
+  serialize as serializeCookie,
+} from '../../../shims/cookie'
+import { cookieStore } from '../cookieStore'
+
+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)
+}
+
+function getDocumentCookies(request: Request): Record<string, string> {
+  if (typeof document === 'undefined' || typeof location === 'undefined') {
+    return {}
+  }
+
+  switch (request.credentials) {
+    case 'same-origin': {
+      const requestUrl = new URL(request.url)
+
+      // Return document cookies only when requested a resource
+      // from the same origin as the current document.
+      return location.origin === requestUrl.origin
+        ? getAllDocumentCookies()
+        : {}
+    }
+
+    case 'include': {
+      // Return all document cookies.
+      return getAllDocumentCookies()
+    }
+
+    default: {
+      return {}
+    }
+  }
+}
+
+export function getAllRequestCookies(request: Request): Record<string, string> {
+  /**
+   * @note While the "cookie" header is a forbidden header field
+   * in the browser, you can read it in Node.js. We need to respect
+   * it for mocking in Node.js.
+   */
+  const requestCookieHeader = request.headers.get('cookie')
+  const cookiesFromHeaders = requestCookieHeader
+    ? parseCookies(requestCookieHeader)
+    : {}
+
+  const cookiesFromDocument = getDocumentCookies(request)
+
+  // Forward the document cookies to the request headers.
+  for (const name in cookiesFromDocument) {
+    request.headers.append(
+      'cookie',
+      serializeCookie(name, cookiesFromDocument[name]),
+    )
+  }
+
+  const cookiesFromStore = cookieStore.getCookies(request.url)
+  const storedCookiesObject = Object.fromEntries(
+    cookiesFromStore.map((cookie) => [cookie.key, cookie.value]),
+  )
+
+  // Forward the raw stored cookies to request headers
+  // so they contain metadata like "expires", "secure", etc.
+  for (const cookie of cookiesFromStore) {
+    request.headers.append('cookie', cookie.toString())
+  }
+
+  return {
+    ...cookiesFromDocument,
+    ...storedCookiesObject,
+    ...cookiesFromHeaders,
+  }
+}

package/src/core/utils/request/onUnhandledRequest.node.test.ts

@@ -0,0 +1,62 @@
+// @vitest-environment node
+import { onUnhandledRequest } from './onUnhandledRequest'
+
+const fixtures = {
+  warningWithoutSuggestions: (url = `/api`) => `\
+[MSW] Warning: intercepted a request without a matching request handler:
+
+  • GET ${url}
+
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`,
+  warningWithResponseBody: (url = `/api`) => `\
+[MSW] Warning: intercepted a request without a matching request handler:
+
+  • POST ${url}
+
+  • Request body: {"variables":{"id":"abc-123"},"query":"query UserName($id: String!) { user(id: $id) { name } }"}
+
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`,
+
+  errorWithoutSuggestions: `\
+[MSW] Error: intercepted a request without a matching request handler:
+
+  • GET /api
+
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`,
+}
+
+beforeAll(() => {
+  vi.spyOn(console, 'warn').mockImplementation(() => void 0)
+  vi.spyOn(console, 'error').mockImplementation(() => void 0)
+})
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+afterAll(() => {
+  vi.restoreAllMocks()
+})
+
+test('prints with an absolute URL and search params', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('https://mswjs.io/api?foo=boo')),
+    'warn',
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(`https://mswjs.io/api?foo=boo`),
+  )
+
+  await onUnhandledRequest(
+    new Request(new URL('http://localhost/api?foo=boo')),
+    'warn',
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(`http://localhost/api?foo=boo`),
+  )
+})

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

@@ -0,0 +1,228 @@
+// @vitest-environment jsdom
+import {
+  onUnhandledRequest,
+  UnhandledRequestCallback,
+} from './onUnhandledRequest'
+
+const fixtures = {
+  warningWithoutSuggestions: (url = `/api`) => `\
+[MSW] Warning: intercepted a request without a matching request handler:
+
+  • GET ${url}
+
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`,
+  warningWithResponseBody: (url = `/api`) => `\
+[MSW] Warning: intercepted a request without a matching request handler:
+
+  • POST ${url}
+
+  • Request body: {"variables":{"id":"abc-123"},"query":"query UserName($id: String!) { user(id: $id) { name } }"}
+
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`,
+
+  errorWithoutSuggestions: `\
+[MSW] Error: intercepted a request without a matching request handler:
+
+  • GET /api
+
+If you still wish to intercept this unhandled request, please create a request handler for it.
+Read more: https://mswjs.io/docs/http/intercepting-requests`,
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'warn').mockImplementation(() => void 0)
+  vi.spyOn(console, 'error').mockImplementation(() => void 0)
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+test('supports the "bypass" request strategy', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('http://localhost/api')),
+    'bypass',
+  )
+
+  expect(console.warn).not.toHaveBeenCalled()
+  expect(console.error).not.toHaveBeenCalled()
+})
+
+test('supports the "warn" request strategy', async () => {
+  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(),
+  )
+})
+
+test('supports the "warn" request strategy with request body', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('http://localhost/api'), {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        variables: {
+          id: 'abc-123',
+        },
+        query: 'query UserName($id: String!) { user(id: $id) { name } }',
+      }),
+    }),
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithResponseBody())
+})
+
+test('supports the "error" request strategy', async () => {
+  await expect(
+    onUnhandledRequest(new Request(new URL('http://localhost/api')), 'error'),
+  ).rejects.toThrow(
+    '[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
+  )
+
+  expect(console.error).toHaveBeenCalledWith(fixtures.errorWithoutSuggestions)
+})
+
+test('supports a custom callback function', async () => {
+  const callback = vi.fn<UnhandledRequestCallback>((request) => {
+    console.warn(`callback: ${request.method} ${request.url}`)
+  })
+  const request = new Request(new URL('/user', 'http://localhost:3000'))
+  await onUnhandledRequest(request, callback)
+
+  expect(callback).toHaveBeenCalledTimes(1)
+  expect(callback).toHaveBeenCalledWith(request, {
+    warning: expect.any(Function),
+    error: expect.any(Function),
+  })
+
+  // Check that the custom logic in the callback was called.
+  expect(console.warn).toHaveBeenCalledWith(
+    `callback: GET http://localhost:3000/user`,
+  )
+})
+
+test('supports calling default strategies from the custom callback function', async () => {
+  const callback = vi.fn<UnhandledRequestCallback>((request, print) => {
+    // Call the default "error" strategy.
+    print.error()
+  })
+  const request = new Request(new URL('http://localhost/api'))
+  await expect(onUnhandledRequest(request, callback)).rejects.toThrow(
+    `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.`,
+  )
+
+  expect(callback).toHaveBeenCalledTimes(1)
+  expect(callback).toHaveBeenCalledWith(request, {
+    warning: expect.any(Function),
+    error: expect.any(Function),
+  })
+
+  // Check that the default strategy was called.
+  expect(console.error).toHaveBeenCalledWith(fixtures.errorWithoutSuggestions)
+})
+
+test('does not print any suggestions given no handlers to suggest', async () => {
+  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(),
+  )
+})
+
+test('throws an exception given unknown request strategy', async () => {
+  await expect(
+    onUnhandledRequest(
+      new Request(new URL('http://localhost/api')),
+      // @ts-expect-error Intentional unknown strategy.
+      'invalid-strategy',
+    ),
+  ).rejects.toThrow(
+    '[MSW] Failed to react to an unhandled request: unknown strategy "invalid-strategy". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+  )
+})
+
+test('prints with a relative URL and search params', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('http://localhost/api?foo=boo')),
+    'warn',
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(`/api?foo=boo`),
+  )
+})
+
+test('prints with an absolute URL and search params', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('https://mswjs.io/api?foo=boo')),
+    'warn',
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(`https://mswjs.io/api?foo=boo`),
+  )
+})
+
+test('ignores common static assets when using the "warn" strategy', async () => {
+  await Promise.allSettled([
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/main.css')),
+      'warn',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/index.mjs')),
+      'warn',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/node_modules/abc-123')),
+      'warn',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://fonts.googleapis.com/some-font')),
+      'warn',
+    ),
+  ])
+
+  expect(console.warn).not.toHaveBeenCalled()
+})
+
+test('ignores common static assets when using the "error" strategy', async () => {
+  await Promise.allSettled([
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/main.css')),
+      'error',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/index.mjs')),
+      'error',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/node_modules/abc-123')),
+      'error',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://fonts.googleapis.com/some-font')),
+      'error',
+    ),
+  ])
+
+  expect(console.error).not.toHaveBeenCalled()
+})
+
+test('exposes common static assets to the explicit callback', async () => {
+  let callbackRequest!: Request
+  await onUnhandledRequest(
+    new Request(new URL('https://example.com/main.css')),
+    (request) => {
+      callbackRequest = request
+    },
+  )
+
+  expect(callbackRequest).toBeInstanceOf(Request)
+  expect(callbackRequest.url).toBe('https://example.com/main.css')
+})

package/src/core/utils/request/onUnhandledRequest.ts

@@ -0,0 +1,81 @@
+import { toPublicUrl } from './toPublicUrl'
+import { InternalError, devUtils } from '../internal/devUtils'
+import { isCommonAssetRequest } from '../../isCommonAssetRequest'
+
+export interface UnhandledRequestPrint {
+  warning(): void
+  error(): void
+}
+
+export type UnhandledRequestCallback = (
+  request: Request,
+  print: UnhandledRequestPrint,
+) => void
+
+export type UnhandledRequestStrategy =
+  | 'bypass'
+  | 'warn'
+  | 'error'
+  | UnhandledRequestCallback
+
+export async function onUnhandledRequest(
+  request: Request,
+  strategy: UnhandledRequestStrategy = 'warn',
+): Promise<void> {
+  const url = new URL(request.url)
+  const publicUrl = toPublicUrl(url) + url.search
+
+  const requestBody =
+    request.method === 'HEAD' || request.method === 'GET'
+      ? null
+      : await request.clone().text()
+  const messageDetails = `\n\n  \u2022 ${request.method} ${publicUrl}\n\n${requestBody ? `  \u2022 Request body: ${requestBody}\n\n` : ''}`
+  const unhandledRequestMessage = `intercepted a request without a matching request handler:${messageDetails}If you still wish to intercept this unhandled request, please create a request handler for it.\nRead more: https://mswjs.io/docs/http/intercepting-requests`
+
+  function applyStrategy(strategy: UnhandledRequestStrategy) {
+    switch (strategy) {
+      case 'error': {
+        // Print a developer-friendly error.
+        devUtils.error('Error: %s', unhandledRequestMessage)
+
+        // Throw an exception to halt request processing and not perform the original request.
+        throw new InternalError(
+          devUtils.formatMessage(
+            'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
+          ),
+        )
+      }
+
+      case 'warn': {
+        devUtils.warn('Warning: %s', unhandledRequestMessage)
+        break
+      }
+
+      case 'bypass':
+        break
+
+      default:
+        throw new InternalError(
+          devUtils.formatMessage(
+            'Failed to react to an unhandled request: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+            strategy,
+          ),
+        )
+    }
+  }
+
+  if (typeof strategy === 'function') {
+    strategy(request, {
+      warning: applyStrategy.bind(null, 'warn'),
+      error: applyStrategy.bind(null, 'error'),
+    })
+    return
+  }
+
+  // Ignore common static asset requests when using a built-in strategy.
+  // There's a slight overhead here because this utility will create a request URL
+  // instance again despite us having done so previously in this function.
+  if (!isCommonAssetRequest(request)) {
+    applyStrategy(strategy)
+  }
+}

package/src/core/utils/request/storeResponseCookies.ts

@@ -0,0 +1,17 @@
+import { cookieStore } from '../cookieStore'
+import { kSetCookie } from '../HttpResponse/decorators'
+
+export async function storeResponseCookies(
+  request: Request,
+  response: Response,
+): Promise<void> {
+  // Grab the raw "Set-Cookie" response header provided
+  // in the HeadersInit for this mocked response.
+  const responseCookies = Reflect.get(response, kSetCookie) as
+    | string
+    | undefined
+
+  if (responseCookies) {
+    await cookieStore.setCookie(responseCookies, request.url)
+  }
+}

package/src/core/utils/request/toPublicUrl.node.test.ts

@@ -0,0 +1,17 @@
+// @vitest-environment node
+import { toPublicUrl } from './toPublicUrl'
+
+test('returns an absolute request URL without search params', () => {
+  expect(toPublicUrl(new URL('https://test.mswjs.io/path'))).toBe(
+    'https://test.mswjs.io/path',
+  )
+
+  expect(toPublicUrl(new URL('http://192.168.0.10/path'))).toBe(
+    'http://192.168.0.10/path',
+  )
+
+  expect(
+    toPublicUrl(new URL('http://localhost/path?foo=bar')),
+    'Must not return relative URL in Node.js',
+  ).toBe('http://localhost/path')
+})

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

@@ -0,0 +1,16 @@
+// @vitest-environment jsdom
+import { toPublicUrl } from './toPublicUrl'
+
+test('returns an absolute request URL without search params', () => {
+  expect(toPublicUrl(new URL('https://test.mswjs.io/path'))).toBe(
+    'https://test.mswjs.io/path',
+  )
+
+  expect(toPublicUrl(new URL('http://localhost/path'))).toBe('/path')
+
+  expect(toPublicUrl(new URL('http://localhost/path?foo=bar'))).toBe('/path')
+})
+
+it('returns a relative URL given the request to the same origin', () => {
+  expect(toPublicUrl('http://localhost/user')).toBe('/user')
+})

package/src/core/utils/request/toPublicUrl.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a relative URL if the given request URL is relative
+ * to the current origin. Otherwise returns an absolute URL.
+ */
+export function toPublicUrl(url: string | URL): string {
+  const urlInstance = url instanceof URL ? url : new URL(url)
+
+  if (
+    typeof location !== 'undefined' &&
+    urlInstance.origin === location.origin
+  ) {
+    return urlInstance.pathname
+  }
+
+  return urlInstance.origin + urlInstance.pathname
+}

package/src/core/utils/toResponseInit.ts

@@ -0,0 +1,7 @@
+export function toResponseInit(response: Response): ResponseInit {
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries()),
+  }
+}

package/src/core/utils/url/cleanUrl.test.ts

@@ -0,0 +1,22 @@
+import { cleanUrl } from './cleanUrl'
+
+it('removes query parameters from a URL string', () => {
+  expect(cleanUrl('/user?id=123')).toEqual('/user')
+  expect(cleanUrl('/user?id=123&id=456')).toEqual('/user')
+  expect(cleanUrl('/user?id=123&role=admin')).toEqual('/user')
+})
+
+it('removes hashes from a URL string', () => {
+  expect(cleanUrl('/user#hash')).toEqual('/user')
+  expect(cleanUrl('/user#hash-with-dashes')).toEqual('/user')
+})
+
+it('removes both query parameters and hashes from a URL string', () => {
+  expect(cleanUrl('/user?id=123#some')).toEqual('/user')
+  expect(cleanUrl('/user?id=123&role=admin#some')).toEqual('/user')
+})
+
+it('preserves optional path parameters', () => {
+  expect(cleanUrl('/user/:id?')).toEqual('/user/:id?')
+  expect(cleanUrl('/user/:id?/:messageId?')).toEqual('/user/:id?/:messageId?')
+})

package/src/core/utils/url/cleanUrl.ts

@@ -0,0 +1,16 @@
+const REDUNDANT_CHARACTERS_EXP = /[?|#].*$/g
+
+/**
+ * Removes search parameters and the fragment
+ * from a given URL string.
+ */
+export function cleanUrl(path: string): string {
+  // If the path ends with an optional path parameter,
+  // return it as-is.
+  if (path.endsWith('?')) {
+    return path
+  }
+
+  // Otherwise, remove the search and fragment from it.
+  return path.replace(REDUNDANT_CHARACTERS_EXP, '')
+}

package/src/core/utils/url/getAbsoluteUrl.node.test.ts

@@ -0,0 +1,19 @@
+/**
+ * @vitest-environment node
+ */
+import { getAbsoluteUrl } from './getAbsoluteUrl'
+
+it('returns a given relative URL as-is', () => {
+  expect(getAbsoluteUrl('/reviews')).toBe('/reviews')
+})
+
+it('rebases a relative URL against a custom base URL', () => {
+  expect(getAbsoluteUrl('/user', 'https://api.github.com')).toEqual(
+    'https://api.github.com/user',
+  )
+})
+it('returns a given absolute URL as-is', () => {
+  expect(getAbsoluteUrl('https://api.mswjs.io/users')).toBe(
+    'https://api.mswjs.io/users',
+  )
+})