@zimic/interceptor 1.2.7-canary.2 → 1.3.0-canary.1

package/dist/http.js

@@ -123,19 +123,144 @@ var DisabledRequestSavingError = class extends TypeError {
 };
 var DisabledRequestSavingError_default = DisabledRequestSavingError;
 
-// ../zimic-utils/dist/chunk-5UH44FTS.mjs
+// ../zimic-utils/dist/data.mjs
 function isDefined(value) {
   return value !== void 0 && value !== null;
 }
 var isDefined_default = isDefined;
-
-// ../zimic-utils/dist/data/isNonEmpty.mjs
 function isNonEmpty(value) {
   return isDefined_default(value) && value !== "";
 }
 var isNonEmpty_default = isNonEmpty;
+async function blobEquals(blob, otherBlob) {
+  if (blob.type !== otherBlob.type || blob.size !== otherBlob.size) {
+    return false;
+  }
+  const reader = blob.stream().getReader();
+  const otherReader = otherBlob.stream().getReader();
+  let buffer = new Uint8Array(0);
+  let otherBuffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const bufferReadPromises = [];
+      if (buffer.length === 0) {
+        bufferReadPromises.push(
+          reader.read().then((result) => {
+            if (!result.done) {
+              buffer = result.value;
+            }
+          })
+        );
+      }
+      if (otherBuffer.length === 0) {
+        bufferReadPromises.push(
+          otherReader.read().then((result) => {
+            if (!result.done) {
+              otherBuffer = result.value;
+            }
+          })
+        );
+      }
+      await Promise.all(bufferReadPromises);
+      const haveStreamsEndedTogether = buffer.length === 0 && otherBuffer.length === 0;
+      if (haveStreamsEndedTogether) {
+        return true;
+      }
+      const hasOneStreamEndedBeforeTheOther = buffer.length === 0 && otherBuffer.length > 0 || buffer.length > 0 && otherBuffer.length === 0;
+      if (hasOneStreamEndedBeforeTheOther) {
+        return false;
+      }
+      const minimumByteLength = Math.min(buffer.length, otherBuffer.length);
+      for (let byteIndex = 0; byteIndex < minimumByteLength; byteIndex++) {
+        if (buffer[byteIndex] !== otherBuffer[byteIndex]) {
+          return false;
+        }
+      }
+      buffer = buffer.slice(minimumByteLength);
+      otherBuffer = otherBuffer.slice(minimumByteLength);
+    }
+  } finally {
+    reader.releaseLock();
+    otherReader.releaseLock();
+  }
+}
+var blobEquals_default = blobEquals;
+function isPrimitiveJSONValue(value) {
+  return typeof value !== "object" || value === null;
+}
+function jsonContains(value, otherValue) {
+  if (isPrimitiveJSONValue(value)) {
+    return value === otherValue;
+  }
+  if (isPrimitiveJSONValue(otherValue)) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    if (!Array.isArray(otherValue)) {
+      return false;
+    }
+    if (value.length < otherValue.length) {
+      return false;
+    }
+    let lastMatchedIndex = -1;
+    return otherValue.every((otherItem) => {
+      for (let index = lastMatchedIndex + 1; index < value.length; index++) {
+        if (jsonContains(value[index], otherItem)) {
+          lastMatchedIndex = index;
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  if (Array.isArray(otherValue)) {
+    return false;
+  }
+  const valueKeys = Object.keys(value);
+  const otherValueKeys = Object.keys(otherValue);
+  if (valueKeys.length < otherValueKeys.length) {
+    return false;
+  }
+  return otherValueKeys.every((key) => {
+    const subValue = value[key];
+    const subOtherValue = otherValue[key];
+    return jsonContains(subValue, subOtherValue);
+  });
+}
+var jsonContains_default = jsonContains;
+function jsonEquals(value, otherValue) {
+  if (isPrimitiveJSONValue(value)) {
+    return value === otherValue;
+  }
+  if (isPrimitiveJSONValue(otherValue)) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    if (!Array.isArray(otherValue)) {
+      return false;
+    }
+    if (value.length !== otherValue.length) {
+      return false;
+    }
+    return value.every((item, index) => jsonEquals(item, otherValue[index]));
+  }
+  if (Array.isArray(otherValue)) {
+    return false;
+  }
+  const valueKeys = Object.keys(value);
+  const otherValueKeys = Object.keys(otherValue);
+  if (valueKeys.length !== otherValueKeys.length) {
+    return false;
+  }
+  return valueKeys.every((key) => {
+    const subValue = value[key];
+    const subOtherValue = otherValue[key];
+    return jsonEquals(subValue, subOtherValue);
+  });
+}
+var jsonEquals_default = jsonEquals;
 
-// ../zimic-utils/dist/import/createCachedDynamicImport.mjs
+// ../zimic-utils/dist/chunk-W66SQPEM.mjs
 function createCachedDynamicImport(importModuleDynamically) {
   let cachedImportResult;
   return async function importModuleDynamicallyWithCache() {
@@ -145,7 +270,7 @@ function createCachedDynamicImport(importModuleDynamically) {
 }
 var createCachedDynamicImport_default = createCachedDynamicImport;
 
-// ../zimic-utils/dist/logging/Logger.mjs
+// ../zimic-utils/dist/logging.mjs
 var Logger = class _Logger {
   prefix;
   raw;
@@ -375,142 +500,7 @@ var TimesCheckError = class extends TypeError {
 };
 var TimesCheckError_default = TimesCheckError;
 
-// ../zimic-utils/dist/chunk-BSG74SVQ.mjs
-async function blobEquals(blob, otherBlob) {
-  if (blob.type !== otherBlob.type || blob.size !== otherBlob.size) {
-    return false;
-  }
-  const reader = blob.stream().getReader();
-  const otherReader = otherBlob.stream().getReader();
-  let buffer = new Uint8Array(0);
-  let otherBuffer = new Uint8Array(0);
-  try {
-    while (true) {
-      const bufferReadPromises = [];
-      if (buffer.length === 0) {
-        bufferReadPromises.push(
-          reader.read().then((result) => {
-            if (!result.done) {
-              buffer = result.value;
-            }
-          })
-        );
-      }
-      if (otherBuffer.length === 0) {
-        bufferReadPromises.push(
-          otherReader.read().then((result) => {
-            if (!result.done) {
-              otherBuffer = result.value;
-            }
-          })
-        );
-      }
-      await Promise.all(bufferReadPromises);
-      const haveStreamsEndedTogether = buffer.length === 0 && otherBuffer.length === 0;
-      if (haveStreamsEndedTogether) {
-        return true;
-      }
-      const hasOneStreamEndedBeforeTheOther = buffer.length === 0 && otherBuffer.length > 0 || buffer.length > 0 && otherBuffer.length === 0;
-      if (hasOneStreamEndedBeforeTheOther) {
-        return false;
-      }
-      const minimumByteLength = Math.min(buffer.length, otherBuffer.length);
-      for (let byteIndex = 0; byteIndex < minimumByteLength; byteIndex++) {
-        if (buffer[byteIndex] !== otherBuffer[byteIndex]) {
-          return false;
-        }
-      }
-      buffer = buffer.slice(minimumByteLength);
-      otherBuffer = otherBuffer.slice(minimumByteLength);
-    }
-  } finally {
-    reader.releaseLock();
-    otherReader.releaseLock();
-  }
-}
-var blobEquals_default = blobEquals;
-
-// ../zimic-utils/dist/chunk-LBZAJMTR.mjs
-function isPrimitiveJSONValue(value) {
-  return typeof value !== "object" || value === null;
-}
-
-// ../zimic-utils/dist/data/jsonContains.mjs
-function jsonContains(value, otherValue) {
-  if (isPrimitiveJSONValue(value)) {
-    return value === otherValue;
-  }
-  if (isPrimitiveJSONValue(otherValue)) {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    if (!Array.isArray(otherValue)) {
-      return false;
-    }
-    if (value.length < otherValue.length) {
-      return false;
-    }
-    let lastMatchedIndex = -1;
-    return otherValue.every((otherItem) => {
-      for (let index = lastMatchedIndex + 1; index < value.length; index++) {
-        if (jsonContains(value[index], otherItem)) {
-          lastMatchedIndex = index;
-          return true;
-        }
-      }
-      return false;
-    });
-  }
-  if (Array.isArray(otherValue)) {
-    return false;
-  }
-  const valueKeys = Object.keys(value);
-  const otherValueKeys = Object.keys(otherValue);
-  if (valueKeys.length < otherValueKeys.length) {
-    return false;
-  }
-  return otherValueKeys.every((key) => {
-    const subValue = value[key];
-    const subOtherValue = otherValue[key];
-    return jsonContains(subValue, subOtherValue);
-  });
-}
-var jsonContains_default = jsonContains;
-
-// ../zimic-utils/dist/data/jsonEquals.mjs
-function jsonEquals(value, otherValue) {
-  if (isPrimitiveJSONValue(value)) {
-    return value === otherValue;
-  }
-  if (isPrimitiveJSONValue(otherValue)) {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    if (!Array.isArray(otherValue)) {
-      return false;
-    }
-    if (value.length !== otherValue.length) {
-      return false;
-    }
-    return value.every((item, index) => jsonEquals(item, otherValue[index]));
-  }
-  if (Array.isArray(otherValue)) {
-    return false;
-  }
-  const valueKeys = Object.keys(value);
-  const otherValueKeys = Object.keys(otherValue);
-  if (valueKeys.length !== otherValueKeys.length) {
-    return false;
-  }
-  return valueKeys.every((key) => {
-    const subValue = value[key];
-    const subOtherValue = otherValue[key];
-    return jsonEquals(subValue, subOtherValue);
-  });
-}
-var jsonEquals_default = jsonEquals;
-
-// ../zimic-utils/dist/chunk-QISSVK3C.mjs
+// ../zimic-utils/dist/time.mjs
 function waitForDelay(milliseconds) {
   return new Promise((resolve) => {
     setTimeout(resolve, milliseconds);
@@ -914,7 +904,7 @@ var LocalHttpRequestHandler = class {
 };
 var LocalHttpRequestHandler_default = LocalHttpRequestHandler;
 
-// ../zimic-utils/dist/chunk-VPHA4ZCK.mjs
+// ../zimic-utils/dist/url.mjs
 function createPathCharactersToEscapeRegex() {
   return /([.(){}+$])/g;
 }
@@ -985,8 +975,6 @@ function createRegexFromPath(path) {
   return new RegExp(`^/?${pathRegexContent}/?$`);
 }
 var createRegexFromPath_default = createRegexFromPath;
-
-// ../zimic-utils/dist/url/excludeNonPathParams.mjs
 function excludeNonPathParams(url) {
   url.hash = "";
   url.search = "";
@@ -995,8 +983,29 @@ function excludeNonPathParams(url) {
   return url;
 }
 var excludeNonPathParams_default = excludeNonPathParams;
-
-// ../zimic-utils/dist/url/validateURLProtocol.mjs
+var DuplicatedPathParamError = class extends Error {
+  constructor(path, paramName) {
+    super(
+      `The path parameter '${paramName}' appears more than once in '${path}'. This is not supported. Please make sure that each parameter is unique.`
+    );
+    this.name = "DuplicatedPathParamError";
+  }
+};
+function validatePathParams(path) {
+  const pathParamMatches = path.toString().matchAll(createPathParamRegex());
+  const uniqueParamNames = /* @__PURE__ */ new Set();
+  for (const paramMatch of pathParamMatches) {
+    const paramName = paramMatch.groups?.identifier;
+    if (!paramName) {
+      continue;
+    }
+    if (uniqueParamNames.has(paramName)) {
+      throw new DuplicatedPathParamError(path, paramName);
+    }
+    uniqueParamNames.add(paramName);
+  }
+}
+var validatePathParams_default = validatePathParams;
 var UnsupportedURLProtocolError = class extends TypeError {
   constructor(protocol, availableProtocols) {
     super(
@@ -1069,6 +1078,7 @@ var DEFAULT_UNHANDLED_REQUEST_STRATEGY = Object.freeze({
 });
 
 // src/http/interceptorWorker/HttpInterceptorWorker.ts
+var RESPONSE_ACTION_SYMBOL = Symbol.for("HttpResponse.action");
 var HttpInterceptorWorker = class _HttpInterceptorWorker {
   platform = null;
   isRunning = false;
@@ -1165,17 +1175,57 @@ var HttpInterceptorWorker = class _HttpInterceptorWorker {
     }
     return interceptor.onUnhandledRequest;
   }
-  static createResponseFromDeclaration(request, declaration) {
+  static setResponseAction(response, action) {
+    Object.defineProperty(response, RESPONSE_ACTION_SYMBOL, {
+      value: action,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+  }
+  static getResponseAction(response) {
+    if (!(RESPONSE_ACTION_SYMBOL in response)) {
+      return void 0;
+    }
+    const action = response[RESPONSE_ACTION_SYMBOL];
+    if (action !== "bypass" && action !== "reject") {
+      return void 0;
+    }
+    return action;
+  }
+  createBypassedResponse() {
+    const response = Response.redirect("about:blank", 302);
+    _HttpInterceptorWorker.setResponseAction(response, "bypass");
+    return response;
+  }
+  static isBypassedResponse(response) {
+    return this.getResponseAction(response) === "bypass";
+  }
+  createRejectedResponse() {
+    const response = Response.error();
+    _HttpInterceptorWorker.setResponseAction(response, "reject");
+    return response;
+  }
+  static isRejectedResponse(response) {
+    return this.getResponseAction(response) === "reject";
+  }
+  createResponseFromDeclaration(request, declaration) {
+    if ("action" in declaration) {
+      if (declaration.action === "bypass") {
+        return this.createBypassedResponse();
+      } else {
+        return this.createRejectedResponse();
+      }
+    }
     const headers = new http.HttpHeaders(declaration.headers);
-    const status = declaration.status;
-    const canHaveBody = methodCanHaveResponseBody(request.method) && status !== 204;
+    const canHaveBody = methodCanHaveResponseBody(request.method) && declaration.status !== 204;
     if (!canHaveBody) {
-      return new Response(null, { headers, status });
+      return new Response(null, { headers, status: declaration.status });
     }
     if (typeof declaration.body === "string" || declaration.body === null || declaration.body === void 0 || declaration.body instanceof FormData || declaration.body instanceof URLSearchParams || declaration.body instanceof Blob || declaration.body instanceof ArrayBuffer || declaration.body instanceof ReadableStream) {
-      return new Response(declaration.body ?? null, { headers, status });
+      return new Response(declaration.body ?? null, { headers, status: declaration.status });
     }
-    return Response.json(declaration.body, { headers, status });
+    return Response.json(declaration.body, { headers, status: declaration.status });
   }
   static async parseRawUnhandledRequest(request) {
     return this.parseRawRequest(
@@ -1604,8 +1654,9 @@ var HttpInterceptorClient = class {
     if (!responseDeclaration) {
       return null;
     }
-    const response = HttpInterceptorWorker_default.createResponseFromDeclaration(request, responseDeclaration);
-    if (this.requestSaving.enabled) {
+    const response = await this.workerOrThrow.createResponseFromDeclaration(request, responseDeclaration);
+    const shouldSaveInterceptedRequest = this.requestSaving.enabled && response && !HttpInterceptorWorker_default.isRejectedResponse(response);
+    if (shouldSaveInterceptedRequest) {
       const responseClone = response.clone();
       const parsedResponse = await HttpInterceptorWorker_default.parseRawResponse(responseClone);
       matchedHandler.saveInterceptedRequest(parsedRequest, parsedResponse);
@@ -1680,31 +1731,6 @@ var HttpInterceptorClient = class {
   }
 };
 var HttpInterceptorClient_default = HttpInterceptorClient;
-
-// ../zimic-utils/dist/url/validatePathParams.mjs
-var DuplicatedPathParamError = class extends Error {
-  constructor(path, paramName) {
-    super(
-      `The path parameter '${paramName}' appears more than once in '${path}'. This is not supported. Please make sure that each parameter is unique.`
-    );
-    this.name = "DuplicatedPathParamError";
-  }
-};
-function validatePathParams(path) {
-  const pathParamMatches = path.toString().matchAll(createPathParamRegex());
-  const uniqueParamNames = /* @__PURE__ */ new Set();
-  for (const paramMatch of pathParamMatches) {
-    const paramName = paramMatch.groups?.identifier;
-    if (!paramName) {
-      continue;
-    }
-    if (uniqueParamNames.has(paramName)) {
-      throw new DuplicatedPathParamError(path, paramName);
-    }
-    uniqueParamNames.add(paramName);
-  }
-}
-var validatePathParams_default = validatePathParams;
 var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
   internalWorker;
   httpHandlersByMethod = {
@@ -1822,7 +1848,7 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
         const requestClone = request.clone();
         let response = null;
         try {
-          response = await createResponse({ ...context, request });
+          response = await createResponse({ request });
         } catch (error) {
           console.error(error);
         }
@@ -1841,6 +1867,23 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     };
     methodHandlers.push(handler);
   }
+  async createResponseFromDeclaration(request, declaration) {
+    const requestClone = request.clone();
+    const response = await super.createResponseFromDeclaration(request, declaration);
+    if (response && HttpInterceptorWorker_default.isBypassedResponse(response)) {
+      try {
+        const response2 = await fetch(msw.bypass(requestClone));
+        return response2;
+      } catch (error) {
+        console.error(error);
+        return null;
+      }
+    }
+    if (response && HttpInterceptorWorker_default.isRejectedResponse(response)) {
+      return response;
+    }
+    return response;
+  }
   async createResponseForRequest(request) {
     const methodHandlers = this.httpHandlersByMethod[request.method];
     const requestURL = excludeNonPathParams_default(new URL(request.url));
@@ -1898,6 +1941,17 @@ var LocalHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
 };
 var LocalHttpInterceptorWorker_default = LocalHttpInterceptorWorker;
 
+// src/server/errors/UnsupportedResponseBypassError.ts
+var UnsupportedResponseBypassError = class extends Error {
+  constructor() {
+    super(
+      "Remote interceptors cannot bypass responses. Use `{ action: 'reject' }` instead.\n\nLearn more: https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond"
+    );
+    this.name = "UnsupportedResponseBypassError";
+  }
+};
+var UnsupportedResponseBypassError_default = UnsupportedResponseBypassError;
+
 // src/utils/crypto.ts
 var importCrypto = createCachedDynamicImport_default(async () => {
   const globalCrypto = globalThis.crypto;
@@ -1925,6 +1979,8 @@ async function serializeResponse(response) {
   const responseClone = response.clone();
   const serializedBody = responseClone.body ? convertArrayBufferToBase64(await responseClone.arrayBuffer()) : null;
   return {
+    type: response.type,
+    action: HttpInterceptorWorker_default.getResponseAction(response),
     status: response.status,
     statusText: response.statusText,
     headers: Object.fromEntries(response.headers),
@@ -2401,8 +2457,8 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
     const request = deserializeRequest(serializedRequest);
     try {
       const rawResponse = await handler?.createResponse({ request }) ?? null;
-      const response = rawResponse && request.method === "HEAD" ? new Response(null, rawResponse) : rawResponse;
-      if (response) {
+      if (rawResponse) {
+        const response = methodCanHaveResponseBody(request.method) ? rawResponse : new Response(null, rawResponse);
         return { response: await serializeResponse(response) };
       }
     } catch (error) {
@@ -2449,10 +2505,7 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       method,
       path,
       interceptor,
-      async createResponse(context) {
-        const response = await createResponse(context);
-        return response;
-      }
+      createResponse
     };
     this.httpHandlers.set(handler.id, handler);
     await this.webSocketClient.request("interceptors/workers/commit", {
@@ -2462,6 +2515,16 @@ var RemoteHttpInterceptorWorker = class extends HttpInterceptorWorker_default {
       path: handler.path
     });
   }
+  async createResponseFromDeclaration(request, declaration) {
+    const response = await super.createResponseFromDeclaration(request, declaration);
+    if (response && HttpInterceptorWorker_default.isBypassedResponse(response)) {
+      throw new UnsupportedResponseBypassError_default();
+    }
+    if (response && HttpInterceptorWorker_default.isRejectedResponse(response)) {
+      return response;
+    }
+    return response;
+  }
   async clearHandlers(options = {}) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError_default();
@@ -2821,6 +2884,10 @@ var InvalidFormDataError = class extends http.InvalidFormDataError {
 };
 var InvalidJSONError = class extends http.InvalidJSONError {
 };
+/* istanbul ignore else -- @preserve
+ * The else is a fallback for when the error is not an instance of Error. */
+/* istanbul ignore if -- @preserve
+ * This is just a type guard to ensure the value is valid. In practice, this condition should never be true. */
 /* istanbul ignore next -- @preserve
  * Ignoring because there will always be a handler for the given method and path at this point. */
 /* istanbul ignore if -- @preserve