msw 2.15.0 → 3.0.0

package/src/{core → sse}/sse.ts

@@ -1,19 +1,18 @@
 import { invariant } from 'outvariant'
-import { DeferredPromise } from '@open-draft/deferred-promise'
 import { Emitter, TypedEvent } from 'rettime'
-import type { ResponseResolver } from './handlers/RequestHandler'
+import type { ResponseResolver } from '#core/handlers/request-handler'
 import {
   HttpHandler,
   type HttpRequestResolverExtras,
   type HttpRequestParsedResult,
-} from './handlers/HttpHandler'
-import type { ResponseResolutionContext } from '#core/utils/executeHandlers'
-import type { Path, PathParams } from './utils/matching/matchRequestUrl'
-import { delay } from './delay'
-import { getTimestamp } from './utils/logging/getTimestamp'
-import { devUtils } from './utils/internal/devUtils'
-import { colors } from './ws/utils/attachWebSocketLogger'
-import { toPublicUrl } from './utils/request/toPublicUrl'
+} from '#http/http-handler'
+import type { ResponseResolutionContext } from '#core/utils/execute-handlers'
+import type { Path, PathParams } from '#core/utils/matching/match-request-url'
+import { delay } from '#utils/delay'
+import { getTimestamp } from '#core/utils/logging/get-timestamp'
+import { devUtils } from '#core/utils/internal/dev-utils'
+import { colors } from '#core/utils/logging/colors'
+import { toPublicUrl } from '#core/utils/request/to-public-url'
 
 type EventMapConstraint = {
   message?: unknown
@@ -252,12 +251,14 @@ class ServerSentEventClient<
 
   #encoder: TextEncoder
   #controller: ReadableStreamDefaultController<Uint8Array>
-  #closed: DeferredPromise<void>
+  #closed: PromiseWithResolvers<void>
+  #isClosed: boolean
 
   constructor(controller: ReadableStreamDefaultController<Uint8Array>) {
     this.#encoder = new TextEncoder()
     this.#controller = controller
-    this.#closed = new DeferredPromise()
+    this.#closed = Promise.withResolvers()
+    this.#isClosed = false
   }
 
   /**
@@ -313,11 +314,12 @@ class ServerSentEventClient<
    * error.
    */
   public error(): void {
-    if (this.#closed.state !== 'pending') {
+    if (this.#isClosed) {
       return
     }
 
     this.#controller.error()
+    this.#isClosed = true
     this.#closed.resolve()
     this[kClientEmitter]?.emit(new TypedEvent('error'))
   }
@@ -326,12 +328,13 @@ class ServerSentEventClient<
    * Closes the underlying `EventSource`, closing the connection.
    */
   public close(): void {
-    if (this.#closed.state !== 'pending') {
+    if (this.#isClosed) {
       return
     }
 
     try {
       this.#controller.close()
+      this.#isClosed = true
       this.#closed.resolve()
     } catch {
       //
@@ -341,7 +344,7 @@ class ServerSentEventClient<
   }
 
   #enqueue(chunk: Uint8Array): void {
-    if (this.#closed.state !== 'pending') {
+    if (this.#isClosed) {
       return
     }
 
@@ -754,15 +757,16 @@ class ObservableEventSource extends EventTarget implements EventSource {
       return
     }
 
-    const aborted = new DeferredPromise<void>()
+    const aborted = Promise.withResolvers<void>()
     const onAbort = () => aborted.resolve()
     signal.addEventListener('abort', onAbort, { once: true })
 
-    await Promise.race([delay(this[kReconnectionTime]), aborted]).finally(
-      () => {
-        signal.removeEventListener('abort', onAbort)
-      },
-    )
+    await Promise.race([
+      delay(this[kReconnectionTime]),
+      aborted.promise,
+    ]).finally(() => {
+      signal.removeEventListener('abort', onAbort)
+    })
 
     if (signal.aborted) {
       return

package/src/tsconfig.core.build.json

@@ -1,6 +1,10 @@
 {
   "extends": "./tsconfig.src.json",
   "compilerOptions": {
-    "composite": false
+    "composite": false,
+    // The single ESM build emits the declarations for "src/node" too.
+    // Explicitly include the Node.js types so imports like "node:async_hooks"
+    // resolve during the declaration emit instead of degrading to "any".
+    "types": ["node"]
   }
 }

package/src/tsconfig.core.json

@@ -1,6 +1,13 @@
 {
   "extends": "./tsconfig.src.json",
-  "include": ["./core/**/*.ts"],
+  "include": [
+    "./core/**/*.ts",
+    "./http/**/*.ts",
+    "./graphql/**/*.ts",
+    "./ws/**/*.ts",
+    "./sse/**/*.ts",
+    "./utils/**/*.ts"
+  ],
   "files": [],
   "compilerOptions": {
     "composite": true

package/src/tsconfig.node.json

@@ -1,6 +1,6 @@
 {
   "extends": "./tsconfig.src.json",
-  "include": ["./node", "./native"],
+  "include": ["./node"],
   "exclude": ["**/*.test.ts"],
   "references": [
     {

package/src/tsconfig.src.json

@@ -3,6 +3,6 @@
   "compilerOptions": {
     "composite": true
   },
-  "include": ["../global.d.ts", "./**/*.ts"],
+  "include": ["./**/*.ts"],
   "exclude": ["./**/*.test.ts"]
 }

package/src/{core → utils}/bypass.test.ts

@@ -3,7 +3,7 @@
  */
 import { bypass } from './bypass'
 
-it('returns bypassed request given a request url string', async () => {
+test('returns bypassed request given a request url string', async () => {
   const request = bypass('https://api.example.com/resource')
 
   // Relative URLs are rebased against the current location.
@@ -12,14 +12,14 @@ it('returns bypassed request given a request url string', async () => {
   expect(Array.from(request.headers)).toEqual([['accept', 'msw/passthrough']])
 })
 
-it('returns bypassed request given a request url', async () => {
+test('returns bypassed request given a request url', async () => {
   const request = bypass(new URL('/resource', 'https://api.example.com'))
 
   expect(request.url).toBe('https://api.example.com/resource')
   expect(Array.from(request.headers)).toEqual([['accept', 'msw/passthrough']])
 })
 
-it('returns bypassed request given request instance', async () => {
+test('returns bypassed request given request instance', async () => {
   const original = new Request('http://localhost/resource', {
     method: 'POST',
     headers: {
@@ -44,7 +44,7 @@ it('returns bypassed request given request instance', async () => {
   ])
 })
 
-it('allows modifying the bypassed request instance', async () => {
+test('allows modifying the bypassed request instance', async () => {
   const original = new Request('http://localhost/resource', {
     method: 'POST',
     body: 'hello world',
@@ -66,7 +66,24 @@ it('allows modifying the bypassed request instance', async () => {
   expect(original.bodyUsed).toBe(false)
 })
 
-it('supports bypassing "keepalive: true" requests', async () => {
+test('removes the "content-length" request header', async () => {
+  // Intercepted requests parsed from the wire include the received
+  // "content-length" header. Deriving a request with a different body
+  // makes that header stale, and the request client would reject the
+  // bypassed request due to the content length mismatch.
+  const original = new Request('http://localhost/resource', {
+    method: 'POST',
+    headers: { 'content-length': '42' },
+    body: 'a-body-that-is-42-characters-long-in-total',
+  })
+  const request = bypass(new Request(original, { body: 'short' }))
+
+  expect(request.headers.get('content-length')).toBeNull()
+  await expect(request.text()).resolves.toBe('short')
+  expect(original.bodyUsed).toBe(false)
+})
+
+test('supports bypassing "keepalive: true" requests', async () => {
   const original = new Request('http://localhost/resource', {
     method: 'POST',
     keepalive: true,

package/src/{core → utils}/bypass.ts

@@ -42,5 +42,16 @@ export function bypass(input: BypassRequestInput, init?: RequestInit): Request {
    */
   requestClone.headers.append('accept', 'msw/passthrough')
 
+  /**
+   * Delete the "content-length" request header.
+   * Intercepted requests are parsed from the wire and include the
+   * received "content-length" header. If the consumer derives a new
+   * request with a different body (e.g. `new Request(request, { body })`),
+   * that header becomes stale and the request client will reject the
+   * bypassed request due to the content length mismatch. The request
+   * client always re-computes this header from the actual request body.
+   */
+  requestClone.headers.delete('content-length')
+
   return requestClone
 }

package/src/{core → utils}/delay.ts

@@ -1,10 +1,10 @@
 import { isNodeProcess } from 'is-node-process'
-import { hasRefCounted } from './utils/internal/hasRefCounted'
+import { hasRefCounted } from '#core/utils/internal/has-ref-counted'
 
-export const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647
-export const MIN_SERVER_RESPONSE_TIME = 100
-export const MAX_SERVER_RESPONSE_TIME = 400
-export const NODE_SERVER_RESPONSE_TIME = 5
+const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647
+const MIN_SERVER_RESPONSE_TIME = 100
+const MAX_SERVER_RESPONSE_TIME = 400
+const NODE_SERVER_RESPONSE_TIME = 5
 
 function getRealisticResponseTime(): number {
   if (isNodeProcess()) {

package/src/utils/get-clean-url-string.test.ts

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

package/src/utils/get-clean-url-string.ts

@@ -0,0 +1,16 @@
+const REDUNDANT_CHARACTERS_EXP = /[?|#].*$/g
+
+/**
+ * Removes search parameters and the fragment from a given URL string.
+ * Unlike `getCleanUrl()` from Interceptors, accepts relative URLs and
+ * path patterns (e.g. "/user/:id?") since it never parses the input as a URL.
+ */
+export function getCleanUrlString(url: string): string {
+  // If the URL ends with an optional path parameter, return it as-is.
+  if (url.endsWith('?')) {
+    return url
+  }
+
+  // Otherwise, remove the search and fragment from it.
+  return url.replace(REDUNDANT_CHARACTERS_EXP, '')
+}

package/src/{core/getResponse.test.ts → utils/get-response.test.ts}

@@ -1,14 +1,14 @@
 // @vitest-environment node
-import { http } from './http'
-import { getResponse } from './getResponse'
+import { http } from '#http/http'
+import { getResponse } from './get-response'
 
-it('returns undefined given empty headers array', async () => {
+test('returns undefined given empty headers array', async () => {
   await expect(
     getResponse([], new Request('http://localhost/')),
   ).resolves.toBeUndefined()
 })
 
-it('returns undefined given no matching handlers', async () => {
+test('returns undefined given no matching handlers', async () => {
   await expect(
     getResponse(
       [http.get('/product', () => void 0)],
@@ -17,7 +17,7 @@ it('returns undefined given no matching handlers', async () => {
   ).resolves.toBeUndefined()
 })
 
-it('returns undefined given a matching handler that returned no response', async () => {
+test('returns undefined given a matching handler that returned no response', async () => {
   await expect(
     getResponse(
       [http.get('*/user', () => void 0)],
@@ -26,7 +26,7 @@ it('returns undefined given a matching handler that returned no response', async
   ).resolves.toBeUndefined()
 })
 
-it('returns undefined given a matching handler that returned explicit undefined', async () => {
+test('returns undefined given a matching handler that returned explicit undefined', async () => {
   await expect(
     getResponse(
       [http.get('*/user', () => undefined)],
@@ -35,7 +35,7 @@ it('returns undefined given a matching handler that returned explicit undefined'
   ).resolves.toBeUndefined()
 })
 
-it('returns the response returned from a matching handler', async () => {
+test('returns the response returned from a matching handler', async () => {
   const response = await getResponse(
     [http.get('*/user', () => Response.json({ name: 'John' }))],
     new Request('http://localhost/user'),
@@ -46,7 +46,7 @@ it('returns the response returned from a matching handler', async () => {
   await expect(response?.json()).resolves.toEqual({ name: 'John' })
 })
 
-it('returns the response from the first matching handler if multiple match', async () => {
+test('returns the response from the first matching handler if multiple match', async () => {
   const response = await getResponse(
     [
       http.get('*/user', () => Response.json({ name: 'John' })),
@@ -60,7 +60,7 @@ it('returns the response from the first matching handler if multiple match', asy
   await expect(response?.json()).resolves.toEqual({ name: 'John' })
 })
 
-it('supports custom base url', async () => {
+test('supports custom base url', async () => {
   const response = await getResponse(
     [http.get('/resource', () => new Response('hello world'))],
     new Request('https://localhost:3000/resource'),

package/src/{core/getResponse.ts → utils/get-response.ts}

@@ -1,9 +1,9 @@
 import { createRequestId } from '@mswjs/interceptors'
-import type { RequestHandler } from './handlers/RequestHandler'
+import type { RequestHandler } from '#core/handlers/request-handler'
 import {
   executeHandlers,
   type ResponseResolutionContext,
-} from './utils/executeHandlers'
+} from '#core/utils/execute-handlers'
 
 /**
  * Finds a response for the given request instance

package/src/{core/isCommonAssetRequest.ts → utils/is-common-asset-request.ts}

@@ -6,11 +6,12 @@
  *
  * @example
  * import { isCommonAssetRequest } from 'msw'
+ * import { HttpNetworkFrame } from 'msw/experimental'
  *
  * await worker.start({
- *   onUnhandledRequest(request, print) {
- *     if (!isCommonAssetRequest(request)) {
- *       print.warning()
+ *   onUnhandledFrame({ frame, defaults }) {
+ *     if (frame instanceof HttpNetworkFrame && !isCommonAssetRequest(frame.data.request)) {
+ *       defaults.warn()
  *     }
  *   }
  * })

package/src/utils/passthrough.test.ts

@@ -0,0 +1,41 @@
+// @vitest-environment node
+import {
+  passthrough,
+  isPassthroughResponse,
+  REQUEST_INTENTION_HEADER_NAME,
+  RequestIntention,
+} from './passthrough'
+
+describe(passthrough, () => {
+  test('creates a 302 response with the intention header', () => {
+    const response = passthrough()
+
+    expect(response).toBeInstanceOf(Response)
+    expect(response.status).toBe(302)
+    expect(response.statusText).toBe('Passthrough')
+    expect(response.headers.get('x-msw-intention')).toBe('passthrough')
+  })
+})
+
+describe(isPassthroughResponse, () => {
+  test('returns true for a passthrough response', () => {
+    expect(isPassthroughResponse(passthrough())).toBe(true)
+    expect(
+      isPassthroughResponse(
+        new Response(null, {
+          status: 302,
+          headers: {
+            [REQUEST_INTENTION_HEADER_NAME]: RequestIntention.passthrough,
+          },
+        }),
+      ),
+    ).toBe(true)
+  })
+
+  test('returns false for a regular response', () => {
+    expect(isPassthroughResponse(new Response(null))).toBe(false)
+    expect(isPassthroughResponse(new Response(null, { status: 302 }))).toBe(
+      false,
+    )
+  })
+})

package/src/utils/passthrough.ts

@@ -0,0 +1,46 @@
+import type { HttpResponse } from '#http/http-response'
+
+export const REQUEST_INTENTION_HEADER_NAME = 'x-msw-intention'
+
+export enum RequestIntention {
+  passthrough = 'passthrough',
+}
+
+/**
+ * Performs the intercepted request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
+ * Unlike `bypass()`, this will not trigger an additional request.
+ *
+ * @example
+ * http.get('/resource', () => {
+ *   return passthrough()
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
+ */
+export function passthrough(): HttpResponse<any> {
+  return new Response(null, {
+    status: 302,
+    statusText: 'Passthrough',
+    headers: {
+      [REQUEST_INTENTION_HEADER_NAME]: RequestIntention.passthrough,
+    },
+  }) as HttpResponse<any>
+}
+
+/**
+ * Returns `true` if the given response was created by `passthrough()`.
+ *
+ * @example
+ * const response = passthrough()
+ * isPassthroughResponse(response) // true
+ */
+export function isPassthroughResponse(response: Response): boolean {
+  return (
+    response.status === 302 &&
+    response.headers.get(REQUEST_INTENTION_HEADER_NAME) ===
+      RequestIntention.passthrough
+  )
+}

package/src/vite/client.d.ts

@@ -0,0 +1,16 @@
+declare module 'virtual:msw' {
+  import type {
+    HttpNetworkFrame,
+    NetworkApi,
+    NetworkSource,
+    WebSocketNetworkFrame,
+  } from 'msw/experimental'
+
+  export const network: Omit<
+    NetworkApi<Array<NetworkSource<HttpNetworkFrame | WebSocketNetworkFrame>>>,
+    'enable' | 'disable'
+  > & {
+    enable(): void | Promise<void>
+    disable(): void | Promise<void>
+  }
+}

package/src/vite/index.ts

@@ -0,0 +1,4 @@
+/// <reference types="msw/vite/client" preserve="true" />
+
+export { msw } from './plugin'
+export type { MswPluginOptions } from './plugin'

package/src/vite/options.d.ts

@@ -0,0 +1,5 @@
+declare module 'virtual:msw/options' {
+  export const defaultNetworkOptions:
+    | typeof import('msw/browser').defaultNetworkOptions
+    | typeof import('msw/node').defaultNetworkOptions
+}