msw 2.15.0 → 3.0.0

package/lib/mockServiceWorker.js

@@ -7,10 +7,15 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.15.0'
-const INTEGRITY_CHECKSUM = '03cb67ac84128e63d7cd722a6e5b7f1e'
+const PACKAGE_VERSION = '3.0.0'
+const INTEGRITY_CHECKSUM = '5cd5cf8b54c3a90f82960cedcd637772'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
+
 const activeClientIds = new Set()
+/**
+ * @type {Map<string, Set<Promise<Response>>>}
+ */
+const pendingRequests = new Map()
 
 addEventListener('install', function () {
   self.skipWaiting()
@@ -20,82 +25,101 @@ addEventListener('activate', function (event) {
   event.waitUntil(self.clients.claim())
 })
 
-addEventListener('message', async function (event) {
+addEventListener('message', function (event) {
   const clientId = Reflect.get(event.source || {}, 'id')
 
   if (!clientId || !self.clients) {
     return
   }
 
-  const client = await self.clients.get(clientId)
-
-  if (!client) {
-    return
-  }
-
-  const allClients = await self.clients.matchAll({
-    type: 'window',
-  })
-
-  switch (event.data) {
-    case 'KEEPALIVE_REQUEST': {
-      sendToClient(client, {
-        type: 'KEEPALIVE_RESPONSE',
-      })
-      break
-    }
-
-    case 'INTEGRITY_CHECK_REQUEST': {
-      sendToClient(client, {
-        type: 'INTEGRITY_CHECK_RESPONSE',
-        payload: {
-          packageVersion: PACKAGE_VERSION,
-          checksum: INTEGRITY_CHECKSUM,
-        },
-      })
-      break
-    }
-
-    case 'MOCK_ACTIVATE': {
-      activeClientIds.add(clientId)
-
-      sendToClient(client, {
-        type: 'MOCKING_ENABLED',
-        payload: {
-          client: {
-            id: client.id,
-            frameType: client.frameType,
-          },
-        },
-      })
-      break
-    }
-
-    case 'CLIENT_CLOSED': {
-      activeClientIds.delete(clientId)
+  event.waitUntil(
+    (async () => {
+      if (event.data === 'CLIENT_CLOSE') {
+        const allClients = await self.clients.matchAll({
+          type: 'window',
+        })
+
+        activeClientIds.delete(clientId)
+
+        // Await any pending requests from the closing client.
+        // This makes sure that those requests are handled and not passthrough.
+        const pending = pendingRequests.get(clientId)
+        if (pending != null && pending.size > 0) {
+          await Promise.allSettled(pending)
+        }
+        pendingRequests.delete(clientId)
+
+        const remainingClients = allClients.filter((client) => {
+          return client.id !== clientId
+        })
+
+        // Unregister itself when there are no more clients
+        if (remainingClients.length === 0) {
+          await self.registration.unregister()
+        }
+
+        const client = await self.clients.get(clientId)
+
+        if (client != null) {
+          await sendToClient(client, {
+            type: 'CLIENT_CLOSED',
+          })
+        }
+
+        return
+      }
 
-      const remainingClients = allClients.filter((client) => {
-        return client.id !== clientId
-      })
+      /**
+       * @note Check for the client AFTER handling "CLIENT_CLOSE".
+       * This prevents early return on "!client" in case the page has reloaded
+       * and disassociated itself from the worker. This ensures self-unregistration
+       * still fires for those pages.
+       */
+      const client = await self.clients.get(clientId)
 
-      // Unregister itself when there are no more clients
-      if (remainingClients.length === 0) {
-        self.registration.unregister()
+      if (!client) {
+        return
       }
 
-      break
-    }
-  }
+      switch (event.data) {
+        case 'KEEPALIVE_REQUEST': {
+          await sendToClient(client, {
+            type: 'KEEPALIVE_RESPONSE',
+          })
+          break
+        }
+
+        case 'INTEGRITY_CHECK_REQUEST': {
+          await sendToClient(client, {
+            type: 'INTEGRITY_CHECK_RESPONSE',
+            payload: {
+              packageVersion: PACKAGE_VERSION,
+              checksum: INTEGRITY_CHECKSUM,
+            },
+          })
+          break
+        }
+
+        case 'MOCK_ACTIVATE': {
+          activeClientIds.add(clientId)
+
+          await sendToClient(client, {
+            type: 'MOCKING_ENABLED',
+            payload: {
+              client: {
+                id: client.id,
+                frameType: client.frameType,
+              },
+            },
+          })
+          break
+        }
+      }
+    })(),
+  )
 })
 
 addEventListener('fetch', function (event) {
-  const requestInterceptedAt = Date.now()
-
-  // Bypass navigation requests.
-  if (event.request.mode === 'navigate') {
-    return
-  }
-
   // Opening the DevTools triggers the "only-if-cached" request
   // that cannot be handled by the worker. Bypass such requests.
   if (
@@ -113,23 +137,54 @@ addEventListener('fetch', function (event) {
   }
 
   const requestId = crypto.randomUUID()
-  event.respondWith(handleRequest(event, requestId, requestInterceptedAt))
+  event.respondWith(handleRequest(event, requestId))
 })
 
 /**
  * @param {FetchEvent} event
  * @param {string} requestId
- * @param {number} requestInterceptedAt
  */
-async function handleRequest(event, requestId, requestInterceptedAt) {
+async function handleRequest(event, requestId) {
   const client = await resolveMainClient(event)
   const requestCloneForEvents = event.request.clone()
-  const response = await getResponse(
-    event,
-    client,
-    requestId,
-    requestInterceptedAt,
-  )
+
+  const responsePromise = getResponse(event, client, requestId)
+
+  if (client != null) {
+    let pending = pendingRequests.get(client.id)
+
+    if (pending == null) {
+      pendingRequests.set(client.id, (pending = new Set()))
+    }
+
+    pending.add(responsePromise)
+    responsePromise
+      .finally(() => pending.delete(responsePromise))
+      .catch(() => {})
+  }
+
+  let response
+
+  try {
+    response = await responsePromise
+  } catch (error) {
+    // The request has settled without a response (e.g. a passthrough
+    // request failed with a network error). Notify the client so it
+    // can release the resources associated with this request.
+    if (client && activeClientIds.has(client.id)) {
+      sendToClient(client, {
+        type: 'REQUEST_ERROR',
+        payload: {
+          request: {
+            id: requestId,
+          },
+          error: serializeError(error),
+        },
+      })
+    }
+
+    throw error
+  }
 
   // Send back the response clone for the "response:*" life-cycle events.
   // Ensure MSW is active and ready to handle the message, otherwise
@@ -217,18 +272,32 @@ async function resolveMainClient(event) {
  * @param {FetchEvent} event
  * @param {Client | undefined} client
  * @param {string} requestId
- * @param {number} requestInterceptedAt
  * @returns {Promise<Response>}
  */
-async function getResponse(event, client, requestId, requestInterceptedAt) {
+async function getResponse(event, client, requestId) {
   // Clone the request because it might've been already used
   // (i.e. its body has been read and sent to the client).
   const requestClone = event.request.clone()
 
-  function passthrough() {
-    // Cast the request headers to a new Headers instance
-    // so the headers can be manipulated with.
-    const headers = new Headers(requestClone.headers)
+  /**
+   * @param {{ request?: { headers?: Array<[string, string]> } }} [data]
+   */
+  function passthrough(data) {
+    const headers = new Headers()
+    const requestHeaders = data?.request?.headers
+
+    if (Array.isArray(requestHeaders)) {
+      // Apply the request headers provided by the client.
+      // Those reflect any modifications made in the request handlers.
+      // Use ".append()" to support multiple headers with the same name.
+      for (const [name, value] of requestHeaders) {
+        headers.append(name, value)
+      }
+    } else {
+      for (const [name, value] of requestClone.headers) {
+        headers.append(name, value)
+      }
+    }
 
     // Remove the "accept" header value that marked this request as passthrough.
     // This prevents request alteration and also keeps it compliant with the
@@ -271,7 +340,6 @@ async function getResponse(event, client, requestId, requestInterceptedAt) {
       type: 'REQUEST',
       payload: {
         id: requestId,
-        interceptedAt: requestInterceptedAt,
         ...serializedRequest,
       },
     },
@@ -280,17 +348,35 @@ async function getResponse(event, client, requestId, requestInterceptedAt) {
 
   switch (clientMessage.type) {
     case 'MOCK_RESPONSE': {
-      return respondWithMock(clientMessage.data)
+      return respondWithMock(clientMessage.data, event)
     }
 
     case 'PASSTHROUGH': {
-      return passthrough()
+      return passthrough(clientMessage.data)
     }
   }
 
   return passthrough()
 }
 
+/**
+ * @param {unknown} error
+ * @returns {{ name: string, message: string }}
+ */
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+    }
+  }
+
+  return {
+    name: 'Error',
+    message: String(error),
+  }
+}
+
 /**
  * @param {Client} client
  * @param {any} message
@@ -318,9 +404,10 @@ function sendToClient(client, message, transferrables = []) {
 
 /**
  * @param {Response} response
- * @returns {Response}
+ * @param {FetchEvent} event
+ * @returns {Promise<Response>}
  */
-function respondWithMock(response) {
+async function respondWithMock(response, event) {
   // Setting response status code to 0 is a no-op.
   // However, when responding with a "Response.error()", the produced Response
   // instance will have status code set to 0. Since it's not possible to create
@@ -329,7 +416,19 @@ function respondWithMock(response) {
     return Response.error()
   }
 
-  const mockedResponse = new Response(response.body, response)
+  let body = response.body
+
+  // Buffer the streamed mocked response body for navigation requests.
+  // The stream is transferred from the client that is being navigated
+  // away from. Once the navigation commits, that client gets destroyed
+  // and the stream will never complete, resulting in an empty document.
+  // Buffering here keeps "event.respondWith()" pending (the navigation
+  // cannot commit) until the entire body arrives from the client.
+  if (event.request.mode === 'navigate' && body instanceof ReadableStream) {
+    body = await new Response(body).arrayBuffer()
+  }
+
+  const mockedResponse = new Response(body, response)
 
   Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
     value: true,

package/lib/node/index.d.ts

@@ -1,113 +1,88 @@
-import { PartialDeep } from 'type-fest';
-import { HttpNetworkFrameEventMap } from "../core/experimental/frames/http-frame";
-import { WebSocketNetworkFrameEventMap } from "../core/experimental/frames/websocket-frame";
-import { AnyHandler, HandlersController, HandlersControllerState } from "../core/experimental/handlers-controller";
-import { SharedOptions, LifeCycleEventEmitter } from "../core/sharedOptions";
-import { Interceptor } from '@mswjs/interceptors';
-import { NetworkApi, DefineNetworkOptions } from "../core/experimental/define-network";
-import { InterceptorSource } from "../core/experimental/sources/interceptor-source";
-import * as rettime from 'rettime';
-
-interface ListenOptions extends SharedOptions {
-}
+import { h as WebSocketNetworkFrameEventMap, i as HandlersMap, n as HandlersController, r as HandlersControllerState, t as AnyHandler } from "../_chunks/handlers-controller.js";
+import { n as SharedOptions, t as LifeCycleEventEmitter } from "../_chunks/shared-options.js";
+import { c as HttpNetworkFrameEventMap, i as NetworkReadyState, n as DefineNetworkOptions, t as InterceptorSource } from "../_chunks/interceptor-source.js";
+import { PartialDeep } from "type-fest";
+//#region src/node/glossary.d.ts
 interface SetupServerCommon {
-    /**
-     * Starts the request interception based on the previously provided request handlers.
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/listen `server.listen()` API reference}
-     */
-    listen: (options?: PartialDeep<ListenOptions>) => void;
-    /**
-     * Stops the request interception by restoring all augmented modules.
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/close `server.close()` API reference}
-     */
-    close: () => void;
-    /**
-     * Prepends given request handlers to the list of existing handlers.
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/use `server.use()` API reference}
-     */
-    use: (...handlers: Array<AnyHandler>) => void;
-    /**
-     * Marks all request handlers that respond using `res.once()` as unused.
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/restore-handlers `server.restore-handlers()` API reference}
-     */
-    restoreHandlers: () => void;
-    /**
-     * Resets request handlers to the initial list given to the `setupServer` call, or to the explicit next request handlers list, if given.
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/reset-handlers `server.reset-handlers()` API reference}
-     */
-    resetHandlers: (...nextHandlers: Array<AnyHandler>) => void;
-    /**
-     * Returns a readonly list of currently active request handlers.
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/list-handlers `server.listHandlers()` API reference}
-     */
-    listHandlers: () => ReadonlyArray<AnyHandler>;
-    /**
-     * Life-cycle events.
-     * Life-cycle events allow you to subscribe to the internal library events occurring during the request/response handling.
-     *
-     * @see {@link https://mswjs.io/docs/api/life-cycle-events Life-cycle Events API reference}
-     */
-    events: LifeCycleEventEmitter<HttpNetworkFrameEventMap & WebSocketNetworkFrameEventMap>;
+  /**
+   * The current ready state of the underlying network.
+   */
+  readonly readyState: NetworkReadyState;
+  /**
+   * Starts the request interception based on the previously provided request handlers.
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/listen `server.listen()` API reference}
+   */
+  listen: (options?: PartialDeep<SharedOptions>) => void;
+  /**
+   * Stops the request interception by restoring all augmented modules.
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/close `server.close()` API reference}
+   */
+  close: () => void;
+  /**
+   * Prepends given request handlers to the list of existing handlers.
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/use `server.use()` API reference}
+   */
+  use: (...handlers: Array<AnyHandler>) => void;
+  /**
+   * Marks all request handlers that respond using `res.once()` as unused.
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/restore-handlers `server.restore-handlers()` API reference}
+   */
+  restoreHandlers: () => void;
+  /**
+   * Resets request handlers to the initial list given to the `setupServer` call, or to the explicit next request handlers list, if given.
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/reset-handlers `server.reset-handlers()` API reference}
+   */
+  resetHandlers: (...nextHandlers: Array<AnyHandler>) => void;
+  /**
+   * Returns a readonly list of currently active request handlers.
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/list-handlers `server.listHandlers()` API reference}
+   */
+  listHandlers: () => ReadonlyArray<AnyHandler>;
+  /**
+   * Life-cycle events.
+   * Life-cycle events allow you to subscribe to the internal library events occurring during the request/response handling.
+   *
+   * @see {@link https://mswjs.io/docs/api/life-cycle-events Life-cycle Events API reference}
+   */
+  events: LifeCycleEventEmitter<HttpNetworkFrameEventMap & WebSocketNetworkFrameEventMap>;
 }
 interface SetupServer extends SetupServerCommon {
-    /**
-     * Wraps the given function in a boundary. Any changes to the
-     * network behavior (e.g. adding runtime request handlers via
-     * `server.use()`) will be scoped to this boundary only.
-     * @param callback A function to run (e.g. a test)
-     *
-     * @see {@link https://mswjs.io/docs/api/setup-server/boundary `server.boundary()` API reference}
-     */
-    boundary: <Args extends Array<any>, R>(callback: (...args: Args) => R) => (...args: Args) => R;
-}
-
-declare class AsyncHandlersController extends HandlersController {
-    #private;
-    constructor(initialHandlers: Array<AnyHandler>);
-    protected getState(): {
-        initialHandlers: Partial<Record<"request" | "websocket", AnyHandler[]>>;
-        handlers: Partial<Record<"request" | "websocket", AnyHandler[]>>;
-    };
-    protected setState(nextState: HandlersControllerState): void;
-    boundary<Args extends Array<any>, R>(callback: (...args: Args) => R): (...args: Args) => R;
+  /**
+   * Wraps the given function in a boundary. Any changes to the
+   * network behavior (e.g. adding runtime request handlers via
+   * `server.use()`) will be scoped to this boundary only.
+   * @param callback A function to run (e.g. a test)
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/boundary `server.boundary()` API reference}
+   */
+  boundary: <Args extends Array<any>, R>(callback: (...args: Args) => R) => (...args: Args) => R;
 }
-
-/**
- * @deprecated
- * Please use the `defineNetwork` API instead.
- */
-declare class SetupServerCommonApi implements SetupServerCommon {
-    protected network: NetworkApi<[InterceptorSource]>;
-    constructor(interceptors: Array<Interceptor<any>>, handlers: Array<AnyHandler> | HandlersController);
-    get events(): rettime.Emitter<any>;
-    listen(options?: PartialDeep<ListenOptions>): void;
-    use(...handlers: Array<AnyHandler>): void;
-    resetHandlers(...nextHandlers: Array<AnyHandler>): void;
-    restoreHandlers(): void;
-    listHandlers(): ReadonlyArray<AnyHandler>;
-    close(): void;
-}
-
-declare const defaultNetworkOptions: DefineNetworkOptions<[InterceptorSource]>;
+//#endregion
+//#region src/node/setup-server.d.ts
+export declare const defaultNetworkOptions: DefineNetworkOptions<[InterceptorSource]>;
 /**
  * Enables request interception in Node.js with the given request handlers.
  * @see {@link https://mswjs.io/docs/api/setup-server `setupServer()` API reference}
  */
-declare function setupServer(...handlers: Array<AnyHandler>): SetupServer;
-/**
- * @deprecated
- * Please use the `defineNetwork` API instead.
- */
-declare class SetupServerApi extends SetupServerCommonApi implements SetupServer {
-    #private;
-    boundary: AsyncHandlersController['boundary'];
-    constructor(handlers: Array<AnyHandler>, interceptors: Array<Interceptor<any>>);
+export declare function setupServer(...handlers: Array<AnyHandler>): SetupServer;
+//#endregion
+//#region src/node/async-handlers-controller.d.ts
+export declare class AsyncHandlersController extends HandlersController {
+  #private;
+  constructor(initialHandlers: Array<AnyHandler>);
+  protected getState(): {
+    initialHandlers: HandlersMap;
+    handlers: HandlersMap;
+  };
+  protected setState(nextState: HandlersControllerState): void;
+  boundary<Args extends Array<any>, R>(callback: (...args: Args) => R): (...args: Args) => R;
 }
-
-export { AsyncHandlersController, type SetupServer, SetupServerApi, SetupServerCommonApi, defaultNetworkOptions, setupServer };
+//#endregion
+export type { SetupServer };
+//# sourceMappingURL=index.d.ts.map