msw 2.14.7 → 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 } from 'strict-event-emitter'
-import type { ResponseResolver } from './handlers/RequestHandler'
+import { Emitter, TypedEvent } from 'rettime'
+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
@@ -105,11 +104,17 @@ class ServerSentEventHandler<
         this.#attachClientLogger(info.request, emitter)
       }
 
-      await resolver({
-        ...info,
-        client,
-        server,
-      })
+      /**
+       * @note Extend the resolver info via assignment instead of a spread.
+       * Spreading the info would invoke its lazy `finalize` getter,
+       * initializing the finalize machinery for resolvers that never use it.
+       */
+      await resolver(
+        Object.assign(info, {
+          client,
+          server,
+        }),
+      )
 
       return response
     })
@@ -151,7 +156,14 @@ class ServerSentEventHandler<
     return matches
   }
 
-  async log(_args: { request: Request; response: Response }): Promise<void> {
+  async log(args: { request: Request; response: Response }): Promise<void> {
+    /**
+     * @note Cancel the response stream because it's not needed for logging.
+     * Otherwise, this cloned response remains unconsumed and its original
+     * doesn't propagate stream cancelations at all.
+     */
+    args.response.body?.cancel()
+
     /**
      * @note Skip the default `this.log()` logic so that when this handler is logged
      * upon handling the request, nothing is printed (we log SSE requests early).
@@ -166,16 +178,14 @@ class ServerSentEventHandler<
     const publicUrl = toPublicUrl(request.url)
 
     /* eslint-disable no-console */
-    emitter.on('message', (payload) => {
+    emitter.on('message', ({ data }) => {
       console.groupCollapsed(
-        devUtils.formatMessage(
-          `${getTimestamp()} SSE %s %c⇣%c ${payload.event}`,
-        ),
+        devUtils.formatMessage(`${getTimestamp()} SSE %s %c⇣%c ${data.event}`),
         publicUrl,
         `color:${colors.mocked}`,
         'color:inherit',
       )
-      console.log(payload.frames)
+      console.log(data.frames)
       console.groupEnd()
     })
 
@@ -227,9 +237,9 @@ type ToEventDiscriminatedUnion<T> = Values<{
 }>
 
 type ServerSentEventClientEventMap = {
-  message: [payload: EventStreamMessage]
-  error: []
-  close: []
+  message: TypedEvent<EventStreamMessage>
+  error: TypedEvent
+  close: TypedEvent
 }
 
 const kClientEmitter = Symbol.for('kClientEmitter')
@@ -240,11 +250,15 @@ class ServerSentEventClient<
   private [kClientEmitter]?: Emitter<ServerSentEventClientEventMap>
 
   #encoder: TextEncoder
-  #writer: WritableStreamDefaultWriter
+  #controller: ReadableStreamDefaultController<Uint8Array>
+  #closed: PromiseWithResolvers<void>
+  #isClosed: boolean
 
-  constructor(writable: WritableStream) {
+  constructor(controller: ReadableStreamDefaultController<Uint8Array>) {
     this.#encoder = new TextEncoder()
-    this.#writer = writable.getWriter()
+    this.#controller = controller
+    this.#closed = Promise.withResolvers()
+    this.#isClosed = false
   }
 
   /**
@@ -300,37 +314,52 @@ class ServerSentEventClient<
    * error.
    */
   public error(): void {
-    this.#writer.abort().catch((error) => {
-      console.error(error)
-      devUtils.error(
-        'Failed to abort server-side EventSource. Please see the original error above.',
-      )
-    })
-    this[kClientEmitter]?.emit('error')
+    if (this.#isClosed) {
+      return
+    }
+
+    this.#controller.error()
+    this.#isClosed = true
+    this.#closed.resolve()
+    this[kClientEmitter]?.emit(new TypedEvent('error'))
   }
 
   /**
    * Closes the underlying `EventSource`, closing the connection.
    */
   public close(): void {
-    this.#writer.close().catch((error) => {
+    if (this.#isClosed) {
+      return
+    }
+
+    try {
+      this.#controller.close()
+      this.#isClosed = true
+      this.#closed.resolve()
+    } catch {
+      //
+    }
+
+    this[kClientEmitter]?.emit(new TypedEvent('close'))
+  }
+
+  #enqueue(chunk: Uint8Array): void {
+    if (this.#isClosed) {
+      return
+    }
+
+    try {
+      this.#controller.enqueue(chunk)
+    } catch (error) {
       console.error(error)
       devUtils.error(
-        'Failed to close server-side EventSource. Please see the original error above.',
+        'Failed to write to server-side EventSource. Please see the original error above.',
       )
-    })
-    this[kClientEmitter]?.emit('close')
+    }
   }
 
   #sendRetry(retry: number): void {
-    this.#writer
-      .write(this.#encoder.encode(`retry:${retry}\n\n`))
-      .catch((error) => {
-        console.error(error)
-        devUtils.error(
-          'Failed to send a retry packet to server-side EventSource. Please see the original error above.',
-        )
-      })
+    this.#enqueue(this.#encoder.encode(`retry:${retry}\n\n`))
   }
 
   #sendMessage(message: {
@@ -361,21 +390,18 @@ class ServerSentEventClient<
 
     frames.push('', '')
 
-    this.#writer
-      .write(this.#encoder.encode(frames.join('\n')))
-      .catch((error) => {
-        console.error(error)
-        devUtils.error(
-          'Failed to send a message to server-side EventSource. Please see the original error above.',
-        )
-      })
+    this.#enqueue(this.#encoder.encode(frames.join('\n')))
 
-    this[kClientEmitter]?.emit('message', {
-      id: message.id,
-      event: message.event?.toString() || 'message',
-      data: message.data,
-      frames,
-    })
+    this[kClientEmitter]?.emit(
+      new TypedEvent('message', {
+        data: {
+          id: message.id,
+          event: message.event?.toString() || 'message',
+          data: message.data,
+          frames,
+        },
+      }),
+    )
   }
 }
 
@@ -731,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
@@ -1002,9 +1029,18 @@ function createEventStream<EventMap extends EventMapConstraint>(
     request.url,
   )
 
-  const { readable, writable } = new TransformStream()
+  let controller!: ReadableStreamDefaultController<Uint8Array>
+
+  const readable = new ReadableStream<Uint8Array>({
+    start(defaultController) {
+      controller = defaultController
+    },
+    cancel() {
+      client.close()
+    },
+  })
 
-  const client = new ServerSentEventClient<EventMap>(writable)
+  const client = new ServerSentEventClient<EventMap>(controller)
   const server = new ServerSentEventServer({
     request,
     client,

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