msw 2.5.2 → 2.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.5.2",
+  "version": "2.6.1",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "./lib/core/index.js",
   "module": "./lib/core/index.mjs",
@@ -58,6 +58,12 @@
       "import": "./lib/core/graphql.mjs",
       "default": "./lib/core/graphql.js"
     },
+    "./core/ws": {
+      "types": "./lib/core/ws.d.ts",
+      "require": "./lib/core/ws.js",
+      "import": "./lib/core/ws.mjs",
+      "default": "./lib/core/ws.js"
+    },
     "./mockServiceWorker.js": "./lib/mockServiceWorker.js",
     "./package.json": "./package.json"
   },
@@ -118,6 +124,7 @@
     "@bundled-es-modules/tough-cookie": "^0.1.6",
     "@inquirer/confirm": "^5.0.0",
     "@mswjs/interceptors": "^0.36.5",
+    "@open-draft/deferred-promise": "^2.2.0",
     "@open-draft/until": "^2.1.0",
     "@types/cookie": "^0.6.0",
     "@types/statuses": "^2.0.4",
@@ -134,6 +141,7 @@
   "devDependencies": {
     "@commitlint/cli": "^18.4.4",
     "@commitlint/config-conventional": "^18.4.4",
+    "@fastify/websocket": "^8.3.1",
     "@open-draft/test-server": "^0.4.2",
     "@ossjs/release": "^0.8.1",
     "@playwright/test": "^1.48.0",
@@ -157,6 +165,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "express": "^5.0.0",
+    "fastify": "^4.26.0",
     "fs-extra": "^11.2.0",
     "fs-teardown": "^0.3.0",
     "glob": "^11.0.0",

package/src/browser/setupWorker/glossary.ts

@@ -5,13 +5,11 @@ import {
   SharedOptions,
 } from '~/core/sharedOptions'
 import { ServiceWorkerMessage } from './start/utils/createMessageChannel'
-import {
-  RequestHandler,
-  RequestHandlerDefaultInfo,
-} from '~/core/handlers/RequestHandler'
+import { RequestHandler } from '~/core/handlers/RequestHandler'
 import type { HttpRequestEventMap, Interceptor } from '@mswjs/interceptors'
-import { Path } from '~/core/utils/matching/matchRequestUrl'
-import { RequiredDeep } from '~/core/typeUtils'
+import type { Path } from '~/core/utils/matching/matchRequestUrl'
+import type { RequiredDeep } from '~/core/typeUtils'
+import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
 
 export type ResolvedPath = Path | URL
 
@@ -92,7 +90,7 @@ export interface SetupWorkerInternalContext {
   startOptions: RequiredDeep<StartOptions>
   worker: ServiceWorker | null
   registration: ServiceWorkerRegistration | null
-  getRequestHandlers(): Array<RequestHandler>
+  getRequestHandlers(): Array<RequestHandler | WebSocketHandler>
   requests: Map<string, Request>
   emitter: Emitter<LifeCycleEventsMap>
   keepAliveInterval?: number
@@ -216,7 +214,7 @@ export interface SetupWorker {
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/use `worker.use()` API reference}
    */
-  use: (...handlers: RequestHandler[]) => void
+  use: (...handlers: Array<RequestHandler | WebSocketHandler>) => void
 
   /**
    * Marks all request handlers that respond using `res.once()` as unused.
@@ -231,14 +229,16 @@ export interface SetupWorker {
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/reset-handlers `worker.resetHandlers()` API reference}
    */
-  resetHandlers: (...nextHandlers: RequestHandler[]) => void
+  resetHandlers: (
+    ...nextHandlers: Array<RequestHandler | WebSocketHandler>
+  ) => void
 
   /**
    * Returns a readonly list of currently active request handlers.
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/list-handlers `worker.listHandlers()` API reference}
    */
-  listHandlers(): ReadonlyArray<RequestHandler<RequestHandlerDefaultInfo, any>>
+  listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>
 
   /**
    * Life-cycle events.

package/src/browser/setupWorker/setupWorker.ts

@@ -18,9 +18,13 @@ import { createFallbackStop } from './stop/createFallbackStop'
 import { devUtils } from '~/core/utils/internal/devUtils'
 import { SetupApi } from '~/core/SetupApi'
 import { mergeRight } from '~/core/utils/internal/mergeRight'
-import { LifeCycleEventsMap } from '~/core/sharedOptions'
+import type { LifeCycleEventsMap } from '~/core/sharedOptions'
+import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
 import { SetupWorker } from './glossary'
 import { supportsReadableStreamTransfer } from '../utils/supportsReadableStreamTransfer'
+import { webSocketInterceptor } from '~/core/ws/webSocketInterceptor'
+import { handleWebSocketEvent } from '~/core/ws/handleWebSocketEvent'
+import { attachWebSocketLogger } from '~/core/ws/utils/attachWebSocketLogger'
 
 interface Listener {
   target: EventTarget
@@ -37,7 +41,7 @@ export class SetupWorkerApi
   private stopHandler: StopHandler = null as any
   private listeners: Array<Listener>
 
-  constructor(...handlers: Array<RequestHandler>) {
+  constructor(...handlers: Array<RequestHandler | WebSocketHandler>) {
     super(...handlers)
 
     invariant(
@@ -176,6 +180,29 @@ export class SetupWorkerApi
       options,
     ) as SetupWorkerInternalContext['startOptions']
 
+    // Enable the WebSocket interception.
+    handleWebSocketEvent({
+      getUnhandledRequestStrategy: () => {
+        return this.context.startOptions.onUnhandledRequest
+      },
+      getHandlers: () => {
+        return this.handlersController.currentHandlers()
+      },
+      onMockedConnection: (connection) => {
+        if (!this.context.startOptions.quiet) {
+          // Attach the logger for mocked connections since
+          // those won't be visible in the browser's devtools.
+          attachWebSocketLogger(connection)
+        }
+      },
+      onPassthroughConnection() {},
+    })
+    webSocketInterceptor.apply()
+
+    this.subscriptions.push(() => {
+      webSocketInterceptor.dispose()
+    })
+
     return await this.startHandler(this.context.startOptions, options)
   }
 
@@ -193,6 +220,8 @@ export class SetupWorkerApi
  *
  * @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker()` API reference}
  */
-export function setupWorker(...handlers: Array<RequestHandler>): SetupWorker {
+export function setupWorker(
+  ...handlers: Array<RequestHandler | WebSocketHandler>
+): SetupWorker {
   return new SetupWorkerApi(...handlers)
 }

package/src/browser/setupWorker/start/createFallbackRequestListener.ts

@@ -8,6 +8,7 @@ import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
 import { SetupWorkerInternalContext, StartOptions } from '../glossary'
 import type { RequiredDeep } from '~/core/typeUtils'
 import { handleRequest } from '~/core/utils/handleRequest'
+import { isHandlerKind } from '~/core/utils/internal/isHandlerKind'
 
 export function createFallbackRequestListener(
   context: SetupWorkerInternalContext,
@@ -24,7 +25,7 @@ export function createFallbackRequestListener(
     const response = await handleRequest(
       request,
       requestId,
-      context.getRequestHandlers(),
+      context.getRequestHandlers().filter(isHandlerKind('RequestHandler')),
       options,
       context.emitter,
       {

package/src/browser/setupWorker/start/createRequestListener.ts

@@ -13,6 +13,7 @@ import { handleRequest } from '~/core/utils/handleRequest'
 import { RequiredDeep } from '~/core/typeUtils'
 import { devUtils } from '~/core/utils/internal/devUtils'
 import { toResponseInit } from '~/core/utils/toResponseInit'
+import { isHandlerKind } from '~/core/utils/internal/isHandlerKind'
 
 export const createRequestListener = (
   context: SetupWorkerInternalContext,
@@ -43,7 +44,7 @@ export const createRequestListener = (
       await handleRequest(
         request,
         requestId,
-        context.getRequestHandlers(),
+        context.getRequestHandlers().filter(isHandlerKind('RequestHandler')),
         options,
         context.emitter,
         {

package/src/browser/setupWorker/start/createStartHandler.ts

@@ -71,6 +71,11 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
         // Make sure we're always clearing the interval - there are reports that not doing this can
         // cause memory leaks in headless browser environments.
         window.clearInterval(context.keepAliveInterval)
+
+        // Notify others about this client disconnecting.
+        // E.g. this will purge the in-memory WebSocket clients since
+        // starting the worker again will assign them new IDs.
+        window.postMessage({ type: 'msw/worker:stop' })
       })
 
       // Check if the active Service Worker has been generated

package/src/browser/setupWorker/stop/createStop.ts

@@ -24,6 +24,12 @@ export const createStop = (
     context.isMockingEnabled = false
     window.clearInterval(context.keepAliveInterval)
 
+    // Post the internal stop message on the window
+    // to let any logic know when the worker has stopped.
+    // E.g. the WebSocket client manager needs this to know
+    // when to clear its in-memory clients list.
+    window.postMessage({ type: 'msw/worker:stop' })
+
     printStopMessage({ quiet: context.startOptions?.quiet })
   }
 }

package/src/core/SetupApi.ts

@@ -1,38 +1,42 @@
 import { invariant } from 'outvariant'
 import { EventMap, Emitter } from 'strict-event-emitter'
-import {
-  RequestHandler,
-  RequestHandlerDefaultInfo,
-} from './handlers/RequestHandler'
+import { RequestHandler } from './handlers/RequestHandler'
 import { LifeCycleEventEmitter } from './sharedOptions'
 import { devUtils } from './utils/internal/devUtils'
 import { pipeEvents } from './utils/internal/pipeEvents'
 import { toReadonlyArray } from './utils/internal/toReadonlyArray'
 import { Disposable } from './utils/internal/Disposable'
+import type { WebSocketHandler } from './handlers/WebSocketHandler'
 
 export abstract class HandlersController {
-  abstract prepend(runtimeHandlers: Array<RequestHandler>): void
-  abstract reset(nextHandles: Array<RequestHandler>): void
-  abstract currentHandlers(): Array<RequestHandler>
+  abstract prepend(
+    runtimeHandlers: Array<RequestHandler | WebSocketHandler>,
+  ): void
+  abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void
+  abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>
 }
 
 export class InMemoryHandlersController implements HandlersController {
-  private handlers: Array<RequestHandler>
+  private handlers: Array<RequestHandler | WebSocketHandler>
 
-  constructor(private initialHandlers: Array<RequestHandler>) {
+  constructor(
+    private initialHandlers: Array<RequestHandler | WebSocketHandler>,
+  ) {
     this.handlers = [...initialHandlers]
   }
 
-  public prepend(runtimeHandles: Array<RequestHandler>): void {
+  public prepend(
+    runtimeHandles: Array<RequestHandler | WebSocketHandler>,
+  ): void {
     this.handlers.unshift(...runtimeHandles)
   }
 
-  public reset(nextHandlers: Array<RequestHandler>): void {
+  public reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void {
     this.handlers =
       nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers]
   }
 
-  public currentHandlers(): Array<RequestHandler> {
+  public currentHandlers(): Array<RequestHandler | WebSocketHandler> {
     return this.handlers
   }
 }
@@ -47,7 +51,7 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
 
   public readonly events: LifeCycleEventEmitter<EventsMap>
 
-  constructor(...initialHandlers: Array<RequestHandler>) {
+  constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>) {
     super()
 
     invariant(
@@ -71,12 +75,14 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
     })
   }
 
-  private validateHandlers(handlers: ReadonlyArray<RequestHandler>): boolean {
+  private validateHandlers(handlers: ReadonlyArray<unknown>): boolean {
     // Guard against incorrect call signature of the setup API.
     return handlers.every((handler) => !Array.isArray(handler))
   }
 
-  public use(...runtimeHandlers: Array<RequestHandler>): void {
+  public use(
+    ...runtimeHandlers: Array<RequestHandler | WebSocketHandler>
+  ): void {
     invariant(
       this.validateHandlers(runtimeHandlers),
       devUtils.formatMessage(
@@ -89,17 +95,19 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
 
   public restoreHandlers(): void {
     this.handlersController.currentHandlers().forEach((handler) => {
-      handler.isUsed = false
+      if ('isUsed' in handler) {
+        handler.isUsed = false
+      }
     })
   }
 
-  public resetHandlers(...nextHandlers: Array<RequestHandler>): void {
+  public resetHandlers(
+    ...nextHandlers: Array<RequestHandler | WebSocketHandler>
+  ): void {
     this.handlersController.reset(nextHandlers)
   }
 
-  public listHandlers(): ReadonlyArray<
-    RequestHandler<RequestHandlerDefaultInfo, any, any>
-  > {
+  public listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler> {
     return toReadonlyArray(this.handlersController.currentHandlers())
   }
 

package/src/core/handlers/RequestHandler.ts

@@ -7,6 +7,7 @@ import {
 import type { ResponseResolutionContext } from '../utils/executeHandlers'
 import type { MaybePromise } from '../typeUtils'
 import { StrictRequest, StrictResponse } from '..//HttpResponse'
+import type { HandlerKind } from './common'
 
 export type DefaultRequestMultipartBody = Record<
   string,
@@ -117,6 +118,8 @@ export abstract class RequestHandler<
     StrictRequest<DefaultBodyType>
   >()
 
+  private readonly __kind: HandlerKind
+
   public info: HandlerInfo & RequestHandlerInternalInfo
   /**
    * Indicates whether this request handler has been used
@@ -151,6 +154,7 @@ export abstract class RequestHandler<
     }
 
     this.isUsed = false
+    this.__kind = 'RequestHandler'
   }
 
   /**

package/src/core/handlers/WebSocketHandler.ts

@@ -0,0 +1,146 @@
+import { Emitter } from 'strict-event-emitter'
+import { createRequestId } from '@mswjs/interceptors'
+import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
+import {
+  type Match,
+  type Path,
+  type PathParams,
+  matchRequestUrl,
+} from '../utils/matching/matchRequestUrl'
+import { getCallFrame } from '../utils/internal/getCallFrame'
+import type { HandlerKind } from './common'
+
+type WebSocketHandlerParsedResult = {
+  match: Match
+}
+
+export type WebSocketHandlerEventMap = {
+  connection: [args: WebSocketHandlerConnection]
+}
+
+export interface WebSocketHandlerConnection extends WebSocketConnectionData {
+  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')
+
+export class WebSocketHandler {
+  private readonly __kind: HandlerKind
+
+  public id: string
+  public callFrame?: string
+
+  protected [kEmitter]: Emitter<WebSocketHandlerEventMap>
+
+  constructor(private readonly url: Path) {
+    this.id = createRequestId()
+
+    this[kEmitter] = new Emitter()
+    this.callFrame = getCallFrame(new Error())
+    this.__kind = 'EventHandler'
+  }
+
+  public parse(args: {
+    event: MessageEvent<WebSocketConnectionData>
+  }): WebSocketHandlerParsedResult {
+    const connection = args.event.data
+    const match = matchRequestUrl(connection.client.url, this.url)
+
+    return {
+      match,
+    }
+  }
+
+  public predicate(args: {
+    event: MessageEvent<WebSocketConnectionData>
+    parsedResult: WebSocketHandlerParsedResult
+  }): boolean {
+    return args.parsedResult.match.matches
+  }
+
+  async [kDispatchEvent](
+    event: MessageEvent<WebSocketConnectionData>,
+  ): Promise<void> {
+    const parsedResult = this.parse({ event })
+    const connection = event.data
+
+    const resolvedConnection: WebSocketHandlerConnection = {
+      ...connection,
+      params: parsedResult.match.params || {},
+    }
+
+    // Support `event.stopPropagation()` for various client/server events.
+    connection.client.addEventListener(
+      'message',
+      createStopPropagationListener(this),
+    )
+    connection.client.addEventListener(
+      'close',
+      createStopPropagationListener(this),
+    )
+
+    connection.server.addEventListener(
+      'open',
+      createStopPropagationListener(this),
+    )
+    connection.server.addEventListener(
+      'message',
+      createStopPropagationListener(this),
+    )
+    connection.server.addEventListener(
+      'error',
+      createStopPropagationListener(this),
+    )
+    connection.server.addEventListener(
+      'close',
+      createStopPropagationListener(this),
+    )
+
+    // Emit the connection event on the handler.
+    // This is what the developer adds listeners for.
+    this[kEmitter].emit('connection', resolvedConnection)
+  }
+}
+
+function createStopPropagationListener(handler: WebSocketHandler) {
+  return function stopPropagationListener(event: Event) {
+    const propagationStoppedAt = Reflect.get(event, 'kPropagationStoppedAt') as
+      | string
+      | undefined
+
+    if (propagationStoppedAt && handler.id !== propagationStoppedAt) {
+      event.stopImmediatePropagation()
+      return
+    }
+
+    Object.defineProperty(event, KOnStopPropagation, {
+      value(this: WebSocketHandler) {
+        Object.defineProperty(event, 'kPropagationStoppedAt', {
+          value: handler.id,
+        })
+      },
+      configurable: true,
+    })
+
+    // Since the same event instance is shared between all client/server objects,
+    // make sure to patch its `stopPropagation` method only once.
+    if (!Reflect.get(event, kStopPropagationPatched)) {
+      event.stopPropagation = new Proxy(event.stopPropagation, {
+        apply: (target, thisArg, args) => {
+          Reflect.get(event, KOnStopPropagation)?.call(handler)
+          return Reflect.apply(target, thisArg, args)
+        },
+      })
+
+      Object.defineProperty(event, kStopPropagationPatched, {
+        value: true,
+        // If something else attempts to redefine this, throw.
+        configurable: false,
+      })
+    }
+  }
+}

package/src/core/handlers/common.ts

@@ -0,0 +1 @@
+export type HandlerKind = 'RequestHandler' | 'EventHandler'

package/src/core/index.ts

@@ -2,13 +2,21 @@ import { checkGlobals } from './utils/internal/checkGlobals'
 
 export { SetupApi } from './SetupApi'
 
-/* Request handlers */
+/* HTTP handlers */
 export { RequestHandler } from './handlers/RequestHandler'
 export { http } from './http'
 export { HttpHandler, HttpMethods } from './handlers/HttpHandler'
 export { graphql } from './graphql'
 export { GraphQLHandler } from './handlers/GraphQLHandler'
 
+/* WebSocket handler */
+export { ws, type WebSocketLink } from './ws'
+export {
+  WebSocketHandler,
+  type WebSocketHandlerEventMap,
+  type WebSocketHandlerConnection,
+} from './handlers/WebSocketHandler'
+
 /* Utils */
 export { matchRequestUrl } from './utils/matching/matchRequestUrl'
 export * from './utils/handleRequest'
@@ -45,6 +53,8 @@ export type {
 } from './handlers/GraphQLHandler'
 export type { GraphQLRequestHandler, GraphQLResponseResolver } from './graphql'
 
+export type { WebSocketData, WebSocketEventListener } from './ws'
+
 export type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'
 export type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'
 

package/src/core/utils/executeHandlers.ts

@@ -1,6 +1,6 @@
 import {
   RequestHandler,
-  RequestHandlerExecutionResult,
+  type RequestHandlerExecutionResult,
 } from '../handlers/RequestHandler'
 
 export interface HandlersExecutionResult {

package/src/core/utils/handleRequest.ts

@@ -1,8 +1,8 @@
 import { until } from '@open-draft/until'
 import { Emitter } from 'strict-event-emitter'
-import { RequestHandler } from '../handlers/RequestHandler'
 import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequiredDeep } from '../typeUtils'
+import type { RequestHandler } from '../handlers/RequestHandler'
 import { HandlersExecutionResult, executeHandlers } from './executeHandlers'
 import { onUnhandledRequest } from './request/onUnhandledRequest'
 import { storeResponseCookies } from './request/storeResponseCookies'

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

@@ -0,0 +1,64 @@
+import { GraphQLHandler } from '../../handlers/GraphQLHandler'
+import { HttpHandler } from '../../handlers/HttpHandler'
+import { RequestHandler } from '../../handlers/RequestHandler'
+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('RequestHandler')(
+      new GraphQLHandler('all', '*', '*', () => {}),
+    ),
+  ).toBe(true)
+})
+
+it('returns true if expected a request handler and given a custom request handler', () => {
+  class MyHandler extends RequestHandler {
+    constructor() {
+      super({ info: { header: '*' }, resolver: () => {} })
+    }
+    predicate = () => false
+    log() {}
+  }
+
+  expect(isHandlerKind('RequestHandler')(new MyHandler())).toBe(true)
+})
+
+it('returns false if expected a request handler but given event handler', () => {
+  expect(isHandlerKind('RequestHandler')(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)
+})
+
+it('returns true if expected an event handler and given an event handler', () => {
+  expect(isHandlerKind('EventHandler')(new WebSocketHandler('*'))).toBe(true)
+})
+
+it('returns true if expected an event handler and given a custom event handler', () => {
+  class MyEventHandler extends WebSocketHandler {
+    constructor() {
+      super('*')
+    }
+  }
+  expect(isHandlerKind('EventHandler')(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)
+})

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

@@ -0,0 +1,21 @@
+import type { HandlerKind } from '../../handlers/common'
+import type { RequestHandler } from '../../handlers/RequestHandler'
+import type { WebSocketHandler } from '../../handlers/WebSocketHandler'
+
+/**
+ * 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) {
+  return (
+    input: unknown,
+  ): input is K extends 'EventHandler' ? WebSocketHandler : RequestHandler => {
+    return (
+      input != null &&
+      typeof input === 'object' &&
+      '__kind' in input &&
+      input.__kind === kind
+    )
+  }
+}