msw 2.14.7 → 3.0.0

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

package/src/core/utils/request/{toPublicUrl.node.test.ts → to-public-url.node.test.ts}

@@ -1,5 +1,5 @@
 // @vitest-environment node
-import { toPublicUrl } from './toPublicUrl'
+import { toPublicUrl } from './to-public-url'
 
 test('returns an absolute request URL without search params', () => {
   expect(toPublicUrl(new URL('https://test.mswjs.io/path'))).toBe(

package/src/core/utils/request/{toPublicUrl.test.ts → to-public-url.test.ts}

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

package/src/core/utils/{HttpResponse/decorators.ts → response-decorators.ts}

@@ -1,7 +1,5 @@
-import statuses from '../../../shims/statuses'
-import type { HttpResponseInit } from '../../HttpResponse'
-
-const { message } = statuses
+import type { HttpResponse, HttpResponseInit } from '#http/http-response'
+import { httpStatusMessages } from './http-status-messages'
 
 const kSetCookie = Symbol('kSetCookie')
 
@@ -15,7 +13,7 @@ export function normalizeResponseInit(
   init: HttpResponseInit = {},
 ): HttpResponseDecoratedInit {
   const status = init?.status || 200
-  const statusText = init?.statusText || message[status] || ''
+  const statusText = init?.statusText || httpStatusMessages[status] || ''
   const headers = new Headers(init?.headers)
 
   return {
@@ -27,7 +25,7 @@ export function normalizeResponseInit(
 }
 
 export function decorateResponse(
-  response: Response,
+  response: HttpResponse<any>,
   init: HttpResponseDecoratedInit,
 ): Response {
   // Allow mocking the response type.
@@ -39,7 +37,7 @@ export function decorateResponse(
     })
   }
 
-  const responseCookies = init.headers.get('set-cookie')
+  const responseCookies = init.headers.getSetCookie()
 
   if (responseCookies) {
     // Record the raw "Set-Cookie" response header provided
@@ -56,6 +54,27 @@ export function decorateResponse(
   return response
 }
 
-export function getRawSetCookie(response: Response): string | undefined {
-  return Reflect.get(response, kSetCookie)
+export function getRawSetCookie(response: Response): Array<string> {
+  return Reflect.get(response, kSetCookie) || []
+}
+
+/**
+ * Copy the given response own properties, like internal symbols,
+ * onto another response. Used for faithful internal copying of responses.
+ */
+export function copyResponseOwnProperties(
+  source: Response,
+  target: Response,
+): void {
+  for (const propertyName of Reflect.ownKeys(source)) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, propertyName)
+    const existingDescriptor = Object.getOwnPropertyDescriptor(
+      target,
+      propertyName,
+    )
+
+    if (descriptor && existingDescriptor == null) {
+      Object.defineProperty(target, propertyName, descriptor)
+    }
+  }
 }

package/src/core/utils/url/{getAbsoluteUrl.node.test.ts → get-absolute-url.node.test.ts}

@@ -1,18 +1,16 @@
-/**
- * @vitest-environment node
- */
-import { getAbsoluteUrl } from './getAbsoluteUrl'
+// @vitest-environment node
+import { getAbsoluteUrl } from './get-absolute-url'
 
-it('returns a given relative URL as-is', () => {
+test('returns a given relative URL as-is', () => {
   expect(getAbsoluteUrl('/reviews')).toBe('/reviews')
 })
 
-it('rebases a relative URL against a custom base URL', () => {
+test('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', () => {
+test('returns a given absolute URL as-is', () => {
   expect(getAbsoluteUrl('https://api.mswjs.io/users')).toBe(
     'https://api.mswjs.io/users',
   )

package/src/core/utils/url/{getAbsoluteUrl.test.ts → get-absolute-url.test.ts}

@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import { getAbsoluteUrl } from './getAbsoluteUrl'
+import { getAbsoluteUrl } from './get-absolute-url'
 
 const rawLocation = window.location
 
@@ -9,11 +9,11 @@ afterAll(() => {
   })
 })
 
-it('resolves a relative URL against the current location (default)', () => {
+test('resolves a relative URL against the current location (default)', () => {
   expect(getAbsoluteUrl('/reviews')).toBe('http://localhost/reviews')
 })
 
-it('supports relative URLs starting with search parameters', () => {
+test('supports relative URLs starting with search parameters', () => {
   Object.defineProperty(window, 'location', {
     value: {
       href: 'http://localhost/nested',
@@ -25,23 +25,23 @@ it('supports relative URLs starting with search parameters', () => {
   )
 })
 
-it('resolves a relative URL against a custom base URL', () => {
+test('resolves a relative URL against a custom base URL', () => {
   expect(getAbsoluteUrl('/user', 'https://api.github.com')).toBe(
     'https://api.github.com/user',
   )
 })
 
-it('returns a given absolute URL as-is', () => {
+test('returns a given absolute URL as-is', () => {
   expect(getAbsoluteUrl('https://api.mswjs.io/users')).toBe(
     'https://api.mswjs.io/users',
   )
 })
 
-it('returns an absolute URL given a relative path without a leading slash', () => {
+test('returns an absolute URL given a relative path without a leading slash', () => {
   expect(getAbsoluteUrl('users')).toBe('http://localhost/users')
 })
 
-it('returns a path with a pattern as-is', () => {
+test('returns a path with a pattern as-is', () => {
   expect(getAbsoluteUrl(':api/user')).toBe('http://localhost/:api/user')
   expect(getAbsoluteUrl('*/resource/*')).toBe('*/resource/*')
 })

package/src/core/utils/url/{getAbsoluteUrl.ts → get-absolute-url.ts}

@@ -1,4 +1,4 @@
-import { isAbsoluteUrl } from './isAbsoluteUrl'
+import { isAbsoluteUrl } from './is-absolute-url'
 
 /**
  * Returns an absolute URL based on the given path.

package/src/core/utils/url/is-absolute-url.test.ts

@@ -0,0 +1,30 @@
+// @vitest-environment node
+import { isAbsoluteUrl } from './is-absolute-url'
+
+test('returns true for the "http" scheme', () => {
+  expect(isAbsoluteUrl('http://www.domain.com')).toEqual(true)
+})
+
+test('returns true for the "https" scheme', () => {
+  expect(isAbsoluteUrl('https://www.domain.com')).toEqual(true)
+})
+
+test('returns true for the "ws" scheme', () => {
+  expect(isAbsoluteUrl('ws://www.domain.com')).toEqual(true)
+})
+
+test('returns true for the "ftp" scheme', () => {
+  expect(isAbsoluteUrl('ftp://www.domain.com')).toEqual(true)
+})
+
+test('returns true for the custom scheme', () => {
+  expect(isAbsoluteUrl('web+my://www.example.com')).toEqual(true)
+})
+
+test('returns false for the relative URL', () => {
+  expect(isAbsoluteUrl('/test')).toEqual(false)
+})
+
+test('returns false for the relative URL without a leading slash', () => {
+  expect(isAbsoluteUrl('test')).toEqual(false)
+})