@mswjs/interceptors 0.39.8 → 0.41.0

package/src/interceptors/fetch/index.ts

@@ -1,4 +1,5 @@
 import { invariant } from 'outvariant'
+import { until } from '@open-draft/until'
 import { DeferredPromise } from '@open-draft/deferred-promise'
 import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
@@ -13,6 +14,7 @@ import { decompressResponse } from './utils/decompression'
 import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
 import { FetchResponse } from '../../utils/fetchUtils'
 import { setRawRequest } from '../../getRawRequest'
+import { isResponseError } from '../../utils/responseUtils'
 
 export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol('fetch')
@@ -59,22 +61,54 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
       }
 
       const responsePromise = new DeferredPromise<Response>()
-      const controller = new RequestController(request)
 
-      this.logger.info('[%s] %s', request.method, request.url)
-      this.logger.info('awaiting for the mocked response...')
+      const controller = new RequestController(request, {
+        passthrough: async () => {
+          this.logger.info('request has not been handled, passthrough...')
 
-      this.logger.info(
-        'emitting the "request" event for %s listener(s)...',
-        this.emitter.listenerCount('request')
-      )
+          /**
+           * @note Clone the request instance right before performing it.
+           * This preserves any modifications made to the intercepted request
+           * in the "request" listener. This also allows the user to read the
+           * request body in the "response" listener (otherwise "unusable").
+           */
+          const requestCloneForResponseEvent = request.clone()
+
+          // Perform the intercepted request as-is.
+          const { error: responseError, data: originalResponse } = await until(
+            () => pureFetch(request)
+          )
+
+          if (responseError) {
+            return responsePromise.reject(responseError)
+          }
+
+          this.logger.info('original fetch performed', originalResponse)
+
+          if (this.emitter.listenerCount('response') > 0) {
+            this.logger.info('emitting the "response" event...')
+
+            const responseClone = originalResponse.clone()
+            await emitAsync(this.emitter, 'response', {
+              response: responseClone,
+              isMockedResponse: false,
+              request: requestCloneForResponseEvent,
+              requestId,
+            })
+          }
+
+          // Resolve the response promise with the original response
+          // since the `fetch()` return this internal promise.
+          responsePromise.resolve(originalResponse)
+        },
+        respondWith: async (rawResponse) => {
+          // Handle mocked `Response.error()` (i.e. request errors).
+          if (isResponseError(rawResponse)) {
+            this.logger.info('request has errored!', { response: rawResponse })
+            responsePromise.reject(createNetworkError(rawResponse))
+            return
+          }
 
-      const isRequestHandled = await handleRequest({
-        request,
-        requestId,
-        emitter: this.emitter,
-        controller,
-        onResponse: async (rawResponse) => {
           this.logger.info('received mocked response!', {
             rawResponse,
           })
@@ -134,51 +168,28 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
 
           responsePromise.resolve(response)
         },
-        onRequestError: (response) => {
-          this.logger.info('request has errored!', { response })
-          responsePromise.reject(createNetworkError(response))
-        },
-        onError: (error) => {
-          this.logger.info('request has been aborted!', { error })
-          responsePromise.reject(error)
+        errorWith: (reason) => {
+          this.logger.info('request has been aborted!', { reason })
+          responsePromise.reject(reason)
         },
       })
 
-      if (isRequestHandled) {
-        this.logger.info('request has been handled, returning mock promise...')
-        return responsePromise
-      }
+      this.logger.info('[%s] %s', request.method, request.url)
+      this.logger.info('awaiting for the mocked response...')
 
       this.logger.info(
-        'no mocked response received, performing request as-is...'
+        'emitting the "request" event for %s listener(s)...',
+        this.emitter.listenerCount('request')
       )
 
-      /**
-       * @note Clone the request instance right before performing it.
-       * This preserves any modifications made to the intercepted request
-       * in the "request" listener. This also allows the user to read the
-       * request body in the "response" listener (otherwise "unusable").
-       */
-      const requestCloneForResponseEvent = request.clone()
-
-      return pureFetch(request).then(async (response) => {
-        this.logger.info('original fetch performed', response)
-
-        if (this.emitter.listenerCount('response') > 0) {
-          this.logger.info('emitting the "response" event...')
-
-          const responseClone = response.clone()
-
-          await emitAsync(this.emitter, 'response', {
-            response: responseClone,
-            isMockedResponse: false,
-            request: requestCloneForResponseEvent,
-            requestId,
-          })
-        }
-
-        return response
+      await handleRequest({
+        request,
+        requestId,
+        emitter: this.emitter,
+        controller,
       })
+
+      return responsePromise
     }
 
     Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {

package/src/utils/handleRequest.ts

@@ -3,12 +3,11 @@ import { DeferredPromise } from '@open-draft/deferred-promise'
 import { until } from '@open-draft/until'
 import type { HttpRequestEventMap } from '../glossary'
 import { emitAsync } from './emitAsync'
-import { kResponsePromise, RequestController } from '../RequestController'
+import { RequestController } from '../RequestController'
 import {
   createServerErrorResponse,
   isResponseError,
   isResponseLike,
-  ResponseError,
 } from './responseUtils'
 import { InterceptorError } from '../InterceptorError'
 import { isNodeLikeError } from './isNodeLikeError'
@@ -19,43 +18,22 @@ interface HandleRequestOptions {
   request: Request
   emitter: Emitter<HttpRequestEventMap>
   controller: RequestController
-
-  /**
-   * Called when the request has been handled
-   * with the given `Response` instance.
-   */
-  onResponse: (response: Response) => void | Promise<void>
-
-  /**
-   * Called when the request has been handled
-   * with the given `Response.error()` instance.
-   */
-  onRequestError: (response: ResponseError) => void
-
-  /**
-   * Called when an unhandled error happens during the
-   * request handling. This is never a thrown error/response.
-   */
-  onError: (error: unknown) => void
 }
 
-/**
- * @returns {Promise<boolean>} Indicates whether the request has been handled.
- */
 export async function handleRequest(
   options: HandleRequestOptions
-): Promise<boolean> {
+): Promise<void> {
   const handleResponse = async (
     response: Response | Error | Record<string, any>
   ) => {
     if (response instanceof Error) {
-      options.onError(response)
+      await options.controller.errorWith(response)
       return true
     }
 
     // Handle "Response.error()" instances.
     if (isResponseError(response)) {
-      options.onRequestError(response)
+      await options.controller.respondWith(response)
       return true
     }
 
@@ -65,13 +43,13 @@ export async function handleRequest(
      * since Response instances are, in fact, objects.
      */
     if (isResponseLike(response)) {
-      await options.onResponse(response)
+      await options.controller.respondWith(response)
       return true
     }
 
     // Handle arbitrary objects provided to `.errorWith(reason)`.
     if (isObject(response)) {
-      options.onError(response)
+      await options.controller.errorWith(response)
       return true
     }
 
@@ -87,7 +65,7 @@ export async function handleRequest(
 
     // Support mocking Node.js-like errors.
     if (isNodeLikeError(error)) {
-      options.onError(error)
+      await options.controller.errorWith(error)
       return true
     }
 
@@ -102,15 +80,14 @@ export async function handleRequest(
   // Add the last "request" listener to check if the request
   // has been handled in any way. If it hasn't, resolve the
   // response promise with undefined.
-  options.emitter.once('request', ({ requestId: pendingRequestId }) => {
-    if (pendingRequestId !== options.requestId) {
-      return
-    }
-
-    if (options.controller[kResponsePromise].state === 'pending') {
-      options.controller[kResponsePromise].resolve(undefined)
-    }
-  })
+  // options.emitter.once('request', async ({ requestId: pendingRequestId }) => {
+  //   if (
+  //     pendingRequestId === options.requestId &&
+  //     options.controller.readyState === RequestController.PENDING
+  //   ) {
+  //     await options.controller.passthrough()
+  //   }
+  // })
 
   const requestAbortPromise = new DeferredPromise<void, unknown>()
 
@@ -119,16 +96,17 @@ export async function handleRequest(
    */
   if (options.request.signal) {
     if (options.request.signal.aborted) {
-      requestAbortPromise.reject(options.request.signal.reason)
-    } else {
-      options.request.signal.addEventListener(
-        'abort',
-        () => {
-          requestAbortPromise.reject(options.request.signal.reason)
-        },
-        { once: true }
-      )
+      await options.controller.errorWith(options.request.signal.reason)
+      return
     }
+
+    options.request.signal.addEventListener(
+      'abort',
+      () => {
+        requestAbortPromise.reject(options.request.signal.reason)
+      },
+      { once: true }
+    )
   }
 
   const result = await until(async () => {
@@ -146,25 +124,21 @@ export async function handleRequest(
       // Short-circuit the request handling promise if the request gets aborted.
       requestAbortPromise,
       requestListenersPromise,
-      options.controller[kResponsePromise],
+      options.controller.handled,
     ])
-
-    // The response promise will settle immediately once
-    // the developer calls either "respondWith" or "errorWith".
-    return await options.controller[kResponsePromise]
   })
 
   // Handle the request being aborted while waiting for the request listeners.
   if (requestAbortPromise.state === 'rejected') {
-    options.onError(requestAbortPromise.rejectionReason)
-    return true
+    await options.controller.errorWith(requestAbortPromise.rejectionReason)
+    return
   }
 
   if (result.error) {
     // Handle the error during the request listener execution.
     // These can be thrown responses or request errors.
     if (await handleResponseError(result.error)) {
-      return true
+      return
     }
 
     // If the developer has added "unhandledException" listeners,
@@ -175,7 +149,28 @@ export async function handleRequest(
       // This is needed because the original controller might have been already
       // interacted with (e.g. "respondWith" or "errorWith" called on it).
       const unhandledExceptionController = new RequestController(
-        options.request
+        options.request,
+        {
+          /**
+           * @note Intentionally empty passthrough handle.
+           * This controller is created within another controller and we only need
+           * to know if `unhandledException` listeners handled the request.
+           */
+          passthrough() {},
+          async respondWith(response) {
+            await handleResponse(response)
+          },
+          async errorWith(reason) {
+            /**
+             * @note Handle the result of the unhandled controller
+             * in the same way as the original request controller.
+             * The exception here is that thrown errors within the
+             * "unhandledException" event do NOT result in another
+             * emit of the same event. They are forwarded as-is.
+             */
+            await options.controller.errorWith(reason)
+          },
+        }
       )
 
       await emitAsync(options.emitter, 'unhandledException', {
@@ -183,53 +178,28 @@ export async function handleRequest(
         request: options.request,
         requestId: options.requestId,
         controller: unhandledExceptionController,
-      }).then(() => {
-        // If all the "unhandledException" listeners have finished
-        // but have not handled the response in any way, preemptively
-        // resolve the pending response promise from the new controller.
-        // This prevents it from hanging forever.
-        if (
-          unhandledExceptionController[kResponsePromise].state === 'pending'
-        ) {
-          unhandledExceptionController[kResponsePromise].resolve(undefined)
-        }
       })
 
-      const nextResult = await until(
-        () => unhandledExceptionController[kResponsePromise]
-      )
-
-      /**
-       * @note Handle the result of the unhandled controller
-       * in the same way as the original request controller.
-       * The exception here is that thrown errors within the
-       * "unhandledException" event do NOT result in another
-       * emit of the same event. They are forwarded as-is.
-       */
-      if (nextResult.error) {
-        return handleResponseError(nextResult.error)
-      }
-
-      if (nextResult.data) {
-        return handleResponse(nextResult.data)
+      // If all the "unhandledException" listeners have finished
+      // but have not handled the request in any way, passthrough.
+      if (
+        unhandledExceptionController.readyState !== RequestController.PENDING
+      ) {
+        return
       }
     }
 
     // Otherwise, coerce unhandled exceptions to a 500 Internal Server Error response.
-    options.onResponse(createServerErrorResponse(result.error))
-    return true
+    await options.controller.respondWith(
+      createServerErrorResponse(result.error)
+    )
+    return
   }
 
-  /**
-   * Handle a mocked Response instance.
-   * @note That this can also be an Error in case
-   * the developer called "errorWith". This differentiates
-   * unhandled exceptions from intended errors.
-   */
-  if (result.data) {
-    return handleResponse(result.data)
+  // If the request hasn't been handled by this point, passthrough.
+  if (options.controller.readyState === RequestController.PENDING) {
+    return await options.controller.passthrough()
   }
 
-  // In all other cases, consider the request unhandled.
-  return false
+  return options.controller.handled
 }

package/lib/browser/Interceptor-af98b768.d.ts

@@ -1,63 +0,0 @@
-import { Logger } from '@open-draft/logger';
-import { Emitter, Listener } from 'strict-event-emitter';
-
-type InterceptorEventMap = Record<string, any>;
-type InterceptorSubscription = () => void;
-/**
- * Request header name to detect when a single request
- * is being handled by nested interceptors (XHR -> ClientRequest).
- * Obscure by design to prevent collisions with user-defined headers.
- * Ideally, come up with the Interceptor-level mechanism for this.
- * @see https://github.com/mswjs/interceptors/issues/378
- */
-declare const INTERNAL_REQUEST_ID_HEADER_NAME = "x-interceptors-internal-request-id";
-declare function getGlobalSymbol<V>(symbol: Symbol): V | undefined;
-declare function deleteGlobalSymbol(symbol: Symbol): void;
-declare enum InterceptorReadyState {
-    INACTIVE = "INACTIVE",
-    APPLYING = "APPLYING",
-    APPLIED = "APPLIED",
-    DISPOSING = "DISPOSING",
-    DISPOSED = "DISPOSED"
-}
-type ExtractEventNames<Events extends Record<string, any>> = Events extends Record<infer EventName, any> ? EventName : never;
-declare class Interceptor<Events extends InterceptorEventMap> {
-    private readonly symbol;
-    protected emitter: Emitter<Events>;
-    protected subscriptions: Array<InterceptorSubscription>;
-    protected logger: Logger;
-    readyState: InterceptorReadyState;
-    constructor(symbol: symbol);
-    /**
-     * Determine if this interceptor can be applied
-     * in the current environment.
-     */
-    protected checkEnvironment(): boolean;
-    /**
-     * Apply this interceptor to the current process.
-     * Returns an already running interceptor instance if it's present.
-     */
-    apply(): void;
-    /**
-     * Setup the module augments and stubs necessary for this interceptor.
-     * This method is not run if there's a running interceptor instance
-     * to prevent instantiating an interceptor multiple times.
-     */
-    protected setup(): void;
-    /**
-     * Listen to the interceptor's public events.
-     */
-    on<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
-    once<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
-    off<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
-    removeAllListeners<EventName extends ExtractEventNames<Events>>(event?: EventName): this;
-    /**
-     * Disposes of any side-effects this interceptor has introduced.
-     */
-    dispose(): void;
-    private getInstance;
-    private setInstance;
-    private clearInstance;
-}
-
-export { ExtractEventNames as E, Interceptor as I, InterceptorEventMap as a, InterceptorSubscription as b, INTERNAL_REQUEST_ID_HEADER_NAME as c, deleteGlobalSymbol as d, InterceptorReadyState as e, getGlobalSymbol as g };

package/lib/browser/chunk-2HUMWGRD.js

@@ -1,37 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/emitAsync.ts
-async function emitAsync(emitter, eventName, ...data) {
-  const listeners = emitter.listeners(eventName);
-  if (listeners.length === 0) {
-    return;
-  }
-  for (const listener of listeners) {
-    await listener.apply(emitter, data);
-  }
-}
-
-// src/utils/hasConfigurableGlobal.ts
-function hasConfigurableGlobal(propertyName) {
-  const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
-  if (typeof descriptor === "undefined") {
-    return false;
-  }
-  if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") {
-    return false;
-  }
-  if (typeof descriptor.get === "undefined" && descriptor.value == null) {
-    return false;
-  }
-  if (typeof descriptor.set === "undefined" && !descriptor.configurable) {
-    console.error(
-      `[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`
-    );
-    return false;
-  }
-  return true;
-}
-
-
-
-
-exports.emitAsync = emitAsync; exports.hasConfigurableGlobal = hasConfigurableGlobal;
-//# sourceMappingURL=chunk-2HUMWGRD.js.map

package/lib/browser/chunk-2HUMWGRD.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/emitAsync.ts","../../src/utils/hasConfigurableGlobal.ts"],"names":[],"mappings":";AAOA,eAAsB,UAIpB,SACA,cACG,MACY;AACf,QAAM,YAAY,QAAQ,UAAU,SAAS;AAE7C,MAAI,UAAU,WAAW,GAAG;AAC1B;AAAA,EACF;AAEA,aAAW,YAAY,WAAW;AAChC,UAAM,SAAS,MAAM,SAAS,IAAI;AAAA,EACpC;AACF;;;ACpBO,SAAS,sBAAsB,cAA+B;AACnE,QAAM,aAAa,OAAO,yBAAyB,YAAY,YAAY;AAG3E,MAAI,OAAO,eAAe,aAAa;AACrC,WAAO;AAAA,EACT;AAGA,MACE,OAAO,WAAW,QAAQ,cAC1B,OAAO,WAAW,IAAI,MAAM,aAC5B;AACA,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,WAAW,QAAQ,eAAe,WAAW,SAAS,MAAM;AACrE,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,WAAW,QAAQ,eAAe,CAAC,WAAW,cAAc;AACrE,YAAQ;AAAA,MACN,mDAAmD;AAAA,IACrD;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT","sourcesContent":["import { Emitter, EventMap } from 'strict-event-emitter'\n\n/**\n * Emits an event on the given emitter but executes\n * the listeners sequentially. This accounts for asynchronous\n * listeners (e.g. those having \"sleep\" and handling the request).\n */\nexport async function emitAsync<\n  Events extends EventMap,\n  EventName extends keyof Events\n>(\n  emitter: Emitter<Events>,\n  eventName: EventName,\n  ...data: Events[EventName]\n): Promise<void> {\n  const listeners = emitter.listeners(eventName)\n\n  if (listeners.length === 0) {\n    return\n  }\n\n  for (const listener of listeners) {\n    await listener.apply(emitter, data)\n  }\n}\n","/**\n * Returns a boolean indicating whether the given global property\n * is defined and is configurable.\n */\nexport function hasConfigurableGlobal(propertyName: string): boolean {\n  const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName)\n\n  // The property is not set at all.\n  if (typeof descriptor === 'undefined') {\n    return false\n  }\n\n  // The property is set to a getter that returns undefined.\n  if (\n    typeof descriptor.get === 'function' &&\n    typeof descriptor.get() === 'undefined'\n  ) {\n    return false\n  }\n\n  // The property is set to a value equal to undefined.\n  if (typeof descriptor.get === 'undefined' && descriptor.value == null) {\n    return false\n  }\n\n  if (typeof descriptor.set === 'undefined' && !descriptor.configurable) {\n    console.error(\n      `[MSW] Failed to apply interceptor: the global \\`${propertyName}\\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`\n    )\n    return false\n  }\n\n  return true\n}\n"]}