@mswjs/interceptors 0.32.2 → 0.33.0

package/lib/node/interceptors/fetch/index.mjs

@@ -1,21 +1,19 @@
 import {
   IS_PATCHED_MODULE
-} from "../../chunk-OJ6O4LSC.mjs";
+} from "../../chunk-BZ3Y7YV5.mjs";
 import {
+  RequestController,
   emitAsync,
-  toInteractiveRequest
-} from "../../chunk-KWV3JXSI.mjs";
+  handleRequest
+} from "../../chunk-KY3RJ2M3.mjs";
 import {
   Interceptor,
-  createRequestId,
-  createServerErrorResponse,
-  isResponseError
-} from "../../chunk-TGTPXCLF.mjs";
+  createRequestId
+} from "../../chunk-BUCULLYM.mjs";
 
 // src/interceptors/fetch/index.ts
 import { invariant } from "outvariant";
 import { DeferredPromise } from "@open-draft/deferred-promise";
-import { until } from "@open-draft/until";
 
 // src/utils/canParseUrl.ts
 function canParseUrl(url) {
@@ -42,131 +40,62 @@ var _FetchInterceptor = class extends Interceptor {
       'Failed to patch the "fetch" module: already patched.'
     );
     globalThis.fetch = async (input, init) => {
-      var _a;
       const requestId = createRequestId();
       const resolvedInput = typeof input === "string" && typeof location !== "undefined" && !canParseUrl(input) ? new URL(input, location.origin) : input;
       const request = new Request(resolvedInput, init);
+      const responsePromise = new DeferredPromise();
+      const controller = new RequestController(request);
       this.logger.info("[%s] %s", request.method, request.url);
-      const { interactiveRequest, requestController } = toInteractiveRequest(request);
+      this.logger.info("awaiting for the mocked response...");
       this.logger.info(
-        'emitting the "request" event for %d listener(s)...',
+        'emitting the "request" event for %s listener(s)...',
         this.emitter.listenerCount("request")
       );
-      this.emitter.once("request", ({ requestId: pendingRequestId }) => {
-        if (pendingRequestId !== requestId) {
-          return;
-        }
-        if (requestController.responsePromise.state === "pending") {
-          requestController.responsePromise.resolve(void 0);
-        }
-      });
-      this.logger.info("awaiting for the mocked response...");
-      const signal = interactiveRequest.signal;
-      const requestAborted = new DeferredPromise();
-      if (signal) {
-        signal.addEventListener(
-          "abort",
-          () => {
-            requestAborted.reject(signal.reason);
-          },
-          { once: true }
-        );
-      }
-      const responsePromise = new DeferredPromise();
-      const respondWith = (response) => {
-        this.logger.info("responding with a mock response:", response);
-        if (this.emitter.listenerCount("response") > 0) {
-          this.logger.info('emitting the "response" event...');
-          const responseClone = response.clone();
-          this.emitter.emit("response", {
-            response: responseClone,
-            isMockedResponse: true,
-            request: interactiveRequest,
-            requestId
+      const isRequestHandled = await handleRequest({
+        request,
+        requestId,
+        emitter: this.emitter,
+        controller,
+        onResponse: async (response) => {
+          this.logger.info("received mocked response!", {
+            response
           });
-        }
-        Object.defineProperty(response, "url", {
-          writable: false,
-          enumerable: true,
-          configurable: false,
-          value: request.url
-        });
-        responsePromise.resolve(response);
-      };
-      const errorWith = (reason) => {
-        responsePromise.reject(reason);
-      };
-      const resolverResult = await until(
-        async () => {
-          const listenersFinished = emitAsync(this.emitter, "request", {
-            request: interactiveRequest,
-            requestId
-          });
-          await Promise.race([
-            requestAborted,
-            // Put the listeners invocation Promise in the same race condition
-            // with the request abort Promise because otherwise awaiting the listeners
-            // would always yield some response (or undefined).
-            listenersFinished,
-            requestController.responsePromise
-          ]);
-          this.logger.info("all request listeners have been resolved!");
-          const mockedResponse2 = await requestController.responsePromise;
-          this.logger.info("event.respondWith called with:", mockedResponse2);
-          return mockedResponse2;
-        }
-      );
-      if (requestAborted.state === "rejected") {
-        this.logger.info(
-          "request has been aborted:",
-          requestAborted.rejectionReason
-        );
-        responsePromise.reject(requestAborted.rejectionReason);
-        return responsePromise;
-      }
-      if (resolverResult.error) {
-        this.logger.info(
-          "request listerner threw an error:",
-          resolverResult.error
-        );
-        if (resolverResult.error instanceof Response) {
-          if (isResponseError(resolverResult.error)) {
-            errorWith(createNetworkError(resolverResult.error));
-          } else {
-            respondWith(resolverResult.error);
+          if (this.emitter.listenerCount("response") > 0) {
+            this.logger.info('emitting the "response" event...');
+            await emitAsync(this.emitter, "response", {
+              // Clone the mocked response for the "response" event listener.
+              // This way, the listener can read the response and not lock its body
+              // for the actual fetch consumer.
+              response: response.clone(),
+              isMockedResponse: true,
+              request,
+              requestId
+            });
           }
-        }
-        if (this.emitter.listenerCount("unhandledException") > 0) {
-          await emitAsync(this.emitter, "unhandledException", {
-            error: resolverResult.error,
-            request,
-            requestId,
-            controller: {
-              respondWith,
-              errorWith
-            }
+          Object.defineProperty(response, "url", {
+            writable: false,
+            enumerable: true,
+            configurable: false,
+            value: request.url
           });
-          if (responsePromise.state !== "pending") {
-            return responsePromise;
-          }
-        }
-        respondWith(createServerErrorResponse(resolverResult.error));
-        return responsePromise;
-      }
-      const mockedResponse = resolverResult.data;
-      if (mockedResponse && !((_a = request.signal) == null ? void 0 : _a.aborted)) {
-        this.logger.info("received mocked response:", mockedResponse);
-        if (isResponseError(mockedResponse)) {
-          this.logger.info(
-            "received a network error response, rejecting the request promise..."
-          );
-          errorWith(createNetworkError(mockedResponse));
-        } else {
-          respondWith(mockedResponse);
+          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);
         }
+      });
+      if (isRequestHandled) {
+        this.logger.info("request has been handled, returning mock promise...");
         return responsePromise;
       }
-      this.logger.info("no mocked response received!");
+      this.logger.info(
+        "no mocked response received, performing request as-is..."
+      );
       return pureFetch(request).then((response) => {
         this.logger.info("original fetch performed", response);
         if (this.emitter.listenerCount("response") > 0) {
@@ -175,7 +104,7 @@ var _FetchInterceptor = class extends Interceptor {
           this.emitter.emit("response", {
             response: responseClone,
             isMockedResponse: false,
-            request: interactiveRequest,
+            request,
             requestId
           });
         }

package/lib/node/interceptors/fetch/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/interceptors/fetch/index.ts","../../../../src/utils/canParseUrl.ts"],"sourcesContent":["import { invariant } from 'outvariant'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { until } from '@open-draft/until'\nimport { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'\nimport { Interceptor } from '../../Interceptor'\nimport { toInteractiveRequest } from '../../utils/toInteractiveRequest'\nimport { emitAsync } from '../../utils/emitAsync'\nimport { canParseUrl } from '../../utils/canParseUrl'\nimport { createRequestId } from '../../createRequestId'\nimport {\n  createServerErrorResponse,\n  isResponseError,\n} from '../../utils/responseUtils'\n\nexport class FetchInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol('fetch')\n\n  constructor() {\n    super(FetchInterceptor.symbol)\n  }\n\n  protected checkEnvironment() {\n    return (\n      typeof globalThis !== 'undefined' &&\n      typeof globalThis.fetch !== 'undefined'\n    )\n  }\n\n  protected async setup() {\n    const pureFetch = globalThis.fetch\n\n    invariant(\n      !(pureFetch as any)[IS_PATCHED_MODULE],\n      'Failed to patch the \"fetch\" module: already patched.'\n    )\n\n    globalThis.fetch = async (input, init) => {\n      const requestId = createRequestId()\n\n      /**\n       * @note Resolve potentially relative request URL\n       * against the present `location`. This is mainly\n       * for native `fetch` in JSDOM.\n       * @see https://github.com/mswjs/msw/issues/1625\n       */\n      const resolvedInput =\n        typeof input === 'string' &&\n        typeof location !== 'undefined' &&\n        !canParseUrl(input)\n          ? new URL(input, location.origin)\n          : input\n\n      const request = new Request(resolvedInput, init)\n\n      this.logger.info('[%s] %s', request.method, request.url)\n\n      const { interactiveRequest, requestController } =\n        toInteractiveRequest(request)\n\n      this.logger.info(\n        'emitting the \"request\" event for %d listener(s)...',\n        this.emitter.listenerCount('request')\n      )\n\n      this.emitter.once('request', ({ requestId: pendingRequestId }) => {\n        if (pendingRequestId !== requestId) {\n          return\n        }\n\n        if (requestController.responsePromise.state === 'pending') {\n          requestController.responsePromise.resolve(undefined)\n        }\n      })\n\n      this.logger.info('awaiting for the mocked response...')\n\n      const signal = interactiveRequest.signal\n      const requestAborted = new DeferredPromise()\n\n      // Signal isn't always defined in react-native.\n      if (signal) {\n        signal.addEventListener(\n          'abort',\n          () => {\n            requestAborted.reject(signal.reason)\n          },\n          { once: true }\n        )\n      }\n\n      const responsePromise = new DeferredPromise<Response>()\n\n      const respondWith = (response: Response): void => {\n        this.logger.info('responding with a mock response:', response)\n\n        if (this.emitter.listenerCount('response') > 0) {\n          this.logger.info('emitting the \"response\" event...')\n\n          // Clone the mocked response for the \"response\" event listener.\n          // This way, the listener can read the response and not lock its body\n          // for the actual fetch consumer.\n          const responseClone = response.clone()\n\n          this.emitter.emit('response', {\n            response: responseClone,\n            isMockedResponse: true,\n            request: interactiveRequest,\n            requestId,\n          })\n        }\n\n        // Set the \"response.url\" property to equal the intercepted request URL.\n        Object.defineProperty(response, 'url', {\n          writable: false,\n          enumerable: true,\n          configurable: false,\n          value: request.url,\n        })\n\n        responsePromise.resolve(response)\n      }\n\n      const errorWith = (reason: unknown): void => {\n        responsePromise.reject(reason)\n      }\n\n      const resolverResult = await until<unknown, Response | undefined>(\n        async () => {\n          const listenersFinished = emitAsync(this.emitter, 'request', {\n            request: interactiveRequest,\n            requestId,\n          })\n\n          await Promise.race([\n            requestAborted,\n            // Put the listeners invocation Promise in the same race condition\n            // with the request abort Promise because otherwise awaiting the listeners\n            // would always yield some response (or undefined).\n            listenersFinished,\n            requestController.responsePromise,\n          ])\n\n          this.logger.info('all request listeners have been resolved!')\n\n          const mockedResponse = await requestController.responsePromise\n          this.logger.info('event.respondWith called with:', mockedResponse)\n\n          return mockedResponse\n        }\n      )\n\n      if (requestAborted.state === 'rejected') {\n        this.logger.info(\n          'request has been aborted:',\n          requestAborted.rejectionReason\n        )\n\n        responsePromise.reject(requestAborted.rejectionReason)\n        return responsePromise\n      }\n\n      if (resolverResult.error) {\n        this.logger.info(\n          'request listerner threw an error:',\n          resolverResult.error\n        )\n\n        // Treat thrown Responses as mocked responses.\n        if (resolverResult.error instanceof Response) {\n          // Treat thrown Response.error() as a request error.\n          if (isResponseError(resolverResult.error)) {\n            errorWith(createNetworkError(resolverResult.error))\n          } else {\n            // Treat the rest of thrown Responses as mocked responses.\n            respondWith(resolverResult.error)\n          }\n        }\n\n        // Emit the \"unhandledException\" interceptor event so the client\n        // can opt-out from exceptions translating to 500 error responses.\n\n        if (this.emitter.listenerCount('unhandledException') > 0) {\n          await emitAsync(this.emitter, 'unhandledException', {\n            error: resolverResult.error,\n            request,\n            requestId,\n            controller: {\n              respondWith,\n              errorWith,\n            },\n          })\n\n          if (responsePromise.state !== 'pending') {\n            return responsePromise\n          }\n        }\n\n        // Unhandled exceptions in the request listeners are\n        // synonymous to unhandled exceptions on the server.\n        // Those are represented as 500 error responses.\n        respondWith(createServerErrorResponse(resolverResult.error))\n        return responsePromise\n      }\n\n      const mockedResponse = resolverResult.data\n\n      if (mockedResponse && !request.signal?.aborted) {\n        this.logger.info('received mocked response:', mockedResponse)\n\n        // Reject the request Promise on mocked \"Response.error\" responses.\n        if (isResponseError(mockedResponse)) {\n          this.logger.info(\n            'received a network error response, rejecting the request promise...'\n          )\n\n          /**\n           * Set the cause of the request promise rejection to the\n           * network error Response instance. This differs from Undici.\n           * Undici will forward the \"response.error\" custom property\n           * as the rejection reason but for \"Response.error()\" static method\n           * \"response.error\" will equal to undefined, making \"cause\" an empty Error.\n           * @see https://github.com/nodejs/undici/blob/83cb522ae0157a19d149d72c7d03d46e34510d0a/lib/fetch/response.js#L344\n           */\n          errorWith(createNetworkError(mockedResponse))\n        } else {\n          respondWith(mockedResponse)\n        }\n\n        return responsePromise\n      }\n\n      this.logger.info('no mocked response received!')\n\n      return pureFetch(request).then((response) => {\n        this.logger.info('original fetch performed', response)\n\n        if (this.emitter.listenerCount('response') > 0) {\n          this.logger.info('emitting the \"response\" event...')\n\n          const responseClone = response.clone()\n\n          this.emitter.emit('response', {\n            response: responseClone,\n            isMockedResponse: false,\n            request: interactiveRequest,\n            requestId,\n          })\n        }\n\n        return response\n      })\n    }\n\n    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {\n      enumerable: true,\n      configurable: true,\n      value: true,\n    })\n\n    this.subscriptions.push(() => {\n      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {\n        value: undefined,\n      })\n\n      globalThis.fetch = pureFetch\n\n      this.logger.info(\n        'restored native \"globalThis.fetch\"!',\n        globalThis.fetch.name\n      )\n    })\n  }\n}\n\nfunction createNetworkError(cause: unknown) {\n  return Object.assign(new TypeError('Failed to fetch'), {\n    cause,\n  })\n}\n","/**\n * Returns a boolean indicating whether the given URL string\n * can be parsed into a `URL` instance.\n * A substitute for `URL.canParse()` for Node.js 18.\n */\nexport function canParseUrl(url: string): boolean {\n  try {\n    new URL(url)\n    return true\n  } catch (_error) {\n    return false\n  }\n}\n"],"mappings":"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","names":["mockedResponse"]}
+{"version":3,"sources":["../../../../src/interceptors/fetch/index.ts","../../../../src/utils/canParseUrl.ts"],"sourcesContent":["import { invariant } from 'outvariant'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'\nimport { Interceptor } from '../../Interceptor'\nimport { RequestController } from '../../RequestController'\nimport { emitAsync } from '../../utils/emitAsync'\nimport { handleRequest } from '../../utils/handleRequest'\nimport { canParseUrl } from '../../utils/canParseUrl'\nimport { createRequestId } from '../../createRequestId'\n\nexport class FetchInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol('fetch')\n\n  constructor() {\n    super(FetchInterceptor.symbol)\n  }\n\n  protected checkEnvironment() {\n    return (\n      typeof globalThis !== 'undefined' &&\n      typeof globalThis.fetch !== 'undefined'\n    )\n  }\n\n  protected async setup() {\n    const pureFetch = globalThis.fetch\n\n    invariant(\n      !(pureFetch as any)[IS_PATCHED_MODULE],\n      'Failed to patch the \"fetch\" module: already patched.'\n    )\n\n    globalThis.fetch = async (input, init) => {\n      const requestId = createRequestId()\n\n      /**\n       * @note Resolve potentially relative request URL\n       * against the present `location`. This is mainly\n       * for native `fetch` in JSDOM.\n       * @see https://github.com/mswjs/msw/issues/1625\n       */\n      const resolvedInput =\n        typeof input === 'string' &&\n        typeof location !== 'undefined' &&\n        !canParseUrl(input)\n          ? new URL(input, location.origin)\n          : input\n\n      const request = new Request(resolvedInput, init)\n      const responsePromise = new DeferredPromise<Response>()\n      const controller = new RequestController(request)\n\n      this.logger.info('[%s] %s', request.method, request.url)\n      this.logger.info('awaiting for the mocked response...')\n\n      this.logger.info(\n        'emitting the \"request\" event for %s listener(s)...',\n        this.emitter.listenerCount('request')\n      )\n\n      const isRequestHandled = await handleRequest({\n        request,\n        requestId,\n        emitter: this.emitter,\n        controller,\n        onResponse: async (response) => {\n          this.logger.info('received mocked response!', {\n            response,\n          })\n\n          if (this.emitter.listenerCount('response') > 0) {\n            this.logger.info('emitting the \"response\" event...')\n\n            // Await the response listeners to finish before resolving\n            // the response promise. This ensures all your logic finishes\n            // before the interceptor resolves the pending response.\n            await emitAsync(this.emitter, 'response', {\n              // Clone the mocked response for the \"response\" event listener.\n              // This way, the listener can read the response and not lock its body\n              // for the actual fetch consumer.\n              response: response.clone(),\n              isMockedResponse: true,\n              request,\n              requestId,\n            })\n          }\n\n          // Set the \"response.url\" property to equal the intercepted request URL.\n          Object.defineProperty(response, 'url', {\n            writable: false,\n            enumerable: true,\n            configurable: false,\n            value: request.url,\n          })\n\n          responsePromise.resolve(response)\n        },\n        onRequestError: (response) => {\n          this.logger.info('request has errored!', { response })\n          responsePromise.reject(createNetworkError(response))\n        },\n        onError: (error) => {\n          this.logger.info('request has been aborted!', { error })\n          responsePromise.reject(error)\n        },\n      })\n\n      if (isRequestHandled) {\n        this.logger.info('request has been handled, returning mock promise...')\n        return responsePromise\n      }\n\n      this.logger.info(\n        'no mocked response received, performing request as-is...'\n      )\n\n      return pureFetch(request).then((response) => {\n        this.logger.info('original fetch performed', response)\n\n        if (this.emitter.listenerCount('response') > 0) {\n          this.logger.info('emitting the \"response\" event...')\n\n          const responseClone = response.clone()\n\n          this.emitter.emit('response', {\n            response: responseClone,\n            isMockedResponse: false,\n            request,\n            requestId,\n          })\n        }\n\n        return response\n      })\n    }\n\n    Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {\n      enumerable: true,\n      configurable: true,\n      value: true,\n    })\n\n    this.subscriptions.push(() => {\n      Object.defineProperty(globalThis.fetch, IS_PATCHED_MODULE, {\n        value: undefined,\n      })\n\n      globalThis.fetch = pureFetch\n\n      this.logger.info(\n        'restored native \"globalThis.fetch\"!',\n        globalThis.fetch.name\n      )\n    })\n  }\n}\n\nfunction createNetworkError(cause: unknown) {\n  return Object.assign(new TypeError('Failed to fetch'), {\n    cause,\n  })\n}\n","/**\n * Returns a boolean indicating whether the given URL string\n * can be parsed into a `URL` instance.\n * A substitute for `URL.canParse()` for Node.js 18.\n */\nexport function canParseUrl(url: string): boolean {\n  try {\n    new URL(url)\n    return true\n  } catch (_error) {\n    return false\n  }\n}\n"],"mappings":"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","names":[]}

package/lib/node/presets/node.d.ts

@@ -1,6 +1,6 @@
 import { ClientRequestInterceptor } from '../interceptors/ClientRequest/index.js';
 import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest/index.js';
-import '../Interceptor-88ee47c0.js';
+import '../Interceptor-a31b1217.js';
 import '@open-draft/deferred-promise';
 import '@open-draft/logger';
 import 'strict-event-emitter';

package/lib/node/presets/node.js

@@ -1,18 +1,18 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkCFRXZJO4js = require('../chunk-CFRXZJO4.js');
+var _chunk2MWIWEWVjs = require('../chunk-2MWIWEWV.js');
 
 
-var _chunkPYD4E2EJjs = require('../chunk-PYD4E2EJ.js');
+var _chunkP6QG76R3js = require('../chunk-P6QG76R3.js');
 require('../chunk-LK6DILFK.js');
-require('../chunk-EIBTX65O.js');
-require('../chunk-UXCYRE4F.js');
-require('../chunk-BFLYGQ6D.js');
+require('../chunk-IDEEMJ3F.js');
+require('../chunk-5WWNCLB3.js');
+require('../chunk-YGM3BCJU.js');
 
 // src/presets/node.ts
 var node_default = [
-  new (0, _chunkCFRXZJO4js.ClientRequestInterceptor)(),
-  new (0, _chunkPYD4E2EJjs.XMLHttpRequestInterceptor)()
+  new (0, _chunk2MWIWEWVjs.ClientRequestInterceptor)(),
+  new (0, _chunkP6QG76R3js.XMLHttpRequestInterceptor)()
 ];
 
 

package/lib/node/presets/node.mjs

@@ -1,13 +1,13 @@
 import {
   ClientRequestInterceptor
-} from "../chunk-CMVICWQS.mjs";
+} from "../chunk-CU3YXMM4.mjs";
 import {
   XMLHttpRequestInterceptor
-} from "../chunk-DV4PBH4D.mjs";
+} from "../chunk-TOV4TYIX.mjs";
 import "../chunk-6HYIRFX2.mjs";
-import "../chunk-OJ6O4LSC.mjs";
-import "../chunk-KWV3JXSI.mjs";
-import "../chunk-TGTPXCLF.mjs";
+import "../chunk-BZ3Y7YV5.mjs";
+import "../chunk-KY3RJ2M3.mjs";
+import "../chunk-BUCULLYM.mjs";
 
 // src/presets/node.ts
 var node_default = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mswjs/interceptors",
   "description": "Low-level HTTP/HTTPS/XHR/fetch request interception library.",
-  "version": "0.32.2",
+  "version": "0.33.0",
   "main": "./lib/node/index.js",
   "module": "./lib/node/index.mjs",
   "types": "./lib/node/index.d.ts",
@@ -161,7 +161,7 @@
     "@open-draft/logger": "^0.3.0",
     "@open-draft/until": "^2.0.0",
     "is-node-process": "^1.2.0",
-    "outvariant": "^1.2.1",
+    "outvariant": "^1.4.3",
     "strict-event-emitter": "^0.5.1"
   },
   "resolutions": {

package/src/InterceptorError.ts

@@ -0,0 +1,7 @@
+export class InterceptorError extends Error {
+  constructor(message?: string) {
+    super(message)
+    this.name = 'InterceptorError'
+    Object.setPrototypeOf(this, InterceptorError.prototype)
+  }
+}

package/src/RemoteHttpInterceptor.ts

@@ -4,8 +4,8 @@ import { Interceptor } from './Interceptor'
 import { BatchInterceptor } from './BatchInterceptor'
 import { ClientRequestInterceptor } from './interceptors/ClientRequest'
 import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
-import { toInteractiveRequest } from './utils/toInteractiveRequest'
-import { emitAsync } from './utils/emitAsync'
+import { handleRequest } from './utils/handleRequest'
+import { RequestController } from './RequestController'
 
 export interface SerializedRequest {
   id: string
@@ -46,7 +46,7 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
 
     let handleParentMessage: NodeJS.MessageListener
 
-    this.on('request', async ({ request, requestId }) => {
+    this.on('request', async ({ request, requestId, controller }) => {
       // Send the stringified intercepted request to
       // the parent process where the remote resolver is established.
       const serializedRequest = JSON.stringify({
@@ -64,6 +64,7 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
         'sent serialized request to the child:',
         serializedRequest
       )
+
       process.send?.(`request:${serializedRequest}`)
 
       const responsePromise = new Promise<void>((resolve) => {
@@ -90,7 +91,12 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
               headers: responseInit.headers,
             })
 
-            request.respondWith(mockedResponse)
+            /**
+             * @todo Support "errorWith" as well.
+             * This response handling from the child is incomplete.
+             */
+
+            controller.respondWith(mockedResponse)
             return resolve()
           }
         }
@@ -158,69 +164,68 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
         serializedRequest,
         requestReviver
       ) as RevivedRequest
+
       logger.info('parsed intercepted request', requestJson)
 
-      const capturedRequest = new Request(requestJson.url, {
+      const request = new Request(requestJson.url, {
         method: requestJson.method,
         headers: new Headers(requestJson.headers),
         credentials: requestJson.credentials,
         body: requestJson.body,
       })
 
-      const { interactiveRequest, requestController } =
-        toInteractiveRequest(capturedRequest)
-
-      this.emitter.once('request', () => {
-        if (requestController.responsePromise.state === 'pending') {
-          requestController.respondWith(undefined)
-        }
-      })
-
-      await emitAsync(this.emitter, 'request', {
-        request: interactiveRequest,
+      const controller = new RequestController(request)
+      await handleRequest({
+        request,
         requestId: requestJson.id,
+        controller,
+        emitter: this.emitter,
+        onResponse: async (response) => {
+          this.logger.info('received mocked response!', { response })
+
+          const responseClone = response.clone()
+          const responseText = await responseClone.text()
+
+          // // Send the mocked response to the child process.
+          const serializedResponse = JSON.stringify({
+            status: response.status,
+            statusText: response.statusText,
+            headers: Array.from(response.headers.entries()),
+            body: responseText,
+          } as SerializedResponse)
+
+          this.process.send(
+            `response:${requestJson.id}:${serializedResponse}`,
+            (error) => {
+              if (error) {
+                return
+              }
+
+              // Emit an optimistic "response" event at this point,
+              // not to rely on the back-and-forth signaling for the sake of the event.
+              this.emitter.emit('response', {
+                request,
+                requestId: requestJson.id,
+                response: responseClone,
+                isMockedResponse: true,
+              })
+            }
+          )
+
+          logger.info(
+            'sent serialized mocked response to the parent:',
+            serializedResponse
+          )
+        },
+        onRequestError: (response) => {
+          this.logger.info('received a network error!', { response })
+          throw new Error('Not implemented')
+        },
+        onError: (error) => {
+          this.logger.info('request has errored!', { error })
+          throw new Error('Not implemented')
+        },
       })
-
-      const mockedResponse = await requestController.responsePromise
-
-      if (!mockedResponse) {
-        return
-      }
-
-      logger.info('event.respondWith called with:', mockedResponse)
-      const responseClone = mockedResponse.clone()
-      const responseText = await mockedResponse.text()
-
-      // Send the mocked response to the child process.
-      const serializedResponse = JSON.stringify({
-        status: mockedResponse.status,
-        statusText: mockedResponse.statusText,
-        headers: Array.from(mockedResponse.headers.entries()),
-        body: responseText,
-      } as SerializedResponse)
-
-      this.process.send(
-        `response:${requestJson.id}:${serializedResponse}`,
-        (error) => {
-          if (error) {
-            return
-          }
-
-          // Emit an optimistic "response" event at this point,
-          // not to rely on the back-and-forth signaling for the sake of the event.
-          this.emitter.emit('response', {
-            response: responseClone,
-            isMockedResponse: true,
-            request: capturedRequest,
-            requestId: requestJson.id,
-          })
-        }
-      )
-
-      logger.info(
-        'sent serialized mocked response to the parent:',
-        serializedResponse
-      )
     }
 
     this.subscriptions.push(() => {

package/src/RequestController.test.ts

@@ -0,0 +1,49 @@
+import { it, expect } from 'vitest'
+import { kResponsePromise, RequestController } from './RequestController'
+
+it('creates a pending response promise on construction', () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  expect(controller[kResponsePromise]).toBeInstanceOf(Promise)
+  expect(controller[kResponsePromise].state).toBe('pending')
+})
+
+it('resolves the response promise with the response provided to "respondWith"', async () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  controller.respondWith(new Response('hello world'))
+
+  const response = (await controller[kResponsePromise]) as Response
+
+  expect(response).toBeInstanceOf(Response)
+  expect(response.status).toBe(200)
+  expect(await response.text()).toBe('hello world')
+})
+
+it('resolves the response promise with the error provided to "errorWith"', async () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  const error = new Error('Oops!')
+  controller.errorWith(error)
+
+  await expect(controller[kResponsePromise]).resolves.toEqual(error)
+})
+
+it('throws when calling "respondWith" multiple times', () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  controller.respondWith(new Response('hello world'))
+
+  expect(() => {
+    controller.respondWith(new Response('second response'))
+  }).toThrow(
+    'Failed to respond to the "GET http://localhost/" request: the "request" event has already been handled.'
+  )
+})
+
+it('throws when calling "errorWith" multiple times', () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  controller.errorWith(new Error('Oops!'))
+
+  expect(() => {
+    controller.errorWith(new Error('second error'))
+  }).toThrow(
+    'Failed to error the "GET http://localhost/" request: the "request" event has already been handled.'
+  )
+})

package/src/RequestController.ts

@@ -0,0 +1,81 @@
+import { invariant } from 'outvariant'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { InterceptorError } from './InterceptorError'
+
+const kRequestHandled = Symbol('kRequestHandled')
+export const kResponsePromise = Symbol('kResponsePromise')
+
+export class RequestController {
+  /**
+   * Internal response promise.
+   * Available only for the library internals to grab the
+   * response instance provided by the developer.
+   * @note This promise cannot be rejected. It's either infinitely
+   * pending or resolved with whichever Response was passed to `respondWith()`.
+   */
+  [kResponsePromise]: DeferredPromise<Response | Error | undefined>;
+
+  /**
+   * Internal flag indicating if this request has been handled.
+   * @note The response promise becomes "fulfilled" on the next tick.
+   */
+  [kRequestHandled]: boolean
+
+  constructor(private request: Request) {
+    this[kRequestHandled] = false
+    this[kResponsePromise] = new DeferredPromise()
+  }
+
+  /**
+   * Respond to this request with the given `Response` instance.
+   * @example
+   * controller.respondWith(new Response())
+   * controller.respondWith(Response.json({ id }))
+   * controller.respondWith(Response.error())
+   */
+  public respondWith(response: Response): void {
+    invariant.as(
+      InterceptorError,
+      !this[kRequestHandled],
+      'Failed to respond to the "%s %s" request: the "request" event has already been handled.',
+      this.request.method,
+      this.request.url
+    )
+
+    this[kRequestHandled] = true
+    this[kResponsePromise].resolve(response)
+
+    /**
+     * @note The request conrtoller doesn't do anything
+     * apart from letting the interceptor await the response
+     * provided by the developer through the response promise.
+     * Each interceptor implements the actual respondWith/errorWith
+     * logic based on that interceptor's needs.
+     */
+  }
+
+  /**
+   * Error this request with the given error.
+   * @example
+   * controller.errorWith()
+   * controller.errorWith(new Error('Oops!'))
+   */
+  public errorWith(error?: Error): void {
+    invariant.as(
+      InterceptorError,
+      !this[kRequestHandled],
+      'Failed to error the "%s %s" request: the "request" event has already been handled.',
+      this.request.method,
+      this.request.url
+    )
+
+    this[kRequestHandled] = true
+
+    /**
+     * @note Resolve the response promise, not reject.
+     * This helps us differentiate between unhandled exceptions
+     * and intended errors ("errorWith") while waiting for the response.
+     */
+    this[kResponsePromise].resolve(error)
+  }
+}