@zayne-labs/callapi 1.7.2 → 1.7.5

package/dist/esm/index.d.ts

@@ -1,9 +1,9 @@
-import { R as ResultModeUnion, a as ResponseTypeUnion, C as CallApiPlugin, D as DefaultPluginArray, b as CallApiSchemas, I as InferSchemaResult, c as CallApiConfig, d as CallApiResult, e as DefaultDataType, f as DefaultThrowOnError, g as DefaultMoreOptions, B as BaseCallApiConfig, h as CallApiParameters } from './error-By05WYGj.js';
-export { l as BaseCallApiExtraOptions, m as CallApiExtraOptions, p as CallApiRequestOptions, q as CallApiRequestOptionsForHooks, r as CallApiResultErrorVariant, s as CallApiResultSuccessVariant, t as CombinedCallApiExtraOptions, E as ErrorContext, H as HTTPError, u as Interceptors, v as InterceptorsOrInterceptorArray, P as PluginInitContext, o as PossibleHTTPError, n as PossibleJavaScriptError, w as PossibleJavascriptErrorNames, x as Register, y as RequestContext, z as RequestErrorContext, A as ResponseContext, F as ResponseErrorContext, k as RetryOptions, S as SuccessContext, i as definePlugin, j as getDefaultOptions } from './error-By05WYGj.js';
+import { R as ResultModeUnion, a as ResponseTypeUnion, C as CallApiPlugin, D as DefaultPluginArray, b as CallApiSchemas, I as InferSchemaResult, c as CallApiConfig, d as CallApiResult, e as DefaultDataType, f as DefaultThrowOnError, g as DefaultMoreOptions, B as BaseCallApiConfig, h as CallApiParameters } from './common-BUhBcx_C.js';
+export { y as BaseCallApiExtraOptions, z as CallApiExtraOptions, A as CallApiRequestOptions, F as CallApiRequestOptionsForHooks, G as CallApiResultErrorVariant, J as CallApiResultSuccessVariant, K as CombinedCallApiExtraOptions, E as ErrorContext, H as HTTPError, p as Hooks, q as HooksOrHooksArray, j as PluginHooks, k as PluginHooksWithMoreOptions, P as PluginInitContext, n as PossibleHTTPError, o as PossibleJavaScriptError, L as Register, r as RequestContext, s as RequestErrorContext, t as RequestStreamContext, u as ResponseContext, v as ResponseErrorContext, w as ResponseStreamContext, m as RetryOptions, S as SharedHookContext, x as SuccessContext, i as definePlugin, l as getDefaultOptions } from './common-BUhBcx_C.js';
 
-declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions>(baseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) => <TData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TSchemas extends CallApiSchemas = TBaseSchemas>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> | undefined) => CallApiResult<InferSchemaResult<TSchemas["data"], TData>, InferSchemaResult<TSchemas["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>;
+declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions>(initBaseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) => <TData = InferSchemaResult<TBaseSchemas["data"], TBaseData>, TErrorData = InferSchemaResult<TBaseSchemas["errorData"], TBaseErrorData>, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends boolean = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, TPluginArray extends CallApiPlugin[] = TBasePluginArray, TSchemas extends CallApiSchemas = TBaseSchemas>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> | undefined) => CallApiResult<InferSchemaResult<TSchemas["data"], TData>, InferSchemaResult<TSchemas["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>;
 declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = {}>(initURL: InferSchemaResult<TSchemas["initURL"], string | URL>, config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas> | undefined) => CallApiResult<InferSchemaResult<TSchemas["data"], TData>, InferSchemaResult<TSchemas["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>;
 
 declare const defineParameters: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions>(...parameters: CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>) => CallApiParameters<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>;
 
-export { CallApiParameters, CallApiPlugin, CallApiSchemas, InferSchemaResult, ResultModeUnion, callApi, createFetchClient, defineParameters };
+export { CallApiParameters, CallApiPlugin, CallApiSchemas, InferSchemaResult, ResponseTypeUnion, ResultModeUnion, callApi, createFetchClient, defineParameters };

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-G4FFGADM.js';
+export { HTTPError, getDefaultOptions } from './chunk-G4FFGADM.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,
@@ -280,6 +300,9 @@ var getResponseType = (response, parser) => ({
 });
 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)) {
     throw new Error(`Invalid response type: ${responseType}`);
   }
@@ -406,10 +429,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 +437,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 +444,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 +495,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 +539,8 @@ var createFetchClient = (baseConfig = {}) => {
       );
       const validSuccessData = await handleValidation(successData, schemas?.data, validators?.data);
       const successContext = {
+        baseConfig,
+        config,
         data: validSuccessData,
         options,
         request,
@@ -547,6 +563,8 @@ var createFetchClient = (baseConfig = {}) => {
         resultMode: options.resultMode
       });
       const errorContext = {
+        baseConfig,
+        config,
         error: apiDetails.error,
         options,
         request,
@@ -590,9 +608,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();