msw 2.9.0 → 2.10.1

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.9.0'
+const PACKAGE_VERSION = '2.10.1'
 const INTEGRITY_CHECKSUM = 'f5825c521429caf22a4dd13b66e243af'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.9.0",
+  "version": "2.10.1",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "type": "commonjs",
   "main": "./lib/core/index.js",
@@ -218,7 +218,7 @@
     "@bundled-es-modules/statuses": "^1.0.1",
     "@bundled-es-modules/tough-cookie": "^0.1.6",
     "@inquirer/confirm": "^5.0.0",
-    "@mswjs/interceptors": "^0.38.7",
+    "@mswjs/interceptors": "^0.39.1",
     "@open-draft/deferred-promise": "^2.2.0",
     "@open-draft/until": "^2.1.0",
     "@types/cookie": "^0.6.0",
@@ -280,7 +280,7 @@
     "vitest-environment-miniflare": "^2.14.4",
     "webpack": "^5.95.0",
     "webpack-http-server": "^0.5.0",
-    "msw": "2.9.0"
+    "msw": "2.10.1"
   },
   "peerDependencies": {
     "typescript": ">= 4.8.x"

package/src/core/handlers/WebSocketHandler.test.ts

@@ -1,17 +1,10 @@
-import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
 import { WebSocketHandler } from './WebSocketHandler'
 
 describe('parse', () => {
   it('matches an exact url', () => {
     expect(
       new WebSocketHandler('ws://localhost:3000').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL('ws://localhost:3000'),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL('ws://localhost:3000'),
       }),
     ).toEqual({
       match: {
@@ -24,13 +17,7 @@ describe('parse', () => {
   it('ignores trailing slash', () => {
     expect(
       new WebSocketHandler('ws://localhost:3000').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL('ws://localhost:3000/'),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL('ws://localhost:3000/'),
       }),
     ).toEqual({
       match: {
@@ -41,13 +28,7 @@ describe('parse', () => {
 
     expect(
       new WebSocketHandler('ws://localhost:3000/').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL('ws://localhost:3000'),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL('ws://localhost:3000/'),
       }),
     ).toEqual({
       match: {
@@ -60,13 +41,7 @@ describe('parse', () => {
   it('supports path parameters', () => {
     expect(
       new WebSocketHandler('ws://localhost:3000/:serviceName').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL('ws://localhost:3000/auth'),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL('ws://localhost:3000/auth'),
       }),
     ).toEqual({
       match: {
@@ -81,15 +56,9 @@ describe('parse', () => {
   it('ignores "/socket.io/" prefix in the client url', () => {
     expect(
       new WebSocketHandler('ws://localhost:3000').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL(
-                'ws://localhost:3000/socket.io/?EIO=4&transport=websocket',
-              ),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL(
+          'ws://localhost:3000/socket.io/?EIO=4&transport=websocket',
+        ),
       }),
     ).toEqual({
       match: {
@@ -100,15 +69,9 @@ describe('parse', () => {
 
     expect(
       new WebSocketHandler('ws://localhost:3000/non-matching').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL(
-                'ws://localhost:3000/socket.io/?EIO=4&transport=websocket',
-              ),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL(
+          'ws://localhost:3000/socket.io/?EIO=4&transport=websocket',
+        ),
       }),
     ).toEqual({
       match: {
@@ -125,13 +88,7 @@ describe('parse', () => {
      */
     expect(
       new WebSocketHandler('ws://localhost:3000/clients/socket.io/123').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL('ws://localhost:3000/clients/socket.io/123'),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL('ws://localhost:3000/clients/socket.io/123'),
       }),
     ).toEqual({
       match: {
@@ -142,13 +99,7 @@ describe('parse', () => {
 
     expect(
       new WebSocketHandler('ws://localhost:3000').parse({
-        event: new MessageEvent('connection', {
-          data: {
-            client: {
-              url: new URL('ws://localhost:3000/clients/socket.io/123'),
-            },
-          } as WebSocketConnectionData,
-        }),
+        url: new URL('ws://localhost:3000/clients/socket.io/123'),
       }),
     ).toEqual({
       match: {

package/src/core/handlers/WebSocketHandler.ts

@@ -1,6 +1,10 @@
 import { Emitter } from 'strict-event-emitter'
 import { createRequestId } from '@mswjs/interceptors'
-import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
+import type {
+  WebSocketClientConnectionProtocol,
+  WebSocketConnectionData,
+  WebSocketServerConnectionProtocol,
+} from '@mswjs/interceptors/WebSocket'
 import {
   type Match,
   type Path,
@@ -18,12 +22,14 @@ export type WebSocketHandlerEventMap = {
   connection: [args: WebSocketHandlerConnection]
 }
 
-export interface WebSocketHandlerConnection extends WebSocketConnectionData {
+export interface WebSocketHandlerConnection {
+  client: WebSocketClientConnectionProtocol
+  server: WebSocketServerConnectionProtocol
+  info: WebSocketConnectionData['info']
   params: PathParams
 }
 
 export const kEmitter = Symbol('kEmitter')
-export const kDispatchEvent = Symbol('kDispatchEvent')
 export const kSender = Symbol('kSender')
 const kStopPropagationPatched = Symbol('kStopPropagationPatched')
 const KOnStopPropagation = Symbol('KOnStopPropagation')
@@ -44,11 +50,8 @@ export class WebSocketHandler {
     this.__kind = 'EventHandler'
   }
 
-  public parse(args: {
-    event: MessageEvent<WebSocketConnectionData>
-  }): WebSocketHandlerParsedResult {
-    const { data: connection } = args.event
-    const { url: clientUrl } = connection.client
+  public parse(args: { url: URL }): WebSocketHandlerParsedResult {
+    const clientUrl = new URL(args.url)
 
     /**
      * @note Remove the Socket.IO path prefix from the WebSocket
@@ -65,23 +68,32 @@ export class WebSocketHandler {
   }
 
   public predicate(args: {
-    event: MessageEvent<WebSocketConnectionData>
+    url: URL
     parsedResult: WebSocketHandlerParsedResult
   }): boolean {
     return args.parsedResult.match.matches
   }
 
-  async [kDispatchEvent](
-    event: MessageEvent<WebSocketConnectionData>,
-  ): Promise<void> {
-    const parsedResult = this.parse({ event })
-    const connection = event.data
+  public async run(
+    connection: Omit<WebSocketHandlerConnection, 'params'>,
+  ): Promise<boolean> {
+    const parsedResult = this.parse({
+      url: connection.client.url,
+    })
+
+    if (!this.predicate({ url: connection.client.url, parsedResult })) {
+      return false
+    }
 
     const resolvedConnection: WebSocketHandlerConnection = {
       ...connection,
       params: parsedResult.match.params || {},
     }
 
+    return this.connect(resolvedConnection)
+  }
+
+  protected connect(connection: WebSocketHandlerConnection): boolean {
     // Support `event.stopPropagation()` for various client/server events.
     connection.client.addEventListener(
       'message',
@@ -111,7 +123,7 @@ export class WebSocketHandler {
 
     // Emit the connection event on the handler.
     // This is what the developer adds listeners for.
-    this[kEmitter].emit('connection', resolvedConnection)
+    return this[kEmitter].emit('connection', connection)
   }
 }
 

package/src/core/ws/WebSocketClientManager.ts

@@ -1,7 +1,7 @@
 import type {
   WebSocketData,
-  WebSocketClientConnection,
   WebSocketClientConnectionProtocol,
+  WebSocketClientEventMap,
 } from '@mswjs/interceptors/WebSocket'
 import { WebSocketClientStore } from './WebSocketClientStore'
 import { WebSocketMemoryClientStore } from './WebSocketMemoryClientStore'
@@ -105,7 +105,9 @@ export class WebSocketClientManager {
     this.channel.postMessage({ type: 'db:update' })
   }
 
-  private async addClient(client: WebSocketClientConnection): Promise<void> {
+  private async addClient(
+    client: WebSocketClientConnectionProtocol,
+  ): Promise<void> {
     await this.store.add(client)
     // Sync the in-memory clients in this runtime with the
     // updated database. This pulls in all the stored clients.
@@ -119,7 +121,9 @@ export class WebSocketClientManager {
    * connection object because `addConnection()` is called only
    * for the opened connections in the same runtime.
    */
-  public async addConnection(client: WebSocketClientConnection): Promise<void> {
+  public async addConnection(
+    client: WebSocketClientConnectionProtocol,
+  ): Promise<void> {
     // Store this client in the map of clients created in this runtime.
     // This way, the manager can distinguish between this runtime clients
     // and extraneous runtime clients when synchronizing clients storage.
@@ -208,4 +212,30 @@ export class WebSocketRemoteClientConnection
       },
     } as WebSocketBroadcastChannelMessage)
   }
+
+  addEventListener<EventType extends keyof WebSocketClientEventMap>(
+    _type: EventType,
+    _listener: (
+      this: WebSocket,
+      event: WebSocketClientEventMap[EventType],
+    ) => void,
+    _options?: AddEventListenerOptions | boolean,
+  ): void {
+    throw new Error(
+      'WebSocketRemoteClientConnection.addEventListener is not supported',
+    )
+  }
+
+  removeEventListener<EventType extends keyof WebSocketClientEventMap>(
+    _event: EventType,
+    _listener: (
+      this: WebSocket,
+      event: WebSocketClientEventMap[EventType],
+    ) => void,
+    _options?: EventListenerOptions | boolean,
+  ): void {
+    throw new Error(
+      'WebSocketRemoteClientConnection.removeEventListener is not supported',
+    )
+  }
 }

package/src/core/ws/handleWebSocketEvent.ts

@@ -1,6 +1,6 @@
 import type { WebSocketConnectionData } from '@mswjs/interceptors/lib/browser/interceptors/WebSocket'
 import { RequestHandler } from '../handlers/RequestHandler'
-import { WebSocketHandler, kDispatchEvent } from '../handlers/WebSocketHandler'
+import { WebSocketHandler } from '../handlers/WebSocketHandler'
 import { webSocketInterceptor } from './webSocketInterceptor'
 import {
   onUnhandledRequest,
@@ -17,67 +17,48 @@ interface HandleWebSocketEventOptions {
 
 export function handleWebSocketEvent(options: HandleWebSocketEventOptions) {
   webSocketInterceptor.on('connection', async (connection) => {
-    const handlers = options.getHandlers()
+    const handlers = options.getHandlers().filter(isHandlerKind('EventHandler'))
 
-    const connectionEvent = new MessageEvent('connection', {
-      data: connection,
-    })
+    // Ignore this connection if the user hasn't defined any handlers.
+    if (handlers.length > 0) {
+      options?.onMockedConnection(connection)
 
-    // First, filter only those WebSocket handlers that
-    // match the "ws.link()" endpoint predicate. Don't dispatch
-    // anything yet so the logger can be attached to the connection
-    // before it potentially sends events.
-    const matchingHandlers: Array<WebSocketHandler> = []
+      await Promise.all(
+        handlers.map((handler) => {
+          // Iterate over the handlers and forward the connection
+          // event to WebSocket event handlers. This is equivalent
+          // to dispatching that event onto multiple listeners.
+          return handler.run(connection)
+        }),
+      )
 
-    for (const handler of handlers) {
-      if (
-        isHandlerKind('EventHandler')(handler) &&
-        handler.predicate({
-          event: connectionEvent,
-          parsedResult: handler.parse({
-            event: connectionEvent,
-          }),
-        })
-      ) {
-        matchingHandlers.push(handler)
-      }
+      return
     }
 
-    if (matchingHandlers.length > 0) {
-      options?.onMockedConnection(connection)
-
-      // Iterate over the handlers and forward the connection
-      // event to WebSocket event handlers. This is equivalent
-      // to dispatching that event onto multiple listeners.
-      for (const handler of matchingHandlers) {
-        handler[kDispatchEvent](connectionEvent)
-      }
-    } else {
-      // Construct a request representing this WebSocket connection.
-      const request = new Request(connection.client.url, {
-        headers: {
-          upgrade: 'websocket',
-          connection: 'upgrade',
-        },
-      })
-      await onUnhandledRequest(
-        request,
-        options.getUnhandledRequestStrategy(),
-      ).catch((error) => {
-        const errorEvent = new Event('error')
-        Object.defineProperty(errorEvent, 'cause', {
-          enumerable: true,
-          configurable: false,
-          value: error,
-        })
-        connection.client.socket.dispatchEvent(errorEvent)
+    // Construct a request representing this WebSocket connection.
+    const request = new Request(connection.client.url, {
+      headers: {
+        upgrade: 'websocket',
+        connection: 'upgrade',
+      },
+    })
+    await onUnhandledRequest(
+      request,
+      options.getUnhandledRequestStrategy(),
+    ).catch((error) => {
+      const errorEvent = new Event('error')
+      Object.defineProperty(errorEvent, 'cause', {
+        enumerable: true,
+        configurable: false,
+        value: error,
       })
+      connection.client.socket.dispatchEvent(errorEvent)
+    })
 
-      options?.onPassthroughConnection(connection)
+    options?.onPassthroughConnection(connection)
 
-      // If none of the "ws" handlers matched,
-      // establish the WebSocket connection as-is.
-      connection.server.connect()
-    }
+    // If none of the "ws" handlers matched,
+    // establish the WebSocket connection as-is.
+    connection.server.connect()
   })
 }

package/src/core/ws/utils/getMessageLength.ts

@@ -15,5 +15,5 @@ export function getMessageLength(data: WebSocketData): number {
     return data.byteLength
   }
 
-  return new Blob([data]).size
+  return new Blob([data as any]).size
 }

package/src/core/ws/utils/getPublicData.ts

@@ -9,7 +9,7 @@ export async function getPublicData(data: WebSocketData): Promise<string> {
 
   // Handle all ArrayBuffer-like objects.
   if (typeof data === 'object' && 'byteLength' in data) {
-    const text = new TextDecoder().decode(data)
+    const text = new TextDecoder().decode(data as ArrayBuffer)
     return `ArrayBuffer(${truncateMessage(text)})`
   }