@depup/msw 2.12.13-depup.0

package/src/core/typeUtils.ts

@@ -0,0 +1,26 @@
+type Fn = (...arg: any[]) => any
+
+export type MaybePromise<T> = T | Promise<T>
+
+export type RequiredDeep<
+  Type,
+  U extends Record<string, unknown> | Fn | undefined = undefined,
+> = Type extends Fn
+  ? Type
+  : /**
+     * @note The "Fn" type satisfies the predicate below.
+     * It must always come first, before the Record check.
+     */
+    Type extends Record<string, any>
+    ? {
+        [Key in keyof Type]-?: NonNullable<Type[Key]> extends NonNullable<U>
+          ? NonNullable<Type[Key]>
+          : RequiredDeep<NonNullable<Type[Key]>, U>
+      }
+    : Type
+
+/**
+ * @fixme Remove this once TS 5.4 is the lowest supported version.
+ * Because "NoInfer" is a built-in type utility there.
+ */
+export type NoInfer<T> = [T][T extends any ? 0 : never]

package/src/core/utils/HttpResponse/decorators.ts

@@ -0,0 +1,76 @@
+import statuses from '../../../shims/statuses'
+import { Headers as HeadersPolyfill } from 'headers-polyfill'
+import type { HttpResponseInit } from '../../HttpResponse'
+
+const { message } = statuses
+
+export const kSetCookie = Symbol('kSetCookie')
+
+export interface HttpResponseDecoratedInit extends HttpResponseInit {
+  status: number
+  statusText: string
+  headers: Headers
+}
+
+export function normalizeResponseInit(
+  init: HttpResponseInit = {},
+): HttpResponseDecoratedInit {
+  const status = init?.status || 200
+  const statusText = init?.statusText || message[status] || ''
+  const headers = new Headers(init?.headers)
+
+  return {
+    ...init,
+    headers,
+    status,
+    statusText,
+  }
+}
+
+export function decorateResponse(
+  response: Response,
+  init: HttpResponseDecoratedInit,
+): Response {
+  // Allow to mock the response type.
+  if (init.type) {
+    Object.defineProperty(response, 'type', {
+      value: init.type,
+      enumerable: true,
+      writable: false,
+    })
+  }
+
+  const responseCookies = init.headers.get('set-cookie')
+
+  if (responseCookies) {
+    // Record the raw "Set-Cookie" response header provided
+    // in the HeadersInit. This is later used to store these cookies
+    // in cookie jar and return the right cookies in the "cookies"
+    // response resolver argument.
+    Object.defineProperty(response, kSetCookie, {
+      value: responseCookies,
+      enumerable: false,
+      writable: false,
+    })
+
+    // Cookie forwarding is only relevant in the browser.
+    if (typeof document !== 'undefined') {
+      // Write the mocked response cookies to the document.
+      // Use `headers-polyfill` to get the Set-Cookie header value correctly.
+      // This is an alternative until TypeScript 5.2
+      // and Node.js v20 become the minimum supported version
+      // and getSetCookie in Headers can be used directly.
+      const responseCookiePairs = HeadersPolyfill.prototype.getSetCookie.call(
+        init.headers,
+      )
+
+      for (const cookieString of responseCookiePairs) {
+        // No need to parse the cookie headers because it's defined
+        // as the valid cookie string to begin with.
+        document.cookie = cookieString
+      }
+    }
+  }
+
+  return response
+}

package/src/core/utils/cookieStore.ts

@@ -0,0 +1,94 @@
+import { isNodeProcess } from 'is-node-process'
+import { invariant } from 'outvariant'
+import {
+  Cookie,
+  CookieJar,
+  MemoryCookieStore,
+  type MemoryCookieStoreIndex,
+} from 'tough-cookie'
+import { jsonParse } from './internal/jsonParse'
+
+class CookieStore {
+  #storageKey = '__msw-cookie-store__'
+  #jar: CookieJar
+  #memoryStore: MemoryCookieStore
+
+  constructor() {
+    if (!isNodeProcess()) {
+      invariant(
+        typeof localStorage !== 'undefined',
+        'Failed to create a CookieStore: `localStorage` is not available in this environment. This is likely an issue with your environment, which has been detected as browser (or browser-like) environment and must implement global browser APIs correctly.',
+      )
+    }
+
+    this.#memoryStore = new MemoryCookieStore()
+    this.#memoryStore.idx = this.getCookieStoreIndex()
+    this.#jar = new CookieJar(this.#memoryStore)
+  }
+
+  public getCookies(url: string): Array<Cookie> {
+    return this.#jar.getCookiesSync(url)
+  }
+
+  public async setCookie(cookieName: string, url: string): Promise<void> {
+    await this.#jar.setCookie(cookieName, url)
+    this.persist()
+  }
+
+  private getCookieStoreIndex(): MemoryCookieStoreIndex {
+    if (
+      typeof localStorage === 'undefined' ||
+      typeof localStorage.getItem !== 'function'
+    ) {
+      return {}
+    }
+
+    const cookiesString = localStorage.getItem(this.#storageKey)
+    if (cookiesString == null) {
+      return {}
+    }
+
+    const rawCookies = jsonParse<Array<Record<string, unknown>>>(cookiesString)
+    if (rawCookies == null) {
+      return {}
+    }
+
+    const cookies: MemoryCookieStoreIndex = {}
+
+    for (const rawCookie of rawCookies) {
+      const cookie = Cookie.fromJSON(rawCookie)
+
+      if (cookie != null && cookie.domain != null && cookie.path != null) {
+        cookies[cookie.domain] ||= {}
+        cookies[cookie.domain][cookie.path] ||= {}
+        cookies[cookie.domain][cookie.path][cookie.key] = cookie
+      }
+    }
+
+    return cookies
+  }
+
+  private persist(): void {
+    if (
+      typeof localStorage === 'undefined' ||
+      typeof localStorage.setItem !== 'function'
+    ) {
+      return
+    }
+
+    const data = []
+    const { idx } = this.#memoryStore
+
+    for (const domain in idx) {
+      for (const path in idx[domain]) {
+        for (const key in idx[domain][path]) {
+          data.push(idx[domain][path][key].toJSON())
+        }
+      }
+    }
+
+    localStorage.setItem(this.#storageKey, JSON.stringify(data))
+  }
+}
+
+export const cookieStore = new CookieStore()

package/src/core/utils/executeHandlers.ts

@@ -0,0 +1,69 @@
+import {
+  RequestHandler,
+  type RequestHandlerExecutionResult,
+} from '../handlers/RequestHandler'
+
+export interface HandlersExecutionResult {
+  handler: RequestHandler
+  parsedResult?: any
+  response?: Response
+}
+
+export interface ResponseResolutionContext {
+  /**
+   * A base url to use when resolving relative urls.
+   * @note This is primarily used by the `@mswjs/http-middleware`
+   * to resolve relative urls in the context of the running server
+   */
+  baseUrl?: string
+  quiet?: boolean
+}
+
+/**
+ * Executes the list of request handlers against the given request.
+ * Returns the execution result object containing any matching request
+ * handler and any mocked response it returned.
+ */
+export const executeHandlers = async <Handlers extends Array<RequestHandler>>({
+  request,
+  requestId,
+  handlers,
+  resolutionContext,
+}: {
+  request: Request
+  requestId: string
+  handlers: Handlers
+  resolutionContext?: ResponseResolutionContext
+}): Promise<HandlersExecutionResult | null> => {
+  let matchingHandler: RequestHandler | null = null
+  let result: RequestHandlerExecutionResult<any> | null = null
+
+  for (const handler of handlers) {
+    result = await handler.run({ request, requestId, resolutionContext })
+
+    // If the handler produces some result for this request,
+    // it automatically becomes matching.
+    if (result !== null) {
+      matchingHandler = handler
+    }
+
+    // Stop the lookup if this handler returns a mocked response.
+    // If it doesn't, it will still be considered the last matching
+    // handler until any of them returns a response. This way we can
+    // distinguish between fallthrough handlers without responses
+    // and the lack of a matching handler.
+    if (result?.response) {
+      break
+    }
+  }
+
+  if (matchingHandler) {
+    return {
+      handler: matchingHandler,
+      parsedResult: result?.parsedResult,
+      response: result?.response,
+    }
+  }
+
+  return null
+}