@mswjs/interceptors 0.20.0 → 0.21.0

package/lib/node/chunk-VKKFXSTL.js

@@ -0,0 +1,660 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+
+var _chunk6V3JXLBFjs = require('./chunk-6V3JXLBF.js');
+
+
+
+var _chunkZJOF5MEZjs = require('./chunk-ZJOF5MEZ.js');
+
+
+
+var _chunkQMIXLBOUjs = require('./chunk-QMIXLBOU.js');
+
+// src/interceptors/ClientRequest/index.ts
+var _http = require('http'); var _http2 = _interopRequireDefault(_http);
+var _https = require('https'); var _https2 = _interopRequireDefault(_https);
+
+// src/interceptors/ClientRequest/NodeClientRequest.ts
+
+var _until = require('@open-draft/until');
+
+// src/interceptors/ClientRequest/utils/normalizeClientRequestEndArgs.ts
+var debug = _chunkQMIXLBOUjs.__require.call(void 0, "debug")("http normalizeClientRequestEndArgs");
+function normalizeClientRequestEndArgs(...args) {
+  debug("arguments", args);
+  const normalizedArgs = new Array(3).fill(null).map((value, index) => args[index] || value);
+  normalizedArgs.sort((a, b) => {
+    if (typeof a === "function") {
+      return 1;
+    }
+    if (typeof b === "function") {
+      return -1;
+    }
+    if (typeof a === "string" && typeof b === "string") {
+      return normalizedArgs.indexOf(a) - normalizedArgs.indexOf(b);
+    }
+    return 0;
+  });
+  debug("normalized args", normalizedArgs);
+  return normalizedArgs;
+}
+
+// src/interceptors/ClientRequest/utils/normalizeClientRequestWriteArgs.ts
+var _debug = require('debug');
+var log = _debug.debug.call(void 0, "http normalizeWriteArgs");
+function normalizeClientRequestWriteArgs(args) {
+  log("normalizing ClientRequest.write arguments...", args);
+  const chunk = args[0];
+  const encoding = typeof args[1] === "string" ? args[1] : void 0;
+  const callback = typeof args[1] === "function" ? args[1] : args[2];
+  const writeArgs = [
+    chunk,
+    encoding,
+    callback
+  ];
+  log("successfully normalized ClientRequest.write arguments:", writeArgs);
+  return writeArgs;
+}
+
+// src/interceptors/ClientRequest/utils/cloneIncomingMessage.ts
+
+var _stream = require('stream');
+var IS_CLONE = Symbol("isClone");
+function cloneIncomingMessage(message) {
+  const clone = message.pipe(new (0, _stream.PassThrough)());
+  inheritProperties(message, clone);
+  const clonedPrototype = Object.create(_http.IncomingMessage.prototype);
+  getPrototypes(clone).forEach((prototype) => {
+    inheritProperties(prototype, clonedPrototype);
+  });
+  Object.setPrototypeOf(clone, clonedPrototype);
+  Object.defineProperty(clone, IS_CLONE, {
+    enumerable: true,
+    value: true
+  });
+  return clone;
+}
+function getPrototypes(source) {
+  const prototypes = [];
+  let current = source;
+  while (current = Object.getPrototypeOf(current)) {
+    prototypes.push(current);
+  }
+  return prototypes;
+}
+function inheritProperties(source, target) {
+  const properties = [
+    ...Object.getOwnPropertyNames(source),
+    ...Object.getOwnPropertySymbols(source)
+  ];
+  for (const property of properties) {
+    if (target.hasOwnProperty(property)) {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(source, property);
+    if (!descriptor) {
+      continue;
+    }
+    Object.defineProperty(target, property, descriptor);
+  }
+}
+
+// src/interceptors/ClientRequest/utils/createResponse.ts
+var _headerspolyfill = require('headers-polyfill');
+function createResponse(message) {
+  const readable = new (0, _chunk6V3JXLBFjs.ReadableStream)({
+    start(controller) {
+      message.on("data", (chunk) => controller.enqueue(chunk));
+      message.on("end", () => controller.close());
+    }
+  });
+  return new (0, _chunk6V3JXLBFjs.Response)(readable, {
+    status: message.statusCode,
+    statusText: message.statusMessage,
+    headers: _headerspolyfill.objectToHeaders.call(void 0, message.headers)
+  });
+}
+
+// src/interceptors/ClientRequest/utils/createRequest.ts
+
+function createRequest(clientRequest) {
+  const headers = new (0, _headerspolyfill.Headers)();
+  const outgoingHeaders = clientRequest.getHeaders();
+  for (const headerName in outgoingHeaders) {
+    const headerValue = outgoingHeaders[headerName];
+    if (!headerValue) {
+      continue;
+    }
+    const valuesList = Array.prototype.concat([], headerValue);
+    for (const value of valuesList) {
+      headers.append(headerName, value.toString());
+    }
+  }
+  return new (0, _chunk6V3JXLBFjs.Request)(clientRequest.url, {
+    method: clientRequest.method || "GET",
+    headers,
+    credentials: "same-origin",
+    body: clientRequest.requestBuffer
+  });
+}
+
+// src/interceptors/ClientRequest/NodeClientRequest.ts
+var _NodeClientRequest = class extends _http.ClientRequest {
+  constructor([url, requestOptions, callback], options) {
+    super(requestOptions, callback);
+    this.chunks = [];
+    this.responseSource = "mock";
+    this.log = options.log.extend(
+      `request ${requestOptions.method} ${url.href}`
+    );
+    this.log("constructing ClientRequest using options:", {
+      url,
+      requestOptions,
+      callback
+    });
+    this.url = url;
+    this.emitter = options.emitter;
+    this.requestBuffer = null;
+    this.response = new (0, _http.IncomingMessage)(this.socket);
+  }
+  writeRequestBodyChunk(chunk, encoding) {
+    if (chunk == null) {
+      return;
+    }
+    if (this.requestBuffer == null) {
+      this.requestBuffer = Buffer.from([]);
+    }
+    const resolvedChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+    this.requestBuffer = Buffer.concat([this.requestBuffer, resolvedChunk]);
+  }
+  write(...args) {
+    var _a;
+    const [chunk, encoding, callback] = normalizeClientRequestWriteArgs(args);
+    this.log("write:", { chunk, encoding, callback });
+    this.chunks.push({ chunk, encoding });
+    this.writeRequestBodyChunk(chunk, encoding);
+    this.log("chunk successfully stored!", (_a = this.requestBuffer) == null ? void 0 : _a.byteLength);
+    if (!chunk || chunk.length === 0) {
+      this.log("written chunk is empty, skipping callback...");
+    } else {
+      callback == null ? void 0 : callback();
+    }
+    return true;
+  }
+  end(...args) {
+    this.log("end", args);
+    const requestId = _chunkZJOF5MEZjs.uuidv4.call(void 0, );
+    const [chunk, encoding, callback] = normalizeClientRequestEndArgs(...args);
+    this.log("normalized arguments:", { chunk, encoding, callback });
+    this.writeRequestBodyChunk(chunk, encoding || void 0);
+    const capturedRequest = createRequest(this);
+    const interactiveRequest = _chunkZJOF5MEZjs.toInteractiveRequest.call(void 0, capturedRequest);
+    if (this.getHeader("X-Request-Id") != null) {
+      this.removeHeader("X-Request-Id");
+      return this.passthrough(chunk, encoding, callback);
+    }
+    this.log(
+      'emitting the "request" event for %d listener(s)...',
+      this.emitter.listenerCount("request")
+    );
+    this.emitter.emit("request", interactiveRequest, requestId);
+    _until.until.call(void 0, async () => {
+      await this.emitter.untilIdle(
+        "request",
+        ({ args: [, pendingRequestId] }) => {
+          return pendingRequestId === requestId;
+        }
+      );
+      const [mockedResponse] = await interactiveRequest.respondWith.invoked();
+      this.log("event.respondWith called with:", mockedResponse);
+      return mockedResponse;
+    }).then(([resolverException, mockedResponse]) => {
+      this.log("the listeners promise awaited!");
+      if (resolverException) {
+        this.log(
+          "encountered resolver exception, aborting request...",
+          resolverException
+        );
+        this.emit("error", resolverException);
+        this.terminate();
+        return this;
+      }
+      for (const [headerName, headerValue] of capturedRequest.headers) {
+        this.setHeader(headerName, headerValue);
+      }
+      if (mockedResponse) {
+        const responseClone = mockedResponse.clone();
+        this.log("received mocked response:", mockedResponse);
+        this.responseSource = "mock";
+        this.respondWith(mockedResponse);
+        this.log(mockedResponse.status, mockedResponse.statusText, "(MOCKED)");
+        callback == null ? void 0 : callback();
+        this.log('emitting the custom "response" event...');
+        this.emitter.emit("response", responseClone, capturedRequest, requestId);
+        this.log("request (mock) is completed");
+        return this;
+      }
+      this.log("no mocked response received!");
+      this.once("response-internal", (message) => {
+        this.log(message.statusCode, message.statusMessage);
+        this.log("original response headers:", message.headers);
+        this.log('emitting the custom "response" event...');
+        this.emitter.emit(
+          "response",
+          createResponse(message),
+          capturedRequest,
+          requestId
+        );
+      });
+      return this.passthrough(chunk, encoding, callback);
+    });
+    return this;
+  }
+  emit(event, ...data) {
+    this.log("emit: %s", event);
+    if (event === "response") {
+      this.log('found "response" event, cloning the response...');
+      try {
+        const response = data[0];
+        const firstClone = cloneIncomingMessage(response);
+        const secondClone = cloneIncomingMessage(response);
+        this.emit("response-internal", secondClone);
+        this.log('response successfully cloned, emitting "response" event...');
+        return super.emit(event, firstClone, ...data.slice(1));
+      } catch (error) {
+        this.log("error when cloning response:", error);
+        return super.emit(event, ...data);
+      }
+    }
+    if (event === "error") {
+      const error = data[0];
+      const errorCode = error.code || "";
+      this.log("error:\n", error);
+      if (this.responseSource === "mock" && _NodeClientRequest.suppressErrorCodes.includes(errorCode)) {
+        if (!this.capturedError) {
+          this.capturedError = error;
+          this.log("captured the first error:", this.capturedError);
+        }
+        return false;
+      }
+    }
+    return super.emit(event, ...data);
+  }
+  passthrough(chunk, encoding, callback) {
+    this.responseSource = "bypass";
+    if (this.capturedError) {
+      this.emit("error", this.capturedError);
+      return this;
+    }
+    this.log("writing request chunks...", this.chunks);
+    for (const { chunk: chunk2, encoding: encoding2 } of this.chunks) {
+      if (encoding2) {
+        super.write(chunk2, encoding2);
+      } else {
+        super.write(chunk2);
+      }
+    }
+    this.once("error", (error) => {
+      this.log("original request error:", error);
+    });
+    this.once("abort", () => {
+      this.log("original request aborted!");
+    });
+    this.once("response-internal", (message) => {
+      this.log(message.statusCode, message.statusMessage);
+      this.log("original response headers:", message.headers);
+    });
+    this.log("performing original request...");
+    return super.end(...[chunk, encoding, callback].filter(Boolean));
+  }
+  respondWith(mockedResponse) {
+    this.log("responding with a mocked response...", mockedResponse);
+    const { status, statusText, headers, body } = mockedResponse;
+    this.response.statusCode = status;
+    this.response.statusMessage = statusText;
+    if (headers) {
+      this.response.headers = {};
+      headers.forEach((headerValue, headerName) => {
+        this.response.rawHeaders.push(headerName, headerValue);
+        const insensitiveHeaderName = headerName.toLowerCase();
+        const prevHeaders = this.response.headers[insensitiveHeaderName];
+        this.response.headers[insensitiveHeaderName] = prevHeaders ? Array.prototype.concat([], prevHeaders, headerValue) : headerValue;
+      });
+    }
+    this.log("mocked response headers ready:", headers);
+    const closeResponseStream = () => {
+      this.response.push(null);
+      this.response.complete = true;
+    };
+    if (body) {
+      const bodyReader = body.getReader();
+      const readNextChunk = async () => {
+        const { done, value } = await bodyReader.read();
+        if (done) {
+          closeResponseStream();
+          return;
+        }
+        this.response.push(value);
+        return readNextChunk();
+      };
+      readNextChunk();
+    } else {
+      closeResponseStream();
+    }
+    this.res = this.response;
+    this.finished = true;
+    Object.defineProperty(this, "writableEnded", {
+      value: true
+    });
+    this.emit("finish");
+    this.emit("response", this.response);
+    this.terminate();
+  }
+  terminate() {
+    var _a;
+    (_a = this.agent) == null ? void 0 : _a.destroy();
+  }
+};
+var NodeClientRequest = _NodeClientRequest;
+NodeClientRequest.suppressErrorCodes = [
+  "ENOTFOUND",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EAI_AGAIN"
+];
+
+// src/interceptors/ClientRequest/utils/normalizeClientRequestArgs.ts
+
+
+
+
+
+
+
+
+
+
+// src/utils/getRequestOptionsByUrl.ts
+function getRequestOptionsByUrl(url) {
+  const options = {
+    method: "GET",
+    protocol: url.protocol,
+    hostname: typeof url.hostname === "string" && url.hostname.startsWith("[") ? url.hostname.slice(1, -1) : url.hostname,
+    host: url.host,
+    path: `${url.pathname}${url.search || ""}`
+  };
+  if (!!url.port) {
+    options.port = Number(url.port);
+  }
+  if (url.username || url.password) {
+    options.auth = `${url.username}:${url.password}`;
+  }
+  return options;
+}
+
+// src/utils/getUrlByRequestOptions.ts
+
+var debug3 = _chunkQMIXLBOUjs.__require.call(void 0, "debug")("utils getUrlByRequestOptions");
+var DEFAULT_PATH = "/";
+var DEFAULT_PROTOCOL = "http:";
+var DEFAULT_HOST = "localhost";
+var DEFAULT_PORT = 80;
+var SSL_PORT = 443;
+function getAgent(options) {
+  return options.agent instanceof _http.Agent ? options.agent : void 0;
+}
+function getProtocolByRequestOptions(options) {
+  var _a;
+  if (options.protocol) {
+    return options.protocol;
+  }
+  const agent = getAgent(options);
+  const agentProtocol = agent == null ? void 0 : agent.protocol;
+  if (agentProtocol) {
+    return agentProtocol;
+  }
+  const port = getPortByRequestOptions(options);
+  const isSecureRequest = options.cert || port === SSL_PORT;
+  return isSecureRequest ? "https:" : ((_a = options.uri) == null ? void 0 : _a.protocol) || DEFAULT_PROTOCOL;
+}
+function getPortByRequestOptions(options) {
+  const agent = getAgent(options);
+  const agentPort = (agent == null ? void 0 : agent.options.port) || (agent == null ? void 0 : agent.defaultPort);
+  const optionsPort = options.port;
+  if (optionsPort || agentPort) {
+    const explicitPort = optionsPort || agentPort || DEFAULT_PORT;
+    return Number(explicitPort);
+  }
+}
+function getHostByRequestOptions(options) {
+  return options.hostname || options.host || DEFAULT_HOST;
+}
+function getAuthByRequestOptions(options) {
+  if (options.auth) {
+    const [username, password] = options.auth.split(":");
+    return { username, password };
+  }
+}
+function getUrlByRequestOptions(options) {
+  debug3("request options", options);
+  const protocol = getProtocolByRequestOptions(options);
+  const host = getHostByRequestOptions(options);
+  const port = getPortByRequestOptions(options);
+  const path = options.path || DEFAULT_PATH;
+  const auth = getAuthByRequestOptions(options);
+  debug3("protocol", protocol);
+  debug3("host", host);
+  debug3("port", port);
+  debug3("path", path);
+  const baseUrl = `${protocol}//${host}`;
+  debug3("base URL:", baseUrl);
+  const url = options.uri ? new URL(options.uri.href) : new URL(path, baseUrl);
+  if (port) {
+    debug3("detected explicit port", port);
+    url.port = port.toString();
+  }
+  if (auth) {
+    debug3("resolved auth", auth);
+    url.username = auth.username;
+    url.password = auth.password;
+  }
+  debug3("created URL:", url);
+  return url;
+}
+
+// src/utils/cloneObject.ts
+var debug4 = _chunkQMIXLBOUjs.__require.call(void 0, "debug")("cloneObject");
+function isPlainObject(obj) {
+  var _a;
+  debug4("is plain object?", obj);
+  if (obj == null || !((_a = obj.constructor) == null ? void 0 : _a.name)) {
+    debug4("given object is undefined, not a plain object...");
+    return false;
+  }
+  debug4("checking the object constructor:", obj.constructor.name);
+  return obj.constructor.name === "Object";
+}
+function cloneObject(obj) {
+  debug4("cloning object:", obj);
+  const enumerableProperties = Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      debug4("analyzing key-value pair:", key, value);
+      acc[key] = isPlainObject(value) ? cloneObject(value) : value;
+      return acc;
+    },
+    {}
+  );
+  return isPlainObject(obj) ? enumerableProperties : Object.assign(Object.getPrototypeOf(obj), enumerableProperties);
+}
+
+// src/utils/isObject.ts
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+
+// src/interceptors/ClientRequest/utils/normalizeClientRequestArgs.ts
+var log2 = _debug.debug.call(void 0, "http normalizeClientRequestArgs");
+function resolveRequestOptions(args, url) {
+  if (typeof args[1] === "undefined" || typeof args[1] === "function") {
+    log2("request options not provided, deriving from the url", url);
+    return getRequestOptionsByUrl(url);
+  }
+  if (args[1]) {
+    log2("has custom RequestOptions!", args[1]);
+    const requestOptionsFromUrl = getRequestOptionsByUrl(url);
+    log2("derived RequestOptions from the URL:", requestOptionsFromUrl);
+    log2("cloning RequestOptions...");
+    const clonedRequestOptions = cloneObject(args[1]);
+    log2("successfully cloned RequestOptions!", clonedRequestOptions);
+    return {
+      ...requestOptionsFromUrl,
+      ...clonedRequestOptions
+    };
+  }
+  log2("using an empty object as request options");
+  return {};
+}
+function resolveCallback(args) {
+  return typeof args[1] === "function" ? args[1] : args[2];
+}
+function normalizeClientRequestArgs(defaultProtocol, ...args) {
+  let url;
+  let options;
+  let callback;
+  log2("arguments", args);
+  log2("using default protocol:", defaultProtocol);
+  if (typeof args[0] === "string") {
+    log2("first argument is a location string:", args[0]);
+    url = new URL(args[0]);
+    log2("created a url:", url);
+    const requestOptionsFromUrl = getRequestOptionsByUrl(url);
+    log2("request options from url:", requestOptionsFromUrl);
+    options = resolveRequestOptions(args, url);
+    log2("resolved request options:", options);
+    callback = resolveCallback(args);
+  } else if (args[0] instanceof URL) {
+    url = args[0];
+    log2("first argument is a URL:", url);
+    options = resolveRequestOptions(args, url);
+    log2("derived request options:", options);
+    callback = resolveCallback(args);
+  } else if ("hash" in args[0] && !("method" in args[0])) {
+    const [legacyUrl] = args;
+    log2("first argument is a legacy URL:", legacyUrl);
+    if (legacyUrl.hostname === null) {
+      log2("given legacy URL is relative (no hostname)");
+      return isObject(args[1]) ? normalizeClientRequestArgs(
+        defaultProtocol,
+        { path: legacyUrl.path, ...args[1] },
+        args[2]
+      ) : normalizeClientRequestArgs(
+        defaultProtocol,
+        { path: legacyUrl.path },
+        args[1]
+      );
+    }
+    log2("given legacy url is absolute");
+    const resolvedUrl = new URL(legacyUrl.href);
+    return args[1] === void 0 ? normalizeClientRequestArgs(defaultProtocol, resolvedUrl) : typeof args[1] === "function" ? normalizeClientRequestArgs(defaultProtocol, resolvedUrl, args[1]) : normalizeClientRequestArgs(
+      defaultProtocol,
+      resolvedUrl,
+      args[1],
+      args[2]
+    );
+  } else if (isObject(args[0])) {
+    options = args[0];
+    log2("first argument is RequestOptions:", options);
+    options.protocol = options.protocol || defaultProtocol;
+    log2("normalized request options:", options);
+    url = getUrlByRequestOptions(options);
+    log2("created a URL from RequestOptions:", url.href);
+    callback = resolveCallback(args);
+  } else {
+    throw new Error(
+      `Failed to construct ClientRequest with these parameters: ${args}`
+    );
+  }
+  options.protocol = options.protocol || url.protocol;
+  options.method = options.method || "GET";
+  if (typeof options.agent === "undefined") {
+    const agent = options.protocol === "https:" ? new (0, _https.Agent)({
+      rejectUnauthorized: options.rejectUnauthorized
+    }) : new (0, _http.Agent)();
+    options.agent = agent;
+    log2("resolved fallback agent:", agent);
+  }
+  if (!options._defaultAgent) {
+    log2(
+      'has no default agent, setting the default agent for "%s"',
+      options.protocol
+    );
+    options._defaultAgent = options.protocol === "https:" ? _https.globalAgent : _http.globalAgent;
+  }
+  log2("successfully resolved url:", url.href);
+  log2("successfully resolved options:", options);
+  log2("successfully resolved callback:", callback);
+  return [url, options, callback];
+}
+
+// src/interceptors/ClientRequest/http.get.ts
+function get(protocol, options) {
+  return (...args) => {
+    const clientRequestArgs = normalizeClientRequestArgs(
+      `${protocol}:`,
+      ...args
+    );
+    const request2 = new NodeClientRequest(clientRequestArgs, options);
+    request2.end();
+    return request2;
+  };
+}
+
+// src/interceptors/ClientRequest/http.request.ts
+
+var log3 = _debug.debug.call(void 0, "http request");
+function request(protocol, options) {
+  return (...args) => {
+    log3('request call (protocol "%s"):', protocol, args);
+    const clientRequestArgs = normalizeClientRequestArgs(
+      `${protocol}:`,
+      ...args
+    );
+    return new NodeClientRequest(clientRequestArgs, options);
+  };
+}
+
+// src/interceptors/ClientRequest/index.ts
+var _ClientRequestInterceptor = class extends _chunkQMIXLBOUjs.Interceptor {
+  constructor() {
+    super(_ClientRequestInterceptor.symbol);
+    this.modules = /* @__PURE__ */ new Map();
+    this.modules.set("http", _http2.default);
+    this.modules.set("https", _https2.default);
+  }
+  setup() {
+    const log4 = this.log.extend("setup");
+    for (const [protocol, requestModule] of this.modules) {
+      const { request: pureRequest, get: pureGet } = requestModule;
+      this.subscriptions.push(() => {
+        requestModule.request = pureRequest;
+        requestModule.get = pureGet;
+        log4('native "%s" module restored!', protocol);
+      });
+      const options = {
+        emitter: this.emitter,
+        log: this.log
+      };
+      requestModule.request = request(protocol, options);
+      requestModule.get = get(protocol, options);
+      log4('native "%s" module patched!', protocol);
+    }
+  }
+};
+var ClientRequestInterceptor = _ClientRequestInterceptor;
+ClientRequestInterceptor.symbol = Symbol("http");
+
+
+
+exports.ClientRequestInterceptor = ClientRequestInterceptor;

package/lib/node/chunk-VQ4DZOBB.js

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/glossary.ts
+var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+
+
+
+exports.IS_PATCHED_MODULE = IS_PATCHED_MODULE;