@igniter-js/caller 0.1.0 → 0.1.2

package/dist/index.js

@@ -462,6 +462,52 @@ var IgniterCallerUrlUtils = class {
 };
 
 // src/builder/igniter-caller-request.builder.ts
+var VALIDATABLE_CONTENT_TYPES = [
+  "json",
+  "xml",
+  "csv"
+];
+function detectContentType(contentType) {
+  if (!contentType) return "text";
+  const ct = contentType.toLowerCase();
+  if (ct.includes("application/json")) return "json";
+  if (ct.includes("application/xml") || ct.includes("text/xml")) return "xml";
+  if (ct.includes("text/csv")) return "csv";
+  if (ct.includes("text/html")) return "html";
+  if (ct.includes("text/plain")) return "text";
+  if (ct.includes("multipart/form-data")) return "formdata";
+  if (ct.includes("application/octet-stream")) return "blob";
+  if (ct.includes("image/") || ct.includes("audio/") || ct.includes("video/") || ct.includes("application/pdf") || ct.includes("application/zip")) {
+    return "blob";
+  }
+  return "text";
+}
+function isValidatableContentType(contentType) {
+  return VALIDATABLE_CONTENT_TYPES.includes(
+    contentType
+  );
+}
+async function parseResponseByContentType(response, contentType) {
+  switch (contentType) {
+    case "json":
+      return response.json();
+    case "xml":
+    case "csv":
+    case "html":
+    case "text":
+      return response.text();
+    case "blob":
+      return response.blob();
+    case "stream":
+      return response.body;
+    case "arraybuffer":
+      return response.arrayBuffer();
+    case "formdata":
+      return response.formData();
+    default:
+      return response.text();
+  }
+}
 var IgniterCallerRequestBuilder = class {
   constructor(params) {
     this.options = {
@@ -491,6 +537,22 @@ var IgniterCallerRequestBuilder = class {
     this.schemas = params.schemas;
     this.schemaValidation = params.schemaValidation;
   }
+  /**
+   * Sets the HTTP method for this request.
+   * @internal Used by IgniterCaller.request() for generic requests.
+   */
+  _setMethod(method) {
+    this.options.method = method;
+    return this;
+  }
+  /**
+   * Sets the URL for this request.
+   * @internal Used when URL is passed to HTTP method directly.
+   */
+  _setUrl(url) {
+    this.options.url = url;
+    return this;
+  }
   /**
    * Overrides the logger for this request chain.
    */
@@ -498,30 +560,45 @@ var IgniterCallerRequestBuilder = class {
     this.logger = logger;
     return this;
   }
-  method(method) {
-    this.options.method = method;
-    return this;
-  }
+  /**
+   * Sets the request URL.
+   */
   url(url) {
     this.options.url = url;
     return this;
   }
+  /**
+   * Sets the request body.
+   * For GET/HEAD requests, body will be automatically converted to query params.
+   */
   body(body) {
     this.options.body = body;
     return this;
   }
+  /**
+   * Sets URL query parameters.
+   */
   params(params) {
     this.options.params = params;
     return this;
   }
+  /**
+   * Merges additional headers into the request.
+   */
   headers(headers) {
     this.options.headers = { ...this.options.headers, ...headers };
     return this;
   }
+  /**
+   * Sets request timeout in milliseconds.
+   */
   timeout(timeout) {
     this.options.timeout = timeout;
     return this;
   }
+  /**
+   * Sets cache strategy and optional cache key.
+   */
   cache(cache, key) {
     this.options.cache = cache;
     this.cacheKey = key;
@@ -548,12 +625,32 @@ var IgniterCallerRequestBuilder = class {
     this.staleTime = milliseconds;
     return this;
   }
+  /**
+   * Sets the expected response type for TypeScript inference.
+   *
+   * - If a Zod/StandardSchema is passed, it will validate the response (only for JSON/XML/CSV)
+   * - If a type parameter is passed (e.g., `responseType<File>()`), it's for typing only
+   *
+   * The actual parsing is based on Content-Type headers, not this setting.
+   *
+   * @example
+   * ```ts
+   * // With Zod schema (validates JSON response)
+   * const result = await api.get('/users').responseType(UserSchema).execute()
+   *
+   * // With type marker (typing only, no validation)
+   * const result = await api.get('/file').responseType<Blob>().execute()
+   * ```
+   */
   responseType(schema) {
-    this.options.responseSchema = schema;
+    if (schema) {
+      this.responseTypeSchema = schema;
+    }
     return this;
   }
   /**
    * Downloads a file via GET request.
+   * @deprecated Use `.responseType<File>().execute()` instead. The response type is auto-detected.
    */
   getFile(url) {
     this.options.method = "GET";
@@ -647,6 +744,19 @@ var IgniterCallerRequestBuilder = class {
       }
     };
   }
+  /**
+   * Executes the HTTP request.
+   *
+   * Response parsing is automatic based on Content-Type headers:
+   * - `application/json` → parsed as JSON
+   * - `text/xml`, `application/xml` → returned as text (parse with your XML library)
+   * - `text/csv` → returned as text
+   * - `text/html`, `text/plain` → returned as text
+   * - `image/*`, `audio/*`, `video/*`, `application/pdf`, etc. → returned as Blob
+   * - `application/octet-stream` → returned as Blob
+   *
+   * Schema validation (if configured) only runs for validatable content types (JSON, XML, CSV).
+   */
   async execute() {
     const effectiveCacheKey = this.cacheKey || this.options.url;
     if (effectiveCacheKey && this.staleTime) {
@@ -658,7 +768,10 @@ var IgniterCallerRequestBuilder = class {
         this.logger?.debug("IgniterCaller.execute cache hit", {
           key: effectiveCacheKey
         });
-        const cachedResult = { data: cached, error: void 0 };
+        const cachedResult = {
+          data: cached,
+          error: void 0
+        };
         await this.emitEvent(cachedResult);
         return cachedResult;
       }
@@ -668,7 +781,10 @@ var IgniterCallerRequestBuilder = class {
       this.logger?.debug("IgniterCaller.execute applying fallback", {
         error: result.error
       });
-      const fallbackResult = { data: this.fallbackFn(), error: void 0 };
+      const fallbackResult = {
+        data: this.fallbackFn(),
+        error: void 0
+      };
       await this.emitEvent(fallbackResult);
       return fallbackResult;
     }
@@ -720,7 +836,6 @@ var IgniterCallerRequestBuilder = class {
     };
   }
   async executeSingleRequest() {
-    const { responseSchema } = this.options;
     let { url, requestInit, controller, timeoutId } = this.buildRequest();
     this.logger?.debug("IgniterCaller.execute started", {
       method: this.options.method,
@@ -754,6 +869,7 @@ var IgniterCallerRequestBuilder = class {
             this.logger
           );
         } catch (error) {
+          clearTimeout(timeoutId);
           return {
             data: void 0,
             error
@@ -782,70 +898,118 @@ var IgniterCallerRequestBuilder = class {
               method: this.options.method,
               url
             }
-          })
+          }),
+          status: httpResponse.status,
+          headers: httpResponse.headers
         };
       }
-      const contentType = httpResponse.headers.get("content-type");
-      const data = contentType?.includes("application/json") ? await httpResponse.json() : await httpResponse.text();
-      let validatedData = data;
-      if (this.schemas) {
-        const { schema: endpointSchema } = IgniterCallerSchemaUtils.findSchema(
-          this.schemas,
-          url,
-          this.options.method
-        );
-        const responseSchema2 = endpointSchema?.responses?.[httpResponse.status];
-        if (responseSchema2) {
-          try {
-            validatedData = await IgniterCallerSchemaUtils.validateResponse(
-              data,
-              responseSchema2,
-              httpResponse.status,
-              this.schemaValidation,
-              { url, method: this.options.method },
-              this.logger
-            );
-          } catch (error) {
-            return {
-              data: void 0,
-              error
-            };
+      const contentTypeHeader = httpResponse.headers.get("content-type");
+      const detectedContentType = detectContentType(contentTypeHeader);
+      let data = await parseResponseByContentType(httpResponse, detectedContentType);
+      const shouldValidate = isValidatableContentType(detectedContentType);
+      if (shouldValidate) {
+        if (this.schemas) {
+          const { schema: endpointSchema } = IgniterCallerSchemaUtils.findSchema(
+            this.schemas,
+            url,
+            this.options.method
+          );
+          const responseSchema = endpointSchema?.responses?.[httpResponse.status];
+          if (responseSchema) {
+            try {
+              data = await IgniterCallerSchemaUtils.validateResponse(
+                data,
+                responseSchema,
+                httpResponse.status,
+                this.schemaValidation,
+                { url, method: this.options.method },
+                this.logger
+              );
+            } catch (error) {
+              return {
+                data: void 0,
+                error,
+                status: httpResponse.status,
+                headers: httpResponse.headers
+              };
+            }
           }
         }
-      }
-      if (responseSchema) {
-        const result = responseSchema.safeParse(data);
-        if (!result.success) {
-          return {
-            data: void 0,
-            error: new IgniterCallerError({
-              code: "IGNITER_CALLER_RESPONSE_VALIDATION_FAILED",
-              operation: "parseResponse",
-              message: `Response validation failed: ${result.error.message}`,
-              logger: this.logger,
-              statusCode: 500,
-              metadata: {
-                method: this.options.method,
-                url
-              },
-              cause: result.error
-            })
-          };
-        }
-        let response2 = {
-          data: result.data,
-          error: void 0
-        };
-        if (this.responseInterceptors && this.responseInterceptors.length > 0) {
-          for (const interceptor of this.responseInterceptors) {
-            response2 = await interceptor(response2);
+        if (this.responseTypeSchema) {
+          if ("safeParse" in this.responseTypeSchema) {
+            const zodSchema = this.responseTypeSchema;
+            const result = zodSchema.safeParse(data);
+            if (!result.success) {
+              return {
+                data: void 0,
+                error: new IgniterCallerError({
+                  code: "IGNITER_CALLER_RESPONSE_VALIDATION_FAILED",
+                  operation: "parseResponse",
+                  message: `Response validation failed: ${result.error.message}`,
+                  logger: this.logger,
+                  statusCode: httpResponse.status,
+                  metadata: {
+                    method: this.options.method,
+                    url
+                  },
+                  cause: result.error
+                }),
+                status: httpResponse.status,
+                headers: httpResponse.headers
+              };
+            }
+            data = result.data;
+          } else if ("~standard" in this.responseTypeSchema) {
+            try {
+              const standardSchema = this.responseTypeSchema;
+              const result = await standardSchema["~standard"].validate(data);
+              if (result.issues) {
+                return {
+                  data: void 0,
+                  error: new IgniterCallerError({
+                    code: "IGNITER_CALLER_RESPONSE_VALIDATION_FAILED",
+                    operation: "parseResponse",
+                    message: `Response validation failed`,
+                    logger: this.logger,
+                    statusCode: httpResponse.status,
+                    metadata: {
+                      method: this.options.method,
+                      url,
+                      issues: result.issues
+                    }
+                  }),
+                  status: httpResponse.status,
+                  headers: httpResponse.headers
+                };
+              }
+              data = result.value;
+            } catch (error) {
+              return {
+                data: void 0,
+                error: new IgniterCallerError({
+                  code: "IGNITER_CALLER_RESPONSE_VALIDATION_FAILED",
+                  operation: "parseResponse",
+                  message: error?.message || "Response validation failed",
+                  logger: this.logger,
+                  statusCode: httpResponse.status,
+                  metadata: {
+                    method: this.options.method,
+                    url
+                  },
+                  cause: error
+                }),
+                status: httpResponse.status,
+                headers: httpResponse.headers
+              };
+            }
           }
         }
-        return response2;
       }
       let response = {
-        data: validatedData,
-        error: void 0
+        data,
+        error: void 0,
+        status: httpResponse.status,
+        headers: httpResponse.headers
       };
       if (this.responseInterceptors && this.responseInterceptors.length > 0) {
         for (const interceptor of this.responseInterceptors) {
@@ -891,21 +1055,32 @@ var IgniterCallerRequestBuilder = class {
   }
   buildRequest() {
     const { method, url, body, params, headers, timeout, baseURL, cache } = this.options;
+    let finalParams = params;
+    if ((method === "GET" || method === "HEAD") && body && typeof body === "object") {
+      const bodyParams = {};
+      for (const [key, value] of Object.entries(body)) {
+        if (value !== void 0 && value !== null) {
+          bodyParams[key] = String(value);
+        }
+      }
+      finalParams = { ...bodyParams, ...params };
+    }
     const fullUrl = IgniterCallerUrlUtils.buildUrl({
       url,
       baseURL,
-      query: params
+      query: finalParams
     });
-    const rawBody = IgniterCallerBodyUtils.isRawBody(body);
+    const shouldIncludeBody = body && method !== "GET" && method !== "HEAD";
+    const rawBody = shouldIncludeBody && IgniterCallerBodyUtils.isRawBody(body);
     const finalHeaders = IgniterCallerBodyUtils.normalizeHeadersForBody(
       headers,
-      body
+      shouldIncludeBody ? body : void 0
     );
     const requestInit = {
       method,
       headers: finalHeaders,
       cache,
-      ...body && method !== "GET" && method !== "HEAD" ? { body: rawBody ? body : JSON.stringify(body) } : {}
+      ...shouldIncludeBody ? { body: rawBody ? body : JSON.stringify(body) } : {}
     };
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout || 3e4);
@@ -1114,8 +1289,11 @@ var _IgniterCaller = class _IgniterCaller {
     this.cookies = cookies;
     return this;
   }
-  get() {
-    return new IgniterCallerRequestBuilder({
+  /**
+   * Creates common request builder params.
+   */
+  createBuilderParams() {
+    return {
       baseURL: this.baseURL,
       defaultHeaders: this.headers,
       defaultCookies: this.cookies,
@@ -1127,80 +1305,192 @@ var _IgniterCaller = class _IgniterCaller {
       },
       schemas: this.schemas,
       schemaValidation: this.schemaValidation
-    }).method("GET");
+    };
   }
-  post() {
-    return new IgniterCallerRequestBuilder({
-      baseURL: this.baseURL,
-      defaultHeaders: this.headers,
-      defaultCookies: this.cookies,
-      logger: this.logger,
-      requestInterceptors: this.requestInterceptors,
-      responseInterceptors: this.responseInterceptors,
-      eventEmitter: async (url, method, result) => {
-        await _IgniterCaller.emitEvent(url, method, result);
-      },
-      schemas: this.schemas,
-      schemaValidation: this.schemaValidation
-    }).method("POST");
+  /**
+   * Resolves the full URL path by prepending baseURL if needed.
+   */
+  resolveSchemaPath(url) {
+    if (this.baseURL && !url.startsWith("http")) {
+      return `${this.baseURL}${url}`;
+    }
+    return url;
   }
-  put() {
-    return new IgniterCallerRequestBuilder({
-      baseURL: this.baseURL,
-      defaultHeaders: this.headers,
-      defaultCookies: this.cookies,
-      logger: this.logger,
-      requestInterceptors: this.requestInterceptors,
-      responseInterceptors: this.responseInterceptors,
-      eventEmitter: async (url, method, result) => {
-        await _IgniterCaller.emitEvent(url, method, result);
-      },
-      schemas: this.schemas,
-      schemaValidation: this.schemaValidation
-    }).method("PUT");
+  /**
+   * Creates a GET request.
+   *
+   * When a URL is provided and matches a schema, the response type is automatically inferred.
+   *
+   * @param url Optional URL for the request. Can also be set via `.url()`.
+   *
+   * @example
+   * ```ts
+   * // With typed schema - response type is inferred
+   * const result = await api.get('/users').execute()
+   * // result.data is typed based on schema
+   *
+   * // Without schema or URL set later
+   * const result = await api.get().url('/users').execute()
+   * ```
+   */
+  get(url) {
+    const builder = new IgniterCallerRequestBuilder(this.createBuilderParams());
+    builder._setMethod("GET");
+    if (url) builder._setUrl(url);
+    return builder;
   }
-  patch() {
-    return new IgniterCallerRequestBuilder({
-      baseURL: this.baseURL,
-      defaultHeaders: this.headers,
-      defaultCookies: this.cookies,
-      logger: this.logger,
-      requestInterceptors: this.requestInterceptors,
-      responseInterceptors: this.responseInterceptors,
-      eventEmitter: async (url, method, result) => {
-        await _IgniterCaller.emitEvent(url, method, result);
-      },
-      schemas: this.schemas,
-      schemaValidation: this.schemaValidation
-    }).method("PATCH");
+  /**
+   * Creates a POST request.
+   *
+   * When a URL is provided and matches a schema, the response type is automatically inferred.
+   *
+   * @param url Optional URL for the request. Can also be set via `.url()`.
+   *
+   * @example
+   * ```ts
+   * const result = await api.post('/users').body({ name: 'John' }).execute()
+   * ```
+   */
+  post(url) {
+    const builder = new IgniterCallerRequestBuilder(this.createBuilderParams());
+    builder._setMethod("POST");
+    if (url) builder._setUrl(url);
+    return builder;
   }
-  delete() {
-    return new IgniterCallerRequestBuilder({
-      baseURL: this.baseURL,
-      defaultHeaders: this.headers,
-      defaultCookies: this.cookies,
-      logger: this.logger,
-      requestInterceptors: this.requestInterceptors,
-      responseInterceptors: this.responseInterceptors,
-      eventEmitter: async (url, method, result) => {
-        await _IgniterCaller.emitEvent(url, method, result);
-      },
-      schemas: this.schemas,
-      schemaValidation: this.schemaValidation
-    }).method("DELETE");
+  /**
+   * Creates a PUT request.
+   *
+   * When a URL is provided and matches a schema, the response type is automatically inferred.
+   *
+   * @param url Optional URL for the request. Can also be set via `.url()`.
+   *
+   * @example
+   * ```ts
+   * const result = await api.put('/users/1').body({ name: 'Jane' }).execute()
+   * ```
+   */
+  put(url) {
+    const builder = new IgniterCallerRequestBuilder(this.createBuilderParams());
+    builder._setMethod("PUT");
+    if (url) builder._setUrl(url);
+    return builder;
   }
-  request() {
-    return new IgniterCallerRequestBuilder({
-      baseURL: this.baseURL,
-      defaultHeaders: this.headers,
-      defaultCookies: this.cookies,
-      logger: this.logger,
-      requestInterceptors: this.requestInterceptors,
-      responseInterceptors: this.responseInterceptors,
-      eventEmitter: async (url, method, result) => {
-        await _IgniterCaller.emitEvent(url, method, result);
+  /**
+   * Creates a PATCH request.
+   *
+   * When a URL is provided and matches a schema, the response type is automatically inferred.
+   *
+   * @param url Optional URL for the request. Can also be set via `.url()`.
+   *
+   * @example
+   * ```ts
+   * const result = await api.patch('/users/1').body({ name: 'Jane' }).execute()
+   * ```
+   */
+  patch(url) {
+    const builder = new IgniterCallerRequestBuilder(this.createBuilderParams());
+    builder._setMethod("PATCH");
+    if (url) builder._setUrl(url);
+    return builder;
+  }
+  /**
+   * Creates a DELETE request.
+   *
+   * When a URL is provided and matches a schema, the response type is automatically inferred.
+   *
+   * @param url Optional URL for the request. Can also be set via `.url()`.
+   *
+   * @example
+   * ```ts
+   * const result = await api.delete('/users/1').execute()
+   * ```
+   */
+  delete(url) {
+    const builder = new IgniterCallerRequestBuilder(this.createBuilderParams());
+    builder._setMethod("DELETE");
+    if (url) builder._setUrl(url);
+    return builder;
+  }
+  /**
+   * Creates a HEAD request.
+   *
+   * When a URL is provided and matches a schema, the response type is automatically inferred.
+   *
+   * @param url Optional URL for the request. Can also be set via `.url()`.
+   */
+  head(url) {
+    const builder = new IgniterCallerRequestBuilder(this.createBuilderParams());
+    builder._setMethod("HEAD");
+    if (url) builder._setUrl(url);
+    return builder;
+  }
+  /**
+   * Executes a request directly with all options in one object (axios-style).
+   *
+   * This is a convenience method for making requests without using the builder pattern.
+   * Useful for dynamic requests where options are constructed programmatically.
+   *
+   * @example
+   * ```ts
+   * const result = await api.request({
+   *   method: 'POST',
+   *   url: '/users',
+   *   body: { name: 'John' },
+   *   headers: { 'X-Custom': 'value' },
+   *   timeout: 5000,
+   * })
+   *
+   * // With caching
+   * const result = await api.request({
+   *   method: 'GET',
+   *   url: '/users',
+   *   staleTime: 30000,
+   * })
+   *
+   * // With retry
+   * const result = await api.request({
+   *   method: 'GET',
+   *   url: '/health',
+   *   retry: { maxAttempts: 3, backoff: 'exponential' },
+   * })
+   * ```
+   */
+  async request(options) {
+    const builder = new IgniterCallerRequestBuilder({
+      ...this.createBuilderParams(),
+      // Override with request-specific options
+      defaultHeaders: {
+        ...this.headers,
+        ...options.headers
       }
     });
+    builder._setMethod(options.method);
+    builder._setUrl(options.url);
+    if (options.body !== void 0) {
+      builder.body(options.body);
+    }
+    if (options.params) {
+      builder.params(options.params);
+    }
+    if (options.timeout) {
+      builder.timeout(options.timeout);
+    }
+    if (options.cache) {
+      builder.cache(options.cache, options.cacheKey);
+    }
+    if (options.staleTime) {
+      builder.stale(options.staleTime);
+    }
+    if (options.retry) {
+      builder.retry(options.retry.maxAttempts, options.retry);
+    }
+    if (options.fallback) {
+      builder.fallback(options.fallback);
+    }
+    if (options.responseSchema) {
+      builder.responseType(options.responseSchema);
+    }
+    return builder.execute();
   }
   /**
    * Executes multiple requests in parallel and returns results as an array.
@@ -1251,7 +1541,7 @@ var _IgniterCaller = class _IgniterCaller {
    * @example
    * ```ts
    * // After creating a user
-   * await api.post().url('/users').body(newUser).execute()
+   * await api.post('/users').body(newUser).execute()
    * await IgniterCaller.invalidate('/users') // Clear users list cache
    * ```
    */