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

package/dist/http.mjs

@@ -1,6 +1,6 @@
 import { InvalidFormDataError as InvalidFormDataError$1, InvalidJSONError as InvalidJSONError$1, HTTP_METHODS, HttpHeaders, HttpSearchParams, HttpFormData, parseHttpBody } from '@zimic/http';
 import color2 from 'picocolors';
-import { http, passthrough } from 'msw';
+import { http, bypass, passthrough } from 'msw';
 import * as mswBrowser from 'msw/browser';
 import * as mswNode from 'msw/node';
 import ClientSocket from 'isomorphic-ws';
@@ -1042,6 +1042,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;
@@ -1138,17 +1139,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 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(
@@ -1577,8 +1618,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);
@@ -1795,7 +1837,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);
         }
@@ -1814,6 +1856,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(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));
@@ -1871,6 +1930,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;
@@ -1898,6 +1968,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),
@@ -2374,8 +2446,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) {
@@ -2422,10 +2494,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", {
@@ -2435,6 +2504,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();
@@ -2794,6 +2873,8 @@ var InvalidFormDataError = class extends InvalidFormDataError$1 {
 };
 var InvalidJSONError = class extends InvalidJSONError$1 {
 };
+/* 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