@depup/msw 2.12.13-depup.0

package/src/core/ws/handleWebSocketEvent.ts

@@ -0,0 +1,64 @@
+import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
+import { RequestHandler } from '../handlers/RequestHandler'
+import { WebSocketHandler } from '../handlers/WebSocketHandler'
+import { webSocketInterceptor } from './webSocketInterceptor'
+import {
+  onUnhandledRequest,
+  UnhandledRequestStrategy,
+} from '../utils/request/onUnhandledRequest'
+import { isHandlerKind } from '../utils/internal/isHandlerKind'
+
+interface HandleWebSocketEventOptions {
+  getUnhandledRequestStrategy: () => UnhandledRequestStrategy
+  getHandlers: () => Array<RequestHandler | WebSocketHandler>
+  onMockedConnection: (connection: WebSocketConnectionData) => void
+  onPassthroughConnection: (onnection: WebSocketConnectionData) => void
+}
+
+export function handleWebSocketEvent(options: HandleWebSocketEventOptions) {
+  webSocketInterceptor.on('connection', async (connection) => {
+    const handlers = options.getHandlers().filter(isHandlerKind('EventHandler'))
+
+    // Ignore this connection if the user hasn't defined any handlers.
+    if (handlers.length > 0) {
+      options?.onMockedConnection(connection)
+
+      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)
+        }),
+      )
+
+      return
+    }
+
+    // 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)
+
+    // If none of the "ws" handlers matched,
+    // establish the WebSocket connection as-is.
+    connection.server.connect()
+  })
+}

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

@@ -0,0 +1,245 @@
+import type {
+  WebSocketClientConnection,
+  WebSocketConnectionData,
+  WebSocketData,
+} from '@mswjs/interceptors/WebSocket'
+import { devUtils } from '../../utils/internal/devUtils'
+import { getTimestamp } from '../../utils/logging/getTimestamp'
+import { toPublicUrl } from '../../utils/request/toPublicUrl'
+import { getMessageLength } from './getMessageLength'
+import { getPublicData } from './getPublicData'
+
+export const colors = {
+  system: '#3b82f6',
+  outgoing: '#22c55e',
+  incoming: '#ef4444',
+  mocked: '#ff6a33',
+}
+
+export function attachWebSocketLogger(
+  connection: WebSocketConnectionData,
+): void {
+  const { client, server } = connection
+
+  logConnectionOpen(client)
+
+  // Log the events sent from the WebSocket client.
+  // WebSocket client connection object is written from the
+  // server's perspective so these message events are outgoing.
+  /**
+   * @todo Provide the reference to the exact event handler
+   * that called this `client.send()`.
+   */
+  client.addEventListener('message', (event) => {
+    logOutgoingClientMessage(event)
+  })
+
+  client.addEventListener('close', (event) => {
+    logConnectionClose(event)
+  })
+
+  // Log client errors (connection closures due to errors).
+  client.socket.addEventListener('error', (event) => {
+    logClientError(event)
+  })
+
+  client.send = new Proxy(client.send, {
+    apply(target, thisArg, args) {
+      const [data] = args
+      const messageEvent = new MessageEvent('message', { data })
+      Object.defineProperties(messageEvent, {
+        currentTarget: {
+          enumerable: true,
+          writable: false,
+          value: client.socket,
+        },
+        target: {
+          enumerable: true,
+          writable: false,
+          value: client.socket,
+        },
+      })
+
+      queueMicrotask(() => {
+        logIncomingMockedClientMessage(messageEvent)
+      })
+
+      return Reflect.apply(target, thisArg, args)
+    },
+  })
+
+  server.addEventListener(
+    'open',
+    () => {
+      server.addEventListener('message', (event) => {
+        logIncomingServerMessage(event)
+      })
+    },
+    { once: true },
+  )
+
+  // Log outgoing client events initiated by the event handler.
+  // The actual client never sent these but the handler did.
+  server.send = new Proxy(server.send, {
+    apply(target, thisArg, args) {
+      const [data] = args
+      const messageEvent = new MessageEvent('message', { data })
+      Object.defineProperties(messageEvent, {
+        currentTarget: {
+          enumerable: true,
+          writable: false,
+          value: server.socket,
+        },
+        target: {
+          enumerable: true,
+          writable: false,
+          value: server.socket,
+        },
+      })
+
+      logOutgoingMockedClientMessage(messageEvent)
+
+      return Reflect.apply(target, thisArg, args)
+    },
+  })
+}
+
+/**
+ * Prints the WebSocket connection.
+ * This is meant to be logged by every WebSocket handler
+ * that intercepted this connection. This helps you see
+ * what handlers observe this connection.
+ */
+export function logConnectionOpen(client: WebSocketClientConnection) {
+  const publicUrl = toPublicUrl(client.url)
+
+  console.groupCollapsed(
+    devUtils.formatMessage(`${getTimestamp()} %c▶%c ${publicUrl}`),
+    `color:${colors.system}`,
+    'color:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log('Client:', client.socket)
+  console.groupEnd()
+}
+
+function logConnectionClose(event: CloseEvent) {
+  const target = event.target as WebSocket
+  const publicUrl = toPublicUrl(target.url)
+
+  console.groupCollapsed(
+    devUtils.formatMessage(
+      `${getTimestamp({ milliseconds: true })} %c■%c ${publicUrl}`,
+    ),
+    `color:${colors.system}`,
+    'color:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log(event)
+  console.groupEnd()
+}
+
+function logClientError(event: Event) {
+  const socket = event.target as WebSocket
+  const publicUrl = toPublicUrl(socket.url)
+
+  console.groupCollapsed(
+    devUtils.formatMessage(
+      `${getTimestamp({ milliseconds: true })} %c\u00D7%c ${publicUrl}`,
+    ),
+    `color:${colors.system}`,
+    'color:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log(event)
+  console.groupEnd()
+}
+
+/**
+ * Prints the outgoing client message.
+ */
+async function logOutgoingClientMessage(event: MessageEvent<WebSocketData>) {
+  const byteLength = getMessageLength(event.data)
+  const publicData = await getPublicData(event.data)
+  const arrow = event.defaultPrevented ? '⇡' : '⬆'
+
+  console.groupCollapsed(
+    devUtils.formatMessage(
+      `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`,
+    ),
+    `color:${colors.outgoing}`,
+    'color:inherit',
+    'color:gray;font-weight:normal',
+    'color:inherit;font-weight:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log(event)
+  console.groupEnd()
+}
+
+/**
+ * Prints the outgoing client message initiated
+ * by `server.send()` in the event handler.
+ */
+async function logOutgoingMockedClientMessage(
+  event: MessageEvent<WebSocketData>,
+) {
+  const byteLength = getMessageLength(event.data)
+  const publicData = await getPublicData(event.data)
+
+  console.groupCollapsed(
+    devUtils.formatMessage(
+      `${getTimestamp({ milliseconds: true })} %c⬆%c ${publicData} %c${byteLength}%c`,
+    ),
+    `color:${colors.mocked}`,
+    'color:inherit',
+    'color:gray;font-weight:normal',
+    'color:inherit;font-weight:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log(event)
+  console.groupEnd()
+}
+
+/**
+ * Prints the outgoing client message initiated
+ * by `client.send()` in the event handler.
+ */
+async function logIncomingMockedClientMessage(
+  event: MessageEvent<WebSocketData>,
+) {
+  const byteLength = getMessageLength(event.data)
+  const publicData = await getPublicData(event.data)
+
+  console.groupCollapsed(
+    devUtils.formatMessage(
+      `${getTimestamp({ milliseconds: true })} %c⬇%c ${publicData} %c${byteLength}%c`,
+    ),
+    `color:${colors.mocked}`,
+    'color:inherit',
+    'color:gray;font-weight:normal',
+    'color:inherit;font-weight:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log(event)
+  console.groupEnd()
+}
+
+async function logIncomingServerMessage(event: MessageEvent<WebSocketData>) {
+  const byteLength = getMessageLength(event.data)
+  const publicData = await getPublicData(event.data)
+  const arrow = event.defaultPrevented ? '⇣' : '⬇'
+
+  console.groupCollapsed(
+    devUtils.formatMessage(
+      `${getTimestamp({ milliseconds: true })} %c${arrow}%c ${publicData} %c${byteLength}%c`,
+    ),
+    `color:${colors.incoming}`,
+    'color:inherit',
+    'color:gray;font-weight:normal',
+    'color:inherit;font-weight:inherit',
+  )
+  // eslint-disable-next-line no-console
+  console.log(event)
+  console.groupEnd()
+}

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

@@ -0,0 +1,16 @@
+import { getMessageLength } from './getMessageLength'
+
+it('returns the length of the string', () => {
+  expect(getMessageLength('')).toBe(0)
+  expect(getMessageLength('hello')).toBe(5)
+})
+
+it('returns the size of the Blob', () => {
+  expect(getMessageLength(new Blob())).toBe(0)
+  expect(getMessageLength(new Blob(['hello']))).toBe(5)
+})
+
+it('returns the byte length of ArrayBuffer', () => {
+  expect(getMessageLength(new ArrayBuffer(0))).toBe(0)
+  expect(getMessageLength(new ArrayBuffer(5))).toBe(5)
+})

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

@@ -0,0 +1,20 @@
+import type { WebSocketData } from '@mswjs/interceptors/WebSocket'
+import { isObject } from '../../utils/internal/isObject'
+
+/**
+ * Returns the byte length of the given WebSocket message.
+ * @example
+ * getMessageLength('hello') // 5
+ * getMessageLength(new Blob(['hello'])) // 5
+ */
+export function getMessageLength(data: WebSocketData): number {
+  if (data instanceof Blob) {
+    return data.size
+  }
+
+  if (isObject(data) && 'byteLength' in data) {
+    return data.byteLength
+  }
+
+  return new Blob([data as any]).size
+}

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

@@ -0,0 +1,38 @@
+import { getPublicData } from './getPublicData'
+
+it('returns a short string as-is', async () => {
+  expect(await getPublicData('')).toBe('')
+  expect(await getPublicData('hello')).toBe('hello')
+})
+
+it('returns a truncated long string', async () => {
+  expect(await getPublicData('this is a very long string')).toBe(
+    'this is a very long stri…',
+  )
+})
+
+it('returns a short Blob text as-is', async () => {
+  expect(await getPublicData(new Blob(['']))).toBe('Blob()')
+  expect(await getPublicData(new Blob(['hello']))).toBe('Blob(hello)')
+})
+
+it('returns a truncated long Blob text', async () => {
+  expect(await getPublicData(new Blob(['this is a very long string']))).toBe(
+    'Blob(this is a very long stri…)',
+  )
+})
+
+it('returns a short ArrayBuffer text as-is', async () => {
+  expect(await getPublicData(new TextEncoder().encode(''))).toBe(
+    'ArrayBuffer()',
+  )
+  expect(await getPublicData(new TextEncoder().encode('hello'))).toBe(
+    'ArrayBuffer(hello)',
+  )
+})
+
+it('returns a truncated ArrayBuffer text', async () => {
+  expect(
+    await getPublicData(new TextEncoder().encode('this is a very long string')),
+  ).toBe('ArrayBuffer(this is a very long stri…)')
+})

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

@@ -0,0 +1,18 @@
+import type { WebSocketData } from '@mswjs/interceptors/WebSocket'
+import { isObject } from '../../utils/internal/isObject'
+import { truncateMessage } from './truncateMessage'
+
+export async function getPublicData(data: WebSocketData): Promise<string> {
+  if (data instanceof Blob) {
+    const text = await data.text()
+    return `Blob(${truncateMessage(text)})`
+  }
+
+  // Handle all ArrayBuffer-like objects.
+  if (isObject(data)) {
+    const text = new TextDecoder().decode(data as ArrayBuffer)
+    return `ArrayBuffer(${truncateMessage(text)})`
+  }
+
+  return truncateMessage(data)
+}

package/src/core/ws/utils/truncateMessage.test.ts

@@ -0,0 +1,12 @@
+import { truncateMessage } from './truncateMessage'
+
+it('returns a short string as-is', () => {
+  expect(truncateMessage('')).toBe('')
+  expect(truncateMessage('hello')).toBe('hello')
+})
+
+it('truncates a long string', () => {
+  expect(truncateMessage('this is a very long string')).toBe(
+    'this is a very long stri…',
+  )
+})

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

@@ -0,0 +1,9 @@
+const MAX_LENGTH = 24
+
+export function truncateMessage(message: string): string {
+  if (message.length <= MAX_LENGTH) {
+    return message
+  }
+
+  return `${message.slice(0, MAX_LENGTH)}…`
+}

package/src/core/ws/webSocketInterceptor.ts

@@ -0,0 +1,3 @@
+import { WebSocketInterceptor } from '@mswjs/interceptors/WebSocket'
+
+export const webSocketInterceptor = new WebSocketInterceptor()

package/src/core/ws.test.ts

@@ -0,0 +1,23 @@
+/**
+ * @vitest-environment node-websocket
+ */
+import { ws } from './ws'
+
+it('exports the "link()" method', () => {
+  expect(ws).toHaveProperty('link')
+  expect(ws.link).toBeInstanceOf(Function)
+})
+
+it('throws an error when calling "ws.link()" without a URL argument', () => {
+  expect(() =>
+    // @ts-expect-error Intentionally invalid call.
+    ws.link(),
+  ).toThrow('Expected a WebSocket server URL but got undefined')
+})
+
+it('throws an error when given a non-path argument to "ws.link()"', () => {
+  expect(() =>
+    // @ts-expect-error Intentionally invalid argument.
+    ws.link(2),
+  ).toThrow('Expected a WebSocket server URL to be a valid path but got number')
+})

package/src/core/ws.ts

@@ -0,0 +1,161 @@
+import { invariant } from 'outvariant'
+import type {
+  WebSocketData,
+  WebSocketClientConnectionProtocol,
+} from '@mswjs/interceptors/WebSocket'
+import {
+  WebSocketHandler,
+  kEmitter,
+  type WebSocketHandlerEventMap,
+} from './handlers/WebSocketHandler'
+import { hasRefCounted } from './utils/internal/hasRefCounted'
+import { Path, isPath } from './utils/matching/matchRequestUrl'
+import { WebSocketClientManager } from './ws/WebSocketClientManager'
+
+const webSocketChannel = new BroadcastChannel('msw:websocket-client-manager')
+
+if (hasRefCounted(webSocketChannel)) {
+  // Allows the Node.js thread to exit if it is the only active handle in the event system.
+  // https://nodejs.org/api/worker_threads.html#broadcastchannelunref
+  webSocketChannel.unref()
+}
+
+export type WebSocketEventListener<
+  EventType extends keyof WebSocketHandlerEventMap,
+> = (...args: WebSocketHandlerEventMap[EventType]) => void
+
+export type WebSocketLink = {
+  /**
+   * A set of all WebSocket clients connected
+   * to this link.
+   *
+   * @see {@link https://mswjs.io/docs/api/ws#clients `clients` API reference}
+   */
+  clients: Set<WebSocketClientConnectionProtocol>
+
+  /**
+   * Adds an event listener to this WebSocket link.
+   *
+   * @example
+   * const chat = ws.link('wss://chat.example.com')
+   * chat.addEventListener('connection', listener)
+   *
+   * @see {@link https://mswjs.io/docs/api/ws#onevent-listener `on()` API reference}
+   */
+  addEventListener<EventType extends keyof WebSocketHandlerEventMap>(
+    event: EventType,
+    listener: WebSocketEventListener<EventType>,
+  ): WebSocketHandler
+
+  /**
+   * Broadcasts the given data to all WebSocket clients.
+   *
+   * @example
+   * const service = ws.link('wss://example.com')
+   * service.addEventListener('connection', () => {
+   *   service.broadcast('hello, everyone!')
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/ws#broadcastdata `broadcast()` API reference}
+   */
+  broadcast(data: WebSocketData): void
+
+  /**
+   * Broadcasts the given data to all WebSocket clients
+   * except the ones provided in the `clients` argument.
+   *
+   * @example
+   * const service = ws.link('wss://example.com')
+   * service.addEventListener('connection', ({ client }) => {
+   *   service.broadcastExcept(client, 'hi, the rest of you!')
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/ws#broadcastexceptclients-data `broadcast()` API reference}
+   */
+  broadcastExcept(
+    clients:
+      | WebSocketClientConnectionProtocol
+      | Array<WebSocketClientConnectionProtocol>,
+    data: WebSocketData,
+  ): void
+}
+
+/**
+ * Intercepts outgoing WebSocket connections to the given URL.
+ *
+ * @example
+ * const chat = ws.link('wss://chat.example.com')
+ * chat.addEventListener('connection', ({ client }) => {
+ *   client.send('hello from server!')
+ * })
+ */
+function createWebSocketLinkHandler(url: Path): WebSocketLink {
+  invariant(url, 'Expected a WebSocket server URL but got undefined')
+
+  invariant(
+    isPath(url),
+    'Expected a WebSocket server URL to be a valid path but got %s',
+    typeof url,
+  )
+
+  const clientManager = new WebSocketClientManager(webSocketChannel)
+
+  return {
+    get clients() {
+      return clientManager.clients
+    },
+    addEventListener(event, listener) {
+      const handler = new WebSocketHandler(url)
+
+      // Add the connection event listener for when the
+      // handler matches and emits a connection event.
+      // When that happens, store that connection in the
+      // set of all connections for reference.
+      handler[kEmitter].on('connection', async ({ client }) => {
+        await clientManager.addConnection(client)
+      })
+
+      // The "handleWebSocketEvent" function will invoke
+      // the "run()" method on the WebSocketHandler.
+      // If the handler matches, it will emit the "connection"
+      // event. Attach the user-defined listener to that event.
+      handler[kEmitter].on(event, listener)
+
+      return handler
+    },
+
+    broadcast(data) {
+      // This will invoke "send()" on the immediate clients
+      // in this runtime and post a message to the broadcast channel
+      // to trigger send for the clients in other runtimes.
+      this.broadcastExcept([], data)
+    },
+
+    broadcastExcept(clients, data) {
+      const ignoreClients = Array.prototype
+        .concat(clients)
+        .map((client) => client.id)
+
+      clientManager.clients.forEach((otherClient) => {
+        if (!ignoreClients.includes(otherClient.id)) {
+          otherClient.send(data)
+        }
+      })
+    },
+  }
+}
+
+/**
+ * A namespace to intercept and mock WebSocket connections.
+ *
+ * @example
+ * const chat = ws.link('wss://chat.example.com')
+ *
+ * @see {@link https://mswjs.io/docs/api/ws `ws` API reference}
+ * @see {@link https://mswjs.io/docs/basics/handling-websocket-events Handling WebSocket events}
+ */
+export const ws = {
+  link: createWebSocketLinkHandler,
+}
+
+export { WebSocketData }

package/src/iife/index.ts

@@ -0,0 +1,2 @@
+export * from '~/core'
+export * from '../browser'