msw 2.1.7 → 2.2.0

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)
 }