msw 2.10.5 → 2.11.1

package/src/core/utils/cookieStore.ts

@@ -1,230 +1,88 @@
-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
+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() {
-    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
+    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.',
+      )
     }
 
-    try {
-      const store = this.getStore()
-      const results = this.filterCookiesFromList(store, {
-        domain,
-        path,
-      })
-      callback(null, results)
-    } catch (error) {
-      if (error instanceof Error) {
-        callback(error, [])
-      }
-    }
+    this.#memoryStore = new MemoryCookieStore()
+    this.#memoryStore.idx = this.getCookieStoreIndex()
+    this.#jar = new CookieJar(this.#memoryStore)
   }
 
-  putCookie(
-    cookie: CookieInstance,
-    callback: (error: Error | null) => void,
-  ): void {
-    try {
-      // Never set cookies with `maxAge` of `0`.
-      if (cookie.maxAge === 0) {
-        return
-      }
-
-      const store = this.getStore()
-      store.push(cookie)
-      this.updateStore(store)
-    } catch (error) {
-      if (error instanceof Error) {
-        callback(error)
-      }
-    }
+  public getCookies(url: string): Array<Cookie> {
+    return this.#jar.getCookiesSync(url)
   }
 
-  updateCookie(
-    oldCookie: CookieInstance,
-    newCookie: CookieInstance,
-    callback: (error: Error | null) => void,
-  ): void {
-    /**
-     * If updating a cookie with `maxAge` of `0`, remove it from the store.
-     * Otherwise, two cookie entries will be created.
-     * @see https://github.com/mswjs/msw/issues/2272
-     */
-    if (newCookie.maxAge === 0) {
-      this.removeCookie(
-        newCookie.domain || '',
-        newCookie.path || '',
-        newCookie.key,
-        callback,
-      )
-      return
-    }
-
-    this.putCookie(newCookie, callback)
+  public async setCookie(cookieName: string, url: string): Promise<void> {
+    await this.#jar.setCookie(cookieName, url)
+    this.persist()
   }
 
-  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)
-      }
+  private getCookieStoreIndex(): MemoryCookieStoreIndex {
+    if (typeof localStorage === 'undefined') {
+      return {}
     }
-  }
 
-  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)
-      }
+    const cookiesString = localStorage.getItem(this.#storageKey)
+    if (cookiesString == null) {
+      return {}
     }
-  }
 
-  getAllCookies(
-    callback: (error: Error | null, cookie: Array<CookieInstance>) => void,
-  ): void {
-    try {
-      callback(null, this.getStore())
-    } catch (error) {
-      if (error instanceof Error) {
-        callback(error, [])
-      }
+    const rawCookies = jsonParse<Array<Record<string, unknown>>>(cookiesString)
+    if (rawCookies == null) {
+      return {}
     }
-  }
 
-  private getStore(): Array<CookieInstance> {
-    try {
-      const json = this.storage.getItem(this.storageKey)
+    const cookies: MemoryCookieStoreIndex = {}
 
-      if (json == null) {
-        return []
-      }
+    for (const rawCookie of rawCookies) {
+      const cookie = Cookie.fromJSON(rawCookie)
 
-      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)
-        }
+      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
-    } catch {
-      return []
     }
-  }
 
-  private updateStore(nextStore: Array<CookieInstance>) {
-    this.storage.setItem(
-      this.storageKey,
-      JSON.stringify(nextStore.map((cookie) => cookie.toJSON())),
-    )
+    return cookies
   }
 
-  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
-      }
+  private persist(): void {
+    if (typeof localStorage === 'undefined') {
+      return
+    }
 
-      if (matches.path && !pathMatch(matches.path, cookie.path || '')) {
-        continue
-      }
+    const data = []
+    const { idx } = this.#memoryStore
 
-      if (matches.key && cookie.key !== matches.key) {
-        continue
+    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())
+        }
       }
-
-      result.push(cookie)
     }
 
-    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))
+    localStorage.setItem(this.#storageKey, JSON.stringify(data))
   }
 }
 
-const store = isNodeProcess()
-  ? new MemoryCookieStore()
-  : new WebStorageCookieStore()
-
-export const cookieStore = new CookieJar(store)
+export const cookieStore = new CookieStore()

package/src/core/utils/handleRequest.test.ts

@@ -487,3 +487,87 @@ describe('[Private] - resolutionContext - used for extensions', () => {
     })
   })
 })
+
+describe('handler with custom predicate', () => {
+  test('matches if custom predicate returns true', async () => {
+    const { emitter, events } = setup()
+
+    const requestId = createRequestId()
+    const request = new Request(new URL('http://localhost/login'), {
+      method: 'POST',
+      body: JSON.stringify({ username: 'test', password: 'password' }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    const handlers: Array<RequestHandler> = [
+      http.post(
+        async ({ request }) => {
+          const body = await request.clone().json()
+          return body.username === 'test' && body.password === 'password'
+        },
+        () =>
+          HttpResponse.json({
+            success: true,
+          }),
+      ),
+    ]
+
+    const result = await handleRequest(
+      request,
+      requestId,
+      handlers,
+      options,
+      emitter,
+      handleRequestOptions,
+    )
+
+    expect(result).toBeDefined()
+    expect(await result?.json()).toStrictEqual({ success: true })
+    expect(events).toEqual([
+      ['request:start', { request, requestId }],
+      ['request:match', { request, requestId }],
+      ['request:end', { request, requestId }],
+    ])
+    expect(handleRequestOptions.onMockedResponse).toHaveBeenCalledTimes(1)
+  })
+
+  test('does not match if custom predicate returns false', async () => {
+    const { emitter, events } = setup()
+
+    const requestId = createRequestId()
+    const request = new Request(new URL('http://localhost/login'), {
+      method: 'POST',
+      body: JSON.stringify({ username: 'test', password: 'passwordd' }),
+      headers: { 'Content-Type': 'application/json' },
+    })
+    const handlers: Array<RequestHandler> = [
+      http.post(
+        async ({ request }) => {
+          const body = await request.clone().json()
+          return body.username === 'test' && body.password === 'password'
+        },
+        () =>
+          HttpResponse.json({
+            success: true,
+          }),
+      ),
+    ]
+
+    const result = await handleRequest(
+      request,
+      requestId,
+      handlers,
+      options,
+      emitter,
+      handleRequestOptions,
+    )
+
+    expect(result).toBeUndefined()
+    expect(events).toEqual([
+      ['request:start', { request, requestId }],
+      ['request:unhandled', { request, requestId }],
+      ['request:end', { request, requestId }],
+    ])
+    expect(options.onUnhandledRequest).toHaveBeenCalledTimes(1)
+    expect(handleRequestOptions.onPassthroughResponse).toHaveBeenCalledTimes(1)
+  })
+})

package/src/core/utils/handleRequest.ts

@@ -105,7 +105,7 @@ export async function handleRequest(
   }
 
   // Store all the received response cookies in the cookie jar.
-  storeResponseCookies(request, response)
+  await storeResponseCookies(request, response)
 
   emitter.emit('request:match', { request, requestId })
 

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

@@ -66,7 +66,7 @@ export function getAllRequestCookies(request: Request): Record<string, string> {
     )
   }
 
-  const cookiesFromStore = cookieStore.getCookiesSync(request.url)
+  const cookiesFromStore = cookieStore.getCookies(request.url)
   const storedCookiesObject = Object.fromEntries(
     cookiesFromStore.map((cookie) => [cookie.key, cookie.value]),
   )

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

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

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

@@ -3,7 +3,7 @@
  */
 import { toPublicUrl } from './toPublicUrl'
 
-test('returns an absolute request URL withouth search params', () => {
+test('returns an absolute request URL without search params', () => {
   expect(toPublicUrl(new URL('https://test.mswjs.io/path'))).toBe(
     'https://test.mswjs.io/path',
   )

package/src/core/ws/WebSocketClientManager.test.ts

@@ -62,7 +62,7 @@ it('adds multiple clients from this runtime to the list of clients', async () =>
   )
   await manager.addConnection(connectionTwo)
 
-  // Must add the new cilent to the list as well.
+  // Must add the new client to the list as well.
   expect(Array.from(manager.clients.values())).toEqual([
     connectionOne,
     connectionTwo,

package/src/node/SetupServerApi.ts

@@ -19,7 +19,7 @@ type RequestHandlersContext = {
 /**
  * A handlers controller that utilizes `AsyncLocalStorage` in Node.js
  * to prevent the request handlers list from being a shared state
- * across mutliple tests.
+ * across multiple tests.
  */
 class AsyncHandlersController implements HandlersController {
   private rootContext: RequestHandlersContext