msw 2.3.1 → 2.3.3

package/lib/mockServiceWorker.js

@@ -8,7 +8,7 @@
  * - Please do NOT serve this file on production.
  */
 
-const PACKAGE_VERSION = '2.3.1'
+const PACKAGE_VERSION = '2.3.3'
 const INTEGRITY_CHECKSUM = '26357c79639bfa20d64c0efca2a87423'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "./lib/core/index.js",
   "module": "./lib/core/index.mjs",
@@ -115,8 +115,8 @@
   "dependencies": {
     "@bundled-es-modules/cookie": "^2.0.0",
     "@bundled-es-modules/statuses": "^1.0.1",
+    "@bundled-es-modules/tough-cookie": "^0.1.6",
     "@inquirer/confirm": "^3.0.0",
-    "@mswjs/cookies": "^1.1.0",
     "@mswjs/interceptors": "^0.29.0",
     "@open-draft/until": "^2.1.0",
     "@types/cookie": "^0.6.0",
@@ -171,7 +171,7 @@
     "simple-git-hooks": "^2.9.0",
     "ts-node": "^10.9.2",
     "tsup": "^8.0.1",
-    "typescript": "^5.4.2",
+    "typescript": "^5.5.2",
     "undici": "^5.20.0",
     "url-loader": "^4.1.1",
     "vitest": "^1.2.2",
@@ -206,12 +206,12 @@
     "check:exports": "node \"./config/scripts/validate-esm.js\"",
     "test": "pnpm test:unit && pnpm test:node && pnpm test:browser && pnpm test:native",
     "test:unit": "vitest",
-    "test:node": "vitest run --config=./test/node/vitest.config.ts",
-    "test:native": "vitest --config=./test/native/vitest.config.ts",
+    "test:node": "vitest run --config=./test/node/vitest.config.mts",
+    "test:native": "vitest --config=./test/native/vitest.config.mts",
     "test:browser": "playwright test -c ./test/browser/playwright.config.ts",
-    "test:modules:node": "vitest --config=./test/modules/node/vitest.config.ts",
+    "test:modules:node": "vitest --config=./test/modules/node/vitest.config.mts",
     "test:modules:browser": "playwright test -c ./test/modules/browser/playwright.config.ts",
-    "test:ts": "vitest --typecheck --config=./test/typings/vitest.config.ts",
+    "test:ts": "vitest --typecheck --config=./test/typings/vitest.config.mts",
     "release": "release publish",
     "postinstall": "node -e \"try{require('./config/scripts/postinstall')}catch(e){}\""
   }

package/src/core/handlers/RequestHandler.ts

@@ -1,6 +1,9 @@
-import { invariant } from 'outvariant'
 import { getCallFrame } from '../utils/internal/getCallFrame'
-import { isIterable } from '../utils/internal/isIterable'
+import {
+  AsyncIterable,
+  Iterable,
+  isIterable,
+} from '../utils/internal/isIterable'
 import type { ResponseResolutionContext } from '../utils/executeHandlers'
 import type { MaybePromise } from '../typeUtils'
 import { StrictRequest, StrictResponse } from '..//HttpResponse'
@@ -52,7 +55,12 @@ export type AsyncResponseResolverReturnType<
   ResponseBodyType extends DefaultBodyType,
 > = MaybePromise<
   | ResponseResolverReturnType<ResponseBodyType>
-  | Generator<
+  | Iterable<
+      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,
+      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,
+      MaybeAsyncResponseResolverReturnType<ResponseBodyType>
+    >
+  | AsyncIterable<
       MaybeAsyncResponseResolverReturnType<ResponseBodyType>,
       MaybeAsyncResponseResolverReturnType<ResponseBodyType>,
       MaybeAsyncResponseResolverReturnType<ResponseBodyType>
@@ -117,12 +125,18 @@ export abstract class RequestHandler<
   public isUsed: boolean
 
   protected resolver: ResponseResolver<ResolverExtras, any, any>
-  private resolverGenerator?: Generator<
-    MaybeAsyncResponseResolverReturnType<any>,
-    MaybeAsyncResponseResolverReturnType<any>,
-    MaybeAsyncResponseResolverReturnType<any>
-  >
-  private resolverGeneratorResult?: Response | StrictResponse<any>
+  private resolverIterator?:
+    | Iterator<
+        MaybeAsyncResponseResolverReturnType<any>,
+        MaybeAsyncResponseResolverReturnType<any>,
+        MaybeAsyncResponseResolverReturnType<any>
+      >
+    | AsyncIterator<
+        MaybeAsyncResponseResolverReturnType<any>,
+        MaybeAsyncResponseResolverReturnType<any>,
+        MaybeAsyncResponseResolverReturnType<any>
+      >
+  private resolverIteratorResult?: Response | StrictResponse<any>
   private options?: HandlerOptions
 
   constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>) {
@@ -256,6 +270,9 @@ export abstract class RequestHandler<
       return null
     }
 
+    // Preemptively mark the handler as used.
+    // Generators will undo this because only when the resolver reaches the
+    // "done" state of the generator that it considers the handler used.
     this.isUsed = true
 
     // Create a response extraction wrapper around the resolver
@@ -301,48 +318,38 @@ export abstract class RequestHandler<
     resolver: ResponseResolver<ResolverExtras>,
   ): ResponseResolver<ResolverExtras> {
     return async (info): Promise<ResponseResolverReturnType<any>> => {
-      const result = this.resolverGenerator || (await resolver(info))
-
-      if (isIterable<AsyncResponseResolverReturnType<any>>(result)) {
-        // Immediately mark this handler as unused.
-        // Only when the generator is done, the handler will be
-        // considered used.
-        this.isUsed = false
-
-        const { value, done } = result[Symbol.iterator]().next()
-        const nextResponse = await value
-
-        if (done) {
-          this.isUsed = true
+      if (!this.resolverIterator) {
+        const result = await resolver(info)
+        if (!isIterable(result)) {
+          return result
         }
+        this.resolverIterator =
+          Symbol.iterator in result
+            ? result[Symbol.iterator]()
+            : result[Symbol.asyncIterator]()
+      }
 
-        // If the generator is done and there is no next value,
-        // return the previous generator's value.
-        if (!nextResponse && done) {
-          invariant(
-            this.resolverGeneratorResult,
-            'Failed to returned a previously stored generator response: the value is not a valid Response.',
-          )
-
-          // Clone the previously stored response from the generator
-          // so that it could be read again.
-          return this.resolverGeneratorResult.clone() as StrictResponse<any>
-        }
+      // Opt-out from marking this handler as used.
+      this.isUsed = false
 
-        if (!this.resolverGenerator) {
-          this.resolverGenerator = result
-        }
+      const { done, value } = await this.resolverIterator.next()
+      const nextResponse = await value
 
-        if (nextResponse) {
-          // Also clone the response before storing it
-          // so it could be read again.
-          this.resolverGeneratorResult = nextResponse?.clone()
-        }
+      if (nextResponse) {
+        this.resolverIteratorResult = nextResponse.clone()
+      }
+
+      if (done) {
+        // A one-time generator resolver stops affecting the network
+        // only after it's been completely exhausted.
+        this.isUsed = true
 
-        return nextResponse
+        // Clone the previously stored response so it can be read
+        // when receiving it repeatedly from the "done" generator.
+        return this.resolverIteratorResult?.clone()
       }
 
-      return result
+      return nextResponse
     }
   }
 

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

@@ -1,9 +1,11 @@
 import statuses from '@bundled-es-modules/statuses'
-import type { HttpResponseInit } from '../../HttpResponse'
 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
@@ -38,21 +40,35 @@ export function decorateResponse(
     })
   }
 
-  // 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 responseCookies = HeadersPolyfill.prototype.getSetCookie.call(
-      init.headers,
-    )
-
-    for (const cookieString of responseCookies) {
-      // No need to parse the cookie headers because it's defined
-      // as the valid cookie string to begin with.
-      document.cookie = cookieString
+  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
+      }
     }
   }
 

package/src/core/utils/cookieStore.ts

@@ -0,0 +1,212 @@
+import { invariant } from 'outvariant'
+import { isNodeProcess } from 'is-node-process'
+import toughCookie, {
+  type Cookie as CookieInstance,
+} from '@bundled-es-modules/tough-cookie'
+
+const { Cookie, CookieJar, Store, MemoryCookieStore, domainMatch, pathMatch } =
+  toughCookie
+
+/**
+ * Custom cookie store that uses the Web Storage API.
+ * @see https://github.com/expo/tough-cookie-web-storage-store
+ */
+class WebStorageCookieStore extends Store {
+  private storage: Storage
+  private storageKey: string
+
+  constructor() {
+    super()
+
+    invariant(
+      typeof localStorage !== 'undefined',
+      'Failed to create a WebStorageCookieStore: `localStorage` is not available in this environment. This is likely an issue with MSW. Please report it on GitHub: https://github.com/mswjs/msw/issues',
+    )
+
+    this.synchronous = true
+    this.storage = localStorage
+    this.storageKey = '__msw-cookie-store__'
+  }
+
+  findCookie(
+    domain: string,
+    path: string,
+    key: string,
+    callback: (error: Error | null, cookie: CookieInstance | null) => void,
+  ): void {
+    try {
+      const store = this.getStore()
+      const cookies = this.filterCookiesFromList(store, { domain, path, key })
+      callback(null, cookies[0] || null)
+    } catch (error) {
+      if (error instanceof Error) {
+        callback(error, null)
+      }
+    }
+  }
+
+  findCookies(
+    domain: string,
+    path: string,
+    allowSpecialUseDomain: boolean,
+    callback: (error: Error | null, cookie: Array<CookieInstance>) => void,
+  ): void {
+    if (!domain) {
+      callback(null, [])
+      return
+    }
+
+    try {
+      const store = this.getStore()
+      const results = this.filterCookiesFromList(store, {
+        domain,
+        path,
+      })
+      callback(null, results)
+    } catch (error) {
+      if (error instanceof Error) {
+        callback(error, [])
+      }
+    }
+  }
+
+  putCookie(
+    cookie: CookieInstance,
+    callback: (error: Error | null) => void,
+  ): void {
+    try {
+      const store = this.getStore()
+      store.push(cookie)
+      this.updateStore(store)
+    } catch (error) {
+      if (error instanceof Error) {
+        callback(error)
+      }
+    }
+  }
+
+  updateCookie(
+    oldCookie: CookieInstance,
+    newCookie: CookieInstance,
+    callback: (error: Error | null) => void,
+  ): void {
+    this.putCookie(newCookie, callback)
+  }
+
+  removeCookie(
+    domain: string,
+    path: string,
+    key: string,
+    callback: (error: Error | null) => void,
+  ): void {
+    try {
+      const store = this.getStore()
+      const nextStore = this.deleteCookiesFromList(store, { domain, path, key })
+      this.updateStore(nextStore)
+      callback(null)
+    } catch (error) {
+      if (error instanceof Error) {
+        callback(error)
+      }
+    }
+  }
+
+  removeCookies(
+    domain: string,
+    path: string,
+    callback: (error: Error | null) => void,
+  ): void {
+    try {
+      const store = this.getStore()
+      const nextStore = this.deleteCookiesFromList(store, { domain, path })
+      this.updateStore(nextStore)
+      callback(null)
+    } catch (error) {
+      if (error instanceof Error) {
+        callback(error)
+      }
+    }
+  }
+
+  getAllCookies(
+    callback: (error: Error | null, cookie: Array<CookieInstance>) => void,
+  ): void {
+    try {
+      callback(null, this.getStore())
+    } catch (error) {
+      if (error instanceof Error) {
+        callback(error, [])
+      }
+    }
+  }
+
+  private getStore(): Array<CookieInstance> {
+    try {
+      const json = this.storage.getItem(this.storageKey)
+
+      if (json == null) {
+        return []
+      }
+
+      const rawCookies = JSON.parse(json) as Array<Record<string, any>>
+      const cookies: Array<CookieInstance> = []
+      for (const rawCookie of rawCookies) {
+        const cookie = Cookie.fromJSON(rawCookie)
+        if (cookie != null) {
+          cookies.push(cookie)
+        }
+      }
+      return cookies
+    } catch {
+      return []
+    }
+  }
+
+  private updateStore(nextStore: Array<CookieInstance>) {
+    this.storage.setItem(
+      this.storageKey,
+      JSON.stringify(nextStore.map((cookie) => cookie.toJSON())),
+    )
+  }
+
+  private filterCookiesFromList(
+    cookies: Array<CookieInstance>,
+    matches: { domain?: string; path?: string; key?: string },
+  ): Array<CookieInstance> {
+    const result: Array<CookieInstance> = []
+
+    for (const cookie of cookies) {
+      if (matches.domain && !domainMatch(matches.domain, cookie.domain || '')) {
+        continue
+      }
+
+      if (matches.path && !pathMatch(matches.path, cookie.path || '')) {
+        continue
+      }
+
+      if (matches.key && cookie.key !== matches.key) {
+        continue
+      }
+
+      result.push(cookie)
+    }
+
+    console.log('filter result:', { cookies, matches, result })
+
+    return result
+  }
+
+  private deleteCookiesFromList(
+    cookies: Array<CookieInstance>,
+    matches: { domain?: string; path?: string; key?: string },
+  ) {
+    const matchingCookies = this.filterCookiesFromList(cookies, matches)
+    return cookies.filter((cookie) => !matchingCookies.includes(cookie))
+  }
+}
+
+const store = isNodeProcess()
+  ? new MemoryCookieStore()
+  : new WebStorageCookieStore()
+
+export const cookieStore = new CookieJar(store)

package/src/core/utils/handleRequest.ts

@@ -5,7 +5,7 @@ import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequiredDeep } from '../typeUtils'
 import { HandlersExecutionResult, executeHandlers } from './executeHandlers'
 import { onUnhandledRequest } from './request/onUnhandledRequest'
-import { readResponseCookies } from './request/readResponseCookies'
+import { storeResponseCookies } from './request/storeResponseCookies'
 
 export interface HandleRequestOptions {
   /**
@@ -110,8 +110,8 @@ export async function handleRequest(
     return
   }
 
-  // Store all the received response cookies in the virtual cookie store.
-  readResponseCookies(request, response)
+  // Store all the received response cookies in the cookie jar.
+  storeResponseCookies(request, response)
 
   emitter.emit('request:match', { request, requestId })
 

package/src/core/utils/internal/isIterable.ts

@@ -1,12 +1,32 @@
+/**
+ * This is the same as TypeScript's `Iterable`, but with all three type parameters.
+ * @todo Remove once TypeScript 5.6 is the minimum.
+ */
+export interface Iterable<T, TReturn, TNext> {
+  [Symbol.iterator](): Iterator<T, TReturn, TNext>
+}
+
+/**
+ * This is the same as TypeScript's `AsyncIterable`, but with all three type parameters.
+ * @todo Remove once TypeScript 5.6 is the minimum.
+ */
+export interface AsyncIterable<T, TReturn, TNext> {
+  [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>
+}
+
 /**
  * Determines if the given function is an iterator.
  */
 export function isIterable<IteratorType>(
   fn: any,
-): fn is Generator<IteratorType, IteratorType, IteratorType> {
+): fn is
+  | Iterable<IteratorType, IteratorType, IteratorType>
+  | AsyncIterable<IteratorType, IteratorType, IteratorType> {
   if (!fn) {
     return false
   }
 
-  return typeof (fn as Generator<unknown>)[Symbol.iterator] == 'function'
+  return (
+    Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator)
+  )
 }

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

@@ -1,29 +1,24 @@
 import cookieUtils from '@bundled-es-modules/cookie'
-import { store } from '@mswjs/cookies'
+import { cookieStore } from '../cookieStore'
 
 function getAllDocumentCookies() {
   return cookieUtils.parse(document.cookie)
 }
 
-/** @todo Rename this to "getDocumentCookies" */
-/**
- * Returns relevant document cookies based on the request `credentials` option.
- */
-export function getRequestCookies(request: Request): Record<string, string> {
-  /**
-   * @note No cookies persist on the document in Node.js: no document.
-   */
+function getDocumentCookies(request: Request): Record<string, string> {
   if (typeof document === 'undefined' || typeof location === 'undefined') {
     return {}
   }
 
   switch (request.credentials) {
     case 'same-origin': {
-      const url = new URL(request.url)
+      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 === url.origin ? getAllDocumentCookies() : {}
+      return location.origin === requestUrl.origin
+        ? getAllDocumentCookies()
+        : {}
     }
 
     case 'include': {
@@ -38,38 +33,40 @@ export function getRequestCookies(request: Request): Record<string, string> {
 }
 
 export function getAllRequestCookies(request: Request): Record<string, string> {
-  const requestCookiesString = request.headers.get('cookie')
-  const cookiesFromHeaders = requestCookiesString
-    ? cookieUtils.parse(requestCookiesString)
+  /**
+   * @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
+    ? cookieUtils.parse(requestCookieHeader)
     : {}
 
-  store.hydrate()
-
-  const cookiesFromStore = Array.from(store.get(request)?.entries()).reduce<
-    Record<string, string>
-  >((cookies, [name, { value }]) => {
-    return Object.assign(cookies, { [name.trim()]: value })
-  }, {})
-
-  const cookiesFromDocument = getRequestCookies(request)
+  const cookiesFromDocument = getDocumentCookies(request)
 
-  const forwardedCookies = {
-    ...cookiesFromDocument,
-    ...cookiesFromStore,
+  // Forward the document cookies to the request headers.
+  for (const name in cookiesFromDocument) {
+    request.headers.append(
+      'cookie',
+      cookieUtils.serialize(name, cookiesFromDocument[name]),
+    )
   }
 
-  // Set the inferred cookies from the cookie store and the document
-  // on the request's headers.
-  /**
-   * @todo Consider making this a separate step so this function
-   * is pure-er.
-   */
-  for (const [name, value] of Object.entries(forwardedCookies)) {
-    request.headers.append('cookie', cookieUtils.serialize(name, value))
+  const cookiesFromStore = cookieStore.getCookiesSync(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 {
-    ...forwardedCookies,
+    ...cookiesFromDocument,
+    ...storedCookiesObject,
     ...cookiesFromHeaders,
   }
 }

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

@@ -0,0 +1,17 @@
+import { cookieStore } from '../cookieStore'
+import { kSetCookie } from '../HttpResponse/decorators'
+
+export function storeResponseCookies(
+  request: Request,
+  response: Response,
+): 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) {
+    cookieStore.setCookie(responseCookies, request.url)
+  }
+}

package/lib/core/utils/request/readResponseCookies.d.mts

@@ -1,3 +0,0 @@
-declare function readResponseCookies(request: Request, response: Response): void;
-
-export { readResponseCookies };

package/lib/core/utils/request/readResponseCookies.d.ts

@@ -1,3 +0,0 @@
-declare function readResponseCookies(request: Request, response: Response): void;
-
-export { readResponseCookies };

package/lib/core/utils/request/readResponseCookies.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/core/utils/request/readResponseCookies.ts"],"sourcesContent":["import { store } from '@mswjs/cookies'\n\nexport function readResponseCookies(\n  request: Request,\n  response: Response,\n): void {\n  store.add({ ...request, url: request.url.toString() }, response)\n  store.persist()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAsB;AAEf,SAAS,oBACd,SACA,UACM;AACN,uBAAM,IAAI,EAAE,GAAG,SAAS,KAAK,QAAQ,IAAI,SAAS,EAAE,GAAG,QAAQ;AAC/D,uBAAM,QAAQ;AAChB;","names":[]}

package/lib/core/utils/request/readResponseCookies.mjs

@@ -1,9 +0,0 @@
-import { store } from "@mswjs/cookies";
-function readResponseCookies(request, response) {
-  store.add({ ...request, url: request.url.toString() }, response);
-  store.persist();
-}
-export {
-  readResponseCookies
-};
-//# sourceMappingURL=readResponseCookies.mjs.map

package/lib/core/utils/request/readResponseCookies.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/core/utils/request/readResponseCookies.ts"],"sourcesContent":["import { store } from '@mswjs/cookies'\n\nexport function readResponseCookies(\n  request: Request,\n  response: Response,\n): void {\n  store.add({ ...request, url: request.url.toString() }, response)\n  store.persist()\n}\n"],"mappings":"AAAA,SAAS,aAAa;AAEf,SAAS,oBACd,SACA,UACM;AACN,QAAM,IAAI,EAAE,GAAG,SAAS,KAAK,QAAQ,IAAI,SAAS,EAAE,GAAG,QAAQ;AAC/D,QAAM,QAAQ;AAChB;","names":[]}