create-request 1.4.3-rc.4 → 1.5.0

package/dist/library/index.cjs

@@ -146,8 +146,8 @@ class RequestError extends Error {
         this.method = method;
         this.status = options.status;
         this.response = options.response;
-        this.isTimeout = options.isTimeout;
-        this.isAborted = options.isAborted;
+        this.isTimeout = !!options.isTimeout;
+        this.isAborted = !!options.isAborted;
         // For better stack traces in modern environments
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, RequestError);
@@ -169,7 +169,7 @@ class RequestError extends Error {
      * ```
      */
     static timeout(url, method, timeoutMs) {
-        return new RequestError(`Timeout ${timeoutMs}ms`, url, method, {
+        return new RequestError(`Timeout:${timeoutMs}`, url, method, {
             isTimeout: true,
         });
     }
@@ -248,16 +248,16 @@ class RequestError extends Error {
             // Check for connection errors (but not timeout errors)
             const isConnectionError = !isTimeoutError && (errorCode === "ECONNREFUSED" || errorCode === "ECONNRESET" || stack.includes("ECONNREFUSED") || stack.includes("connect"));
             if (isTimeoutError) {
-                message = `Timeout ${url}`;
+                message = `Timeout:${url}`;
             }
             else if (isDnsError) {
-                message = `DNS error ${url}`;
+                message = `DNS:${url}`;
             }
             else if (isConnectionError) {
-                message = `Connection refused ${url}`;
+                message = `Conn:${url}`;
             }
             else {
-                message = `Network error ${url}`;
+                message = `Net:${url}`;
             }
         }
         const error = new RequestError(message, url, method, {
@@ -367,7 +367,7 @@ class ResponseWrapper {
      */
     checkBodyNotConsumed() {
         if (this.response.bodyUsed) {
-            throw new RequestError("Body already consumed", this.url || "", this.method || "", {
+            throw new RequestError("Body used", this.url || "", this.method || "", {
                 status: this.response.status,
                 response: this.response,
             });
@@ -409,7 +409,7 @@ class ResponseWrapper {
             return String(x);
         });
         const errorMessage = errorMessages.join(", ");
-        throw new RequestError(`GraphQL errors: ${errorMessage}`, this.url || "", this.method || "", {
+        throw new RequestError(`GQL: ${errorMessage}`, this.url || "", this.method || "", {
             status: this.response.status,
             response: this.response,
         });
@@ -449,8 +449,7 @@ class ResponseWrapper {
             if (error instanceof RequestError) {
                 throw error;
             }
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url || "", this.method || "", {
+            throw new RequestError(`Bad JSON: ${error instanceof Error ? error.message : String(error)}`, this.url || "", this.method || "", {
                 status: this.response.status,
                 response: this.response,
             });
@@ -479,8 +478,7 @@ class ResponseWrapper {
             return text;
         }
         catch (e) {
-            const errorMessage = e instanceof Error ? e.message : String(e);
-            throw new RequestError(`Read failed: ${errorMessage}`, this.url || "", this.method || "", {
+            throw new RequestError(`Read: ${e instanceof Error ? e.message : String(e)}`, this.url || "", this.method || "", {
                 status: this.response.status,
                 response: this.response,
             });
@@ -511,8 +509,7 @@ class ResponseWrapper {
             return blob;
         }
         catch (e) {
-            const errorMessage = e instanceof Error ? e.message : String(e);
-            throw new RequestError(`Read failed: ${errorMessage}`, this.url || "", this.method || "", {
+            throw new RequestError(`Read: ${e instanceof Error ? e.message : String(e)}`, this.url || "", this.method || "", {
                 status: this.response.status,
                 response: this.response,
             });
@@ -544,8 +541,7 @@ class ResponseWrapper {
             return arrayBuffer;
         }
         catch (e) {
-            const errorMessage = e instanceof Error ? e.message : String(e);
-            throw new RequestError(`Read failed: ${errorMessage}`, this.url || "", this.method || "", {
+            throw new RequestError(`Read: ${e instanceof Error ? e.message : String(e)}`, this.url || "", this.method || "", {
                 status: this.response.status,
                 response: this.response,
             });
@@ -611,8 +607,7 @@ class ResponseWrapper {
             }
             // Enhance selector errors with context
             if (selector) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new RequestError(`Data selector failed: ${errorMessage}`, this.url || "", this.method || "", {
+                throw new RequestError(`Selector: ${error instanceof Error ? error.message : String(error)}`, this.url || "", this.method || "", {
                     status: this.response.status,
                     response: this.response,
                 });
@@ -1058,10 +1053,11 @@ class BaseRequest {
         return Object.assign(callable, fluent);
     }
     validateUrl(url) {
+        const errorMessage = "Bad URL";
         if (!url?.trim())
-            throw new RequestError("Invalid URL", url, this.method);
+            throw new RequestError(errorMessage, url, this.method);
         if (url.includes("\0") || url.includes("\r") || url.includes("\n")) {
-            throw new RequestError("Invalid URL", url, this.method);
+            throw new RequestError(errorMessage, url, this.method);
         }
         const trimmed = url.trim();
         if (/^https?:\/\//.test(trimmed)) {
@@ -1069,7 +1065,7 @@ class BaseRequest {
                 new URL(trimmed);
             }
             catch {
-                throw new RequestError("Invalid URL", trimmed, this.method);
+                throw new RequestError(errorMessage, trimmed, this.method);
             }
         }
     }
@@ -1125,7 +1121,7 @@ class BaseRequest {
      */
     withTimeout(timeout) {
         if (!Number.isFinite(timeout) || timeout <= 0)
-            throw new RequestError("Invalid timeout", this.url, this.method);
+            throw new RequestError("Bad timeout", this.url, this.method);
         this.requestOptions.timeout = timeout;
         return this;
     }
@@ -1164,24 +1160,24 @@ class BaseRequest {
     withRetries(retries) {
         if (typeof retries === "number") {
             if (!Number.isInteger(retries) || retries < 0) {
-                throw new RequestError(`Invalid retries: ${retries}`, this.url, this.method);
+                throw new RequestError(`Bad retries: ${retries}`, this.url, this.method);
             }
             this.requestOptions.retries = retries;
         }
         else {
             // Validate RetryConfig
             if (!Number.isInteger(retries.attempts) || retries.attempts < 0) {
-                throw new RequestError(`Invalid attempts: ${retries.attempts}`, this.url, this.method);
+                throw new RequestError(`Bad attempts: ${retries.attempts}`, this.url, this.method);
             }
             // Validate delay if provided
             if (retries.delay !== undefined) {
                 if (typeof retries.delay === "number") {
                     if (!Number.isFinite(retries.delay) || retries.delay < 0) {
-                        throw new RequestError(`Invalid delay: ${retries.delay}`, this.url, this.method);
+                        throw new RequestError(`Bad delay: ${retries.delay}`, this.url, this.method);
                     }
                 }
                 else if (typeof retries.delay !== "function") {
-                    throw new RequestError(`Invalid delay: ${typeof retries.delay}`, this.url, this.method);
+                    throw new RequestError(`Bad delay: ${typeof retries.delay}`, this.url, this.method);
                 }
             }
             this.requestOptions.retries = retries;
@@ -1664,7 +1660,7 @@ class BaseRequest {
         if (typeof Buffer !== "undefined")
             return Buffer.from(str).toString("base64");
         // Fallback (should never happen in modern environments)
-        throw new RequestError("Encoding not supported", this.url, this.method);
+        throw new RequestError("No encoder", this.url, this.method);
     }
     /**
      * Sets a Bearer token for authentication.
@@ -1948,6 +1944,24 @@ class BaseRequest {
         const response = await this.getResponse();
         return response.getBlob();
     }
+    /**
+     * Execute the request and get the response body as an ArrayBuffer.
+     * Useful for processing binary data at a low level.
+     *
+     * @returns A promise that resolves to the response body as an ArrayBuffer
+     * @throws {RequestError} When the request fails or reading the response fails
+     *
+     * @example
+     * ```typescript
+     * const buffer = await request.getArrayBuffer();
+     * const uint8Array = new Uint8Array(buffer);
+     * // Process the binary data
+     * ```
+     */
+    async getArrayBuffer() {
+        const response = await this.getResponse();
+        return response.getArrayBuffer();
+    }
     /**
      * Execute the request and get the response body as a ReadableStream.
      * Note: Unlike other methods, streams cannot be cached. The body can only be consumed once.
@@ -2083,7 +2097,7 @@ class BaseRequest {
                     const delay = typeof retriesConfig.delay === "function" ? retriesConfig.delay({ attempt: attempt + 1, error: requestError }) : retriesConfig.delay;
                     // Validate delay result
                     if (typeof delay !== "number" || !Number.isFinite(delay) || delay < 0) {
-                        throw new RequestError(`Invalid delay: ${delay}`, url, method);
+                        throw new RequestError(`Bad delay: ${delay}`, url, method);
                     }
                     // Wait for the delay
                     if (delay > 0) {
@@ -2114,8 +2128,7 @@ class BaseRequest {
                 currentConfig = result;
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new RequestError(`Req Interceptor failed: ${errorMessage}`, currentConfig.url, currentConfig.method);
+                throw new RequestError(`ReqI: ${error instanceof Error ? error.message : String(error)}`, currentConfig.url, currentConfig.method);
             }
         }
         return currentConfig;
@@ -2129,17 +2142,14 @@ class BaseRequest {
         const globalConfig = Config.getInstance();
         const globalInterceptors = globalConfig.getResponseInterceptors();
         // Per-request in order, then global in reverse
-        const allInterceptors = [...this.responseInterceptors, ...globalInterceptors.reverse()];
+        const allInterceptors = [...this.responseInterceptors, ...[...globalInterceptors].reverse()];
         let currentResponse = response;
         for (let i = 0; i < allInterceptors.length; i++) {
             try {
                 currentResponse = await allInterceptors[i](currentResponse);
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const url = currentResponse.url || "";
-                const method = currentResponse.method || "";
-                throw new RequestError(`Res Interceptor failed: ${errorMessage}`, url, method);
+                throw new RequestError(`ResI: ${error instanceof Error ? error.message : String(error)}`, currentResponse.url || "", currentResponse.method || "");
             }
         }
         return currentResponse;
@@ -2153,7 +2163,7 @@ class BaseRequest {
         const globalConfig = Config.getInstance();
         const globalInterceptors = globalConfig.getErrorInterceptors();
         // Per-request in order, then global in reverse
-        const allInterceptors = [...this.errorInterceptors, ...globalInterceptors.reverse()];
+        const allInterceptors = [...this.errorInterceptors, ...[...globalInterceptors].reverse()];
         let currentError = error;
         for (let i = 0; i < allInterceptors.length; i++) {
             try {
@@ -2170,10 +2180,10 @@ class BaseRequest {
                     currentError = interceptorError;
                 }
                 else {
-                    const errorMessage = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+                    const em = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
                     // Always wrap in RequestError when we have context
                     if (currentError instanceof RequestError) {
-                        currentError = new RequestError(`Err Interceptor ${i + 1} failed: ${errorMessage}`, currentError.url, currentError.method, {
+                        currentError = new RequestError(`ErrI${i + 1}: ${em}`, currentError.url, currentError.method, {
                             status: currentError.status,
                             response: currentError.response,
                         });
@@ -2350,6 +2360,11 @@ class BaseRequest {
                 // It will check for timeout patterns as a safety net (useful for external AbortControllers)
                 throw RequestError.networkError(url, method, errorObj);
             }
+            // Status 0 indicates the request failed before receiving a proper HTTP response
+            // (e.g., CORS errors, network failures that don't throw). Treat as network error.
+            if (response.status === 0) {
+                throw RequestError.networkError(url, method, new Error("Failed with status 0 (network error or CORS blocked)"));
+            }
             if (!response.ok) {
                 throw RequestError.fromResponse(response, url, method);
             }
@@ -2449,8 +2464,7 @@ class BodyRequest extends BaseRequest {
                 JSON.stringify(body);
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method);
+                throw new RequestError(`Bad JSON: ${error instanceof Error ? error.message : String(error)}`, this.url, this.method);
             }
         }
         else {
@@ -2497,21 +2511,21 @@ class BodyRequest extends BaseRequest {
      */
     withGraphQL(query, variables, options) {
         if (typeof query !== "string" || query.length === 0) {
-            throw new RequestError("Invalid query", this.url, this.method);
+            throw new RequestError("Bad query", this.url, this.method);
         }
         const graphQLBody = {
             query: query,
         };
         if (variables !== undefined) {
             if (typeof variables !== "object" || variables === null || Array.isArray(variables)) {
-                throw new RequestError("Invalid vars", this.url, this.method);
+                throw new RequestError("Bad vars", this.url, this.method);
             }
             graphQLBody.variables = variables;
         }
         // Store GraphQL options if provided
         if (options !== undefined) {
             if (typeof options !== "object" || options === null || Array.isArray(options)) {
-                throw new RequestError("Invalid options", this.url, this.method);
+                throw new RequestError("Bad opts", this.url, this.method);
             }
             // Store only the known GraphQL options properties
             const opts = options;
@@ -2524,8 +2538,7 @@ class BodyRequest extends BaseRequest {
             JSON.stringify(graphQLBody);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new RequestError(`Invalid JSON: ${errorMessage}`, this.url, this.method);
+            throw new RequestError(`Bad JSON: ${error instanceof Error ? error.message : String(error)}`, this.url, this.method);
         }
         this.body = graphQLBody;
         this.bodyType = BodyType.JSON;
@@ -2639,7 +2652,7 @@ class DeleteRequest extends BaseRequest {
  *
  * @example
  * const request = new PostRequest('/api/users')
- *   .withJson({ name: 'John', email: 'john@example.com' });
+ *   .withBody({ name: 'John', email: 'john@example.com' });
  * const data = await request.getData();
  */
 class PostRequest extends BodyRequest {
@@ -2654,7 +2667,7 @@ class PostRequest extends BodyRequest {
  *
  * @example
  * const request = new PutRequest('/api/users/123')
- *   .withJson({ id: '123', name: 'John', email: 'john@example.com' });
+ *   .withBody({ id: '123', name: 'John', email: 'john@example.com' });
  * const data = await request.getData();
  */
 class PutRequest extends BodyRequest {
@@ -2669,7 +2682,7 @@ class PutRequest extends BodyRequest {
  *
  * @example
  * const request = new PatchRequest('/api/users/123')
- *   .withJson({ email: 'new.email@example.com' });
+ *   .withBody({ email: 'new.email@example.com' });
  * const data = await request.getData();
  */
 class PatchRequest extends BodyRequest {
@@ -2703,7 +2716,7 @@ function get(url) {
  *
  * @example
  * const request = post('/api/users')
- *   .withJson({ name: 'John', email: 'john@example.com' });
+ *   .withBody({ name: 'John', email: 'john@example.com' });
  * const newUser = await request.getData();
  */
 function post(url) {
@@ -2718,7 +2731,7 @@ function post(url) {
  *
  * @example
  * const request = put('/api/users/123')
- *   .withJson({ name: 'John Updated', email: 'john@example.com' });
+ *   .withBody({ name: 'John Updated', email: 'john@example.com' });
  * const updatedUser = await request.getData();
  */
 function put(url) {
@@ -2747,7 +2760,7 @@ function del(url) {
  *
  * @example
  * const request = patch('/api/users/123')
- *   .withJson({ status: 'active' });
+ *   .withBody({ status: 'active' });
  * const patchedUser = await request.getData();
  */
 function patch(url) {
@@ -2785,267 +2798,155 @@ function options(url) {
 }
 
 /**
- * Resolves a URL against a base URL.
- * If the URL is absolute (starts with http:// or https://), it is returned as-is.
- * Otherwise, it is resolved relative to the base URL.
- *
- * @param baseURL - The base URL to resolve against, or undefined if not set
- * @param url - The URL to resolve, or undefined to return the base URL
- * @returns The resolved absolute URL string
- * @example
- * resolveURL("https://api.example.com", "/users") // "https://api.example.com/users"
- * resolveURL("https://api.example.com", "users") // "https://api.example.com/users"
- * resolveURL("https://api.example.com", "https://other.com") // "https://other.com"
- */
-function resolveURL(baseURL, url) {
-    if (!url)
-        return baseURL || "";
-    if (!baseURL)
-        return url;
-    if (/^https?:\/\//.test(url))
-        return url;
-    try {
-        return new URL(url, baseURL.endsWith("/") ? baseURL : baseURL + "/").toString();
-    }
-    catch {
-        return baseURL.replace(/\/$/, "") + (url.startsWith("/") ? url : "/" + url);
-    }
-}
-/**
- * API builder for creating configured API instances with default settings.
- * Allows you to set default headers, timeouts, authentication, and other options
- * that will be applied to all requests created through this builder.
- *
- * @example
- * ```typescript
- * const api = create.api()
- *   .withBaseURL("https://api.example.com")
- *   .withBearerToken("token123")
- *   .withTimeout(5000);
- *
- * // All requests will use the base URL, bearer token, and timeout
- * await api.get("/users").getJson();
- * await api.post("/posts").withBody({ title: "Hello" }).getJson();
- * ```
+ * Internal API builder implementation.
  */
-class ApiBuilder {
+class ApiBuilderImpl {
     baseURL;
-    modifiers;
-    /**
-     * Sets the base URL for all requests created through this API builder.
-     * Relative URLs will be resolved against this base URL.
-     *
-     * @param baseURL - The base URL to use for all requests
-     * @returns The API builder instance for method chaining
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.get("/users").getJson(); // Requests https://api.example.com/users
-     * ```
-     */
+    modifiers = [];
+    proxy;
     withBaseURL(baseURL) {
         this.baseURL = baseURL;
-        return this;
+        return this.getProxy();
     }
-    /**
-     * Adds a modifier function that will be applied to all requests created through this builder.
-     *
-     * @private
-     * @param modifier - A function that modifies a request and returns it
-     * @returns The API builder instance for method chaining
-     */
-    addModifier(modifier) {
-        if (!this.modifiers)
-            this.modifiers = [];
-        this.modifiers.push(modifier);
-        return this;
+    resolveURL(url) {
+        if (!url)
+            return this.baseURL || "";
+        if (/^https?:\/\//.test(url))
+            return url;
+        if (!this.baseURL)
+            return url;
+        return this.baseURL.replace(/\/$/, "") + (url[0] === "/" ? url : "/" + url);
     }
-    /**
-     * Creates a GET request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns A GetRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.get("/users").getJson();
-     * await api.get("https://other.com/data").getJson(); // Absolute URL overrides base
-     * ```
-     */
-    get = (url) => {
-        const request = get(resolveURL(this.baseURL, url));
+    applyModifiers(request) {
         if (this.modifiers)
             for (const modifier of this.modifiers)
                 modifier(request);
+    }
+    get(url) {
+        const request = new GetRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates a POST request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns A PostRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.post("/users").withBody({ name: "John" }).getJson();
-     * ```
-     */
-    post = (url) => {
-        const request = post(resolveURL(this.baseURL, url));
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    }
+    post(url) {
+        const request = new PostRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates a PUT request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns A PutRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.put("/users/123").withBody({ name: "Jane" }).getJson();
-     * ```
-     */
-    put = (url) => {
-        const request = put(resolveURL(this.baseURL, url));
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    }
+    put(url) {
+        const request = new PutRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates a DELETE request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns A DeleteRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.del("/users/123").getResponse();
-     * ```
-     */
-    del = (url) => {
-        const request = del(resolveURL(this.baseURL, url));
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    }
+    del(url) {
+        const request = new DeleteRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates a PATCH request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns A PatchRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.patch("/users/123").withBody({ name: "Updated" }).getJson();
-     * ```
-     */
-    patch = (url) => {
-        const request = patch(resolveURL(this.baseURL, url));
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    }
+    patch(url) {
+        const request = new PatchRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates a HEAD request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns A HeadRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * const response = await api.head("/users").getResponse();
-     * ```
-     */
-    head = (url) => {
-        const request = head(resolveURL(this.baseURL, url));
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    }
+    head(url) {
+        const request = new HeadRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates an OPTIONS request with the configured default settings.
-     *
-     * @param url - Optional URL path. If not provided, uses the base URL. If relative, resolves against base URL.
-     * @returns An OptionsRequest instance ready to be executed
-     * @example
-     * ```typescript
-     * const api = create.api().withBaseURL("https://api.example.com");
-     * await api.options("/users").getResponse();
-     * ```
-     */
-    options = (url) => {
-        const request = options(resolveURL(this.baseURL, url));
-        if (this.modifiers)
-            for (const modifier of this.modifiers)
-                modifier(request);
+    }
+    options(url) {
+        const request = new OptionsRequest(this.resolveURL(url));
+        this.applyModifiers(request);
         return request;
-    };
-    /**
-     * Creates a new ApiBuilder instance with a Proxy that enables dynamic method forwarding.
-     * The Proxy allows calling any `with*` method from BaseRequest on the API builder,
-     * which will apply that configuration to all requests created through this builder.
-     *
-     * @internal
-     */
-    constructor() {
-        const proxy = new Proxy(this, {
+    }
+    addModifier(modifier) {
+        this.modifiers.push(modifier);
+        return this.getProxy();
+    }
+    getProxy() {
+        if (!this.proxy) {
+            this.proxy = this.createProxy();
+        }
+        return this.proxy;
+    }
+    createProxy() {
+        const disallowedMethods = new Set(["withBody", "withGraphQL", "withAbortController"]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+        return new Proxy(this, {
             get(target, prop) {
-                const propertyValue = target[prop];
-                if (propertyValue !== undefined) {
-                    if (typeof propertyValue === "function") {
-                        return (...args) => {
-                            const result = propertyValue.apply(target, args);
-                            return result === target ? proxy : result;
-                        };
-                    }
-                    return propertyValue;
+                const implTarget = target;
+                // Return undefined for disallowed methods
+                if (typeof prop === "string" && disallowedMethods.has(prop)) {
+                    return undefined;
                 }
-                if (typeof prop === "string" && prop.startsWith("with") && prop !== "withBaseURL") {
-                    if (prop === "withAbortController" || prop === "withBody" || prop === "withGraphQL" || prop === "withQueryParam" || prop === "withQueryParams")
-                        return undefined;
-                    const prototypeMethod = BaseRequest.prototype[prop];
-                    if (typeof prototypeMethod === "function") {
-                        return (...args) => {
-                            target.addModifier((request) => prototypeMethod.apply(request, args));
-                            return proxy;
-                        };
-                    }
+                // Check if it's an HTTP method - these should be called directly
+                if (prop === "get" || prop === "post" || prop === "put" || prop === "del" || prop === "patch" || prop === "head" || prop === "options") {
+                    return implTarget[prop].bind(implTarget);
+                }
+                // Check if it's a configuration method that already exists
+                if (prop === "withBaseURL") {
+                    return implTarget[prop].bind(implTarget);
                 }
-                return undefined;
+                // Check if the property exists on BaseRequest prototype
+                // If it's a 'with...' method or other chainable method, create a modifier for it
+                if (typeof prop === "string" && (prop.startsWith("with") || prop === "onRetry")) {
+                    return (...args) => {
+                        return implTarget.addModifier((request) => {
+                            const method = request[prop];
+                            if (typeof method === "function") {
+                                method.apply(request, args);
+                            }
+                        });
+                    };
+                }
+                // For other properties, return them directly if they exist
+                const targetValue = implTarget[prop];
+                return targetValue;
             },
         });
-        return proxy;
+    }
+    static create() {
+        return new ApiBuilderImpl().getProxy();
     }
 }
 /**
- * Creates a new API builder instance for configuring default request settings.
- * The builder allows you to set base URLs, authentication, headers, timeouts,
- * and other options that will be applied to all requests created through it.
+ * Creates a new API builder for configuring default request settings.
+ * The API builder allows you to set up a base URL, default headers, timeout,
+ * and other configuration options that will be applied to all requests made through it.
+ *
+ * @returns A new API builder instance
  *
- * @returns A new ApiBuilder instance with all configuration methods available
  * @example
  * ```typescript
- * // Create an API instance with default configuration
- * const api = create.api()
- *   .withBaseURL("https://api.example.com")
- *   .withBearerToken("your-token")
- *   .withTimeout(5000)
- *   .withHeaders({ "X-Custom": "value" });
+ * // Create an API instance with defaults
+ * const api = api()
+ *   .withBaseURL('https://api.example.com')
+ *   .withBearerToken('token123')
+ *   .withTimeout(5000);
  *
  * // All requests will use these defaults
- * const users = await api.get("/users").getJson();
- * const newUser = await api.post("/users").withBody({ name: "John" }).getJson();
+ * const users = await api.get('/users').getJson();
+ * const newUser = await api.post('/users').withBody({ name: 'John' }).getJson();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use without URL when baseURL is set
+ * const api = api().withBaseURL('https://api.example.com');
+ * const data = await api.get().getJson(); // Requests to https://api.example.com
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Override defaults per request
+ * const api = api()
+ *   .withBaseURL('https://api.example.com')
+ *   .withTimeout(5000);
+ *
+ * // This request uses a longer timeout
+ * await api.get('/slow-endpoint').withTimeout(30000).getJson();
  * ```
  */
 function api() {
-    return new ApiBuilder();
+    return ApiBuilderImpl.create();
 }
 
 /**
@@ -3061,7 +2962,7 @@ function api() {
  *
  * // POST request with body
  * const newUser = await create.post('/api/users')
- *   .withJson({ name: 'John', email: 'john@example.com' })
+ *   .withBody({ name: 'John', email: 'john@example.com' })
  *   .getJson();
  *
  * // Configure API instance with defaults
@@ -3094,13 +2995,13 @@ exports.PostRequest = PostRequest;
 exports.PutRequest = PutRequest;
 exports.RequestError = RequestError;
 exports.ResponseWrapper = ResponseWrapper;
-exports.api = api;
+exports.createApi = api;
+exports.createDelete = del;
+exports.createGet = get;
+exports.createHead = head;
+exports.createOptions = options;
+exports.createPatch = patch;
+exports.createPost = post;
+exports.createPut = put;
 exports["default"] = create;
-exports.del = del;
-exports.get = get;
-exports.head = head;
-exports.options = options;
-exports.patch = patch;
-exports.post = post;
-exports.put = put;
 //# sourceMappingURL=index.cjs.map