msw 2.12.5 → 2.12.6

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.12.5'
+const PACKAGE_VERSION = '2.12.6'
 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.12.5",
+  "version": "2.12.6",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "type": "commonjs",
   "main": "./lib/core/index.js",
@@ -285,7 +285,7 @@
     "vitest-environment-miniflare": "^2.14.4",
     "webpack": "^5.95.0",
     "webpack-http-server": "^0.5.0",
-    "msw": "2.12.5"
+    "msw": "2.12.6"
   },
   "peerDependencies": {
     "typescript": ">= 4.8.x"

package/src/browser/setupWorker/start/createFallbackRequestListener.ts

@@ -29,6 +29,9 @@ export function createFallbackRequestListener(
       options,
       context.emitter,
       {
+        resolutionContext: {
+          quiet: options.quiet,
+        },
         onMockedResponse(_, { handler, parsedResult }) {
           if (!options.quiet) {
             context.emitter.once('response:mocked', ({ response }) => {

package/src/browser/setupWorker/start/createRequestListener.ts

@@ -46,6 +46,9 @@ export const createRequestListener = (
         options,
         context.emitter,
         {
+          resolutionContext: {
+            quiet: options.quiet,
+          },
           onPassthroughResponse() {
             event.postMessage('PASSTHROUGH')
           },

package/src/core/sse.ts

@@ -6,6 +6,7 @@ import {
   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'
@@ -67,9 +68,19 @@ export const sse: ServerSentEventRequestHandler = (path, resolver) => {
   return new ServerSentEventHandler(path, resolver)
 }
 
+const SSE_RESPONSE_INIT: ResponseInit = {
+  headers: {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache',
+    connection: 'keep-alive',
+  },
+}
+
 class ServerSentEventHandler<
   EventMap extends EventMapConstraint,
 > extends HttpHandler {
+  #emitter: Emitter<ServerSentEventClientEventMap>
+
   constructor(path: Path, resolver: ServerSentEventResolver<EventMap, any>) {
     invariant(
       typeof EventSource !== 'undefined',
@@ -77,37 +88,12 @@ class ServerSentEventHandler<
       path,
     )
 
-    const clientEmitter = new Emitter<ServerSentEventClientEventMap>()
-
     super('GET', path, async (info) => {
-      const responseInit: ResponseInit = {
-        headers: {
-          'content-type': 'text/event-stream',
-          'cache-control': 'no-cache',
-          connection: 'keep-alive',
-        },
-      }
-
-      /**
-       * @note Log the intercepted request early.
-       * Normally, the `this.log()` method is called when the handler returns a response.
-       * For SSE, call that method earlier so the logs are in correct order.
-       */
-      await super.log({
-        request: info.request,
-        /**
-         * @note Construct a placeholder response since SSE response
-         * is being streamed and cannot be cloned/consumed for logging.
-         */
-        response: new Response('[streaming]', responseInit),
-      })
-      this.#attachClientLogger(info.request, clientEmitter)
-
       const stream = new ReadableStream({
-        async start(controller) {
+        start: async (controller) => {
           const client = new ServerSentEventClient<EventMap>({
             controller,
-            emitter: clientEmitter,
+            emitter: this.#emitter,
           })
           const server = new ServerSentEventServer({
             request: info.request,
@@ -122,19 +108,42 @@ class ServerSentEventHandler<
         },
       })
 
-      return new Response(stream, responseInit)
+      return new Response(stream, SSE_RESPONSE_INIT)
     })
+
+    this.#emitter = new Emitter<ServerSentEventClientEventMap>()
   }
 
   async predicate(args: {
     request: Request
     parsedResult: HttpRequestParsedResult
+    resolutionContext?: ResponseResolutionContext
   }) {
     if (args.request.headers.get('accept') !== 'text/event-stream') {
       return false
     }
 
-    return super.predicate(args)
+    const matches = await super.predicate(args)
+
+    if (matches && !args.resolutionContext?.quiet) {
+      /**
+       * @note Log the intercepted request early.
+       * Normally, the `this.log()` method is called when the handler returns a response.
+       * For SSE, call that method earlier so the logs are in correct order.
+       */
+      await super.log({
+        request: args.request,
+        /**
+         * @note Construct a placeholder response since SSE response
+         * is being streamed and cannot be cloned/consumed for logging.
+         */
+        response: new Response('[streaming]', SSE_RESPONSE_INIT),
+      })
+
+      this.#attachClientLogger(args.request, this.#emitter)
+    }
+
+    return matches
   }
 
   async log(_args: { request: Request; response: Response }): Promise<void> {

package/src/core/utils/executeHandlers.ts

@@ -10,7 +10,13 @@ export interface HandlersExecutionResult {
 }
 
 export interface ResponseResolutionContext {
+  /**
+   * A base url to use when resolving relative urls.
+   * @note This is primarily used by the `@mswjs/http-middleware`
+   * to resolve relative urls in the context of the running server
+   */
   baseUrl?: string
+  quiet?: boolean
 }
 
 /**

package/src/core/utils/handleRequest.ts

@@ -3,7 +3,11 @@ import { Emitter } from 'strict-event-emitter'
 import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequiredDeep } from '../typeUtils'
 import type { RequestHandler } from '../handlers/RequestHandler'
-import { HandlersExecutionResult, executeHandlers } from './executeHandlers'
+import {
+  type HandlersExecutionResult,
+  type ResponseResolutionContext,
+  executeHandlers,
+} from './executeHandlers'
 import { onUnhandledRequest } from './request/onUnhandledRequest'
 import { storeResponseCookies } from './request/storeResponseCookies'
 
@@ -13,14 +17,7 @@ export interface HandleRequestOptions {
    * but is exposed to aid in creating extensions like
    * `@mswjs/http-middleware`.
    */
-  resolutionContext?: {
-    /**
-     * A base url to use when resolving relative urls.
-     * @note This is primarily used by the `@mswjs/http-middleware`
-     * to resolve relative urls in the context of the running server
-     */
-    baseUrl?: string
-  }
+  resolutionContext?: ResponseResolutionContext
 
   /**
    * Invoked whenever a request is performed as-is.