msw 2.14.2 → 2.14.4

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.14.2'
+const PACKAGE_VERSION = '2.14.4'
 const INTEGRITY_CHECKSUM = '4db4a41e972cec1b64cc569c66952d82'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.14.2",
+  "version": "2.14.4",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "type": "commonjs",
   "main": "./lib/core/index.js",
@@ -233,7 +233,7 @@
     "outvariant": "^1.4.3",
     "path-to-regexp": "^6.3.0",
     "picocolors": "^1.1.1",
-    "rettime": "^0.11.7",
+    "rettime": "^0.11.11",
     "statuses": "^2.0.2",
     "strict-event-emitter": "^0.5.1",
     "tough-cookie": "^6.0.1",
@@ -286,7 +286,7 @@
     "vitest-environment-miniflare": "^2.14.4",
     "webpack": "^5.106.2",
     "webpack-http-server": "^0.5.0",
-    "msw": "^2.14.2"
+    "msw": "^2.14.4"
   },
   "peerDependencies": {
     "typescript": ">= 4.8.x"
@@ -313,7 +313,7 @@
     "build": "pnpm clean && cross-env NODE_ENV=production tsup && pnpm patch:dts",
     "patch:dts": "node \"./config/scripts/patch-ts.js\"",
     "publint": "publint",
-    "test": "pnpm test:unit && pnpm test:node && pnpm test:browser && pnpm test:native",
+    "test": "pnpm test:unit && pnpm test:node && pnpm test:browser && pnpm test:native && pnpm test:memory",
     "test:unit": "vitest",
     "test:node": "vitest --config=./test/node/vitest.config.ts",
     "test:native": "vitest --config=./test/native/vitest.config.ts",
@@ -322,6 +322,7 @@
     "test:modules:browser": "playwright test -c ./test/modules/browser/playwright.config.ts",
     "test:e2e": "vitest run --config=./test/e2e/vitest.config.ts",
     "test:ts": "vitest --config=./test/typings/vitest.config.ts",
+    "test:memory": "vitest --config=./test/memory/vitest.config.ts",
     "release": "release publish",
     "postinstall": "node -e \"import('./config/scripts/postinstall.js').catch(() => void 0)\"",
     "knip": "knip"

package/src/browser/sources/service-worker-source.ts

@@ -330,6 +330,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
 
   async #handleResponse(event: WorkerChannelResponseEvent): Promise<void> {
     const { request, response, isMockedResponse } = event.data
+    const frame = this.#frames.get(request.id)
 
     /**
      * CORS requests with `mode: "no-cors"` result in "opaque" responses.
@@ -340,10 +341,10 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
      */
     if (response.type?.includes('opaque')) {
       this.#frames.delete(request.id)
+      frame?.events.removeAllListeners()
       return
     }
 
-    const frame = this.#frames.get(request.id)
     this.#frames.delete(request.id)
 
     /**
@@ -379,17 +380,21 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
             },
           )
 
-    frame.events.emit(
-      new ResponseEvent(
-        isMockedResponse ? 'response:mocked' : 'response:bypass',
-        {
-          requestId: frame.data.id,
-          request: fetchRequest,
-          response: fetchResponse,
-          isMockedResponse,
-        },
-      ),
-    )
+    try {
+      frame.events.emit(
+        new ResponseEvent(
+          isMockedResponse ? 'response:mocked' : 'response:bypass',
+          {
+            requestId: frame.data.id,
+            request: fetchRequest,
+            response: fetchResponse,
+            isMockedResponse,
+          },
+        ),
+      )
+    } finally {
+      frame.events.removeAllListeners()
+    }
   }
 
   #defaultFindWorker: FindWorker = (workerUrl, mockServiceWorkerUrl) => {

package/src/core/experimental/sources/interceptor-source.ts

@@ -87,16 +87,26 @@ export class InterceptorSource extends NetworkSource {
     }
 
     queueMicrotask(() => {
-      httpFrame.events.emit(
-        new ResponseEvent(
-          isMockedResponse ? 'response:mocked' : 'response:bypass',
-          {
-            requestId,
-            request,
-            response,
-          },
-        ),
-      )
+      try {
+        httpFrame.events.emit(
+          new ResponseEvent(
+            isMockedResponse ? 'response:mocked' : 'response:bypass',
+            {
+              requestId,
+              request,
+              response,
+            },
+          ),
+        )
+      } finally {
+        /**
+         * @note Remove any listeners from this frame.
+         * Past this point, it won't emit anything. The removal is crucial
+         * to prevent "rettime" from keeping the abort cleanup listeners internally.
+         * @see https://github.com/mswjs/msw/issues/2735
+         */
+        httpFrame.events.removeAllListeners()
+      }
     })
   }
 

package/src/core/handlers/RequestHandler.ts

@@ -13,6 +13,7 @@ import {
   type DefaultUnsafeFetchResponse,
 } from '../HttpResponse'
 import type { GraphQLRequestBody } from './GraphQLHandler'
+import { devUtils } from '../utils/internal/devUtils'
 import { getRawSetCookie } from '../utils/HttpResponse/decorators'
 
 export type DefaultRequestMultipartBody = Record<
@@ -90,8 +91,22 @@ export type ResponseResolverInfo<
 > = {
   request: StrictRequest<RequestBodyType>
   requestId: string
+  /**
+   * Schedule a callback to run after this response resolver completes.
+   * Handy for cleaning up the side effects introduced in the resolver.
+   * @example
+   * sse('/', ({ client, finalize }) => {
+   *   const interval = setInterval(() => client.send({ data: 'ping' }))
+   *   finalize(() => clearInterval(interval))
+   * })
+   */
+  finalize: ResponseResolverFinalizeFunction
 } & ResolverExtraInfo
 
+type ResponseResolverFinalizeFunction = (
+  callback: () => MaybePromise<void>,
+) => void
+
 export type ResponseResolver<
   ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>,
   RequestBodyType extends DefaultBodyType = DefaultBodyType,
@@ -149,7 +164,9 @@ export abstract class RequestHandler<
         MaybeAsyncResponseResolverReturnType<any>
       >
   private resolverIteratorResult?: Response | HttpResponse<any>
+  private resolverIteratorCleanups?: Array<() => MaybePromise<void>>
   private options?: HandlerOptions
+  private scheduledCleanups: Map<string, Array<() => MaybePromise<void>>>
 
   public info: HandlerInfo & RequestHandlerInternalInfo
 
@@ -162,6 +179,7 @@ export abstract class RequestHandler<
   constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>) {
     this.resolver = args.resolver
     this.options = args.options
+    this.scheduledCleanups = new Map()
 
     const callFrame = getCallFrame(new Error())
 
@@ -180,9 +198,12 @@ export abstract class RequestHandler<
    * from a clean state.
    */
   protected reset(): void {
+    this.scheduledCleanups.clear()
+
     const iterator = this.resolverIterator
     this.resolverIterator = undefined
     this.resolverIteratorResult = undefined
+    this.resolverIteratorCleanups = undefined
 
     if (typeof iterator?.return === 'function') {
       void Promise.resolve(iterator.return())
@@ -332,21 +353,39 @@ export abstract class RequestHandler<
       parsedResult,
     })
 
+    const listenerController = new AbortController()
+
+    args.request.signal.addEventListener(
+      'abort',
+      () => this.runScheduledCleanups(args.requestId),
+      {
+        once: true,
+        signal: listenerController.signal,
+      },
+    )
+
     const mockedResponsePromise = (
       executeResolver({
         ...resolverExtras,
+        finalize: (callback) => {
+          this.scheduleCleanup(args.requestId, callback)
+        },
         requestId: args.requestId,
         request: args.request,
-      }) as Promise<Response | undefined>
-    ).catch((errorOrResponse) => {
-      // Allow throwing a Response instance in a response resolver.
-      if (errorOrResponse instanceof Response) {
-        return errorOrResponse
-      }
+      }) as Promise<Response>
+    )
+      .catch((errorOrResponse) => {
+        // Allow throwing a Response instance in a response resolver.
+        if (errorOrResponse instanceof Response) {
+          return errorOrResponse
+        }
 
-      // Otherwise, throw the error as-is.
-      throw errorOrResponse
-    })
+        // Otherwise, throw the error as-is.
+        throw errorOrResponse
+      })
+      .finally(() => {
+        listenerController.abort()
+      })
 
     const mockedResponse = await mockedResponsePromise
 
@@ -371,12 +410,40 @@ export abstract class RequestHandler<
   ): ResponseResolver<ResolverExtras> {
     return async (info): Promise<ResponseResolverReturnType<any>> => {
       if (!this.resolverIterator) {
-        const result = await resolver(info)
+        let result
+
+        try {
+          result = await resolver(info)
+        } catch (error) {
+          // Ensure cleanup if the resolver throws, regardless of the returned type.
+          await this.runScheduledCleanups(info.requestId)
+
+          // Re-throw the error for the "run()" method to handle (e.g. thrown responses).
+          throw error
+        }
 
         if (!isIterable(result)) {
+          // Otherwise, run the cleanup immediately if it's a plain response resolver.
+          await this.runScheduledCleanups(info.requestId)
           return result
         }
 
+        /**
+         * @note Carry over any previously registered cleanups onto the iterator cleanups.
+         * This is only relevant if "finalize()" is called in a regular resolver that
+         * returns an iterator.
+         * @example
+         * http.get('/', async ({ finalize }) => {
+         *   finalize(cleanup)
+         *   return (async function*() {})()
+         * })
+         */
+        const existingCleanups = this.scheduledCleanups.get(info.requestId)
+        if (existingCleanups != null && existingCleanups.length > 0) {
+          this.resolverIteratorCleanups = existingCleanups
+          this.scheduledCleanups.delete(info.requestId)
+        }
+
         this.resolverIterator =
           Symbol.iterator in result
             ? result[Symbol.iterator]()
@@ -398,6 +465,8 @@ export abstract class RequestHandler<
         // only after it's been completely exhausted.
         this.isUsed = true
 
+        await this.runScheduledCleanups(info.requestId)
+
         // Clone the previously stored response so it can be read
         // when receiving it repeatedly from the "done" generator.
         return this.resolverIteratorResult?.clone()
@@ -421,6 +490,71 @@ export abstract class RequestHandler<
       parsedResult: args.parsedResult,
     }
   }
+
+  private scheduleCleanup(
+    requestId: string,
+    callback: () => MaybePromise<void>,
+  ): void {
+    if (this.resolverIterator) {
+      ;(this.resolverIteratorCleanups ||= []).unshift(callback)
+      return
+    }
+
+    const cleanups = this.scheduledCleanups.get(requestId) || []
+    cleanups.unshift(callback)
+    this.scheduledCleanups.set(requestId, cleanups)
+  }
+
+  private async exhaustCleanups(
+    cleanups: Array<() => MaybePromise<void>>,
+  ): Promise<void> {
+    const errors: Array<Error> = []
+
+    for (const cleanup of cleanups) {
+      try {
+        await cleanup()
+      } catch (error) {
+        if (error instanceof Error) {
+          errors.push(error)
+        }
+      }
+    }
+
+    if (errors.length > 0) {
+      devUtils.error(
+        'Failed to execute cleanup for request handler "%s"',
+        this.info.header,
+        new AggregateError(
+          errors,
+          `Failed to execute cleanup for request handler "${this.info.header}"`,
+        ),
+      )
+    }
+  }
+
+  private async runScheduledCleanups(requestId: string): Promise<void> {
+    if (
+      this.resolverIterator &&
+      this.resolverIteratorCleanups != null &&
+      this.resolverIteratorCleanups.length > 0
+    ) {
+      try {
+        await this.exhaustCleanups(this.resolverIteratorCleanups)
+      } finally {
+        this.resolverIteratorCleanups = undefined
+      }
+      return
+    }
+
+    const cleanups = this.scheduledCleanups.get(requestId)
+
+    if (!cleanups || cleanups.length == 0) {
+      return
+    }
+
+    await this.exhaustCleanups(cleanups)
+    this.scheduledCleanups.delete(requestId)
+  }
 }
 
 /**