feat(wip): migrate setupServer to the new architecture

Author: kettanaito

src/node/async-handler-controller.ts

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

src/node/index.ts

@@ -1,8 +1,10 @@
 export type { SetupServer, ListenOptions } from './glossary'
 export { SetupServerApi } from './SetupServerApi'
-export { setupServer } from './setupServer'
+// export { setupServer } from './setupServer'
 export {
   setupRemoteServer,
   SetupRemoteServer,
   SetupRemoteServerApi,
 } from './setup-remote-server'
+
+export { setupServer } from './setup-server'

src/node/setup-server-common-api.ts

@@ -0,0 +1,48 @@
+import type { Interceptor } from '@mswjs/interceptors'
+import { defineNetwork, type NetworkApi } from '~/core/new/define-network'
+import type {
+  AnyHandler,
+  HandlersController,
+} from '~/core/new/handlers-controller'
+import { InterceptorSource } from '~/core/new/sources/interceptor-source'
+import type { SetupServerCommon } from './glossary'
+
+export class SetupServerCommonApi implements SetupServerCommon {
+  protected network: NetworkApi<AnyHandler>
+
+  public events: SetupServerCommon['events']
+  public use: SetupServerCommon['use']
+  public resetHandlers: SetupServerCommon['resetHandlers']
+  public restoreHandlers: SetupServerCommon['restoreHandlers']
+  public listHandlers: SetupServerCommon['listHandlers']
+
+  constructor(
+    interceptors: Array<Interceptor<any>> = [],
+    handlers: Array<AnyHandler>,
+    handlersController?: HandlersController<AnyHandler>,
+  ) {
+    this.network = defineNetwork({
+      sources: [
+        new InterceptorSource({
+          interceptors,
+        }),
+      ],
+      handlers,
+      handlersController,
+    })
+
+    this.events = this.network.events
+    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(): void {
+    this.network.enable()
+  }
+
+  public close(): void {
+    this.network.disable()
+  }
+}

src/node/setup-server.ts

@@ -0,0 +1,59 @@
+import { type Interceptor } from '@mswjs/interceptors'
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
+import { FetchInterceptor } from '@mswjs/interceptors/fetch'
+import { WebSocketInterceptor } from '@mswjs/interceptors/WebSocket'
+import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
+import { type AnyHandler } from '~/core/new/handlers-controller'
+import { SetupServerCommonApi } from './setup-server-common-api'
+import {
+  type AsyncHandlersController,
+  asyncHandlersController,
+} from './async-handler-controller'
+import type { SetupServer } from './glossary'
+
+export function setupServer(...handlers: Array<AnyHandler>): SetupServerApi {
+  return new SetupServerApi(handlers)
+}
+
+export class SetupServerApi
+  extends SetupServerCommonApi
+  implements SetupServer
+{
+  protected handlersController: AsyncHandlersController<AnyHandler>
+
+  constructor(
+    handlers: Array<AnyHandler>,
+    interceptors: Array<Interceptor<any>> = [
+      new ClientRequestInterceptor(),
+      new XMLHttpRequestInterceptor(),
+      new FetchInterceptor(),
+      new WebSocketInterceptor(),
+    ],
+  ) {
+    const handlersController = asyncHandlersController(handlers)
+    super(interceptors, handlers, handlersController)
+
+    this.handlersController = handlersController
+  }
+
+  public listen(): void {
+    super.listen()
+
+    /** @todo Check for remote option. */
+  }
+
+  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>(
+        {
+          initialHandlers: this.handlersController.currentHandlers(),
+          handlers: [],
+        },
+        callback,
+        ...args,
+      )
+    }
+  }
+}