fix: add handler input validation to handlers controller

Author: kettanaito

src/core/new/handlers-controller.ts

@@ -1,32 +1,82 @@
+import { invariant } from 'outvariant'
 import { RequestHandler } from '../handlers/RequestHandler'
 import { WebSocketHandler } from '../handlers/WebSocketHandler'
+import { devUtils } from '../utils/internal/devUtils'
 
 export type AnyHandler = RequestHandler | WebSocketHandler
 
-export interface HandlersController<Handler extends AnyHandler = AnyHandler> {
-  currentHandlers(): Array<Handler>
-  use(nextHandlers: Array<Handler>): void
-  reset(nextHandlers: Array<Handler>): void
+export type HandlersControllerFunction<Controller extends HandlersController> =
+  (initialHandlers: Array<AnyHandler>) => Controller
+
+export interface HandlersController {
+  currentHandlers(): Array<AnyHandler>
+  use(nextHandlers: Array<AnyHandler>): void
+  reset(nextHandlers: Array<AnyHandler>): void
+}
+
+export function validateHandlers(handlers: Array<AnyHandler>): boolean {
+  return handlers.every((handler) => !Array.isArray(handler))
+}
+
+export function defineHandlersController<
+  Controller extends HandlersController = HandlersController,
+>(
+  init: HandlersControllerFunction<Controller>,
+): HandlersControllerFunction<Controller> {
+  return (initialHandlers) => {
+    invariant(
+      validateHandlers(initialHandlers),
+      devUtils.formatMessage(
+        'Failed to create a handlers controller: invalid handlers. Did you forget to spread the handlers array?',
+      ),
+    )
+
+    const api = init(initialHandlers)
+
+    return {
+      ...api,
+      use(nextHandlers) {
+        invariant(
+          validateHandlers(nextHandlers),
+          devUtils.formatMessage(
+            'Failed to prepend runtime handlers: invalid handlers. Did you forget to spread the handlers array?',
+          ),
+        )
+
+        return api.use(nextHandlers)
+      },
+      reset(nextHandlers) {
+        invariant(
+          nextHandlers.length > 0 ? validateHandlers(nextHandlers) : true,
+          devUtils.formatMessage(
+            'Failed to replace initial handlers during reset: invalid handlers. Did you forget to spread the handlers array?',
+          ),
+        )
+
+        return api.reset(nextHandlers)
+      },
+    }
+  }
 }
 
 /**
  * A simple handler controller that keeps the list of handlers in memory.
  */
-export function inMemoryHandlersController<Handler extends AnyHandler>(
-  initialHandlers: Array<Handler>,
-): HandlersController<Handler> {
-  let handlers = [...initialHandlers]
-
-  return {
-    currentHandlers() {
-      return handlers
-    },
-    use(nextHandlers) {
-      handlers.unshift(...nextHandlers)
-    },
-    reset(nextHandlers) {
-      handlers =
-        nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers]
-    },
-  }
-}
+export const inMemoryHandlersController = defineHandlersController(
+  (initialHandlers) => {
+    let handlers = [...initialHandlers]
+
+    return {
+      currentHandlers() {
+        return handlers
+      },
+      use(nextHandlers) {
+        handlers.unshift(...nextHandlers)
+      },
+      reset(nextHandlers) {
+        handlers =
+          nextHandlers.length > 0 ? [...nextHandlers] : [...initialHandlers]
+      },
+    }
+  },
+)

src/node/async-handler-controller.ts

@@ -1,45 +1,46 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
-import { HandlersController, AnyHandler } from '~/core/new/handlers-controller'
+import {
+  HandlersController,
+  AnyHandler,
+  defineHandlersController,
+} from '~/core/new/handlers-controller'
 
-export interface AsyncHandlersController<Handler extends AnyHandler>
-  extends HandlersController<Handler> {
-  context: AsyncLocalStorage<AsyncHandlersControllerContext<Handler>>
+export interface AsyncHandlersController extends HandlersController {
+  context: AsyncLocalStorage<AsyncHandlersControllerContext>
 }
 
-export interface AsyncHandlersControllerContext<Handler extends AnyHandler> {
-  initialHandlers: Array<Handler>
-  handlers: Array<Handler>
+export interface AsyncHandlersControllerContext {
+  initialHandlers: Array<AnyHandler>
+  handlers: Array<AnyHandler>
 }
 
-export function asyncHandlersController<Handler extends AnyHandler>(
-  initialHandlers: Array<Handler>,
-): AsyncHandlersController<Handler> {
-  const context = new AsyncLocalStorage<
-    AsyncHandlersControllerContext<Handler>
-  >()
-  const fallbackContext: AsyncHandlersControllerContext<Handler> = {
-    initialHandlers: [...initialHandlers],
-    handlers: [],
-  }
+export const asyncHandlersController =
+  defineHandlersController<AsyncHandlersController>((initialHandlers) => {
+    const context = new AsyncLocalStorage<AsyncHandlersControllerContext>()
 
-  const getContext = () => {
-    return context.getStore() || fallbackContext
-  }
+    const fallbackContext: AsyncHandlersControllerContext = {
+      initialHandlers: [...initialHandlers],
+      handlers: [],
+    }
 
-  return {
-    context,
-    currentHandlers() {
-      const { initialHandlers, handlers } = getContext()
-      return [...handlers, ...initialHandlers]
-    },
-    use(nextHandlers) {
-      getContext().handlers.unshift(...nextHandlers)
-    },
-    reset(nextHandlers) {
-      const context = getContext()
-      context.handlers = []
-      context.initialHandlers =
-        nextHandlers.length > 0 ? nextHandlers : context.initialHandlers
-    },
-  }
-}
+    const getContext = () => {
+      return context.getStore() || fallbackContext
+    }
+
+    return {
+      context,
+      currentHandlers() {
+        const { initialHandlers, handlers } = getContext()
+        return [...handlers, ...initialHandlers]
+      },
+      use(nextHandlers) {
+        getContext().handlers.unshift(...nextHandlers)
+      },
+      reset(nextHandlers) {
+        const context = getContext()
+        context.handlers = []
+        context.initialHandlers =
+          nextHandlers.length > 0 ? nextHandlers : context.initialHandlers
+      },
+    }
+  })

src/node/setup-server.ts

@@ -41,7 +41,7 @@ export class SetupServerApi implements SetupServer {
   public listHandlers: SetupServerCommon['listHandlers']
 
   #network: NetworkApi<AnyHandler>
-  #handlersController: AsyncHandlersController<AnyHandler>
+  #handlersController: AsyncHandlersController
   #currentHandlersProxy?: ReversibleProxy<HandlersController['currentHandlers']>
   #listenOptions?: Partial<ListenOptions>
 

test/node/msw-api/setup-server/input-validation.node.test.ts

@@ -12,6 +12,6 @@ test('throws an error given an Array of request handlers to "setupServer"', () =
   }
 
   expect(createServer).toThrow(
-    `[MSW] Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`,
+    `[MSW] Failed to create a handlers controller: invalid handlers. Did you forget to spread the handlers array?`,
   )
 })

test/node/msw-api/setup-server/use.node.test.ts

@@ -134,6 +134,6 @@ test('throws if provided the invalid handlers array', async () => {
       [http.get('*', () => new Response())],
     ),
   ).toThrow(
-    '[MSW] Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?',
+    '[MSW] Failed to prepend runtime handlers: invalid handlers. Did you forget to spread the handlers array?',
   )
 })