@mswjs/interceptors 0.19.5 → 0.20.0

package/src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts

@@ -0,0 +1,111 @@
+import type { Debugger } from 'debug'
+import { until } from '@open-draft/until'
+import { XMLHttpRequestEmitter } from '.'
+import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
+import { XMLHttpRequestController } from './XMLHttpRequestController'
+
+export interface XMLHttpRequestProxyOptions {
+  emitter: XMLHttpRequestEmitter
+  log: Debugger
+}
+
+/**
+ * Create a proxied `XMLHttpRequest` class.
+ * The proxied class establishes spies on certain methods,
+ * allowing us to intercept requests and respond to them.
+ */
+export function createXMLHttpRequestProxy({
+  emitter,
+  log,
+}: XMLHttpRequestProxyOptions) {
+  const XMLHttpRequestProxy = new Proxy(globalThis.XMLHttpRequest, {
+    construct(target, args) {
+      log('constructed new XMLHttpRequest')
+
+      const originalRequest = Reflect.construct(target, args)
+
+      const requestController = new XMLHttpRequestController(
+        originalRequest,
+        log
+      )
+
+      requestController.onRequest = async function (request, requestId) {
+        // Notify the consumer about a new request.
+        const interactiveRequest = toInteractiveRequest(request)
+
+        this.log(
+          'emitting the "request" event for %s listener(s)...',
+          emitter.listenerCount('request')
+        )
+        emitter.emit('request', interactiveRequest, requestId)
+
+        this.log('awaiting mocked response...')
+
+        const [middlewareException, mockedResponse] = await until(async () => {
+          await emitter.untilIdle(
+            'request',
+            ({ args: [, pendingRequestId] }) => {
+              return pendingRequestId === requestId
+            }
+          )
+
+          this.log('all "request" listeners settled!')
+
+          const [mockedResponse] =
+            await interactiveRequest.respondWith.invoked()
+
+          this.log('event.respondWith called with:', mockedResponse)
+
+          return mockedResponse
+        })
+
+        if (middlewareException) {
+          this.log(
+            'request listener threw an exception, aborting request...',
+            middlewareException
+          )
+
+          /**
+           * @todo Consider forwarding this error to the stderr as well
+           * since not all consumers are expecting to handle errors.
+           * If they don't, this error will be swallowed.
+           */
+          requestController.errorWith(middlewareException)
+          return
+        }
+
+        if (typeof mockedResponse !== 'undefined') {
+          this.log(
+            'received mocked response: %d %s',
+            mockedResponse.status,
+            mockedResponse.statusText
+          )
+
+          return requestController.respondWith(mockedResponse)
+        }
+
+        this.log('no mocked response received, performing request as-is...')
+      }
+
+      requestController.onResponse = async function (
+        response,
+        request,
+        requestId
+      ) {
+        this.log(
+          'emitting the "response" event for %s listener(s)...',
+          emitter.listenerCount('response')
+        )
+
+        emitter.emit('response', response, request, requestId)
+      }
+
+      // Return the proxied request from the controller
+      // so that the controller can react to the consumer's interactions
+      // with this request (opening/sending/etc).
+      return requestController.request
+    },
+  })
+
+  return XMLHttpRequestProxy
+}

package/src/interceptors/XMLHttpRequest/index.ts

@@ -3,7 +3,7 @@ import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
 import { InteractiveRequest } from '../../utils/toInteractiveRequest'
 import { Interceptor } from '../../Interceptor'
 import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
-import { createXMLHttpRequestOverride } from './XMLHttpRequestOverride'
+import { createXMLHttpRequestProxy } from './XMLHttpRequestProxy'
 
 export type XMLHttpRequestEventListener = (
   request: InteractiveRequest,
@@ -20,10 +20,7 @@ export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap>
   }
 
   protected checkEnvironment() {
-    return (
-      typeof window !== 'undefined' &&
-      typeof window.XMLHttpRequest !== 'undefined'
-    )
+    return typeof globalThis.XMLHttpRequest !== 'undefined'
   }
 
   protected setup() {
@@ -31,36 +28,38 @@ export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap>
 
     log('patching "XMLHttpRequest" module...')
 
-    const PureXMLHttpRequest = window.XMLHttpRequest
+    const PureXMLHttpRequest = globalThis.XMLHttpRequest
 
     invariant(
       !(PureXMLHttpRequest as any)[IS_PATCHED_MODULE],
       'Failed to patch the "XMLHttpRequest" module: already patched.'
     )
 
-    window.XMLHttpRequest = createXMLHttpRequestOverride({
-      XMLHttpRequest: PureXMLHttpRequest,
+    globalThis.XMLHttpRequest = createXMLHttpRequestProxy({
       emitter: this.emitter,
       log: this.log,
     })
 
-    log('native "XMLHttpRequest" module patched!', window.XMLHttpRequest.name)
+    log(
+      'native "XMLHttpRequest" module patched!',
+      globalThis.XMLHttpRequest.name
+    )
 
-    Object.defineProperty(window.XMLHttpRequest, IS_PATCHED_MODULE, {
+    Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
       enumerable: true,
       configurable: true,
       value: true,
     })
 
     this.subscriptions.push(() => {
-      Object.defineProperty(window.XMLHttpRequest, IS_PATCHED_MODULE, {
+      Object.defineProperty(globalThis.XMLHttpRequest, IS_PATCHED_MODULE, {
         value: undefined,
       })
 
-      window.XMLHttpRequest = PureXMLHttpRequest
+      globalThis.XMLHttpRequest = PureXMLHttpRequest
       log(
         'native "XMLHttpRequest" module restored!',
-        window.XMLHttpRequest.name
+        globalThis.XMLHttpRequest.name
       )
     })
   }

package/src/utils/createProxy.ts

@@ -0,0 +1,78 @@
+export interface ProxyOptions<Target extends Record<string, any>> {
+  constructorCall?(args: Array<unknown>, next: NextFunction<Target>): Target
+
+  methodCall?<F extends keyof Target>(
+    this: Target,
+    data: [methodName: F, args: Array<unknown>],
+    next: NextFunction<void>
+  ): void
+
+  setProperty?(
+    data: [propertyName: string | symbol, nextValue: unknown],
+    next: NextFunction<void>
+  ): void
+
+  getProperty?(
+    data: [propertyName: string | symbol, receiver: Target],
+    next: NextFunction<void>
+  ): void
+}
+
+export type NextFunction<ReturnType> = () => ReturnType
+
+export function createProxy<Target extends object>(
+  target: Target,
+  options: ProxyOptions<Target>
+): Target {
+  const proxy = new Proxy(target, optionsToProxyHandler(options))
+  return proxy
+}
+
+function optionsToProxyHandler<T extends Record<string, any>>(
+  options: ProxyOptions<T>
+): ProxyHandler<T> {
+  const { constructorCall, methodCall, getProperty, setProperty } = options
+  const handler: ProxyHandler<T> = {}
+
+  if (typeof constructorCall !== 'undefined') {
+    handler.construct = function (target, args, newTarget) {
+      const next = Reflect.construct.bind(null, target as any, args, newTarget)
+      return constructorCall.call(newTarget, args, next)
+    }
+  }
+
+  if (typeof setProperty !== 'undefined') {
+    handler.set = function (target, propertyName, nextValue, receiver) {
+      const next = () => Reflect.set(target, propertyName, nextValue, receiver)
+      return setProperty.call(target, [propertyName, nextValue], next) as any
+    }
+  }
+
+  handler.get = function (target, propertyName, receiver) {
+    /**
+     * @note Using `Reflect.get()` here causes "TypeError: Illegal invocation".
+     */
+    const next = () => target[propertyName as any]
+
+    const value =
+      typeof getProperty !== 'undefined'
+        ? getProperty.call(target, [propertyName, receiver], next)
+        : next()
+
+    if (typeof value === 'function') {
+      return (...args: Array<any>) => {
+        const next = value.bind(target, ...args)
+
+        if (typeof methodCall !== 'undefined') {
+          return methodCall.call(target, [propertyName as any, args], next)
+        }
+
+        return next()
+      }
+    }
+
+    return value
+  }
+
+  return handler
+}

package/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.d.ts

@@ -1,93 +0,0 @@
-/**
- * XMLHttpRequest override class.
- * Inspired by https://github.com/marvinhagemeister/xhr-mocklet.
- */
-import type { Debugger } from 'debug';
-import { Headers } from 'headers-polyfill';
-import type { XMLHttpRequestEmitter } from '.';
-declare type XMLHttpRequestEventHandler = (this: XMLHttpRequest, event: Event | ProgressEvent<any>) => void;
-interface XMLHttpRequestEvent<EventMap extends any> {
-    name: keyof EventMap;
-    listener: XMLHttpRequestEventHandler;
-}
-interface CreateXMLHttpRequestOverrideOptions {
-    XMLHttpRequest: typeof window.XMLHttpRequest;
-    emitter: XMLHttpRequestEmitter;
-    log: Debugger;
-}
-interface InternalXMLHttpRequestEventTargetEventMap extends XMLHttpRequestEventTargetEventMap {
-    readystatechange: Event;
-}
-export declare type ExtractCallbacks<Key extends string> = Key extends 'abort' | `on${infer _CallbackName}` ? Key : never;
-export declare const createXMLHttpRequestOverride: (options: CreateXMLHttpRequestOverrideOptions) => {
-    new (): {
-        _requestHeaders: Headers;
-        _responseHeaders: Headers;
-        _responseBuffer: Uint8Array;
-        _events: XMLHttpRequestEvent<InternalXMLHttpRequestEventTargetEventMap>[];
-        log: Debugger;
-        readonly UNSENT: 0;
-        readonly OPENED: 1;
-        readonly HEADERS_RECEIVED: 2;
-        readonly LOADING: 3;
-        readonly DONE: 4;
-        method: string;
-        url: string;
-        withCredentials: boolean;
-        status: number;
-        statusText: string;
-        user?: string | undefined;
-        password?: string | undefined;
-        async?: boolean | undefined;
-        responseType: XMLHttpRequestResponseType;
-        responseURL: string;
-        upload: XMLHttpRequestUpload;
-        readyState: number;
-        onreadystatechange: (this: XMLHttpRequest, ev: Event) => any;
-        timeout: number;
-        onabort: (this: XMLHttpRequestEventTarget, event: ProgressEvent) => any;
-        onerror: (this: XMLHttpRequestEventTarget, event: Event) => any;
-        onload: (this: XMLHttpRequestEventTarget, event: ProgressEvent) => any;
-        onloadend: (this: XMLHttpRequestEventTarget, event: ProgressEvent) => any;
-        onloadstart: (this: XMLHttpRequestEventTarget, event: ProgressEvent) => any;
-        onprogress: (this: XMLHttpRequestEventTarget, event: ProgressEvent) => any;
-        ontimeout: (this: XMLHttpRequestEventTarget, event: ProgressEvent) => any;
-        setReadyState(nextState: number): void;
-        /**
-         * Triggers both direct callback and attached event listeners
-         * for the given event.
-         */
-        trigger<K extends "readystatechange" | keyof XMLHttpRequestEventTargetEventMap>(eventName: K, options?: ProgressEventInit | undefined): any;
-        reset(): void;
-        open(method: string, url: string, async?: boolean, user?: string | undefined, password?: string | undefined): Promise<void>;
-        send(data?: string | ArrayBuffer | undefined): void;
-        readonly responseText: string;
-        readonly response: unknown;
-        readonly responseXML: Document | null;
-        abort(): void;
-        dispatchEvent(): boolean;
-        setRequestHeader(name: string, value: string): void;
-        getResponseHeader(name: string): string | null;
-        getAllResponseHeaders(): string;
-        addEventListener<Event_1 extends keyof InternalXMLHttpRequestEventTargetEventMap>(event: Event_1, listener: XMLHttpRequestEventHandler): void;
-        removeEventListener<Event_2 extends keyof XMLHttpRequestEventMap>(event: Event_2, listener: (event?: XMLHttpRequestEventMap[Event_2] | undefined) => void): void;
-        overrideMimeType(): void;
-        /**
-         * Propagates mock XMLHttpRequest instance callbacks
-         * to the given XMLHttpRequest instance.
-         */
-        propagateCallbacks(request: XMLHttpRequest): void;
-        /**
-         * Propagates the mock XMLHttpRequest instance listeners
-         * to the given XMLHttpRequest instance.
-         */
-        propagateListeners(request: XMLHttpRequest): void;
-        propagateHeaders(request: XMLHttpRequest, headers: Headers): void;
-    };
-    readonly UNSENT: 0;
-    readonly OPENED: 1;
-    readonly HEADERS_RECEIVED: 2;
-    readonly LOADING: 3;
-    readonly DONE: 4;
-};
-export {};