@mswjs/interceptors 0.15.2 → 0.15.3

package/src/interceptors/fetch/index.ts

@@ -1,106 +1,80 @@
 import {
   Headers,
-  flattenHeadersObject,
-  objectToHeaders,
   headersToObject,
+  objectToHeaders,
+  flattenHeadersObject,
 } from 'headers-polyfill'
-import type {
-  HttpRequestEventMap,
-  InteractiveIsomorphicRequest,
+import {
+  Interceptor,
+  IsomorphicRequest,
   IsomorphicResponse,
-} from '../../glossary'
-import { Interceptor } from '../../Interceptor'
-import { createLazyCallback } from '../../utils/createLazyCallback'
+} from '../../createInterceptor'
 import { toIsoResponse } from '../../utils/toIsoResponse'
 import { uuidv4 } from '../../utils/uuid'
 
-export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
-  static symbol = Symbol('fetch')
-
-  constructor() {
-    super(FetchInterceptor.symbol)
-  }
-
-  protected checkEnvironment() {
-    return (
-      typeof globalThis !== 'undefined' &&
-      typeof globalThis.fetch !== 'undefined'
-    )
-  }
+const debug = require('debug')('fetch')
 
-  protected setup() {
-    const pureFetch = globalThis.fetch
+export const interceptFetch: Interceptor = (observer, resolver) => {
+  const pureFetch = window.fetch
 
-    globalThis.fetch = async (input, init) => {
-      const request = new Request(input, init)
-      const url = typeof input === 'string' ? input : input.url
-      const method = request.method
+  debug('replacing "window.fetch"...')
 
-      this.log('[%s] %s', method, url)
+  window.fetch = async (input, init) => {
+    const request = new Request(input, init)
+    const url = typeof input === 'string' ? input : input.url
+    const method = request.method
 
-      const isomorphicRequest: InteractiveIsomorphicRequest = {
-        id: uuidv4(),
-        url: new URL(url, location.origin),
-        method: method,
-        headers: new Headers(request.headers),
-        credentials: request.credentials,
-        body: await request.clone().text(),
-        respondWith: createLazyCallback(),
-      }
-
-      this.log('isomorphic request', isomorphicRequest)
-
-      this.log(
-        'emitting the "request" event for %d listener(s)...',
-        this.emitter.listenerCount('request')
-      )
-      this.emitter.emit('request', isomorphicRequest)
+    debug('[%s] %s', method, url)
 
-      this.log('awaiting for the mocked response...')
-
-      await this.emitter.untilIdle('request')
-      this.log('all request listeners have been resolved!')
-
-      const [mockedResponse] = await isomorphicRequest.respondWith.invoked()
-      this.log('event.respondWith called with:', mockedResponse)
-
-      if (mockedResponse) {
-        this.log('received mocked response:', mockedResponse)
-
-        const isomorphicResponse = toIsoResponse(mockedResponse)
-        this.log('derived isomorphic response:', isomorphicResponse)
-
-        this.emitter.emit('response', isomorphicRequest, isomorphicResponse)
+    const isoRequest: IsomorphicRequest = {
+      id: uuidv4(),
+      url: new URL(url, location.origin),
+      method: method,
+      headers: new Headers(request.headers),
+      credentials: request.credentials,
+      body: await request.clone().text(),
+    }
+    debug('isomorphic request', isoRequest)
+    observer.emit('request', isoRequest)
 
-        return new Response(mockedResponse.body, {
-          ...isomorphicResponse,
-          // `Response.headers` cannot be instantiated with the `Headers` polyfill.
-          // Apparently, it halts if the `Headers` class contains unknown properties
-          // (i.e. the internal `Headers.map`).
-          headers: flattenHeadersObject(mockedResponse.headers || {}),
-        })
-      }
+    debug('awaiting for the mocked response...')
+    const response = await resolver(isoRequest, request)
+    debug('mocked response', response)
 
-      this.log('no mocked response received!')
+    if (response) {
+      const isomorphicResponse = toIsoResponse(response)
+      debug('derived isomorphic response', isomorphicResponse)
 
-      return pureFetch(request).then(async (response) => {
-        const cloneResponse = response.clone()
-        this.log('original fetch performed', cloneResponse)
+      observer.emit('response', isoRequest, isomorphicResponse)
 
-        this.emitter.emit(
-          'response',
-          isomorphicRequest,
-          await normalizeFetchResponse(cloneResponse)
-        )
-        return response
+      return new Response(response.body, {
+        ...isomorphicResponse,
+        // `Response.headers` cannot be instantiated with the `Headers` polyfill.
+        // Apparently, it halts if the `Headers` class contains unknown properties
+        // (i.e. the internal `Headers.map`).
+        headers: flattenHeadersObject(response.headers || {}),
       })
     }
 
-    this.subscriptions.push(() => {
-      globalThis.fetch = pureFetch
-      this.log('restored native "globalThis.fetch"!', globalThis.fetch.name)
+    debug('no mocked response found, bypassing...')
+
+    return pureFetch(request).then(async (response) => {
+      const cloneResponse = response.clone()
+      debug('original fetch performed', cloneResponse)
+
+      observer.emit(
+        'response',
+        isoRequest,
+        await normalizeFetchResponse(cloneResponse)
+      )
+      return response
     })
   }
+
+  return () => {
+    debug('restoring modules...')
+    window.fetch = pureFetch
+  }
 }
 
 async function normalizeFetchResponse(

package/src/presets/browser.ts

@@ -1,8 +1,8 @@
-import { FetchInterceptor } from '../interceptors/fetch'
-import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest'
+import { interceptXMLHttpRequest } from '../interceptors/XMLHttpRequest'
+import { interceptFetch } from '../interceptors/fetch'
 
 /**
  * The default preset provisions the interception of requests
  * regardless of their type (fetch/XMLHttpRequest).
  */
-export default [new FetchInterceptor(), new XMLHttpRequestInterceptor()]
+export default [interceptXMLHttpRequest, interceptFetch]

package/src/presets/node.ts

@@ -1,8 +1,8 @@
-import { ClientRequestInterceptor } from '../interceptors/ClientRequest'
-import { XMLHttpRequestInterceptor } from '../interceptors/XMLHttpRequest'
+import { interceptClientRequest } from '../interceptors/ClientRequest'
+import { interceptXMLHttpRequest } from '../interceptors/XMLHttpRequest'
 
 /**
  * The default preset provisions the interception of requests
  * regardless of their type (http/https/XMLHttpRequest).
  */
-export default [new ClientRequestInterceptor(), new XMLHttpRequestInterceptor()]
+export default [interceptClientRequest, interceptXMLHttpRequest]

package/src/remote.ts

@@ -0,0 +1,174 @@
+import { ChildProcess } from 'child_process'
+import { Headers } from 'headers-polyfill'
+import { invariant } from 'outvariant'
+import { StrictEventEmitter } from 'strict-event-emitter'
+import {
+  createInterceptor,
+  InterceptorApi,
+  InterceptorEventsMap,
+  InterceptorOptions,
+  IsomorphicRequest,
+  Resolver,
+} from './createInterceptor'
+import { toIsoResponse } from './utils/toIsoResponse'
+
+export type CreateRemoteInterceptorOptions = Omit<
+  InterceptorOptions,
+  'resolver'
+>
+
+export type RemoteResolverApi = Pick<InterceptorApi, 'on'>
+
+export interface CreateRemoteResolverOptions {
+  process: ChildProcess
+  resolver: Resolver
+}
+
+function requestReviver(key: string, value: any) {
+  switch (key) {
+    case 'url':
+      return new URL(value)
+
+    case 'headers':
+      return new Headers(value)
+
+    default:
+      return value
+  }
+}
+
+/**
+ * Creates a remote request interceptor that delegates
+ * the mocked response resolution to the parent process.
+ * The parent process must establish a remote resolver
+ * by calling `createRemoteResolver` function.
+ */
+export function createRemoteInterceptor(
+  options: CreateRemoteInterceptorOptions
+): InterceptorApi {
+  invariant(
+    process.connected,
+    `Failed to create a remote interceptor: the current process (%s) does not have a parent. Please make sure you're spawning this process as a child process in order to use remote request interception.`,
+    process.pid
+  )
+
+  if (typeof process.send === 'undefined') {
+    throw new Error(
+      `\
+Failed to create a remote interceptor: the current process (${process.pid}) does not have the IPC enabled. Please make sure you're spawning this process with the "ipc" stdio value set:
+
+spawn('node', ['module.js'], { stdio: ['ipc'] })\
+`
+    )
+  }
+
+  let handleParentMessage: NodeJS.MessageListener
+
+  const interceptor = createInterceptor({
+    ...options,
+    resolver(request) {
+      const serializedRequest = JSON.stringify(request)
+      process.send?.(`request:${serializedRequest}`)
+
+      return new Promise((resolve) => {
+        handleParentMessage = (message) => {
+          if (typeof message !== 'string') {
+            return
+          }
+
+          if (message.startsWith(`response:${request.id}`)) {
+            const [, responseString] =
+              message.match(/^response:.+?:(.+)$/) || []
+
+            if (!responseString) {
+              return resolve()
+            }
+
+            const mockedResponse = JSON.parse(responseString)
+
+            return resolve(mockedResponse)
+          }
+        }
+
+        process.addListener('message', handleParentMessage)
+      })
+    },
+  })
+
+  return {
+    ...interceptor,
+    restore() {
+      interceptor.restore()
+      process.removeListener('message', handleParentMessage)
+    },
+  }
+}
+
+/**
+ * Creates a response resolver function attached to the given `ChildProcess`.
+ * The child process must establish a remote interceptor by calling `createRemoteInterceptor` function.
+ */
+export function createRemoteResolver(
+  options: CreateRemoteResolverOptions
+): RemoteResolverApi {
+  const observer = new StrictEventEmitter<InterceptorEventsMap>()
+
+  const handleChildMessage: NodeJS.MessageListener = async (message) => {
+    if (typeof message !== 'string') {
+      return
+    }
+
+    if (message.startsWith('request:')) {
+      const [, requestString] = message.match(/^request:(.+)$/) || []
+
+      if (!requestString) {
+        return
+      }
+
+      const isoRequest: IsomorphicRequest = JSON.parse(
+        requestString,
+        requestReviver
+      )
+
+      observer.emit('request', isoRequest)
+
+      // Retrieve the mocked response.
+      const mockedResponse = await options.resolver(
+        isoRequest,
+        undefined as any
+      )
+
+      // Send the mocked response to the child process.
+      const serializedResponse = JSON.stringify(mockedResponse)
+      options.process.send(
+        `response:${isoRequest.id}:${serializedResponse}`,
+        (error) => {
+          if (error) {
+            return
+          }
+
+          if (mockedResponse) {
+            // Emit an optimisting "response" event at this point,
+            // not to rely on the back-and-forth signaling for the sake of the event.
+            observer.emit('response', isoRequest, toIsoResponse(mockedResponse))
+          }
+        }
+      )
+    }
+  }
+
+  const cleanup = () => {
+    options.process.removeListener('message', handleChildMessage)
+  }
+
+  options.process.addListener('message', handleChildMessage)
+  options.process.addListener('disconnect', cleanup)
+  options.process.addListener('error', cleanup)
+  options.process.addListener('exit', cleanup)
+
+  return {
+    on(event, listener) {
+      observer.addListener(event, listener)
+    },
+  }
+}

package/src/utils/toIsoResponse.ts

@@ -1,5 +1,5 @@
 import { objectToHeaders } from 'headers-polyfill'
-import { IsomorphicResponse, MockedResponse } from '../glossary'
+import { IsomorphicResponse, MockedResponse } from '../createInterceptor'
 
 /**
  * Converts a given mocked response object into an isomorphic response.

package/LICENSE.md

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2018–present Artem Zakharchenko
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/lib/BatchInterceptor.d.ts

@@ -1,18 +0,0 @@
-import { EventMapType } from 'strict-event-emitter';
-import { ExtractEventNames, Interceptor } from './Interceptor';
-export interface BatchInterceptorOptions<InterceptorList extends Interceptor<any>[]> {
-    name: string;
-    interceptors: InterceptorList;
-}
-export declare type ExtractEventMapType<InterceptorList extends Interceptor<any>[]> = InterceptorList extends Array<infer InterceptorType> ? InterceptorType extends Interceptor<infer EventMap> ? EventMap : never : never;
-/**
- * A batch interceptor that exposes a single interface
- * to apply and operate with multiple interceptors at once.
- */
-export declare class BatchInterceptor<InterceptorList extends Interceptor<any>[], EventMap extends EventMapType = ExtractEventMapType<InterceptorList>> extends Interceptor<EventMap> {
-    static symbol: Symbol;
-    private interceptors;
-    constructor(options: BatchInterceptorOptions<InterceptorList>);
-    protected setup(): void;
-    on<Event extends ExtractEventNames<EventMap>>(event: Event, listener: EventMap[Event]): void;
-}

package/lib/BatchInterceptor.js

@@ -1,79 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchInterceptor = void 0;
-var Interceptor_1 = require("./Interceptor");
-/**
- * A batch interceptor that exposes a single interface
- * to apply and operate with multiple interceptors at once.
- */
-var BatchInterceptor = /** @class */ (function (_super) {
-    __extends(BatchInterceptor, _super);
-    function BatchInterceptor(options) {
-        var _this = this;
-        BatchInterceptor.symbol = Symbol(options.name);
-        _this = _super.call(this, BatchInterceptor.symbol) || this;
-        _this.interceptors = options.interceptors;
-        return _this;
-    }
-    BatchInterceptor.prototype.setup = function () {
-        var e_1, _a;
-        var log = this.log.extend('setup');
-        log('applying all %d interceptors...', this.interceptors.length);
-        var _loop_1 = function (interceptor) {
-            log('applying "%s" interceptor...', interceptor.constructor.name);
-            interceptor.apply();
-            log('adding interceptor dispose subscription');
-            this_1.subscriptions.push(function () { return interceptor.dispose(); });
-        };
-        var this_1 = this;
-        try {
-            for (var _b = __values(this.interceptors), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var interceptor = _c.value;
-                _loop_1(interceptor);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    BatchInterceptor.prototype.on = function (event, listener) {
-        // Instead of adding a listener to the batch interceptor,
-        // propagate the listener to each of the individual interceptors.
-        this.interceptors.forEach(function (interceptor) {
-            interceptor.on(event, listener);
-        });
-    };
-    return BatchInterceptor;
-}(Interceptor_1.Interceptor));
-exports.BatchInterceptor = BatchInterceptor;
-//# sourceMappingURL=BatchInterceptor.js.map

package/lib/BatchInterceptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BatchInterceptor.js","sourceRoot":"","sources":["../src/BatchInterceptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,6CAA8D;AAgB9D;;;GAGG;AACH;IAGU,oCAAqB;IAK7B,0BAAY,OAAiD;QAA7D,iBAIC;QAHC,gBAAgB,CAAC,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC9C,QAAA,kBAAM,gBAAgB,CAAC,MAAM,CAAC,SAAA;QAC9B,KAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAA;;IAC1C,CAAC;IAES,gCAAK,GAAf;;QACE,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;QAEpC,GAAG,CAAC,iCAAiC,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;gCAErD,WAAW;YACpB,GAAG,CAAC,8BAA8B,EAAE,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;YACjE,WAAW,CAAC,KAAK,EAAE,CAAA;YAEnB,GAAG,CAAC,yCAAyC,CAAC,CAAA;YAC9C,OAAK,aAAa,CAAC,IAAI,CAAC,cAAM,OAAA,WAAW,CAAC,OAAO,EAAE,EAArB,CAAqB,CAAC,CAAA;;;;YALtD,KAA0B,IAAA,KAAA,SAAA,IAAI,CAAC,YAAY,CAAA,gBAAA;gBAAtC,IAAM,WAAW,WAAA;wBAAX,WAAW;aAMrB;;;;;;;;;IACH,CAAC;IAEM,6BAAE,GAAT,UACE,KAAY,EACZ,QAAyB;QAEzB,yDAAyD;QACzD,iEAAiE;QACjE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,UAAC,WAAW;YACpC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjC,CAAC,CAAC,CAAA;IACJ,CAAC;IACH,uBAAC;AAAD,CAAC,AAtCD,CAGU,yBAAW,GAmCpB;AAtCY,4CAAgB"}

package/lib/Interceptor.d.ts

@@ -1,49 +0,0 @@
-import { Debugger } from 'debug';
-import { AsyncEventEmitter } from './utils/AsyncEventEmitter';
-export declare type InterceptorEventMap = Record<string, (...args: any[]) => void>;
-export declare type InterceptorSubscription = () => void;
-export declare function getGlobalSymbol<V>(symbol: Symbol): V | undefined;
-export declare function deleteGlobalSymbol(symbol: Symbol): void;
-export declare enum InterceptorReadyState {
-    IDLE = "IDLE",
-    APPLYING = "APPLYING",
-    APPLIED = "APPLIED",
-    DISPOSING = "DISPOSING",
-    DISPOSED = "DISPOSED"
-}
-export declare type ExtractEventNames<EventMap extends Record<string, any>> = EventMap extends Record<infer EventName, any> ? EventName : never;
-export declare class Interceptor<EventMap extends InterceptorEventMap> {
-    private readonly symbol;
-    protected emitter: AsyncEventEmitter<EventMap>;
-    protected subscriptions: InterceptorSubscription[];
-    protected log: Debugger;
-    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<Event extends ExtractEventNames<EventMap>>(event: Event, listener: EventMap[Event]): void;
-    /**
-     * Disposes of any side-effects this interceptor has introduced.
-     */
-    dispose(): void;
-    private getInstance;
-    private setInstance;
-    private clearInstance;
-}