@zayne-labs/callapi 1.7.2 → 1.7.4

package/dist/esm/index.js

@@ -1,5 +1,35 @@
-import { splitConfig, isFunction, splitBaseConfig, combineHooks, defaultExtraOptions, defaultRequestOptions, mergeAndResolveHeaders, isSerializable, executeHooks, HTTPError, resolveErrorResult, isHTTPErrorInstance, waitUntil, omitKeys, isPlainObject, isString, isArray, toQueryString, getFetchImpl, isReadableStream, isObject } from './chunk-IAT2JZPC.js';
-export { HTTPError, getDefaultOptions } from './chunk-IAT2JZPC.js';
+import { splitConfig, isFunction, splitBaseConfig, defaultExtraOptions, defaultRequestOptions, createTimeoutSignal, createCombinedSignal, mergeAndResolveHeaders, isSerializable, HTTPError, resolveErrorResult, isHTTPErrorInstance, waitUntil, omitKeys, isPlainObject, isString, isArray, toQueryString, getFetchImpl, isReadableStream, isObject } from './chunk-FE6ZVVZS.js';
+export { HTTPError, getDefaultOptions } from './chunk-FE6ZVVZS.js';
+
+// src/hooks.ts
+var hookRegistries = {
+  onError: /* @__PURE__ */ new Set(),
+  onRequest: /* @__PURE__ */ new Set(),
+  onRequestError: /* @__PURE__ */ new Set(),
+  onRequestStream: /* @__PURE__ */ new Set(),
+  onResponse: /* @__PURE__ */ new Set(),
+  onResponseError: /* @__PURE__ */ new Set(),
+  onResponseStream: /* @__PURE__ */ new Set(),
+  onRetry: /* @__PURE__ */ new Set(),
+  onSuccess: /* @__PURE__ */ new Set()
+};
+var composeTwoHooks = (hooks, mergedHooksExecutionMode) => {
+  if (hooks.length === 0) return;
+  const mergedHook = async (ctx) => {
+    if (mergedHooksExecutionMode === "sequential") {
+      for (const hook of hooks) {
+        await hook?.(ctx);
+      }
+      return;
+    }
+    if (mergedHooksExecutionMode === "parallel") {
+      const hookArray = [...hooks];
+      await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
+    }
+  };
+  return mergedHook;
+};
+var executeHooks = (...hooks) => Promise.all(hooks);
 
 // src/stream.ts
 var createProgressEvent = (options) => {
@@ -22,17 +52,19 @@ var calculateTotalBytesFromBody = async (requestBody, existingTotalBytes) => {
   return totalBytes;
 };
 var toStreamableRequest = async (context) => {
-  const { options, request, requestInstance } = context;
+  const { baseConfig, config, options, request, requestInstance } = context;
   if (!options.onRequestStream || !requestInstance.body) return;
   const contentLength = requestInstance.headers.get("content-length") ?? new Headers(request.headers).get("content-length") ?? request.body?.size;
   let totalBytes = Number(contentLength ?? 0);
-  const shouldForceContentLengthCalc = isObject(options.forceStreamSizeCalc) ? options.forceStreamSizeCalc.request : options.forceStreamSizeCalc;
+  const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.request : options.forceCalculateStreamSize;
   if (!contentLength && shouldForceContentLengthCalc) {
     totalBytes = await calculateTotalBytesFromBody(requestInstance.clone().body, totalBytes);
   }
   let transferredBytes = 0;
   await executeHooks(
     options.onRequestStream({
+      baseConfig,
+      config,
       event: createProgressEvent({ chunk: new Uint8Array(), totalBytes, transferredBytes }),
       options,
       request,
@@ -48,6 +80,8 @@ var toStreamableRequest = async (context) => {
         totalBytes = Math.max(totalBytes, transferredBytes);
         await executeHooks(
           options.onRequestStream?.({
+            baseConfig,
+            config,
             event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
             options,
             request,
@@ -61,19 +95,21 @@ var toStreamableRequest = async (context) => {
   });
 };
 var toStreamableResponse = async (context) => {
-  const { options, request, response } = context;
+  const { baseConfig, config, options, request, response } = context;
   if (!options.onResponseStream || !response.body) {
     return response;
   }
   const contentLength = response.headers.get("content-length");
   let totalBytes = Number(contentLength ?? 0);
-  const shouldForceContentLengthCalc = isObject(options.forceStreamSizeCalc) ? options.forceStreamSizeCalc.response : options.forceStreamSizeCalc;
+  const shouldForceContentLengthCalc = isObject(options.forceCalculateStreamSize) ? options.forceCalculateStreamSize.response : options.forceCalculateStreamSize;
   if (!contentLength && shouldForceContentLengthCalc) {
     totalBytes = await calculateTotalBytesFromBody(response.clone().body, totalBytes);
   }
   let transferredBytes = 0;
   await executeHooks(
     options.onResponseStream({
+      baseConfig,
+      config,
       event: createProgressEvent({ chunk: new Uint8Array(), totalBytes, transferredBytes }),
       options,
       request,
@@ -89,6 +125,8 @@ var toStreamableResponse = async (context) => {
         totalBytes = Math.max(totalBytes, transferredBytes);
         await executeHooks(
           options.onResponseStream?.({
+            baseConfig,
+            config,
             event: createProgressEvent({ chunk, totalBytes, transferredBytes }),
             options,
             request,
@@ -104,16 +142,16 @@ 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, newFetchController, options, request } = context;
-  const generateDedupeKey = () => {
-    const shouldHaveDedupeKey = options.dedupeStrategy === "cancel" || options.dedupeStrategy === "defer";
-    if (!shouldHaveDedupeKey) {
-      return null;
-    }
-    return `${options.fullURL}-${JSON.stringify({ options, request })}`;
-  };
-  const dedupeKey = options.dedupeKey ?? generateDedupeKey();
+  const { $RequestInfoCache, baseConfig, config, newFetchController, options, request } = context;
+  const dedupeKey = options.dedupeKey ?? generateDedupeKey(options, request);
   const $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
   if (dedupeKey !== null) {
     await waitUntil(0.1);
@@ -134,24 +172,33 @@ var createDedupeStrategy = async (context) => {
       options.fullURL,
       isReadableStream(request.body) && !request.duplex ? { ...request, duplex: "half" } : request
     );
-    void toStreamableRequest({
+    await toStreamableRequest({
+      baseConfig,
+      config,
       options,
       request,
       requestInstance: requestInstance.clone()
     });
-    const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : (
-      // eslint-disable-next-line unicorn/no-nested-ternary -- Allow
-      isReadableStream(request.body) ? fetchApi(requestInstance.clone()) : fetchApi(options.fullURL, request)
-    );
+    const getFetchApiPromise = () => {
+      if (isReadableStream(request.body)) {
+        return fetchApi(requestInstance.clone());
+      }
+      return fetchApi(options.fullURL, request);
+    };
+    const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : getFetchApiPromise();
     $RequestInfoCacheOrNull?.set(dedupeKey, { controller: newFetchController, responsePromise });
     const streamableResponse = toStreamableResponse({
+      baseConfig,
+      config,
       options,
       request,
       response: await responsePromise
     });
     return streamableResponse;
   };
-  const removeDedupeKeyFromCache = () => $RequestInfoCacheOrNull?.delete(dedupeKey);
+  const removeDedupeKeyFromCache = () => {
+    $RequestInfoCacheOrNull?.delete(dedupeKey);
+  };
   return {
     handleRequestCancelStrategy,
     handleRequestDeferStrategy,
@@ -163,61 +210,34 @@ var createDedupeStrategy = async (context) => {
 var definePlugin = (plugin) => {
   return plugin;
 };
-var createMergedHook = (hooks, mergedHooksExecutionMode) => {
-  if (hooks.length === 0) return;
-  const mergedHook = async (ctx) => {
-    if (mergedHooksExecutionMode === "sequential") {
-      for (const hook of hooks) {
-        await hook?.(ctx);
-      }
-      return;
-    }
-    if (mergedHooksExecutionMode === "parallel") {
-      const hookArray = [...hooks];
-      await Promise.all(hookArray.map((uniqueHook) => uniqueHook?.(ctx)));
-    }
-  };
-  return mergedHook;
-};
-var hooksEnum = {
-  onError: /* @__PURE__ */ new Set(),
-  onRequest: /* @__PURE__ */ new Set(),
-  onRequestError: /* @__PURE__ */ new Set(),
-  onRequestStream: /* @__PURE__ */ new Set(),
-  onResponse: /* @__PURE__ */ new Set(),
-  onResponseError: /* @__PURE__ */ new Set(),
-  onResponseStream: /* @__PURE__ */ new Set(),
-  onRetry: /* @__PURE__ */ new Set(),
-  onSuccess: /* @__PURE__ */ new Set()
-};
-var getPluginArray = (plugins) => {
+var resolvePluginArray = (plugins, basePlugins) => {
   if (!plugins) {
     return [];
   }
+  if (isFunction(plugins)) {
+    return plugins({ basePlugins: basePlugins ?? [] });
+  }
   return plugins;
 };
 var initializePlugins = async (context) => {
   const { baseConfig, config, initURL, options, request } = context;
-  const hookRegistries = structuredClone(hooksEnum);
+  const clonedHookRegistries = structuredClone(hookRegistries);
   const addMainHooks = () => {
-    for (const key of Object.keys(hooksEnum)) {
+    for (const key of Object.keys(clonedHookRegistries)) {
       const mainHook = options[key];
-      hookRegistries[key].add(mainHook);
+      clonedHookRegistries[key].add(mainHook);
     }
   };
   const addPluginHooks = (pluginHooks) => {
-    for (const key of Object.keys(hooksEnum)) {
+    for (const key of Object.keys(clonedHookRegistries)) {
       const pluginHook = pluginHooks[key];
-      hookRegistries[key].add(pluginHook);
+      clonedHookRegistries[key].add(pluginHook);
     }
   };
   if (options.mergedHooksExecutionOrder === "mainHooksBeforePlugins") {
     addMainHooks();
   }
-  const resolvedPlugins = [
-    ...getPluginArray(options.plugins),
-    ...getPluginArray(options.extend?.plugins)
-  ];
+  const resolvedPlugins = resolvePluginArray(options.plugins, baseConfig.plugins);
   let resolvedUrl = initURL;
   let resolvedOptions = options;
   let resolvedRequestOptions = request;
@@ -250,10 +270,10 @@ var initializePlugins = async (context) => {
     addMainHooks();
   }
   const resolvedHooks = {};
-  for (const [key, hookRegistry] of Object.entries(hookRegistries)) {
+  for (const [key, hookRegistry] of Object.entries(clonedHookRegistries)) {
     const flattenedHookArray = [...hookRegistry].flat().filter(Boolean);
-    const mergedHook = createMergedHook(flattenedHookArray, options.mergedHooksExecutionMode);
-    resolvedHooks[key] = mergedHook;
+    const composedHook = composeTwoHooks(flattenedHookArray, options.mergedHooksExecutionMode);
+    resolvedHooks[key] = composedHook;
   }
   return {
     resolvedHooks,
@@ -406,10 +426,6 @@ var mergeUrlWithParamsAndQuery = (url, params, query) => {
   return mergeUrlWithQuery(urlWithMergedParams, query);
 };
 
-// src/utils/polyfills.ts
-var createCombinedSignal = (...signals) => AbortSignal.any(signals.filter(Boolean));
-var createTimeoutSignal = (milliseconds) => AbortSignal.timeout(milliseconds);
-
 // src/validation.ts
 var standardSchemaParser = async (schema, inputData) => {
   const result = await schema["~standard"].validate(inputData);
@@ -418,11 +434,6 @@ var standardSchemaParser = async (schema, inputData) => {
   }
   return result.value;
 };
-var createExtensibleSchemasAndValidators = (options) => {
-  const schemas = options.schemas && { ...options.schemas, ...options.extend?.schemas };
-  const validators = options.validators && { ...options.validators, ...options.extend?.validators };
-  return { schemas, validators };
-};
 var handleValidation = async (responseData, schema, validator) => {
   const validResponseData = validator ? validator(responseData) : responseData;
   const schemaValidResponseData = schema ? await standardSchemaParser(schema, validResponseData) : validResponseData;
@@ -430,35 +441,27 @@ var handleValidation = async (responseData, schema, validator) => {
 };
 
 // src/createFetchClient.ts
-var createFetchClient = (baseConfig = {}) => {
+var createFetchClient = (initBaseConfig = {}) => {
   const $RequestInfoCache = /* @__PURE__ */ new Map();
   const callApi2 = async (...parameters) => {
-    const [initURL, config = {}] = parameters;
-    const [fetchOptions, extraOptions] = splitConfig(config);
-    const resolvedBaseConfig = isFunction(baseConfig) ? baseConfig({
-      initURL: initURL.toString(),
-      options: extraOptions,
-      request: fetchOptions
-    }) : baseConfig;
+    const [initURL, initConfig = {}] = parameters;
+    const [fetchOptions, extraOptions] = splitConfig(initConfig);
+    const resolvedBaseConfig = isFunction(initBaseConfig) ? initBaseConfig({ initURL: initURL.toString(), options: extraOptions, request: fetchOptions }) : initBaseConfig;
     const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
-    for (const key of Object.keys(hooksEnum)) {
-      combineHooks(
-        baseExtraOptions[key],
-        extraOptions[key]
-      );
-    }
     const mergedExtraOptions = {
       ...defaultExtraOptions,
       ...baseExtraOptions,
-      ...!baseExtraOptions.mergeMainOptionsManuallyFromBase && extraOptions
+      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "options" && extraOptions
     };
     const mergedRequestOptions = {
       ...defaultRequestOptions,
       ...baseFetchOptions,
-      ...fetchOptions
+      ...baseExtraOptions.skipAutoMergeFor !== "all" && baseExtraOptions.skipAutoMergeFor !== "request" && fetchOptions
     };
+    const baseConfig = resolvedBaseConfig;
+    const config = initConfig;
     const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
-      baseConfig: resolvedBaseConfig,
+      baseConfig,
       config,
       initURL,
       options: mergedExtraOptions,
@@ -489,18 +492,26 @@ var createFetchClient = (baseConfig = {}) => {
       }),
       signal: combinedSignal
     };
-    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({ $RequestInfoCache, newFetchController, options, request });
+    const { handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
+      $RequestInfoCache,
+      baseConfig,
+      config,
+      newFetchController,
+      options,
+      request
+    });
     await handleRequestCancelStrategy();
     try {
-      await executeHooks(options.onRequest?.({ options, request }));
+      await executeHooks(options.onRequest?.({ baseConfig, config, options, request }));
       request.headers = mergeAndResolveHeaders({
         auth: options.auth,
         body: request.body,
         headers: request.headers
       });
       const response = await handleRequestDeferStrategy();
-      const { schemas, validators } = createExtensibleSchemasAndValidators(options);
       const shouldCloneResponse = options.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) {
         const errorData = await resolveResponseData(
           shouldCloneResponse ? response.clone() : response,
@@ -525,6 +536,8 @@ var createFetchClient = (baseConfig = {}) => {
       );
       const validSuccessData = await handleValidation(successData, schemas?.data, validators?.data);
       const successContext = {
+        baseConfig,
+        config,
         data: validSuccessData,
         options,
         request,
@@ -547,6 +560,8 @@ var createFetchClient = (baseConfig = {}) => {
         resultMode: options.resultMode
       });
       const errorContext = {
+        baseConfig,
+        config,
         error: apiDetails.error,
         options,
         request,
@@ -590,9 +605,9 @@ var createFetchClient = (baseConfig = {}) => {
         return await handleRetryOrGetResult({ message });
       }
       await executeHooks(
-        // == At this point only the request errors exist, so the request error interceptor is called
+        // == At this point only the request errors exist, so the request error hook is called
         options.onRequestError?.(errorContext),
-        // == Also call the onError interceptor
+        // == Also call the onError hook
         options.onError?.(errorContext)
       );
       return await handleRetryOrGetResult();