@zayne-labs/callapi 1.7.8 → 1.7.12

package/dist/esm/index.js

@@ -1,5 +1,5 @@
-import { splitConfig, isFunction, splitBaseConfig, createTimeoutSignal, createCombinedSignal, commonDefaults, mergeAndResolveHeaders, isSerializable, HTTPError, resolveErrorResult, isHTTPErrorInstance, waitUntil, hookDefaults, dedupeDefaults, responseDefaults, omitKeys, retryDefaults, isArray, isPlainObject, isString, toQueryString, getFetchImpl, isReadableStream, isObject, requestOptionDefaults } from './chunk-DLKKYMSL.js';
-export { HTTPError } from './chunk-DLKKYMSL.js';
+import { splitConfig, isFunction, splitBaseConfig, createTimeoutSignal, createCombinedSignal, commonDefaults, getHeaders, isSerializable, resolveResponseData, HTTPError, resolveSuccessResult, resolveErrorResult, isHTTPErrorInstance, getCustomizedErrorResult, waitUntil, hookDefaults, dedupeDefaults, retryDefaults, isArray, isPlainObject, isString, toQueryString, getFetchImpl, isReadableStream, isHTTPError, requestOptionDefaults, isObject } from './chunk-SJZKYDA4.js';
+export { HTTPError } from './chunk-SJZKYDA4.js';
 
 // src/hooks.ts
 var hookRegistries = {
@@ -29,7 +29,25 @@ var composeTwoHooks = (hooks, mergedHooksExecutionMode) => {
   };
   return mergedHook;
 };
-var executeHooks = (...hooks) => Promise.all(hooks);
+var executeHooksInTryBlock = async (...hookResults) => {
+  await Promise.all(hookResults);
+};
+var createExecuteHooksFn = (info) => {
+  const { errorInfo, shouldThrowOnError } = info;
+  const executeHooksInCatchBlock = async (...hookResults) => {
+    try {
+      await Promise.all(hookResults);
+      return null;
+    } catch (hookError) {
+      const hookErrorResult = resolveErrorResult(hookError, errorInfo);
+      if (shouldThrowOnError) {
+        throw hookError;
+      }
+      return hookErrorResult;
+    }
+  };
+  return executeHooksInCatchBlock;
+};
 
 // src/stream.ts
 var createProgressEvent = (options) => {
@@ -61,7 +79,7 @@ var toStreamableRequest = async (context) => {
     totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
   }
   let transferredBytes = 0;
-  await executeHooks(
+  await executeHooksInTryBlock(
     options.onRequestStream({
       baseConfig,
       config,
@@ -78,7 +96,7 @@ var toStreamableRequest = async (context) => {
       for await (const chunk of body) {
         transferredBytes += chunk.byteLength;
         totalBytes = Math.max(totalBytes, transferredBytes);
-        await executeHooks(
+        await executeHooksInTryBlock(
           options.onRequestStream?.({
             baseConfig,
             config,
@@ -106,7 +124,7 @@ var toStreamableResponse = async (context) => {
     totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
   }
   let transferredBytes = 0;
-  await executeHooks(
+  await executeHooksInTryBlock(
     options.onResponseStream({
       baseConfig,
       config,
@@ -123,7 +141,7 @@ var toStreamableResponse = async (context) => {
       for await (const chunk of body) {
         transferredBytes += chunk.byteLength;
         totalBytes = Math.max(totalBytes, transferredBytes);
-        await executeHooks(
+        await executeHooksInTryBlock(
           options.onResponseStream?.({
             baseConfig,
             config,
@@ -284,7 +302,7 @@ var initializePlugins = async (context) => {
     const flattenedHookArray = [...hookRegistry].flat();
     const mergedHooksExecutionMode = options.mergedHooksExecutionMode ?? hookDefaults.mergedHooksExecutionMode;
     const composedHook = composeTwoHooks(flattenedHookArray, mergedHooksExecutionMode);
-    resolvedHooks[key] = composedHook;
+    composedHook && (resolvedHooks[key] = composedHook);
   }
   return {
     resolvedHooks,
@@ -294,46 +312,6 @@ var initializePlugins = async (context) => {
   };
 };
 
-// src/response.ts
-var getResponseType = (response, parser) => ({
-  arrayBuffer: () => response.arrayBuffer(),
-  blob: () => response.blob(),
-  formData: () => response.formData(),
-  json: async () => {
-    const text = await response.text();
-    return parser(text);
-  },
-  stream: () => response.body,
-  text: () => response.text()
-});
-var resolveResponseData = (response, responseType, parser) => {
-  const selectedParser = parser ?? responseDefaults.responseParser;
-  const selectedResponseType = responseType ?? responseDefaults.responseType;
-  const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
-  if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) {
-    throw new Error(`Invalid response type: ${responseType}`);
-  }
-  return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
-};
-var resolveSuccessResult = (info) => {
-  const { data, response, resultMode } = info;
-  const apiDetails = { data, error: null, response };
-  if (!resultMode) {
-    return apiDetails;
-  }
-  const resultModeMap = {
-    all: apiDetails,
-    allWithException: apiDetails,
-    allWithoutResponse: omitKeys(apiDetails, ["response"]),
-    onlyError: apiDetails.error,
-    onlyResponse: apiDetails.response,
-    onlyResponseWithException: apiDetails.response,
-    onlySuccess: apiDetails.data,
-    onlySuccessWithException: apiDetails.data
-  };
-  return resultModeMap[resultMode];
-};
-
 // src/retry.ts
 var getLinearDelay = (currentAttemptCount, options) => {
   const retryDelay = options.retryDelay ?? options.retry?.delay;
@@ -342,14 +320,16 @@ var getLinearDelay = (currentAttemptCount, options) => {
 };
 var getExponentialDelay = (currentAttemptCount, options) => {
   const retryDelay = options.retryDelay ?? options.retry?.delay ?? retryDefaults.delay;
-  const resolveRetryDelay = Number(isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay);
+  const resolvedRetryDelay = Number(
+    isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay
+  );
   const maxDelay = Number(options.retryMaxDelay ?? options.retry?.maxDelay ?? retryDefaults.maxDelay);
-  const exponentialDelay = resolveRetryDelay * 2 ** currentAttemptCount;
+  const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
   return Math.min(exponentialDelay, maxDelay);
 };
 var createRetryStrategy = (ctx) => {
   const { options } = ctx;
-  const currentAttemptCount = options["~retryAttemptCount"] ?? 0;
+  const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
   const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? retryDefaults.strategy;
   const getDelay = () => {
     switch (retryStrategy) {
@@ -360,46 +340,33 @@ var createRetryStrategy = (ctx) => {
         return getLinearDelay(currentAttemptCount, options);
       }
       default: {
-        throw new Error(`Invalid retry strategy: ${retryStrategy}`);
+        throw new Error(`Invalid retry strategy: ${String(retryStrategy)}`);
       }
     }
   };
   const shouldAttemptRetry = async () => {
     const retryCondition = options.retryCondition ?? options.retry?.condition ?? retryDefaults.condition;
-    const maxRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? retryDefaults.attempts;
+    const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? retryDefaults.attempts;
     const customRetryCondition = await retryCondition(ctx);
-    const baseShouldRetry = maxRetryAttempts > currentAttemptCount && customRetryCondition;
-    if (ctx.error.name !== "HTTPError") {
-      return baseShouldRetry;
+    const baseShouldRetry = maximumRetryAttempts >= currentAttemptCount && customRetryCondition;
+    if (!baseShouldRetry) {
+      return false;
     }
-    const retryMethods = new Set(
-      options.retryMethods ?? options.retry?.methods ?? retryDefaults.methods
-    );
+    if (!isHTTPError(ctx.error)) {
+      return true;
+    }
+    const selectedMethodArray = options.retryMethods ?? options.retry?.methods ?? retryDefaults.methods;
+    const retryMethods = new Set(selectedMethodArray);
+    const method = ctx.request.method ?? requestOptionDefaults.method;
+    const includesMethod = Boolean(method) && retryMethods.has(method);
     const selectedStatusCodeArray = options.retryStatusCodes ?? options.retry?.statusCodes;
     const retryStatusCodes = selectedStatusCodeArray ? new Set(selectedStatusCodeArray) : null;
-    const includesMethod = Boolean(ctx.request.method) && retryMethods.has(ctx.request.method);
     const includesStatusCodes = Boolean(ctx.response?.status) && (retryStatusCodes?.has(ctx.response.status) ?? true);
-    const shouldRetry = baseShouldRetry && includesMethod && includesStatusCodes;
+    const shouldRetry = includesMethod && includesStatusCodes;
     return shouldRetry;
   };
-  const executeRetryHook = async (shouldThrowOnError) => {
-    try {
-      return await executeHooks(options.onRetry?.(ctx));
-    } catch (error) {
-      const { apiDetails } = resolveErrorResult({
-        cloneResponse: options.cloneResponse,
-        defaultErrorMessage: options.defaultErrorMessage,
-        error,
-        resultMode: options.resultMode
-      });
-      if (shouldThrowOnError) {
-        throw error;
-      }
-      return apiDetails;
-    }
-  };
   return {
-    executeRetryHook,
+    currentAttemptCount,
     getDelay,
     shouldAttemptRetry
   };
@@ -507,7 +474,7 @@ var createFetchClient = (initBaseConfig = {}) => {
     const request = {
       ...resolvedRequestOptions,
       body: isSerializable(resolvedRequestOptions.body) ? bodySerializer(resolvedRequestOptions.body) : resolvedRequestOptions.body,
-      headers: mergeAndResolveHeaders({
+      headers: await getHeaders({
         auth: options.auth,
         baseHeaders: baseFetchOptions.headers,
         body: resolvedRequestOptions.body,
@@ -530,16 +497,16 @@ var createFetchClient = (initBaseConfig = {}) => {
     });
     await handleRequestCancelStrategy();
     try {
-      await executeHooks(options.onRequest?.({ baseConfig, config, options, request }));
-      request.headers = mergeAndResolveHeaders({
+      await executeHooksInTryBlock(options.onRequest?.({ baseConfig, config, options, request }));
+      request.headers = await getHeaders({
         auth: options.auth,
         body: request.body,
         headers: request.headers
       });
       const response = await handleRequestDeferStrategy();
       const shouldCloneResponse = dedupeStrategy === "defer" || options.cloneResponse;
-      const schemas = isFunction(options.schemas) ? options.schemas({ baseSchemas: baseExtraOptions.schemas ?? {} }) : options.schemas;
-      const validators = isFunction(options.validators) ? options.validators({ baseValidators: baseExtraOptions.validators ?? {} }) : options.validators;
+      const schemas = isFunction(options.schemas) ? options.schemas({ baseSchemas: baseExtraOptions.schemas }) : options.schemas;
+      const validators = isFunction(options.validators) ? options.validators({ baseValidators: baseExtraOptions.validators }) : options.validators;
       if (!response.ok) {
         const errorData = await resolveResponseData(
           shouldCloneResponse ? response.clone() : response,
@@ -571,74 +538,89 @@ var createFetchClient = (initBaseConfig = {}) => {
         request,
         response
       };
-      await executeHooks(
+      await executeHooksInTryBlock(
         options.onSuccess?.(successContext),
         options.onResponse?.({ ...successContext, error: null })
       );
-      return await resolveSuccessResult({
-        data: successContext.data,
+      const successResult = await resolveSuccessResult(successContext.data, {
         response: successContext.response,
         resultMode: options.resultMode
       });
+      return successResult;
     } catch (error) {
-      const { apiDetails, getErrorResult } = resolveErrorResult({
+      const errorInfo = {
         cloneResponse: options.cloneResponse,
         defaultErrorMessage: options.defaultErrorMessage,
-        error,
         resultMode: options.resultMode
-      });
+      };
+      const generalErrorResult = resolveErrorResult(error, errorInfo);
       const errorContext = {
         baseConfig,
         config,
-        error: apiDetails.error,
+        error: generalErrorResult?.error,
         options,
         request,
-        response: apiDetails.response
+        response: generalErrorResult?.response
       };
       const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
-      const handleRetryOrGetResult = async (customInfo) => {
-        const { executeRetryHook, getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
+      const executeHooksInCatchBlock = createExecuteHooksFn({ errorInfo, shouldThrowOnError });
+      const handleRetryOrGetErrorResult = async () => {
+        const { currentAttemptCount, getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
         const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
         if (shouldRetry) {
-          await executeRetryHook(shouldThrowOnError);
+          const retryContext = {
+            ...errorContext,
+            retryAttemptCount: currentAttemptCount
+          };
+          const hookError2 = await executeHooksInCatchBlock(options.onRetry?.(retryContext));
+          if (hookError2) {
+            return hookError2;
+          }
           const delay = getDelay();
           await waitUntil(delay);
           const updatedOptions = {
             ...config,
-            "~retryAttemptCount": (options["~retryAttemptCount"] ?? 0) + 1
+            "~retryAttemptCount": currentAttemptCount + 1
           };
           return callApi2(initURL, updatedOptions);
         }
         if (shouldThrowOnError) {
           throw error;
         }
-        return customInfo ? getErrorResult(customInfo) : getErrorResult();
+        return generalErrorResult;
       };
       if (isHTTPErrorInstance(error)) {
-        await executeHooks(
+        const hookError2 = await executeHooksInCatchBlock(
           options.onResponseError?.(errorContext),
           options.onError?.(errorContext),
           options.onResponse?.({ ...errorContext, data: null })
         );
-        return await handleRetryOrGetResult();
+        if (hookError2) {
+          return hookError2;
+        }
+        return await handleRetryOrGetErrorResult();
       }
       if (error instanceof DOMException && error.name === "AbortError") {
         const { message, name } = error;
         !shouldThrowOnError && console.error(`${name}:`, message);
-        return await handleRetryOrGetResult();
+        return await handleRetryOrGetErrorResult();
       }
       if (error instanceof DOMException && error.name === "TimeoutError") {
         const message = `Request timed out after ${options.timeout}ms`;
         !shouldThrowOnError && console.error(`${error.name}:`, message);
-        return await handleRetryOrGetResult({ message });
+        const errorResult = await handleRetryOrGetErrorResult();
+        return getCustomizedErrorResult(errorResult, { message });
       }
-      await executeHooks(
+      const hookError = await executeHooksInCatchBlock(
         // == At this point only the request errors exist, so the request error hook is called
         options.onRequestError?.(errorContext),
         // == Also call the onError hook
         options.onError?.(errorContext)
       );
-      return await handleRetryOrGetResult();
+      if (hookError) {
+        return hookError;
+      }
+      return await handleRetryOrGetErrorResult();
     } finally {
       removeDedupeKeyFromCache();
     }