msw 2.12.13 → 2.13.0

package/src/core/utils/internal/isHandlerKind.test.ts

@@ -5,14 +5,12 @@ import { WebSocketHandler } from '../../handlers/WebSocketHandler'
 import { isHandlerKind } from './isHandlerKind'
 
 it('returns true if expected a request handler and given a request handler', () => {
-  expect(
-    isHandlerKind('RequestHandler')(new HttpHandler('*', '*', () => {})),
-  ).toBe(true)
+  expect(isHandlerKind('request')(new HttpHandler('*', '*', () => {}))).toBe(
+    true,
+  )
 
   expect(
-    isHandlerKind('RequestHandler')(
-      new GraphQLHandler('all', '*', '*', () => {}),
-    ),
+    isHandlerKind('request')(new GraphQLHandler('all', '*', '*', () => {})),
   ).toBe(true)
 })
 
@@ -25,24 +23,24 @@ it('returns true if expected a request handler and given a custom request handle
     log() {}
   }
 
-  expect(isHandlerKind('RequestHandler')(new MyHandler())).toBe(true)
+  expect(isHandlerKind('request')(new MyHandler())).toBe(true)
 })
 
 it('returns false if expected a request handler but given event handler', () => {
-  expect(isHandlerKind('RequestHandler')(new WebSocketHandler('*'))).toBe(false)
+  expect(isHandlerKind('request')(new WebSocketHandler('*'))).toBe(false)
 })
 
 it('returns false if expected a request handler but given arbitrary object', () => {
-  expect(isHandlerKind('RequestHandler')(undefined)).toBe(false)
-  expect(isHandlerKind('RequestHandler')(null)).toBe(false)
-  expect(isHandlerKind('RequestHandler')({})).toBe(false)
-  expect(isHandlerKind('RequestHandler')([])).toBe(false)
-  expect(isHandlerKind('RequestHandler')(123)).toBe(false)
-  expect(isHandlerKind('RequestHandler')('hello')).toBe(false)
+  expect(isHandlerKind('request')(undefined)).toBe(false)
+  expect(isHandlerKind('request')(null)).toBe(false)
+  expect(isHandlerKind('request')({})).toBe(false)
+  expect(isHandlerKind('request')([])).toBe(false)
+  expect(isHandlerKind('request')(123)).toBe(false)
+  expect(isHandlerKind('request')('hello')).toBe(false)
 })
 
 it('returns true if expected an event handler and given an event handler', () => {
-  expect(isHandlerKind('EventHandler')(new WebSocketHandler('*'))).toBe(true)
+  expect(isHandlerKind('websocket')(new WebSocketHandler('*'))).toBe(true)
 })
 
 it('returns true if expected an event handler and given a custom event handler', () => {
@@ -51,14 +49,14 @@ it('returns true if expected an event handler and given a custom event handler',
       super('*')
     }
   }
-  expect(isHandlerKind('EventHandler')(new MyEventHandler())).toBe(true)
+  expect(isHandlerKind('websocket')(new MyEventHandler())).toBe(true)
 })
 
 it('returns false if expected an event handler but given arbitrary object', () => {
-  expect(isHandlerKind('EventHandler')(undefined)).toBe(false)
-  expect(isHandlerKind('EventHandler')(null)).toBe(false)
-  expect(isHandlerKind('EventHandler')({})).toBe(false)
-  expect(isHandlerKind('EventHandler')([])).toBe(false)
-  expect(isHandlerKind('EventHandler')(123)).toBe(false)
-  expect(isHandlerKind('EventHandler')('hello')).toBe(false)
+  expect(isHandlerKind('websocket')(undefined)).toBe(false)
+  expect(isHandlerKind('websocket')(null)).toBe(false)
+  expect(isHandlerKind('websocket')({})).toBe(false)
+  expect(isHandlerKind('websocket')([])).toBe(false)
+  expect(isHandlerKind('websocket')(123)).toBe(false)
+  expect(isHandlerKind('websocket')('hello')).toBe(false)
 })

package/src/core/utils/internal/isHandlerKind.ts

@@ -1,21 +1,17 @@
-import type { HandlerKind } from '../../handlers/common'
+import type { AnyHandler } from '../../experimental/handlers-controller'
 import type { RequestHandler } from '../../handlers/RequestHandler'
 import type { WebSocketHandler } from '../../handlers/WebSocketHandler'
+import { isObject } from './isObject'
 
 /**
  * A filter function that ensures that the provided argument
  * is a handler of the given kind. This helps differentiate
  * between different kinds of handlers, e.g. request and event handlers.
  */
-export function isHandlerKind<K extends HandlerKind>(kind: K) {
+export function isHandlerKind<K extends AnyHandler['kind']>(kind: K) {
   return (
     input: unknown,
-  ): input is K extends 'EventHandler' ? WebSocketHandler : RequestHandler => {
-    return (
-      input != null &&
-      typeof input === 'object' &&
-      '__kind' in input &&
-      input.__kind === kind
-    )
+  ): input is K extends 'websocket' ? WebSocketHandler : RequestHandler => {
+    return isObject(input) && 'kind' in input && input.kind === kind
   }
 }

package/src/core/utils/matching/matchRequestUrl.test.ts

@@ -1,6 +1,4 @@
-/**
- * @vitest-environment jsdom
- */
+// @vitest-environment jsdom
 import { coercePath, matchRequestUrl } from './matchRequestUrl'
 
 describe('matchRequestUrl', () => {
@@ -87,6 +85,77 @@ describe('matchRequestUrl', () => {
     })
   })
 
+  test('returns true when matching URLs with wildcard ports', () => {
+    expect
+      .soft(
+        matchRequestUrl(new URL('http://localhost:3000'), 'http://localhost:*'),
+      )
+      .toEqual({
+        matches: true,
+        params: {
+          '0': '3000/',
+        },
+      })
+
+    expect
+      .soft(
+        matchRequestUrl(
+          new URL('http://localhost:3000'),
+          'http://localhost:*/',
+        ),
+      )
+      .toEqual({
+        matches: true,
+        params: {
+          '0': '3000',
+        },
+      })
+  })
+
+  test('returns true when matching URLs with wildcard ports and pathnames', () => {
+    expect(
+      matchRequestUrl(
+        new URL('http://localhost:3000/resource'),
+        'http://localhost:*/resource',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        '0': '3000',
+      },
+    })
+  })
+
+  test('matches wildcard ports with other wildcard parameters', () => {
+    expect(
+      matchRequestUrl(
+        new URL('http://subdomain.localhost:3000/user/settings'),
+        'http://*.localhost:*/user/*',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        '0': 'subdomain',
+        '1': '3000',
+        '2': 'settings',
+      },
+    })
+  })
+
+  test('matches wildcard ports that also match a part of the pathname', () => {
+    expect(
+      matchRequestUrl(
+        new URL('http://localhost:3000/user/settings'),
+        'http://localhost:*/settings',
+      ),
+    ).toEqual({
+      matches: true,
+      params: {
+        '0': '3000/user',
+      },
+    })
+  })
+
   test('returns true for matching WebSocket URL', () => {
     expect(
       matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://test.mswjs.io'),
@@ -130,6 +199,17 @@ describe('matchRequestUrl', () => {
       },
     })
   })
+
+  test('returns true for matching WebSocket URLs with wildcard ports', () => {
+    expect(
+      matchRequestUrl(new URL('ws://localhost:3000'), 'ws://localhost:*'),
+    ).toEqual({
+      matches: true,
+      params: {
+        '0': '3000/',
+      },
+    })
+  })
 })
 
 describe('coercePath', () => {
@@ -156,6 +236,10 @@ describe('coercePath', () => {
     expect(coercePath('https://example.com:8080/:5678')).toEqual(
       'https\\://example.com\\:8080/:5678',
     )
+    expect(coercePath('http://localhost:*')).toEqual(
+      'http\\://localhost\\:(.*)',
+    )
+    expect(coercePath('ws://localhost:*')).toEqual('ws\\://localhost\\:(.*)')
   })
 
   test('replaces wildcard with an unnnamed capturing group', () => {

package/src/core/utils/matching/matchRequestUrl.ts

@@ -40,9 +40,9 @@ export function coercePath(path: string): string {
       )
       /**
        * Escape the port so that "path-to-regexp" can match
-       * absolute URLs including port numbers.
+       * absolute URLs with numeric or wildcard ports.
        */
-      .replace(/([^/])(:)(?=\d+)/, '$1\\$2')
+      .replace(/([^/])(:)(?=(?:\d+|\(\.\*\))(?=\/|$))/, '$1\\$2')
       /**
        * Escape the protocol so that "path-to-regexp" could match
        * absolute URL.

package/src/core/utils/request/onUnhandledRequest.ts

@@ -3,8 +3,8 @@ import { InternalError, devUtils } from '../internal/devUtils'
 import { isCommonAssetRequest } from '../../isCommonAssetRequest'
 
 export interface UnhandledRequestPrint {
-  warning(): void
-  error(): void
+  warning: () => void
+  error: () => void
 }
 
 export type UnhandledRequestCallback = (

package/src/core/ws/WebSocketClientManager.test.ts

@@ -1,14 +1,11 @@
 // @vitest-environment node-websocket
 import { setMaxListeners } from 'node:events'
-import {
-  WebSocketClientConnection,
-  WebSocketData,
-  WebSocketTransport,
-} from '@mswjs/interceptors/WebSocket'
+import { WebSocketClientConnection } from '@mswjs/interceptors/WebSocket'
 import {
   WebSocketClientManager,
   WebSocketBroadcastChannelMessage,
 } from './WebSocketClientManager'
+import { TestWebSocketTransport } from '../../../test/support/ws-test-utils'
 
 const channel = new BroadcastChannel('test:channel')
 
@@ -23,11 +20,6 @@ vi.spyOn(channel, 'postMessage')
 
 const socket = new WebSocket('ws://localhost')
 
-class TestWebSocketTransport extends EventTarget implements WebSocketTransport {
-  send(_data: WebSocketData): void {}
-  close(_code?: number | undefined, _reason?: string | undefined): void {}
-}
-
 afterEach(() => {
   vi.resetAllMocks()
 })

package/src/core/ws/handleWebSocketEvent.ts

@@ -17,7 +17,11 @@ interface HandleWebSocketEventOptions {
 
 export function handleWebSocketEvent(options: HandleWebSocketEventOptions) {
   webSocketInterceptor.on('connection', async (connection) => {
-    const handlers = options.getHandlers().filter(isHandlerKind('EventHandler'))
+    /**
+     * @todo @fixme Reference the handlers controller here and use `.getHandlersByKind`.
+     * That one relies on the pre-grouped handlers map and will be more performant.
+     */
+    const handlers = options.getHandlers().filter(isHandlerKind('websocket'))
 
     // Ignore this connection if the user hasn't defined any handlers.
     if (handlers.length > 0) {

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

@@ -18,8 +18,9 @@ export const colors = {
 
 export function attachWebSocketLogger(
   connection: WebSocketConnectionData,
-): void {
+): () => void {
   const { client, server } = connection
+  const controller = new AbortController()
 
   logConnectionOpen(client)
 
@@ -30,19 +31,32 @@ export function attachWebSocketLogger(
    * @todo Provide the reference to the exact event handler
    * that called this `client.send()`.
    */
-  client.addEventListener('message', (event) => {
-    logOutgoingClientMessage(event)
-  })
+  client.addEventListener(
+    'message',
+    (event) => {
+      logOutgoingClientMessage(event)
+    },
+    { signal: controller.signal },
+  )
 
-  client.addEventListener('close', (event) => {
-    logConnectionClose(event)
-  })
+  client.addEventListener(
+    'close',
+    (event) => {
+      logConnectionClose(event)
+    },
+    { signal: controller.signal },
+  )
 
   // Log client errors (connection closures due to errors).
-  client.socket.addEventListener('error', (event) => {
-    logClientError(event)
-  })
+  client.socket.addEventListener(
+    'error',
+    (event) => {
+      logClientError(event)
+    },
+    { signal: controller.signal },
+  )
 
+  const { send: originalClientSend } = client
   client.send = new Proxy(client.send, {
     apply(target, thisArg, args) {
       const [data] = args
@@ -75,11 +89,15 @@ export function attachWebSocketLogger(
         logIncomingServerMessage(event)
       })
     },
-    { once: true },
+    {
+      once: true,
+      signal: controller.signal,
+    },
   )
 
   // Log outgoing client events initiated by the event handler.
   // The actual client never sent these but the handler did.
+  const { send: originalServerSend } = server
   server.send = new Proxy(server.send, {
     apply(target, thisArg, args) {
       const [data] = args
@@ -102,6 +120,20 @@ export function attachWebSocketLogger(
       return Reflect.apply(target, thisArg, args)
     },
   })
+
+  // Undo method proxies.
+  controller.signal.addEventListener(
+    'abort',
+    () => {
+      client.send = originalClientSend
+      server.send = originalServerSend
+    },
+    { once: true },
+  )
+
+  return () => {
+    controller.abort()
+  }
 }
 
 /**

package/src/core/ws.test.ts

@@ -1,6 +1,4 @@
-/**
- * @vitest-environment node-websocket
- */
+// @vitest-environment node-websocket
 import { ws } from './ws'
 
 it('exports the "link()" method', () => {

package/src/core/ws.ts

@@ -9,7 +9,7 @@ import {
   type WebSocketHandlerEventMap,
 } from './handlers/WebSocketHandler'
 import { hasRefCounted } from './utils/internal/hasRefCounted'
-import { Path, isPath } from './utils/matching/matchRequestUrl'
+import { type Path, isPath } from './utils/matching/matchRequestUrl'
 import { WebSocketClientManager } from './ws/WebSocketClientManager'
 
 const webSocketChannel = new BroadcastChannel('msw:websocket-client-manager')
@@ -42,10 +42,10 @@ export type WebSocketLink = {
    *
    * @see {@link https://mswjs.io/docs/api/ws#onevent-listener `on()` API reference}
    */
-  addEventListener<EventType extends keyof WebSocketHandlerEventMap>(
+  addEventListener: <EventType extends keyof WebSocketHandlerEventMap>(
     event: EventType,
     listener: WebSocketEventListener<EventType>,
-  ): WebSocketHandler
+  ) => WebSocketHandler
 
   /**
    * Broadcasts the given data to all WebSocket clients.
@@ -58,7 +58,7 @@ export type WebSocketLink = {
    *
    * @see {@link https://mswjs.io/docs/api/ws#broadcastdata `broadcast()` API reference}
    */
-  broadcast(data: WebSocketData): void
+  broadcast: (data: WebSocketData) => void
 
   /**
    * Broadcasts the given data to all WebSocket clients
@@ -72,12 +72,12 @@ export type WebSocketLink = {
    *
    * @see {@link https://mswjs.io/docs/api/ws#broadcastexceptclients-data `broadcast()` API reference}
    */
-  broadcastExcept(
+  broadcastExcept: (
     clients:
       | WebSocketClientConnectionProtocol
       | Array<WebSocketClientConnectionProtocol>,
     data: WebSocketData,
-  ): void
+  ) => void
 }
 
 /**

package/src/iife/index.ts

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

package/src/native/index.ts

@@ -1,21 +1,44 @@
+import type { Interceptor } from '@mswjs/interceptors'
 import { FetchInterceptor } from '@mswjs/interceptors/fetch'
 import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
-import type { RequestHandler } from '~/core/handlers/RequestHandler'
-import { SetupServerCommonApi } from '../node/SetupServerCommonApi'
+import { type AnyHandler } from '#core/experimental/handlers-controller'
+import {
+  defineNetwork,
+  DefineNetworkOptions,
+} from '#core/experimental/define-network'
+import { InterceptorSource } from '#core/experimental/sources/interceptor-source'
+import { type SetupServerCommon } from '../node/glossary'
+import { defineSetupServerApi } from '../node/setup-server-common'
+
+const defaultInterceptors: Array<Interceptor<any>> = [
+  new FetchInterceptor(),
+  new XMLHttpRequestInterceptor(),
+]
+
+export const defaultNetworkOptions: DefineNetworkOptions<[InterceptorSource]> =
+  {
+    sources: [
+      new InterceptorSource({
+        interceptors: defaultInterceptors,
+      }),
+    ],
+    onUnhandledFrame: 'warn',
+    context: {
+      quiet: true,
+    },
+  }
 
 /**
  * Sets up a requests interception in React Native with the given request handlers.
- * @param {RequestHandler[]} handlers List of request handlers.
+ * @param {Array<AnyHandler>} handlers List of request handlers.
  *
  * @see {@link https://mswjs.io/docs/api/setup-server `setupServer()` API reference}
  */
-export function setupServer(
-  ...handlers: Array<RequestHandler>
-): SetupServerCommonApi {
-  // Provision request interception via patching the `XMLHttpRequest` class only
-  // in React Native. There is no `http`/`https` modules in that environment.
-  return new SetupServerCommonApi(
-    [new FetchInterceptor(), new XMLHttpRequestInterceptor()],
+export function setupServer(...handlers: Array<AnyHandler>): SetupServerCommon {
+  const network = defineNetwork({
+    ...defaultNetworkOptions,
     handlers,
-  )
+  })
+
+  return defineSetupServerApi(network)
 }

package/src/node/async-handlers-controller.test.ts

@@ -0,0 +1,50 @@
+import { http } from '../core/http'
+import { AsyncHandlersController } from './async-handlers-controller'
+
+it('respects initial handlers in the boundary', () => {
+  {
+    const controller = new AsyncHandlersController([])
+    controller.boundary(() => {
+      expect(controller.currentHandlers()).toEqual([])
+    })()
+  }
+
+  {
+    const initialHandlers = [http.get('/', () => {})]
+    const controller = new AsyncHandlersController(initialHandlers)
+    controller.boundary(() => {
+      expect(controller.currentHandlers()).toEqual(initialHandlers)
+    })()
+  }
+})
+
+it('provides boundary-specific overrides', () => {
+  const initialHandlers = [http.get('/one', () => {})]
+  const controller = new AsyncHandlersController(initialHandlers)
+
+  controller.boundary(() => {
+    const runtimeHandlers = [http.get('/two', () => {})]
+    controller.use(runtimeHandlers)
+    expect(controller.currentHandlers()).toEqual([
+      ...runtimeHandlers,
+      ...initialHandlers,
+    ])
+  })()
+
+  expect(controller.currentHandlers()).toEqual(initialHandlers)
+})
+
+it('resets the handlers in the boundary', () => {
+  const initialHandlers = [http.get('/one', () => {})]
+  const controller = new AsyncHandlersController(initialHandlers)
+
+  controller.boundary(() => {
+    const runtimeHandlers = [http.get('/two', () => {})]
+    controller.use(runtimeHandlers)
+    controller.reset([])
+
+    expect(controller.currentHandlers()).toEqual(initialHandlers)
+  })()
+
+  expect(controller.currentHandlers()).toEqual(initialHandlers)
+})

package/src/node/async-handlers-controller.ts

@@ -0,0 +1,69 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import {
+  type AnyHandler,
+  type HandlersMap,
+  HandlersController,
+  HandlersControllerState,
+} from '#core/experimental/handlers-controller'
+
+export interface AsyncHandlersControllerContext {
+  initialHandlers: HandlersMap
+  handlers: HandlersMap
+}
+
+export class AsyncHandlersController extends HandlersController {
+  #asyncContext: AsyncLocalStorage<AsyncHandlersControllerContext>
+  #fallbackContext: AsyncHandlersControllerContext
+
+  constructor(initialHandlers: Array<AnyHandler>) {
+    super()
+
+    const initialState = this.getInitialState(initialHandlers)
+
+    this.#asyncContext = new AsyncLocalStorage()
+    this.#fallbackContext = {
+      initialHandlers: initialState.initialHandlers,
+      handlers: initialState.handlers,
+    }
+  }
+
+  protected getState() {
+    const { initialHandlers, handlers } = this.#getContext()
+
+    return {
+      initialHandlers,
+      handlers,
+    }
+  }
+
+  protected setState(nextState: HandlersControllerState): void {
+    const context = this.#getContext()
+
+    if (nextState.initialHandlers) {
+      context.initialHandlers = nextState.initialHandlers
+    }
+
+    if (nextState.handlers) {
+      context.handlers = nextState.handlers
+    }
+  }
+
+  public boundary<Args extends Array<any>, R>(callback: (...args: Args) => R) {
+    return (...args: Args) => {
+      const initialHandlers = { ...this.getState().handlers }
+
+      return this.#asyncContext.run(
+        {
+          initialHandlers,
+          handlers: { ...initialHandlers },
+        },
+        callback,
+        ...args,
+      )
+    }
+  }
+
+  #getContext() {
+    return this.#asyncContext.getStore() || this.#fallbackContext
+  }
+}