msw 2.1.6 → 2.2.0

package/src/node/SetupServerApi.ts

@@ -1,113 +1,82 @@
-import {
-  BatchInterceptor,
-  HttpRequestEventMap,
-  Interceptor,
-  InterceptorReadyState,
-} from '@mswjs/interceptors'
-import { invariant } from 'outvariant'
-import { SetupApi } from '~/core/SetupApi'
-import { RequestHandler } from '~/core/handlers/RequestHandler'
-import { LifeCycleEventsMap, SharedOptions } from '~/core/sharedOptions'
-import { RequiredDeep } from '~/core/typeUtils'
-import { handleRequest } from '~/core/utils/handleRequest'
-import { devUtils } from '~/core/utils/internal/devUtils'
-import { mergeRight } from '~/core/utils/internal/mergeRight'
-import { SetupServer } from './glossary'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
+import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
+import { FetchInterceptor } from '@mswjs/interceptors/fetch'
+import { HandlersController } from '~/core/SetupApi'
+import type { RequestHandler } from '~/core/handlers/RequestHandler'
+import type { SetupServer } from './glossary'
+import { SetupServerCommonApi } from './SetupServerCommonApi'
 
-const DEFAULT_LISTEN_OPTIONS: RequiredDeep<SharedOptions> = {
-  onUnhandledRequest: 'warn',
-}
-
-export class SetupServerApi
-  extends SetupApi<LifeCycleEventsMap>
-  implements SetupServer
-{
-  protected readonly interceptor: BatchInterceptor<
-    Array<Interceptor<HttpRequestEventMap>>,
-    HttpRequestEventMap
-  >
-  private resolvedOptions: RequiredDeep<SharedOptions>
+const store = new AsyncLocalStorage<RequestHandlersContext>()
 
-  constructor(
-    interceptors: Array<{
-      new (): Interceptor<HttpRequestEventMap>
-    }>,
-    ...handlers: Array<RequestHandler>
-  ) {
-    super(...handlers)
+type RequestHandlersContext = {
+  initialHandlers: Array<RequestHandler>
+  handlers: Array<RequestHandler>
+}
 
-    this.interceptor = new BatchInterceptor({
-      name: 'setup-server',
-      interceptors: interceptors.map((Interceptor) => new Interceptor()),
-    })
-    this.resolvedOptions = {} as RequiredDeep<SharedOptions>
+/**
+ * A handlers controller that utilizes `AsyncLocalStorage` in Node.js
+ * to prevent the request handlers list from being a shared state
+ * across mutliple tests.
+ */
+class AsyncHandlersController implements HandlersController {
+  private rootContext: RequestHandlersContext
 
-    this.init()
+  constructor(initialHandlers: Array<RequestHandler>) {
+    this.rootContext = { initialHandlers, handlers: [] }
   }
 
-  /**
-   * Subscribe to all requests that are using the interceptor object
-   */
-  private init(): void {
-    this.interceptor.on('request', async ({ request, requestId }) => {
-      const response = await handleRequest(
-        request,
-        requestId,
-        this.currentHandlers,
-        this.resolvedOptions,
-        this.emitter,
-      )
-
-      if (response) {
-        request.respondWith(response)
-      }
+  get context(): RequestHandlersContext {
+    return store.getStore() || this.rootContext
+  }
 
-      return
-    })
+  public prepend(runtimeHandlers: Array<RequestHandler>) {
+    this.context.handlers.unshift(...runtimeHandlers)
+  }
 
-    this.interceptor.on(
-      'response',
-      ({ response, isMockedResponse, request, requestId }) => {
-        this.emitter.emit(
-          isMockedResponse ? 'response:mocked' : 'response:bypass',
-          {
-            response,
-            request,
-            requestId,
-          },
-        )
-      },
-    )
+  public reset(nextHandlers: Array<RequestHandler>) {
+    const context = this.context
+    context.handlers = []
+    context.initialHandlers =
+      nextHandlers.length > 0 ? nextHandlers : context.initialHandlers
   }
 
-  public listen(options: Partial<SharedOptions> = {}): void {
-    this.resolvedOptions = mergeRight(
-      DEFAULT_LISTEN_OPTIONS,
-      options,
-    ) as RequiredDeep<SharedOptions>
+  public currentHandlers(): Array<RequestHandler> {
+    const { initialHandlers, handlers } = this.context
+    return handlers.concat(initialHandlers)
+  }
+}
 
-    // Apply the interceptor when starting the server.
-    this.interceptor.apply()
+export class SetupServerApi
+  extends SetupServerCommonApi
+  implements SetupServer
+{
+  constructor(handlers: Array<RequestHandler>) {
+    super(
+      [ClientRequestInterceptor, XMLHttpRequestInterceptor, FetchInterceptor],
+      handlers,
+    )
 
-    this.subscriptions.push(() => {
-      this.interceptor.dispose()
-    })
+    this.handlersController = new AsyncHandlersController(handlers)
+  }
 
-    // Assert that the interceptor has been applied successfully.
-    // Also guards us from forgetting to call "interceptor.apply()"
-    // as a part of the "listen" method.
-    invariant(
-      [InterceptorReadyState.APPLYING, InterceptorReadyState.APPLIED].includes(
-        this.interceptor.readyState,
-      ),
-      devUtils.formatMessage(
-        'Failed to start "setupServer": the interceptor failed to apply. This is likely an issue with the library and you should report it at "%s".',
-      ),
-      'https://github.com/mswjs/msw/issues/new/choose',
-    )
+  public boundary<Fn extends (...args: Array<any>) => unknown>(
+    callback: Fn,
+  ): (...args: Parameters<Fn>) => ReturnType<Fn> {
+    return (...args: Parameters<Fn>): ReturnType<Fn> => {
+      return store.run<any, any>(
+        {
+          initialHandlers: this.handlersController.currentHandlers(),
+          handlers: [],
+        },
+        callback,
+        ...args,
+      )
+    }
   }
 
   public close(): void {
-    this.dispose()
+    super.close()
+    store.disable()
   }
 }

package/src/node/SetupServerCommonApi.ts

@@ -0,0 +1,116 @@
+/**
+ * @note This API is extended by both "msw/node" and "msw/native"
+ * so be minding about the things you import!
+ */
+import type { RequiredDeep } from 'type-fest'
+import { invariant } from 'outvariant'
+import {
+  BatchInterceptor,
+  InterceptorReadyState,
+  type HttpRequestEventMap,
+  type Interceptor,
+} from '@mswjs/interceptors'
+import type { LifeCycleEventsMap, SharedOptions } from '~/core/sharedOptions'
+import { SetupApi } from '~/core/SetupApi'
+import { handleRequest } from '~/core/utils/handleRequest'
+import type { RequestHandler } from '~/core/handlers/RequestHandler'
+import { mergeRight } from '~/core/utils/internal/mergeRight'
+import { devUtils } from '~/core/utils/internal/devUtils'
+import type { SetupServerCommon } from './glossary'
+
+export const DEFAULT_LISTEN_OPTIONS: RequiredDeep<SharedOptions> = {
+  onUnhandledRequest: 'warn',
+}
+
+export class SetupServerCommonApi
+  extends SetupApi<LifeCycleEventsMap>
+  implements SetupServerCommon
+{
+  protected readonly interceptor: BatchInterceptor<
+    Array<Interceptor<HttpRequestEventMap>>,
+    HttpRequestEventMap
+  >
+  private resolvedOptions: RequiredDeep<SharedOptions>
+
+  constructor(
+    interceptors: Array<{ new (): Interceptor<HttpRequestEventMap> }>,
+    handlers: Array<RequestHandler>,
+  ) {
+    super(...handlers)
+
+    this.interceptor = new BatchInterceptor({
+      name: 'setup-server',
+      interceptors: interceptors.map((Interceptor) => new Interceptor()),
+    })
+
+    this.resolvedOptions = {} as RequiredDeep<SharedOptions>
+
+    this.init()
+  }
+
+  /**
+   * Subscribe to all requests that are using the interceptor object
+   */
+  private init(): void {
+    this.interceptor.on('request', async ({ request, requestId }) => {
+      const response = await handleRequest(
+        request,
+        requestId,
+        this.handlersController.currentHandlers(),
+        this.resolvedOptions,
+        this.emitter,
+      )
+
+      if (response) {
+        request.respondWith(response)
+      }
+
+      return
+    })
+
+    this.interceptor.on(
+      'response',
+      ({ response, isMockedResponse, request, requestId }) => {
+        this.emitter.emit(
+          isMockedResponse ? 'response:mocked' : 'response:bypass',
+          {
+            response,
+            request,
+            requestId,
+          },
+        )
+      },
+    )
+  }
+
+  public listen(options: Partial<SharedOptions> = {}): void {
+    this.resolvedOptions = mergeRight(
+      DEFAULT_LISTEN_OPTIONS,
+      options,
+    ) as RequiredDeep<SharedOptions>
+
+    // Apply the interceptor when starting the server.
+    this.interceptor.apply()
+
+    this.subscriptions.push(() => {
+      this.interceptor.dispose()
+    })
+
+    // Assert that the interceptor has been applied successfully.
+    // Also guards us from forgetting to call "interceptor.apply()"
+    // as a part of the "listen" method.
+    invariant(
+      [InterceptorReadyState.APPLYING, InterceptorReadyState.APPLIED].includes(
+        this.interceptor.readyState,
+      ),
+      devUtils.formatMessage(
+        'Failed to start "setupServer": the interceptor failed to apply. This is likely an issue with the library and you should report it at "%s".',
+      ),
+      'https://github.com/mswjs/msw/issues/new/choose',
+    )
+  }
+
+  public close(): void {
+    this.dispose()
+  }
+}

package/src/node/glossary.ts

@@ -1,15 +1,15 @@
 import type { PartialDeep } from 'type-fest'
-import {
+import type {
   RequestHandler,
   RequestHandlerDefaultInfo,
 } from '~/core/handlers/RequestHandler'
-import {
+import type {
   LifeCycleEventEmitter,
   LifeCycleEventsMap,
   SharedOptions,
 } from '~/core/sharedOptions'
 
-export interface SetupServer {
+export interface SetupServerCommon {
   /**
    * Starts requests interception based on the previously provided request handlers.
    *
@@ -60,3 +60,17 @@ export interface SetupServer {
    */
   events: LifeCycleEventEmitter<LifeCycleEventsMap>
 }
+
+export interface SetupServer extends SetupServerCommon {
+  /**
+   * Wraps the given function in a boundary. Any changes to the
+   * network behavior (e.g. adding runtime request handlers via
+   * `server.use()`) will be scoped to this boundary only.
+   * @param callback A function to run (e.g. a test)
+   *
+   * @see {@link https://mswjs.io/docs/api/setup-server/boundary `server.boundary()` API reference}
+   */
+  boundary<Fn extends (...args: Array<any>) => unknown>(
+    callback: Fn,
+  ): (...args: Parameters<Fn>) => ReturnType<Fn>
+}

package/src/node/setupServer.ts

@@ -1,9 +1,5 @@
-import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
-import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
-import { FetchInterceptor } from '@mswjs/interceptors/fetch'
-import { RequestHandler } from '~/core/handlers/RequestHandler'
+import type { RequestHandler } from '~/core/handlers/RequestHandler'
 import { SetupServerApi } from './SetupServerApi'
-import { SetupServer } from './glossary'
 
 /**
  * Sets up a requests interception in Node.js with the given request handlers.
@@ -13,9 +9,6 @@ import { SetupServer } from './glossary'
  */
 export const setupServer = (
   ...handlers: Array<RequestHandler>
-): SetupServer => {
-  return new SetupServerApi(
-    [ClientRequestInterceptor, XMLHttpRequestInterceptor, FetchInterceptor],
-    ...handlers,
-  )
+): SetupServerApi => {
+  return new SetupServerApi(handlers)
 }