@zayne-labs/callapi 1.7.5 → 1.7.6

package/dist/esm/index.js

@@ -1,5 +1,5 @@
-import { splitConfig, isFunction, splitBaseConfig, defaultExtraOptions, defaultRequestOptions, createTimeoutSignal, createCombinedSignal, mergeAndResolveHeaders, isSerializable, HTTPError, resolveErrorResult, isHTTPErrorInstance, waitUntil, omitKeys, isPlainObject, isString, isArray, toQueryString, getFetchImpl, isReadableStream, isObject } from './chunk-G4FFGADM.js';
-export { HTTPError, getDefaultOptions } from './chunk-G4FFGADM.js';
+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-UVFIGKZS.js';
+export { HTTPError } from './chunk-UVFIGKZS.js';
 
 // src/hooks.ts
 var hookRegistries = {
@@ -142,23 +142,24 @@ var toStreamableResponse = async (context) => {
 };
 
 // src/dedupe.ts
-var generateDedupeKey = (options, request) => {
-  const shouldHaveDedupeKey = options.dedupeStrategy === "cancel" || options.dedupeStrategy === "defer";
-  if (!shouldHaveDedupeKey) {
-    return null;
-  }
-  return `${options.fullURL}-${JSON.stringify({ options, request })}`;
-};
 var createDedupeStrategy = async (context) => {
   const { $RequestInfoCache, baseConfig, config, newFetchController, options, request } = context;
-  const dedupeKey = options.dedupeKey ?? generateDedupeKey(options, request);
+  const dedupeStrategy = options.dedupeStrategy ?? dedupeDefaults.dedupeStrategy;
+  const generateDedupeKey = () => {
+    const shouldHaveDedupeKey = dedupeStrategy === "cancel" || dedupeStrategy === "defer";
+    if (!shouldHaveDedupeKey) {
+      return null;
+    }
+    return `${options.fullURL}-${JSON.stringify({ options, request })}`;
+  };
+  const dedupeKey = options.dedupeKey ?? generateDedupeKey();
   const $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
   if (dedupeKey !== null) {
     await waitUntil(0.1);
   }
   const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
   const handleRequestCancelStrategy = () => {
-    const shouldCancelRequest = prevRequestInfo && options.dedupeStrategy === "cancel";
+    const shouldCancelRequest = prevRequestInfo && dedupeStrategy === "cancel";
     if (!shouldCancelRequest) return;
     const message = options.dedupeKey ? `Duplicate request detected - Aborting previous request with key '${options.dedupeKey}' as a new request was initiated` : `Duplicate request detected - Aborting previous request to '${options.fullURL}' as a new request with identical options was initiated`;
     const reason = new DOMException(message, "AbortError");
@@ -167,7 +168,7 @@ var createDedupeStrategy = async (context) => {
   };
   const handleRequestDeferStrategy = async () => {
     const fetchApi = getFetchImpl(options.customFetchImpl);
-    const shouldUsePromiseFromCache = prevRequestInfo && options.dedupeStrategy === "defer";
+    const shouldUsePromiseFromCache = prevRequestInfo && dedupeStrategy === "defer";
     const requestInstance = new Request(
       options.fullURL,
       isReadableStream(request.body) && !request.duplex ? { ...request, duplex: "half" } : request
@@ -183,7 +184,9 @@ var createDedupeStrategy = async (context) => {
       if (isReadableStream(request.body)) {
         return fetchApi(requestInstance.clone());
       }
-      return fetchApi(options.fullURL, request);
+      const method = request.method ?? requestOptionDefaults.method;
+      const modifiedRequest = { ...request, method };
+      return fetchApi(options.fullURL, modifiedRequest);
     };
     const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : getFetchApiPromise();
     $RequestInfoCacheOrNull?.set(dedupeKey, { controller: newFetchController, responsePromise });
@@ -200,6 +203,7 @@ var createDedupeStrategy = async (context) => {
     $RequestInfoCacheOrNull?.delete(dedupeKey);
   };
   return {
+    dedupeStrategy,
     handleRequestCancelStrategy,
     handleRequestDeferStrategy,
     removeDedupeKeyFromCache
@@ -224,17 +228,23 @@ var initializePlugins = async (context) => {
   const clonedHookRegistries = structuredClone(hookRegistries);
   const addMainHooks = () => {
     for (const key of Object.keys(clonedHookRegistries)) {
-      const mainHook = options[key];
+      const baseHook = baseConfig[key];
+      const instanceHook = config[key];
+      const overriddenHook = options[key];
+      const mainHook = isArray(baseHook) && Boolean(instanceHook) ? [baseHook, instanceHook].flat() : overriddenHook;
+      if (!mainHook) continue;
       clonedHookRegistries[key].add(mainHook);
     }
   };
   const addPluginHooks = (pluginHooks) => {
     for (const key of Object.keys(clonedHookRegistries)) {
       const pluginHook = pluginHooks[key];
+      if (!pluginHook) continue;
       clonedHookRegistries[key].add(pluginHook);
     }
   };
-  if (options.mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
+  const mergedHooksExecutionOrder = options.mergedHooksExecutionOrder ?? hookDefaults.mergedHooksExecutionOrder;
+  if (mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
     addMainHooks();
   }
   const resolvedPlugins = resolvePluginArray(options.plugins, baseConfig.plugins);
@@ -266,13 +276,14 @@ var initializePlugins = async (context) => {
     if (!plugin.hooks) continue;
     addPluginHooks(plugin.hooks);
   }
-  if (!options.mergedHooksExecutionOrder || options.mergedHooksExecutionOrder === "mainHooksAfterPlugins") {
+  if (mergedHooksExecutionOrder === "mainHooksAfterPlugins") {
     addMainHooks();
   }
   const resolvedHooks = {};
   for (const [key, hookRegistry] of Object.entries(clonedHookRegistries)) {
-    const flattenedHookArray = [...hookRegistry].flat().filter(Boolean);
-    const composedHook = composeTwoHooks(flattenedHookArray, options.mergedHooksExecutionMode);
+    const flattenedHookArray = [...hookRegistry].flat();
+    const mergedHooksExecutionMode = options.mergedHooksExecutionMode ?? hookDefaults.mergedHooksExecutionMode;
+    const composedHook = composeTwoHooks(flattenedHookArray, mergedHooksExecutionMode);
     resolvedHooks[key] = composedHook;
   }
   return {
@@ -289,25 +300,20 @@ var getResponseType = (response, parser) => ({
   blob: () => response.blob(),
   formData: () => response.formData(),
   json: async () => {
-    if (parser) {
-      const text = await response.text();
-      return parser(text);
-    }
-    return response.json();
+    const text = await response.text();
+    return parser(text);
   },
   stream: () => response.body,
   text: () => response.text()
 });
-var resolveResponseData = async (response, responseType, parser) => {
-  const RESPONSE_TYPE_LOOKUP = getResponseType(response, parser);
-  if (!responseType) {
-    return RESPONSE_TYPE_LOOKUP.json();
-  }
-  if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, responseType)) {
+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}`);
   }
-  const responseData = await RESPONSE_TYPE_LOOKUP[responseType]();
-  return responseData;
+  return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
 };
 var resolveSuccessResult = (info) => {
   const { data, response, resultMode } = info;
@@ -329,37 +335,52 @@ var resolveSuccessResult = (info) => {
 };
 
 // src/retry.ts
-var getLinearDelay = (options) => options.retryDelay ?? 1e3;
+var getLinearDelay = (currentAttemptCount, options) => {
+  const retryDelay = options.retryDelay ?? options.retry?.delay;
+  const resolveRetryDelay = (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? retryDefaults.delay;
+  return resolveRetryDelay;
+};
 var getExponentialDelay = (currentAttemptCount, options) => {
-  const maxDelay = options.retryMaxDelay ?? 1e4;
-  const exponentialDelay = (options.retryDelay ?? 1e3) * 2 ** currentAttemptCount;
+  const retryDelay = options.retryDelay ?? options.retry?.delay ?? retryDefaults.delay;
+  const resolveRetryDelay = Number(isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay);
+  const maxDelay = Number(options.retryMaxDelay ?? options.retry?.maxDelay ?? retryDefaults.maxDelay);
+  const exponentialDelay = resolveRetryDelay * 2 ** currentAttemptCount;
   return Math.min(exponentialDelay, maxDelay);
 };
 var createRetryStrategy = (ctx) => {
   const { options } = ctx;
-  const currentRetryCount = options["~retryCount"] ?? 0;
+  const currentAttemptCount = options["~retryAttemptCount"] ?? 0;
+  const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? retryDefaults.strategy;
   const getDelay = () => {
-    if (options.retryStrategy === "exponential") {
-      return getExponentialDelay(currentRetryCount, options);
+    switch (retryStrategy) {
+      case "exponential": {
+        return getExponentialDelay(currentAttemptCount, options);
+      }
+      case "linear": {
+        return getLinearDelay(currentAttemptCount, options);
+      }
+      default: {
+        throw new Error(`Invalid retry strategy: ${retryStrategy}`);
+      }
     }
-    return getLinearDelay(options);
   };
   const shouldAttemptRetry = async () => {
-    const customRetryCondition = await options.retryCondition?.(ctx) ?? true;
-    const maxRetryAttempts = options.retryAttempts ?? 0;
-    const baseRetryCondition = maxRetryAttempts > currentRetryCount && customRetryCondition;
+    const retryCondition = options.retryCondition ?? options.retry?.condition ?? retryDefaults.condition;
+    const maxRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? retryDefaults.attempts;
+    const customRetryCondition = await retryCondition(ctx);
+    const baseShouldRetry = maxRetryAttempts > currentAttemptCount && customRetryCondition;
     if (ctx.error.name !== "HTTPError") {
-      return baseRetryCondition;
+      return baseShouldRetry;
     }
-    const includesMethod = (
-      // eslint-disable-next-line no-implicit-coercion -- Boolean doesn't narrow
-      !!ctx.request.method && options.retryMethods?.includes(ctx.request.method)
-    );
-    const includesCodes = (
-      // eslint-disable-next-line no-implicit-coercion -- Boolean doesn't narrow
-      !!ctx.response?.status && options.retryStatusCodes?.includes(ctx.response.status)
+    const retryMethods = new Set(
+      options.retryMethods ?? options.retry?.methods ?? retryDefaults.methods
     );
-    return includesCodes && includesMethod && baseRetryCondition;
+    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;
+    return shouldRetry;
   };
   const executeRetryHook = async (shouldThrowOnError) => {
     try {
@@ -452,12 +473,10 @@ var createFetchClient = (initBaseConfig = {}) => {
     const resolvedBaseConfig = isFunction(initBaseConfig) ? initBaseConfig({ initURL: initURL.toString(), options: extraOptions, request: fetchOptions }) : initBaseConfig;
     const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
     const mergedExtraOptions = {
-      ...defaultExtraOptions,
       ...baseExtraOptions,
       ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "options" && extraOptions
     };
     const mergedRequestOptions = {
-      ...defaultRequestOptions,
       ...baseFetchOptions,
       ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "request" && fetchOptions
     };
@@ -470,7 +489,7 @@ var createFetchClient = (initBaseConfig = {}) => {
       options: mergedExtraOptions,
       request: mergedRequestOptions
     });
-    const fullURL = `${resolvedOptions.baseURL}${mergeUrlWithParamsAndQuery(url, resolvedOptions.params, resolvedOptions.query)}`;
+    const fullURL = `${resolvedOptions.baseURL ?? ""}${mergeUrlWithParamsAndQuery(url, resolvedOptions.params, resolvedOptions.query)}`;
     const options = {
       ...resolvedOptions,
       ...resolvedHooks,
@@ -484,9 +503,10 @@ var createFetchClient = (initBaseConfig = {}) => {
       timeoutSignal,
       newFetchController.signal
     );
+    const bodySerializer = options.bodySerializer ?? commonDefaults.bodySerializer;
     const request = {
       ...resolvedRequestOptions,
-      body: isSerializable(resolvedRequestOptions.body) ? options.bodySerializer(resolvedRequestOptions.body) : resolvedRequestOptions.body,
+      body: isSerializable(resolvedRequestOptions.body) ? bodySerializer(resolvedRequestOptions.body) : resolvedRequestOptions.body,
       headers: mergeAndResolveHeaders({
         auth: options.auth,
         baseHeaders: baseFetchOptions.headers,
@@ -495,7 +515,12 @@ var createFetchClient = (initBaseConfig = {}) => {
       }),
       signal: combinedSignal
     };
-    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
+    const {
+      dedupeStrategy,
+      handleRequestCancelStrategy,
+      handleRequestDeferStrategy,
+      removeDedupeKeyFromCache
+    } = await createDedupeStrategy({
       $RequestInfoCache,
       baseConfig,
       config,
@@ -512,7 +537,7 @@ var createFetchClient = (initBaseConfig = {}) => {
         headers: request.headers
       });
       const response = await handleRequestDeferStrategy();
-      const shouldCloneResponse = options.dedupeStrategy === "defer" || options.cloneResponse;
+      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;
       if (!response.ok) {
@@ -580,7 +605,7 @@ var createFetchClient = (initBaseConfig = {}) => {
           await waitUntil(delay);
           const updatedOptions = {
             ...config,
-            "~retryCount": (options["~retryCount"] ?? 0) + 1
+            "~retryAttemptCount": (options["~retryAttemptCount"] ?? 0) + 1
           };
           return callApi2(initURL, updatedOptions);
         }