fix: support legacy onUnhandledRequest

Author: kettanaito

src/browser/setup-worker.ts

@@ -6,7 +6,7 @@ import {
   type NetworkApi,
 } from '~/core/new/define-network'
 import {
-  onUnhandledFrame,
+  fromLegacyOnUnhandledRequest,
   UnhandledFrameStrategy,
 } from '~/core/new/on-unhandled-frame'
 import { UnhandledRequestCallback } from '~/core/utils/request/onUnhandledRequest'
@@ -76,44 +76,27 @@ export function setupWorker(
           }),
         ],
         handlers,
-        async onUnhandledFrame({ frame, defaults }) {
-          /**
-           * @note `setupWorker` does not handle unhandled WebSocket events.
-           * This will be a new API in 3.0, most likely. We can remove this
-           * mapping then.
-           */
-          if (
-            frame.protocol === 'http' &&
-            options?.onUnhandledRequest !== undefined
-          ) {
-            if (typeof options.onUnhandledRequest === 'function') {
-              options.onUnhandledRequest(frame.data.request, {
-                warning: defaults.warn,
-                error: defaults.error,
-              })
-            } else {
-              await onUnhandledFrame(frame, 'warn')
-            }
-          }
-        },
+        onUnhandledFrame: fromLegacyOnUnhandledRequest(
+          () => options?.onUnhandledRequest,
+        ),
       })
 
       await network.enable()
     },
-    listHandlers() {
-      return network.listHandlers()
+    stop() {
+      network.disable()
     },
-    use(...handlers) {
-      return network.use(...handlers)
+    get listHandlers() {
+      return network.listHandlers.bind(network)
     },
-    resetHandlers(...handlers) {
-      return network.resetHandlers(...handlers)
+    get use() {
+      return network.use.bind(network)
     },
-    restoreHandlers() {
-      return network.restoreHandlers()
+    get resetHandlers() {
+      return network.resetHandlers.bind(network)
     },
-    stop() {
-      network.disable()
+    get restoreHandlers() {
+      return network.restoreHandlers.bind(network)
     },
   }
 }

src/core/new/define-network.ts

@@ -23,7 +23,7 @@ export interface DefineNetworkOptions<Handler extends AnyHandler> {
   /**
    * A list of the initial handlers.
    */
-  handlers?: Array<Handler>
+  handlers: Array<Handler>
 
   /**
    * A custom handlers controller to use.
@@ -69,8 +69,7 @@ export function defineNetwork<Handler extends AnyHandler>(
   const events = new Emitter()
 
   const handlersController =
-    options.handlersController ||
-    inMemoryHandlersController(options.handlers || [])
+    options.handlersController || inMemoryHandlersController(options.handlers)
 
   return {
     async enable() {
@@ -85,7 +84,18 @@ export function defineNetwork<Handler extends AnyHandler>(
         )
 
         if (!wasFrameHandled) {
-          await onUnhandledFrame(frame, options.onUnhandledFrame || 'bypass')
+          await onUnhandledFrame(
+            frame,
+            options.onUnhandledFrame || 'bypass',
+          ).catch((error) => {
+            /**
+             * @fixme `.errorWith()` should exist on WebSocket frames too
+             * since you can error the connection by dispatching the "error" event.
+             */
+            if (frame.protocol === 'http') {
+              frame.errorWith(error)
+            }
+          })
         }
       })
 

src/core/new/on-unhandled-frame.ts

@@ -1,5 +1,6 @@
 import { isCommonAssetRequest } from '../isCommonAssetRequest'
 import { devUtils, InternalError } from '../utils/internal/devUtils'
+import { UnhandledRequestStrategy } from '../utils/request/onUnhandledRequest'
 import type { NetworkFrame } from './sources/index'
 
 export type UnhandledFrameStrategy = 'bypass' | 'warn' | 'error'
@@ -12,7 +13,7 @@ export type UnhandledFrameDefaults = {
 export type UnhandledFrameCallback = (args: {
   frame: NetworkFrame
   defaults: UnhandledFrameDefaults
-}) => void
+}) => Promise<void> | void
 
 export async function onUnhandledFrame(
   frame: NetworkFrame,
@@ -25,31 +26,43 @@ export async function onUnhandledFrame(
 
     const message = await frame.getUnhandledFrameMessage()
 
-    if (strategy === 'warn') {
-      return devUtils.warn('Warning: %s', message)
-    }
+    switch (strategy) {
+      case 'warn': {
+        return devUtils.warn('Warning: %s', message)
+      }
 
-    if (strategy === 'error') {
-      return devUtils.error('Error: %s', message)
-    }
+      case 'error': {
+        // Print a developer-friendly error.
+        devUtils.error('Error: %s', message)
+
+        return Promise.reject(
+          new Error(
+            devUtils.formatMessage(
+              'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
+            ),
+          ),
+        )
+      }
 
-    throw new InternalError(
-      devUtils.formatMessage(
-        'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
-        strategy,
-      ),
-    )
+      default: {
+        throw new InternalError(
+          devUtils.formatMessage(
+            'Failed to react to an unhandled network frame: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
+            strategy satisfies never,
+          ),
+        )
+      }
+    }
   }
 
   if (typeof strategyOrCallback === 'function') {
-    strategyOrCallback({
+    return strategyOrCallback({
       frame,
       defaults: {
         warn: applyStrategy.bind(null, 'warn'),
         error: applyStrategy.bind(null, 'warn'),
       },
     })
-    return
   }
 
   // Ignore static assets, framework/bundler requests, modules served via HTTP.
@@ -59,3 +72,28 @@ export async function onUnhandledFrame(
 
   await applyStrategy(strategyOrCallback)
 }
+
+export function fromLegacyOnUnhandledRequest(
+  getLegacyValue: () => UnhandledRequestStrategy | undefined,
+): UnhandledFrameCallback {
+  return ({ frame, defaults }) => {
+    if (frame.protocol !== 'http') {
+      return
+    }
+
+    const legacyOnUnhandledRequestStrategy = getLegacyValue()
+
+    if (legacyOnUnhandledRequestStrategy === undefined) {
+      return
+    }
+
+    if (typeof legacyOnUnhandledRequestStrategy === 'function') {
+      return legacyOnUnhandledRequestStrategy(frame.data.request, {
+        warning: defaults.warn,
+        error: defaults.error,
+      })
+    }
+
+    return onUnhandledFrame(frame, legacyOnUnhandledRequestStrategy)
+  }
+}

src/core/new/sources/index.ts

@@ -14,7 +14,7 @@ export abstract class NetworkSource {
    * @param sources A list of network sources.
    */
   static from(...sources: Array<NetworkSource>): NetworkSource {
-    return new BatchNetworkSource(sources)
+    return sources.length > 1 ? new BatchNetworkSource(sources) : sources[0]
   }
 
   protected emitter: Emitter<NetworkSourceEventMap>

src/core/new/sources/interceptor-source.ts

@@ -143,11 +143,11 @@ class InterceptorHttpNetworkFrame extends HttpNetworkFrame {
       return this.respondWith(reason)
     }
 
-    /**
-     * @note We do not currently support the `.errorWith()` flow.
-     * Instead, exceptions are expected to throw as-is to be coerced into 500 responses.
-     */
-    throw reason
+    if (reason instanceof InternalError) {
+      throw reason
+    }
+
+    this.#controller.errorWith(reason as any)
   }
 
   public passthrough(): void {

src/node/setup-server.ts

@@ -9,56 +9,82 @@ import {
   ReversibleProxy,
   reversibleProxy,
 } from '~/core/utils/internal/reversibleProxy'
-import { SetupServerCommonApi } from './setup-server-common'
 import {
   type AsyncHandlersController,
   asyncHandlersController,
 } from './async-handler-controller'
-import type { ListenOptions, SetupServer } from './glossary'
+import type { ListenOptions, SetupServer, SetupServerCommon } from './glossary'
 import { HandlersController } from '~/core/SetupApi'
+import { defineNetwork, NetworkApi } from '~/core/new/define-network'
+import { InterceptorSource } from '~/core/new/sources/interceptor-source'
+import { fromLegacyOnUnhandledRequest } from '~/core/new/on-unhandled-frame'
 
 /**
  * Enables request interception in Node.js with the given request handlers.
  *
  * @see {@link https://mswjs.io/docs/api/setup-server `setupServer()` API reference}
  */
 export function setupServer(...handlers: Array<AnyHandler>): SetupServerApi {
-  return new SetupServerApi(handlers)
+  return new SetupServerApi(handlers, [
+    new ClientRequestInterceptor(),
+    new XMLHttpRequestInterceptor(),
+    new FetchInterceptor(),
+    new WebSocketInterceptor() as any,
+  ])
 }
 
-export class SetupServerApi
-  extends SetupServerCommonApi
-  implements SetupServer
-{
-  #currentHandlersProxy?: ReversibleProxy<HandlersController['currentHandlers']>
+export class SetupServerApi implements SetupServer {
+  public events: SetupServerCommon['events']
+  public use: SetupServerCommon['use']
+  public resetHandlers: SetupServerCommon['resetHandlers']
+  public restoreHandlers: SetupServerCommon['restoreHandlers']
+  public listHandlers: SetupServerCommon['listHandlers']
 
-  protected handlersController: AsyncHandlersController<AnyHandler>
+  #network: NetworkApi<AnyHandler>
+  #handlersController: AsyncHandlersController<AnyHandler>
+  #currentHandlersProxy?: ReversibleProxy<HandlersController['currentHandlers']>
+  #listenOptions?: Partial<ListenOptions>
 
   constructor(
     handlers: Array<AnyHandler>,
-    interceptors: Array<Interceptor<any>> = [
-      new ClientRequestInterceptor(),
-      new XMLHttpRequestInterceptor(),
-      new FetchInterceptor(),
-      new WebSocketInterceptor() as any,
-    ],
+    interceptors: Array<Interceptor<any>> = [],
   ) {
-    const handlersController = asyncHandlersController(handlers)
-    super(interceptors, handlers, handlersController)
+    this.#handlersController = asyncHandlersController(handlers)
+
+    this.#network = defineNetwork({
+      sources: [
+        new InterceptorSource({
+          interceptors,
+        }),
+      ],
+      handlers,
+      handlersController: this.#handlersController,
+      onUnhandledFrame: fromLegacyOnUnhandledRequest(() => {
+        return this.#listenOptions?.onUnhandledRequest
+      }),
+    })
 
-    this.handlersController = handlersController
+    /**
+     * @fixme This expects a readonly emitter (subset of methods).
+     */
+    this.events = this.#network.events as any
+    this.use = this.#network.use.bind(this.#network)
+    this.resetHandlers = this.#network.resetHandlers.bind(this.#network)
+    this.restoreHandlers = this.#network.restoreHandlers.bind(this.#network)
+    this.listHandlers = this.#network.listHandlers.bind(this.#network)
   }
 
   public listen(options?: Partial<ListenOptions>): void {
-    super.listen()
+    this.#listenOptions = options
+    this.#network.enable()
 
     if (options?.remote?.enabled) {
       const remoteRequestHandler = new RemoteRequestHandler({
         port: options.remote.port,
       })
 
       this.#currentHandlersProxy = reversibleProxy(
-        this.handlersController.currentHandlers,
+        this.#handlersController.currentHandlers,
         {
           apply(target, thisArg, argArray) {
             return [
@@ -69,17 +95,18 @@ export class SetupServerApi
         },
       )
 
-      this.handlersController.currentHandlers = this.#currentHandlersProxy.proxy
+      this.#handlersController.currentHandlers =
+        this.#currentHandlersProxy.proxy
     }
   }
 
   public boundary<Args extends Array<any>, R>(
     callback: (...args: Args) => R,
   ): (...args: Args) => R {
     return (...args: Args): R => {
-      return this.handlersController.context.run<any, any>(
+      return this.#handlersController.context.run<any, any>(
         {
-          initialHandlers: this.handlersController.currentHandlers(),
+          initialHandlers: this.#handlersController.currentHandlers(),
           handlers: [],
         },
         callback,
@@ -89,7 +116,7 @@ export class SetupServerApi
   }
 
   public close(): void {
-    super.close()
+    this.#network.disable()
     this.#currentHandlersProxy?.reverse()
   }
 }