hanzio 1.1.0 → 1.2.0

package/dist/src/api-wrapper/index.js

@@ -38,13 +38,16 @@ function hasJsonContentType(headers) {
   const ct = getHeader(headers, "content-type") ?? "";
   return ct.includes("application/json");
 }
-function buildFetchBody(body, headers) {
+function buildFetchBody(body, headers, configError) {
   if (body === undefined || body === null)
     return;
   if (body instanceof FormData || body instanceof Blob)
     return body;
   if (hasJsonContentType(headers))
     return JSON.stringify(body);
+  if (typeof body === "object" && (Object.getPrototypeOf(body) === Object.prototype || Object.getPrototypeOf(body) === null) && configError) {
+    throw configError("Request body is a plain object but Content-Type is not application/json");
+  }
   return body;
 }
 function getHeadersAsObject(headers) {
@@ -339,39 +342,61 @@ var isNetworkError = (e) => e instanceof NetworkError;
 var isRequestAbortedError = (e) => e instanceof RequestAbortedError;
 var isConfigError = (e) => e instanceof ConfigError;
 var isActionError = (e) => e instanceof ActionError;
+function isNonRetryableApiError(error) {
+  return error instanceof HttpResponseError || error instanceof ResponseValidationError || error instanceof RequestValidationError || error instanceof ConfigError || error instanceof RequestAbortedError;
+}
 // src/api-wrapper/builders.ts
 import { ZodError as ZodError2 } from "zod";
-function buildUrl(endpoint, params, reqQuery, baseApiUrls, defaultBaseApiUrl, url, configError) {
+function formatQueryString(queryParams, doNotEncode) {
+  if (Object.keys(queryParams).length === 0)
+    return "";
+  return doNotEncode ? Object.entries(queryParams).map(([key, value]) => `${key}=${value}`).join("&") : new URLSearchParams(queryParams).toString();
+}
+function buildUrl(options) {
+  const {
+    endpoint,
+    params,
+    queryParams,
+    baseApiUrls,
+    defaultBaseApiUrl,
+    url,
+    doNotEncodeQueryParams,
+    configError
+  } = options;
+  let finalUrl;
   if (url) {
-    const finalUrl2 = replacePathParams(url, params, configError);
-    const queryString2 = new URLSearchParams(buildQueryParamsRaw(endpoint, reqQuery)).toString();
-    return {
-      finalUrl: finalUrl2,
-      fullUrl: queryString2 ? `${finalUrl2}?${queryString2}` : finalUrl2
-    };
-  }
-  const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
-  if (!defaultBaseUrl) {
-    throw configError("At least one base API URL is required");
-  }
-  const baseUrlKey = endpoint.baseApiUrl ?? defaultBaseUrl;
-  const configBaseUrl = baseApiUrls[baseUrlKey];
-  if (!configBaseUrl) {
-    throw configError(`Unknown base API URL: ${baseUrlKey}`);
+    finalUrl = replacePathParams(url, params, configError);
+  } else {
+    const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
+    if (!defaultBaseUrl) {
+      throw configError("At least one base API URL is required");
+    }
+    const baseUrlKey = endpoint.baseApiUrl ?? defaultBaseUrl;
+    const configBaseUrl = baseApiUrls[baseUrlKey];
+    if (!configBaseUrl) {
+      throw configError(`Unknown base API URL: ${baseUrlKey}`);
+    }
+    const baseUrl = typeof configBaseUrl === "function" ? configBaseUrl() : configBaseUrl;
+    const path = typeof endpoint.path === "function" ? endpoint.path(baseUrl) : endpoint.path;
+    finalUrl = `${baseUrl}${replacePathParams(path, params, configError)}`;
   }
-  const baseUrl = typeof configBaseUrl === "function" ? configBaseUrl() : configBaseUrl;
-  const path = typeof endpoint.path === "function" ? endpoint.path(baseUrl) : endpoint.path;
-  const finalUrl = replacePathParams(`${baseUrl}${path}`, params, configError);
-  const queryString = new URLSearchParams(buildQueryParamsRaw(endpoint, reqQuery)).toString();
+  const queryString = formatQueryString(queryParams, doNotEncodeQueryParams);
   return {
     finalUrl,
     fullUrl: queryString ? `${finalUrl}?${queryString}` : finalUrl
   };
 }
-function buildQueryParamsRaw(endpoint, query) {
-  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
-  const merged = { ...defaultParams, ...query ?? {} };
-  return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]));
+function buildPathParams(endpoint, params, ctx) {
+  if (!endpoint.reqParamsSchema)
+    return params;
+  try {
+    return endpoint.reqParamsSchema.parse(params);
+  } catch (error) {
+    if (error instanceof ZodError2) {
+      throw new RequestValidationError(error, "params", params, ctx());
+    }
+    throw error;
+  }
 }
 function buildQueryParams(endpoint, query, ctx) {
   const defaultParams = endpoint.reqDefaultQueryParams ?? {};
@@ -504,8 +529,8 @@ function createActionCache() {
 function makeDefineAction() {
   function defineAction(...args) {
     if (args.length === 0) {
-      return (def2) => ({
-        ...def2,
+      return (def) => ({
+        ...def,
         noRuntimeInput: false
       });
     }
@@ -536,6 +561,7 @@ var SENSITIVE_BODY_KEYS = new Set([
   "refresh_token",
   "secret",
   "client_secret",
+  "clientsecret",
   "apikey",
   "api_key"
 ]);
@@ -626,16 +652,14 @@ async function validateResponse(schema, data, ctx) {
   }
 }
 async function httpRequest(config, ctx) {
-  const queryString = config.doNotEncodeQueryParams ? Object.entries(config.queryParams).map(([key, value]) => `${key}=${value}`).join("&") : new URLSearchParams(config.queryParams).toString();
-  const fullUrl = queryString ? `${config.url}?${queryString}` : config.url;
   const timeoutController = new AbortController;
   const timeout = config.timeoutMs === undefined ? undefined : setTimeout(() => timeoutController.abort(), config.timeoutMs);
   const signal = mergeSignals(timeoutController.signal, config.userSignal);
   try {
-    return await config.fetchFn(fullUrl, {
+    return await config.fetchFn(config.fullUrl, {
       method: config.method,
       headers: config.headers,
-      body: buildFetchBody(config.body, config.headers),
+      body: buildFetchBody(config.body, config.headers, (msg) => new ConfigError(msg, ctx())),
       signal
     });
   } catch (error) {
@@ -648,6 +672,8 @@ async function httpRequest(config, ctx) {
       }
       throw new RequestAbortedError(ctx(), error);
     }
+    if (error instanceof ConfigError)
+      throw error;
     throw new NetworkError(error instanceof Error ? error.message : String(error), ctx(), error);
   } finally {
     if (timeout)
@@ -684,35 +710,26 @@ async function readErrorResponse(response) {
   };
 }
 function getRetryDelay(params) {
+  const maxDelay = params.maxRetryDelayMs ?? 30000;
   const { retryDelay, attempt, response } = params;
   if (response && (response.status === 429 || response.status === 503)) {
     const retryAfter = response.headers.get("retry-after");
     if (retryAfter) {
       const seconds = Number(retryAfter);
-      if (Number.isFinite(seconds))
-        return seconds * 1000;
+      if (Number.isFinite(seconds)) {
+        return Math.min(Math.max(0, seconds * 1000), maxDelay);
+      }
       const dateMs = Date.parse(retryAfter);
       if (!Number.isNaN(dateMs)) {
-        return Math.max(0, dateMs - Date.now());
+        return Math.min(Math.max(0, dateMs - Date.now()), maxDelay);
       }
     }
   }
-  if (typeof retryDelay === "function")
-    return retryDelay(attempt);
-  return retryDelay;
+  const delayMs = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+  return Math.min(delayMs, maxDelay);
 }
 function shouldAttemptRetryOnError(error) {
-  if (error instanceof HttpResponseError)
-    return false;
-  if (error instanceof ResponseValidationError)
-    return false;
-  if (error instanceof RequestValidationError)
-    return false;
-  if (error instanceof ConfigError)
-    return false;
-  if (error instanceof RequestAbortedError)
-    return false;
-  return true;
+  return !isNonRetryableApiError(error);
 }
 function shouldAttemptRetryOnHttp(retryCtx) {
   const { error, response } = retryCtx;
@@ -725,6 +742,7 @@ async function makeRequestWithRetry(args) {
     config,
     maxRetries,
     retryDelay,
+    maxRetryDelayMs,
     validateFn,
     shouldRetry,
     logger,
@@ -763,7 +781,8 @@ async function makeRequestWithRetry(args) {
           const delayMs = getRetryDelay({
             retryDelay,
             attempt: retryCount,
-            response
+            response,
+            maxRetryDelayMs
           });
           await onRetry?.({
             ...retryCtx,
@@ -778,12 +797,12 @@ async function makeRequestWithRetry(args) {
         throw new HttpResponseError(response.status, body, responseHeaders, ctx({ attempt: retryCount }));
       }
       return {
-        validatedData: await validateFn(response),
+        validatedData: await validateFn(response, retryCount),
         retryCount,
         httpStatus: response.status
       };
     } catch (error) {
-      if (error instanceof HttpResponseError || error instanceof ResponseValidationError || error instanceof RequestValidationError || error instanceof ConfigError || error instanceof RequestAbortedError) {
+      if (isNonRetryableApiError(error)) {
         throw error;
       }
       const retryCtx = {
@@ -800,7 +819,8 @@ async function makeRequestWithRetry(args) {
       const delayMs = getRetryDelay({
         retryDelay,
         attempt: retryCount,
-        response: undefined
+        response: undefined,
+        maxRetryDelayMs
       });
       await onRetry?.({
         ...retryCtx,
@@ -814,19 +834,21 @@ async function makeRequestWithRetry(args) {
 }
 async function validateAndTransformResponse(endpoint, response, ctx) {
   const responseHeaders = getHeadersAsObject(response.headers);
+  const text = await response.text();
+  const responseSizeBytes = new TextEncoder().encode(text).length;
   let responseData;
   if (hasJsonContentType(responseHeaders)) {
-    const text = await response.text();
     try {
       responseData = text === "" ? undefined : JSON.parse(text);
     } catch (error) {
       throw new ResponseValidationError(makeJsonParseZodError(error, text), text, ctx());
     }
   } else {
-    responseData = await response.text();
+    responseData = text;
   }
   const transformedData = endpoint.resFormatter ? endpoint.resFormatter(responseData, responseHeaders) : responseData;
-  return validateResponse(endpoint.resSchema, transformedData, ctx);
+  const data = await validateResponse(endpoint.resSchema, transformedData, ctx);
+  return { data, responseSizeBytes };
 }
 function defaultShouldRetry(ctx) {
   if (ctx.error)
@@ -845,6 +867,28 @@ function isActionInvokeOptionsOnly(value) {
     return false;
   return Object.keys(value).every((k) => k === "signal" || k === "meta");
 }
+function resolveActionInvocation(action, actionName, first, second) {
+  if (!action.noRuntimeInput) {
+    return { input: first, options: second ?? {} };
+  }
+  if (first === undefined || first === null) {
+    return { input: undefined, options: second ?? {} };
+  }
+  if (second !== undefined) {
+    return { input: undefined, options: second };
+  }
+  if (isActionInvokeOptionsOnly(first)) {
+    return { input: undefined, options: first };
+  }
+  throw new ConfigError(`Action "${actionName}" does not accept input; pass only optional { signal, meta }`, {
+    endpoint: actionName,
+    method: "GET",
+    url: "",
+    attempt: 0,
+    maxRetries: 0,
+    elapsedMs: 0
+  });
+}
 function createApiClientImpl(apiConfig) {
   let actions = {};
   const cache = createActionCache();
@@ -873,22 +917,12 @@ function createApiClientImpl(apiConfig) {
       throw await reportApiError(new ConfigError(`Unknown API endpoint: ${String(endpointKey)}`, ctx()), apiConfig);
     }
     baseContext.method = endpoint.method;
-    let finalUrl;
-    let fullUrl;
-    try {
-      const built = buildUrl(endpoint, rawInput.reqParams, rawInput.reqQuery, apiConfig.baseApiUrls, apiConfig.defaultBaseApiUrl, input.url, (msg) => new ConfigError(msg, ctx()));
-      finalUrl = built.finalUrl;
-      fullUrl = built.fullUrl;
-    } catch (e) {
-      if (e instanceof ApiError)
-        throw await reportApiError(e, apiConfig);
-      throw e;
-    }
-    baseContext.url = fullUrl;
+    let pathParams;
     let queryParams;
     let body;
     let headers;
     try {
+      pathParams = buildPathParams(endpoint, rawInput.reqParams, ctx);
       queryParams = buildQueryParams(endpoint, rawInput.reqQuery, ctx);
       body = buildRequestBody(endpoint, rawInput.reqBody, ctx);
       headers = buildHeaders(endpoint, rawInput.reqHeaders, apiConfig.defaultHeaders ?? {}, ctx);
@@ -897,6 +931,25 @@ function createApiClientImpl(apiConfig) {
         throw await reportApiError(e, apiConfig);
       throw e;
     }
+    let fullUrl;
+    try {
+      const built = buildUrl({
+        endpoint,
+        params: pathParams,
+        queryParams,
+        baseApiUrls: apiConfig.baseApiUrls,
+        defaultBaseApiUrl: apiConfig.defaultBaseApiUrl,
+        url: input.url,
+        doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
+        configError: (msg) => new ConfigError(msg, ctx())
+      });
+      fullUrl = built.fullUrl;
+    } catch (e) {
+      if (e instanceof ApiError)
+        throw await reportApiError(e, apiConfig);
+      throw e;
+    }
+    baseContext.url = fullUrl;
     baseContext.requestHeaders = headers;
     baseContext.requestBody = body;
     if (apiConfig.onRequest) {
@@ -921,11 +974,9 @@ function createApiClientImpl(apiConfig) {
     }
     const config = {
       method: endpoint.method,
-      url: finalUrl,
-      queryParams,
+      fullUrl,
       body,
       headers,
-      doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
       timeoutMs: input.timeoutMs ?? apiConfig.timeoutMs,
       fetchFn: input.fetch ?? apiConfig.fetch ?? fetch,
       userSignal: input.signal
@@ -935,7 +986,8 @@ function createApiClientImpl(apiConfig) {
         config,
         maxRetries,
         retryDelay: apiConfig.retryDelayMs ?? 300,
-        validateFn: (response) => validateAndTransformResponse(endpoint, response, ctx),
+        maxRetryDelayMs: apiConfig.maxRetryDelayMs,
+        validateFn: (response, attempt) => validateAndTransformResponse(endpoint, response, (over) => ctx({ attempt, ...over })),
         shouldRetry: apiConfig.shouldRetry ?? defaultShouldRetry,
         logger: apiConfig.logger,
         ctx,
@@ -947,10 +999,10 @@ function createApiClientImpl(apiConfig) {
         onRetry: apiConfig.onRetry
       });
       const responseTimeMs = elapsed();
-      const responseSizeMb = calculateSizeInMb(result.validatedData);
+      const responseSizeMb = result.validatedData.responseSizeBytes / (1024 * 1024);
       const requestBodySizeMb = calculateSizeInMb(config.body);
       return {
-        data: result.validatedData,
+        data: result.validatedData.data,
         requestBodySizeMb,
         responseSizeMb,
         responseTimeMs,
@@ -1006,22 +1058,14 @@ function createApiClientImpl(apiConfig) {
       throw await reportApiError(wrapped, apiConfig);
     }
   }
+  async function dispatchAction(name, first, second) {
+    const action = actions[name];
+    const { input, options } = resolveActionInvocation(action, name, first, second);
+    return invokeAction(name, input, options);
+  }
   const request = async (key, input, options) => {
     if (key in actions) {
-      const action = actions[key];
-      if (action.noRuntimeInput) {
-        if (input === undefined || input === null) {
-          return invokeAction(key, undefined, options ?? {});
-        }
-        if (options !== undefined) {
-          return invokeAction(key, undefined, options);
-        }
-        if (isActionInvokeOptionsOnly(input)) {
-          return invokeAction(key, undefined, input);
-        }
-        return invokeAction(key, undefined, {});
-      }
-      return invokeAction(key, input, options);
+      return dispatchAction(key, input, options);
     }
     return invokeEndpoint(key, input ?? {});
   };
@@ -1035,22 +1079,7 @@ function createApiClientImpl(apiConfig) {
         return (input) => invokeEndpoint(prop, input ?? {});
       }
       if (prop in actions) {
-        const action = actions[prop];
-        if (action.noRuntimeInput) {
-          return (first, second) => {
-            if (first === undefined || first === null) {
-              return invokeAction(prop, undefined, second ?? {});
-            }
-            if (second !== undefined) {
-              return invokeAction(prop, undefined, second);
-            }
-            if (isActionInvokeOptionsOnly(first)) {
-              return invokeAction(prop, undefined, first);
-            }
-            return invokeAction(prop, undefined, {});
-          };
-        }
-        return (input, opt) => invokeAction(prop, input, opt);
+        return (first, second) => dispatchAction(prop, first, second);
       }
       return;
     }
@@ -1079,24 +1108,25 @@ function createApiClientImpl(apiConfig) {
 }
 var createApiClient = (apiConfig) => createApiClientImpl(apiConfig);
 export {
-  isResponseValidationError,
-  isRequestValidationError,
-  isRequestTimeoutError,
-  isRequestAbortedError,
-  isNetworkError,
-  isHttpResponseError,
-  isConfigError,
-  isApiError,
-  isActionError,
-  defineAction,
-  createApiClient,
-  ResponseValidationError,
-  RequestValidationError,
-  RequestTimeoutError,
-  RequestAbortedError,
-  NetworkError,
-  HttpResponseError,
-  ConfigError,
+  ActionError,
   ApiError,
-  ActionError
+  ConfigError,
+  HttpResponseError,
+  NetworkError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  RequestValidationError,
+  ResponseValidationError,
+  createApiClient,
+  defineAction,
+  isActionError,
+  isApiError,
+  isConfigError,
+  isHttpResponseError,
+  isNetworkError,
+  isNonRetryableApiError,
+  isRequestAbortedError,
+  isRequestTimeoutError,
+  isRequestValidationError,
+  isResponseValidationError
 };