@zimic/fetch 1.4.1 → 1.4.3-canary.0

package/dist/index.js

@@ -2,96 +2,7 @@
 
 var http = require('@zimic/http');
 
-// src/client/errors/FetchResponseError.ts
-var FetchResponseError = class extends Error {
-  constructor(request, response) {
-    super(`${request.method} ${request.url} failed with status ${response.status}: ${response.statusText}`);
-    this.request = request;
-    this.response = response;
-    this.name = "FetchResponseError";
-  }
-  toObject({
-    includeRequestBody = false,
-    includeResponseBody = false
-  } = {}) {
-    const partialObject = {
-      name: this.name,
-      message: this.message
-    };
-    if (!includeRequestBody && !includeResponseBody) {
-      return {
-        ...partialObject,
-        request: this.requestToObject({ includeBody: false }),
-        response: this.responseToObject({ includeBody: false })
-      };
-    }
-    return Promise.all([
-      Promise.resolve(this.requestToObject({ includeBody: includeRequestBody })),
-      Promise.resolve(this.responseToObject({ includeBody: includeResponseBody }))
-    ]).then(([request, response]) => ({ ...partialObject, request, response }));
-  }
-  requestToObject(options) {
-    const request = this.request;
-    const requestObject = {
-      url: request.url,
-      path: request.path,
-      method: request.method,
-      headers: this.convertHeadersToObject(request),
-      cache: request.cache,
-      destination: request.destination,
-      credentials: request.credentials,
-      integrity: request.integrity,
-      keepalive: request.keepalive,
-      mode: request.mode,
-      redirect: request.redirect,
-      referrer: request.referrer,
-      referrerPolicy: request.referrerPolicy
-    };
-    if (!options.includeBody) {
-      return requestObject;
-    }
-    return this.withIncludedBodyIfAvailable("request", requestObject);
-  }
-  responseToObject(options) {
-    const response = this.response;
-    const responseObject = {
-      url: response.url,
-      type: response.type,
-      status: response.status,
-      statusText: response.statusText,
-      ok: response.ok,
-      headers: this.convertHeadersToObject(response),
-      redirected: response.redirected
-    };
-    if (!options.includeBody) {
-      return responseObject;
-    }
-    return this.withIncludedBodyIfAvailable("response", responseObject);
-  }
-  convertHeadersToObject(resource) {
-    return http.HttpHeaders.prototype.toObject.call(resource.headers);
-  }
-  withIncludedBodyIfAvailable(resourceType, resourceObject) {
-    const resource = this[resourceType];
-    if (resource.bodyUsed) {
-      console.warn(
-        "[@zimic/fetch]",
-        `Could not include the ${resourceType} body because it is already used. If you access the body before calling \`error.toObject()\`, consider reading it from a cloned ${resourceType}.
-
-Learn more: https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject`
-      );
-      return resourceObject;
-    }
-    return http.parseHttpBody(resource).then((body) => {
-      resourceObject.body = body;
-      return resourceObject;
-    }).catch((error) => {
-      console.error("[@zimic/fetch]", `Failed to parse ${resourceType} body:`, error);
-      return resourceObject;
-    });
-  }
-};
-var FetchResponseError_default = FetchResponseError;
+// src/client/request/FetchRequest.ts
 
 // ../zimic-utils/dist/url.mjs
 function createPathCharactersToEscapeRegex() {
@@ -187,141 +98,342 @@ function joinURL(...parts) {
   }).filter((part) => part.length > 0).join("/");
 }
 var joinURL_default = joinURL;
+var BODY_METHOD = ["json", "formData", "text", "arrayBuffer", "blob", "bytes"];
+function isBodyMethod(property, value) {
+  return BODY_METHOD.includes(property) && typeof value === "function";
+}
+function getOrSetBoundBodyMethod(resource, property, value) {
+  const isValueAlreadyBound = Object.prototype.hasOwnProperty.call(resource, property);
+  if (isValueAlreadyBound) {
+    return value;
+  }
+  const boundValue = value.bind(resource);
+  Object.defineProperty(resource, property, {
+    value: boundValue,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+  return boundValue;
+}
+function withIncludedBodyIfAvailable(resource, resourceObject) {
+  const resourceType = resource instanceof Request ? "request" : "response";
+  if (resource.bodyUsed) {
+    console.warn(
+      "[@zimic/fetch]",
+      `Could not include the ${resourceType} body because it is already used. If you access the body before calling \`toObject()\`, consider reading it from a cloned ${resourceType}.
+
+Learn more: https://zimic.dev/docs/fetch/api/fetch-response-error#errortoobject`
+    );
+    return resourceObject;
+  }
+  return http.parseHttpBody(resource.clone()).then((body) => {
+    resourceObject.body = body;
+    return resourceObject;
+  }).catch((error) => {
+    console.error("[@zimic/fetch]", `Failed to parse ${resourceType} body:`, error);
+    return resourceObject;
+  });
+}
+
+// src/client/request/FetchRequest.ts
+var FETCH_REQUEST_BRAND = Symbol.for("FetchRequest");
+var FETCH_REQUEST_EXTRA_PROPERTIES = [FETCH_REQUEST_BRAND, "raw", "path", "toObject"];
+function createFetchRequestClass() {
+  const FetchRequestClass = function FetchRequest2(fetch, input, init) {
+    let actualInput;
+    const actualInit = {
+      baseURL: init?.baseURL ?? fetch.baseURL,
+      method: init?.method ?? fetch.method,
+      headers: new http.HttpHeaders(fetch.headers),
+      searchParams: new http.HttpSearchParams(fetch.searchParams),
+      body: init?.body ?? fetch.body,
+      mode: init?.mode ?? fetch.mode,
+      cache: init?.cache ?? fetch.cache,
+      credentials: init?.credentials ?? fetch.credentials,
+      integrity: init?.integrity ?? fetch.integrity,
+      keepalive: init?.keepalive ?? fetch.keepalive,
+      priority: init?.priority ?? fetch.priority,
+      redirect: init?.redirect ?? fetch.redirect,
+      referrer: init?.referrer ?? fetch.referrer,
+      referrerPolicy: init?.referrerPolicy ?? fetch.referrerPolicy,
+      signal: init?.signal ?? fetch.signal,
+      window: init?.window === void 0 ? fetch.window : init.window,
+      duplex: init?.duplex ?? fetch.duplex
+    };
+    if (init?.headers !== void 0) {
+      actualInit.headers.assign(new http.HttpHeaders(init.headers));
+    }
+    let url;
+    const baseURL = new URL(actualInit.baseURL);
+    if (input instanceof Request) {
+      const request2 = input;
+      actualInit.headers.assign(new http.HttpHeaders(request2.headers));
+      url = new URL(input.url);
+      actualInput = request2 instanceof FetchRequestClass ? request2.raw : request2;
+    } else {
+      url = new URL(input instanceof URL ? input : joinURL_default(baseURL, input));
+      actualInit.searchParams.assign(
+        new http.HttpSearchParams(url.searchParams)
+      );
+      if (init?.searchParams !== void 0) {
+        actualInit.searchParams.assign(new http.HttpSearchParams(init.searchParams));
+      }
+      url.search = actualInit.searchParams.toString();
+      actualInput = url;
+    }
+    const request = new Request(actualInput, actualInit);
+    const baseURLWithoutTrailingSlash = baseURL.toString().replace(/\/$/, "");
+    const path = excludeNonPathParams_default(url).toString().replace(baseURLWithoutTrailingSlash, "");
+    function clone() {
+      return new FetchRequestClass(fetch, request.clone());
+    }
+    function toObject(options) {
+      const requestObject = {
+        url: request.url,
+        path,
+        method: request.method,
+        headers: http.HttpHeaders.prototype.toObject.call(request.headers),
+        cache: request.cache,
+        destination: request.destination,
+        credentials: request.credentials,
+        integrity: request.integrity,
+        keepalive: request.keepalive,
+        mode: request.mode,
+        redirect: request.redirect,
+        referrer: request.referrer,
+        referrerPolicy: request.referrerPolicy
+      };
+      if (!options?.includeBody) {
+        return requestObject;
+      }
+      return withIncludedBodyIfAvailable(request, requestObject);
+    }
+    const fetchRequest = new Proxy(request, {
+      get(target, property) {
+        if (property === FETCH_REQUEST_BRAND) {
+          return true;
+        }
+        if (property === "raw") {
+          return request;
+        }
+        if (property === "path") {
+          return path;
+        }
+        if (property === "clone") {
+          return clone;
+        }
+        if (property === "toObject") {
+          return toObject;
+        }
+        const value = Reflect.get(target, property, target);
+        if (isBodyMethod(property, value)) {
+          return getOrSetBoundBodyMethod(request, property, value);
+        }
+        return value;
+      },
+      has(target, property) {
+        return FETCH_REQUEST_EXTRA_PROPERTIES.includes(property) || Reflect.has(target, property);
+      }
+    });
+    return fetchRequest;
+  };
+  Object.defineProperty(FetchRequestClass, Symbol.hasInstance, {
+    value(instance) {
+      return instance instanceof Request && FETCH_REQUEST_BRAND in instance && instance[FETCH_REQUEST_BRAND] === true;
+    },
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.setPrototypeOf(FetchRequestClass.prototype, Request.prototype);
+  return FetchRequestClass;
+}
+var FetchRequest = createFetchRequestClass();
+
+// src/client/response/error/FetchResponseError.ts
+var FetchResponseError = class extends Error {
+  constructor(request, response) {
+    super(`${request.method} ${request.url} failed with status ${response.status}: ${response.statusText}`);
+    this.request = request;
+    this.response = response;
+    this.name = "FetchResponseError";
+  }
+  toObject(options) {
+    const partialObject = {
+      name: this.name,
+      message: this.message
+    };
+    if (!options?.includeRequestBody && !options?.includeResponseBody) {
+      return {
+        ...partialObject,
+        request: this.request.toObject({ includeBody: false }),
+        response: this.response.toObject({ includeBody: false })
+      };
+    }
+    return Promise.all([
+      Promise.resolve(this.request.toObject({ includeBody: options.includeRequestBody })),
+      Promise.resolve(this.response.toObject({ includeBody: options.includeResponseBody }))
+    ]).then(([request, response]) => ({ ...partialObject, request, response }));
+  }
+};
+var FetchResponseError_default = FetchResponseError;
+
+// src/client/response/FetchResponse.ts
+var FETCH_RESPONSE_BRAND = Symbol.for("FetchResponse");
+var FETCH_RESPONSE_EXTRA_PROPERTIES = [FETCH_RESPONSE_BRAND, "raw", "request", "error", "toObject"];
+function createFetchResponseClass() {
+  const FetchResponseClass = function FetchResponse2(fetchRequest, responseOrBody, init) {
+    const response = responseOrBody instanceof Response ? responseOrBody : new Response(responseOrBody, init);
+    let error = null;
+    function clone() {
+      return new FetchResponseClass(fetchRequest, response.clone());
+    }
+    function toObject(options) {
+      const responseObject = {
+        url: response.url,
+        type: response.type,
+        status: response.status,
+        statusText: response.statusText,
+        ok: response.ok,
+        headers: http.HttpHeaders.prototype.toObject.call(response.headers),
+        redirected: response.redirected
+      };
+      if (!options?.includeBody) {
+        return responseObject;
+      }
+      return withIncludedBodyIfAvailable(response, responseObject);
+    }
+    const fetchResponse = new Proxy(response, {
+      get(target, property, receiver) {
+        if (property === FETCH_RESPONSE_BRAND) {
+          return true;
+        }
+        if (property === "raw") {
+          return response;
+        }
+        if (property === "request") {
+          return fetchRequest;
+        }
+        if (property === "error") {
+          error ??= new FetchResponseError_default(fetchRequest, receiver);
+          return error;
+        }
+        if (property === "clone") {
+          return clone;
+        }
+        if (property === "toObject") {
+          return toObject;
+        }
+        const value = Reflect.get(target, property, target);
+        if (isBodyMethod(property, value)) {
+          return getOrSetBoundBodyMethod(response, property, value);
+        }
+        return value;
+      },
+      has(target, property) {
+        return FETCH_RESPONSE_EXTRA_PROPERTIES.includes(property) || Reflect.has(target, property);
+      }
+    });
+    return fetchResponse;
+  };
+  Object.defineProperty(FetchResponseClass, Symbol.hasInstance, {
+    value(instance) {
+      return instance instanceof Response && FETCH_RESPONSE_BRAND in instance && instance[FETCH_RESPONSE_BRAND] === true;
+    },
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+  Object.setPrototypeOf(FetchResponseClass.prototype, Response.prototype);
+  return FetchResponseClass;
+}
+var FetchResponse = createFetchResponseClass();
+Object.setPrototypeOf(FetchResponse.prototype, Response.prototype);
 
 // src/client/FetchClient.ts
+var FETCH_OPTIONS_DEFAULT_PROPERTIES = [
+  "baseURL",
+  "onRequest",
+  "onResponse",
+  "body",
+  "cache",
+  "credentials",
+  "integrity",
+  "keepalive",
+  "mode",
+  "priority",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "window",
+  "duplex"
+];
 var FetchClient = class {
   fetch;
-  constructor({ headers = {}, searchParams = {}, ...otherOptions }) {
+  constructor(options) {
     this.fetch = this.createFetchFunction();
-    this.fetch.headers = headers;
-    this.fetch.searchParams = searchParams;
-    Object.assign(this.fetch, otherOptions);
+    this.assignDefaults(this.fetch, options);
     this.fetch.loose = this.fetch;
-    this.fetch.Request = this.createRequestClass(this.fetch);
+    this.fetch.Request = this.createFetchRequestConstructor(this.fetch);
+  }
+  assignDefaults(fetch, { headers = {}, searchParams = {}, ...otherOptions }) {
+    fetch.headers = headers;
+    fetch.searchParams = searchParams;
+    for (const property of FETCH_OPTIONS_DEFAULT_PROPERTIES) {
+      const propertyValue = otherOptions[property];
+      if (propertyValue !== void 0) {
+        fetch[property] = propertyValue;
+      }
+    }
   }
   get defaults() {
     return this.fetch;
   }
   createFetchFunction() {
     const fetch = async (input, init) => {
-      const request = await this.createFetchRequest(input, init);
-      const requestClone = request.clone();
-      const rawResponse = await globalThis.fetch(
-        // Optimize type checking by narrowing the type of request
-        requestClone
-      );
-      const response = await this.createFetchResponse(request, rawResponse);
-      return response;
+      const fetchRequest = await this.createFetchRequest(input, init);
+      const response = await globalThis.fetch(fetchRequest.raw.clone());
+      const fetchResponse = await this.createFetchResponse(fetchRequest, response);
+      return fetchResponse;
     };
-    Object.setPrototypeOf(fetch, this);
-    return fetch;
+    return Object.setPrototypeOf(fetch, this);
+  }
+  createFetchRequestConstructor(fetch) {
+    function Request2(input, init) {
+      return new FetchRequest(fetch, input, init);
+    }
+    Object.setPrototypeOf(Request2.prototype, FetchRequest.prototype);
+    return Request2;
   }
   async createFetchRequest(input, init) {
-    let request = input instanceof Request ? input : new this.fetch.Request(input, init);
+    let fetchRequest = new this.fetch.Request(input, init);
     if (this.fetch.onRequest) {
-      const requestAfterInterceptor = await this.fetch.onRequest(
-        // Optimize type checking by narrowing the type of request
-        request
-      );
-      if (requestAfterInterceptor !== request) {
-        const isFetchRequest = requestAfterInterceptor instanceof this.fetch.Request;
-        request = isFetchRequest ? requestAfterInterceptor : new this.fetch.Request(requestAfterInterceptor, init);
+      const newRequest = await this.fetch.onRequest(fetchRequest);
+      if (newRequest !== fetchRequest) {
+        if (newRequest instanceof FetchRequest) {
+          fetchRequest = newRequest;
+        } else {
+          fetchRequest = new this.fetch.Request(newRequest, init);
+        }
       }
     }
-    return request;
+    return fetchRequest;
   }
-  async createFetchResponse(fetchRequest, rawResponse) {
-    let response = this.defineFetchResponseProperties(fetchRequest, rawResponse);
+  async createFetchResponse(fetchRequest, response) {
+    let fetchResponse = new FetchResponse(fetchRequest, response);
     if (this.fetch.onResponse) {
-      const responseAfterInterceptor = await this.fetch.onResponse(
-        // Optimize type checking by narrowing the type of response
-        response
-      );
-      const isFetchResponse = responseAfterInterceptor instanceof Response && "request" in responseAfterInterceptor && responseAfterInterceptor.request instanceof this.fetch.Request;
-      response = isFetchResponse ? responseAfterInterceptor : this.defineFetchResponseProperties(fetchRequest, responseAfterInterceptor);
+      const newResponse = await this.fetch.onResponse(fetchResponse);
+      fetchResponse = newResponse instanceof FetchResponse ? newResponse : new FetchResponse(fetchRequest, newResponse);
     }
-    return response;
-  }
-  defineFetchResponseProperties(fetchRequest, response) {
-    const fetchResponse = response;
-    Object.defineProperty(fetchResponse, "request", {
-      value: fetchRequest,
-      writable: false,
-      enumerable: true,
-      configurable: false
-    });
-    let responseError;
-    Object.defineProperty(fetchResponse, "error", {
-      get() {
-        responseError ??= new FetchResponseError_default(fetchRequest, fetchResponse);
-        return responseError;
-      },
-      enumerable: true,
-      configurable: false
-    });
     return fetchResponse;
   }
-  createRequestClass(fetch) {
-    class Request2 extends globalThis.Request {
-      path;
-      constructor(input, init) {
-        let actualInput;
-        const actualInit = {
-          baseURL: init?.baseURL ?? fetch.baseURL,
-          method: init?.method ?? fetch.method,
-          headers: new http.HttpHeaders(fetch.headers),
-          searchParams: new http.HttpSearchParams(fetch.searchParams),
-          body: init?.body ?? fetch.body,
-          mode: init?.mode ?? fetch.mode,
-          cache: init?.cache ?? fetch.cache,
-          credentials: init?.credentials ?? fetch.credentials,
-          integrity: init?.integrity ?? fetch.integrity,
-          keepalive: init?.keepalive ?? fetch.keepalive,
-          priority: init?.priority ?? fetch.priority,
-          redirect: init?.redirect ?? fetch.redirect,
-          referrer: init?.referrer ?? fetch.referrer,
-          referrerPolicy: init?.referrerPolicy ?? fetch.referrerPolicy,
-          signal: init?.signal ?? fetch.signal,
-          window: init?.window === void 0 ? fetch.window : init.window,
-          duplex: init?.duplex ?? fetch.duplex
-        };
-        if (init?.headers) {
-          actualInit.headers.assign(new http.HttpHeaders(init.headers));
-        }
-        let url;
-        const baseURL = new URL(actualInit.baseURL);
-        if (input instanceof globalThis.Request) {
-          const request = input;
-          actualInit.headers.assign(new http.HttpHeaders(request.headers));
-          url = new URL(input.url);
-          actualInput = request;
-        } else {
-          url = new URL(input instanceof URL ? input : joinURL_default(baseURL, input));
-          actualInit.searchParams.assign(
-            new http.HttpSearchParams(url.searchParams)
-          );
-          if (init?.searchParams) {
-            actualInit.searchParams.assign(new http.HttpSearchParams(init.searchParams));
-          }
-          url.search = actualInit.searchParams.toString();
-          actualInput = url;
-        }
-        super(actualInput, actualInit);
-        const baseURLWithoutTrailingSlash = baseURL.toString().replace(/\/$/, "");
-        this.path = excludeNonPathParams_default(url).toString().replace(baseURLWithoutTrailingSlash, "");
-      }
-      clone() {
-        const rawClone = super.clone();
-        return new Request2(rawClone);
-      }
-    }
-    return Request2;
-  }
   isRequest(request, method, path) {
-    return request instanceof Request && request.method === method && "path" in request && typeof request.path === "string" && createRegexFromPath_default(path).test(request.path);
+    return request instanceof FetchRequest && request.method === method && typeof request.path === "string" && createRegexFromPath_default(path).test(request.path);
   }
   isResponse(response, method, path) {
-    return response instanceof Response && "request" in response && this.isRequest(response.request, method, path) && "error" in response && (response.error === null || response.error instanceof FetchResponseError_default);
+    return response instanceof FetchResponse && this.isRequest(response.request, method, path);
   }
   isResponseError(error, method, path) {
     return error instanceof FetchResponseError_default && this.isRequest(error.request, method, path) && this.isResponse(error.response, method, path);
@@ -336,6 +448,8 @@ function createFetch(options) {
 }
 var factory_default = createFetch;
 
+exports.FetchRequest = FetchRequest;
+exports.FetchResponse = FetchResponse;
 exports.FetchResponseError = FetchResponseError_default;
 exports.createFetch = factory_default;
 //# sourceMappingURL=index.js.map