@zayne-labs/callapi 1.6.16 → 1.6.18

package/dist/cjs/{error-BokQ-iQX.d.cts → error-DH3yCjyX.d.cts}

@@ -115,77 +115,25 @@ interface CallApiValidators<TData = unknown, TErrorData = unknown> {
 }
 type InferSchemaResult<TSchema, TData> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TData;
 
-/**
- * @description Makes a type required if TSchema type is undefined or if the output type of TSchema contains undefined, otherwise keeps it as is
- */
-type MakeSchemaOptionRequired<TSchema extends StandardSchemaV1 | undefined, TObject> = undefined extends TSchema ? TObject : undefined extends InferSchemaResult<TSchema, NonNullable<unknown>> ? TObject : Required<TObject>;
-type JsonPrimitive = boolean | number | string | null | undefined;
-type SerializableObject = Record<keyof object, unknown>;
-type SerializableArray = Array<JsonPrimitive | SerializableArray | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableArray | SerializableObject>;
-type Body = UnmaskType<RequestInit["body"] | SerializableArray | SerializableObject>;
-type BodyOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["body"], {
+type Params = UnmaskType<Record<string, boolean | number | string> | Array<boolean | number | string>>;
+type Query = UnmaskType<Record<string, boolean | number | string>>;
+type InitURL = UnmaskType<string | URL>;
+interface UrlOptions<TSchemas extends CallApiSchemas> {
     /**
-     * Body of the request, can be a object or any other supported body type.
+     * URL to be used in the request.
      */
-    body?: InferSchemaResult<TSchemas["body"], Body>;
-}>;
-type Method = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
-type MethodOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["method"], {
+    readonly initURL?: string;
     /**
-     * HTTP method for the request.
-     * @default "GET"
+     * Parameters to be appended to the URL (i.e: /:id)
      */
-    method?: InferSchemaResult<TSchemas["method"], Method>;
-}>;
-type Headers = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders> | Record<"Content-Type", CommonContentTypes> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | RequestInit["headers"]>;
-type HeadersOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["headers"], {
+    params?: InferSchemaResult<TSchemas["params"], Params>;
     /**
-     * Headers to be used in the request.
+     * Query parameters to append to the URL.
      */
-    headers?: InferSchemaResult<TSchemas["headers"], Headers>;
-}>;
-interface Register {
+    query?: InferSchemaResult<TSchemas["query"], Query>;
 }
-type GlobalMeta = Register extends {
-    meta?: infer TMeta extends Record<string, unknown>;
-} ? TMeta : never;
-type MetaOption<TSchemas extends CallApiSchemas> = {
-    /**
-     * - An optional field you can fill with additional information,
-     * to associate with the request, typically used for logging or tracing.
-     *
-     * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
-     *
-     * @example
-     * ```ts
-     * const callMainApi = callApi.create({
-     * 	baseURL: "https://main-api.com",
-     * 	onResponseError: ({ response, options }) => {
-     * 		if (options.meta?.userId) {
-     * 			console.error(`User ${options.meta.userId} made an error`);
-     * 		}
-     * 	},
-     * });
-     *
-     * const response = await callMainApi({
-     * 	url: "https://example.com/api/data",
-     * 	meta: { userId: "123" },
-     * });
-     * ```
-     */
-    meta?: InferSchemaResult<TSchemas["meta"], GlobalMeta>;
-};
-type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
-    resultMode: "onlySuccessWithException";
-} : TErrorData extends false | undefined ? {
-    resultMode?: "onlySuccessWithException";
-} : undefined extends TResultMode ? {
-    resultMode?: TResultMode;
-} : {
-    resultMode: TResultMode;
-};
 
-type RetryCondition<TErrorData> = (context: ErrorContext<TErrorData>) => boolean | Promise<boolean>;
+type RetryCondition<TErrorData> = (context: ErrorContext<TErrorData>) => Awaitable<boolean>;
 interface RetryOptions<TErrorData> {
     /**
      * Keeps track of the number of times the request has already been retried
@@ -215,12 +163,12 @@ interface RetryOptions<TErrorData> {
      * HTTP methods that are allowed to retry
      * @default ["GET", "POST"]
      */
-    retryMethods?: Method[];
+    retryMethods?: Method[] | ((context: ErrorContext<TErrorData>) => Method[]);
     /**
      * HTTP status codes that trigger a retry
      * @default [409, 425, 429, 500, 502, 503, 504]
      */
-    retryStatusCodes?: Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber>;
+    retryStatusCodes?: Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber> | ((context: ErrorContext<TErrorData>) => Array<409 | 425 | 429 | 500 | 502 | 503 | 504 | AnyNumber>);
     /**
      * Strategy to use when retrying
      * @default "linear"
@@ -255,6 +203,7 @@ type InferPluginOptions<TPluginArray extends CallApiPlugin[]> = UnionToIntersect
 type PluginInitContext<TMoreOptions = DefaultMoreOptions> = WithMoreOptions<TMoreOptions> & {
     baseConfig: BaseCallApiExtraOptions & CallApiRequestOptions;
     config: CallApiExtraOptions & CallApiRequestOptions;
+    defaultOptions: CallApiExtraOptions;
     initURL: InitURL | undefined;
     options: CombinedCallApiExtraOptions;
     request: CallApiRequestOptionsForHooks;
@@ -296,8 +245,76 @@ declare const definePlugin: <TPlugin extends CallApiPlugin | AnyFunction<CallApi
 type Plugins<TPluginArray extends CallApiPlugin[]> = TPluginArray;
 
 declare const fetchSpecificKeys: ("body" | "cache" | "credentials" | "headers" | "integrity" | "keepalive" | "method" | "mode" | "priority" | "redirect" | "referrer" | "referrerPolicy" | "signal" | "window")[];
-declare const defaultRetryMethods: ("GET" | "POST")[];
-declare const defaultRetryStatusCodes: Required<BaseCallApiExtraOptions>["retryStatusCodes"];
+
+/**
+ * @description Makes a type required if TSchema type is undefined or if the output type of TSchema contains undefined, otherwise keeps it as is
+ */
+type MakeSchemaOptionRequired<TSchema extends StandardSchemaV1 | undefined, TObject> = undefined extends TSchema ? TObject : undefined extends InferSchemaResult<TSchema, NonNullable<unknown>> ? TObject : Required<TObject>;
+type JsonPrimitive = boolean | number | string | null | undefined;
+type SerializableObject = Record<keyof object, unknown>;
+type SerializableArray = Array<JsonPrimitive | SerializableArray | SerializableObject> | ReadonlyArray<JsonPrimitive | SerializableArray | SerializableObject>;
+type Body = UnmaskType<RequestInit["body"] | SerializableArray | SerializableObject>;
+type BodyOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["body"], {
+    /**
+     * Body of the request, can be a object or any other supported body type.
+     */
+    body?: InferSchemaResult<TSchemas["body"], Body>;
+}>;
+type Method = UnmaskType<"CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE" | AnyString>;
+type MethodOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["method"], {
+    /**
+     * HTTP method for the request.
+     * @default "GET"
+     */
+    method?: InferSchemaResult<TSchemas["method"], Method>;
+}>;
+type Headers = UnmaskType<Record<"Authorization", CommonAuthorizationHeaders> | Record<"Content-Type", CommonContentTypes> | Record<CommonRequestHeaders, string | undefined> | Record<string, string | undefined> | RequestInit["headers"]>;
+type HeadersOption<TSchemas extends CallApiSchemas> = MakeSchemaOptionRequired<TSchemas["headers"], {
+    /**
+     * Headers to be used in the request.
+     */
+    headers?: InferSchemaResult<TSchemas["headers"], Headers>;
+}>;
+interface Register {
+}
+type GlobalMeta = Register extends {
+    meta?: infer TMeta extends Record<string, unknown>;
+} ? TMeta : never;
+type MetaOption<TSchemas extends CallApiSchemas> = {
+    /**
+     * - An optional field you can fill with additional information,
+     * to associate with the request, typically used for logging or tracing.
+     *
+     * - A good use case for this, would be to use the info to handle specific cases in any of the shared interceptors.
+     *
+     * @example
+     * ```ts
+     * const callMainApi = callApi.create({
+     * 	baseURL: "https://main-api.com",
+     * 	onResponseError: ({ response, options }) => {
+     * 		if (options.meta?.userId) {
+     * 			console.error(`User ${options.meta.userId} made an error`);
+     * 		}
+     * 	},
+     * });
+     *
+     * const response = await callMainApi({
+     * 	url: "https://example.com/api/data",
+     * 	meta: { userId: "123" },
+     * });
+     * ```
+     */
+    meta?: InferSchemaResult<TSchemas["meta"], GlobalMeta>;
+};
+type ResultModeOption<TErrorData, TResultMode extends ResultModeUnion> = TErrorData extends false ? {
+    resultMode: "onlySuccessWithException";
+} : TErrorData extends false | undefined ? {
+    resultMode?: "onlySuccessWithException";
+} : undefined extends TResultMode ? {
+    resultMode?: TResultMode;
+} : {
+    resultMode: TResultMode;
+};
 
 type FetchSpecificKeysUnion = Exclude<(typeof fetchSpecificKeys)[number], "body" | "headers" | "method">;
 type CallApiRequestOptions<TSchemas extends CallApiSchemas = DefaultMoreOptions> = BodyOption<TSchemas> & HeadersOption<TSchemas> & MethodOption<TSchemas> & Pick<RequestInit, FetchSpecificKeysUnion>;
@@ -448,13 +465,15 @@ declare const optionsEnumToOmitFromBase: ("dedupeKey" | "extend")[];
 type BaseCallApiExtraOptions<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = Omit<Partial<CallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>>, (typeof optionsEnumToOmitFromBase)[number]>;
 type CombinedCallApiExtraOptions = BaseCallApiExtraOptions & CallApiExtraOptions;
 type BaseCallApiConfig<TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends boolean = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TBaseSchemas extends CallApiSchemas = DefaultMoreOptions> = (CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>) | ((context: {
+    defaultOptions: CallApiExtraOptions;
     initURL: string;
     options: CallApiExtraOptions;
     request: CallApiRequestOptions;
 }) => CallApiRequestOptions<TBaseSchemas> & BaseCallApiExtraOptions<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBasePluginArray, TBaseSchemas>);
+type CallApiConfig<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = CallApiRequestOptions<TSchemas> & CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>;
 type CallApiParameters<TData = DefaultDataType, TErrorData = DefaultDataType, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends boolean = DefaultThrowOnError, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TSchemas extends CallApiSchemas = DefaultMoreOptions> = [
     initURL: InferSchemaResult<TSchemas["initURL"], InitURL>,
-    config?: CallApiRequestOptions<TSchemas> & CallApiExtraOptions<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>
+    config?: CallApiConfig<TData, TErrorData, TResultMode, TThrowOnError, TResponseType, TPluginArray, TSchemas>
 ];
 type RequestContext = UnmaskType<{
     options: CombinedCallApiExtraOptions;
@@ -539,24 +558,7 @@ type ResultModeMap<TData = DefaultDataType, TErrorData = DefaultDataType, TRespo
 }>;
 type ResultModeUnion = keyof ResultModeMap | undefined;
 type GetCallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = TErrorData extends false | undefined ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : ResultModeUnion | undefined extends TResultMode ? TThrowOnError extends true ? ResultModeMap<TData, TErrorData, TResponseType>["allWithException"] : ResultModeMap<TData, TErrorData, TResponseType>["all"] : TResultMode extends NonNullable<ResultModeUnion> ? TResultMode extends "onlySuccess" ? ResultModeMap<TData, TErrorData, TResponseType>["onlySuccessWithException"] : TResultMode extends "onlyResponse" ? ResultModeMap<TData, TErrorData, TResponseType>["onlyResponseWithException"] : ResultModeMap<TData, TErrorData, TResponseType>[TResultMode] : never;
-
-type Params = UnmaskType<Record<string, boolean | number | string> | Array<boolean | number | string>>;
-type Query = UnmaskType<Record<string, boolean | number | string>>;
-type InitURL = UnmaskType<string | URL>;
-interface UrlOptions<TSchemas extends CallApiSchemas> {
-    /**
-     * URL to be used in the request.
-     */
-    readonly initURL?: string;
-    /**
-     * Parameters to be appended to the URL (i.e: /:id)
-     */
-    params?: InferSchemaResult<TSchemas["params"], Params>;
-    /**
-     * Query parameters to append to the URL.
-     */
-    query?: InferSchemaResult<TSchemas["query"], Query>;
-}
+type CallApiResult<TData, TErrorData, TResultMode extends ResultModeUnion, TThrowOnError extends boolean, TResponseType extends ResponseTypeUnion> = Promise<GetCallApiResult<TData, TErrorData, TResultMode, TThrowOnError, TResponseType>>;
 
 type ErrorDetails<TErrorResponse> = {
     defaultErrorMessage: string;
@@ -574,4 +576,4 @@ declare class HTTPError<TErrorResponse = Record<string, unknown>> extends Error
     constructor(errorDetails: ErrorDetails<TErrorResponse>, errorOptions?: ErrorOptions);
 }
 
-export { type AnyString as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ExtraOptions as E, type Interceptors as F, type GetCallApiResult as G, HTTPError as H, type InferSchemaResult as I, type PossibleJavascriptErrorNames as J, type Register as K, type RequestContext as L, type MetaOption as M, type RequestErrorContext as N, type ResponseContext as O, type PossibleJavaScriptError as P, type ResponseErrorContext as Q, type ResultModeUnion as R, type SerializableArray as S, type SuccessContext as T, type UrlOptions as U, defaultRetryMethods as V, defaultRetryStatusCodes as W, type ResponseTypeUnion as a, type CallApiSchemas as b, type SerializableObject as c, type CommonContentTypes as d, type CommonRequestHeaders as e, type Auth as f, type Awaitable as g, type CombinedCallApiExtraOptions as h, type CallApiRequestOptionsForHooks as i, type CallApiValidators as j, type InterceptorsOrInterceptorArray as k, type RetryOptions as l, type ResultModeOption as m, type DefaultDataType as n, type DefaultThrowOnError as o, type DefaultMoreOptions as p, type CallApiParameters as q, definePlugin as r, type PluginInitContext as s, type BaseCallApiExtraOptions as t, type CallApiExtraOptions as u, type PossibleHTTPError as v, type CallApiRequestOptions as w, type CallApiResultErrorVariant as x, type CallApiResultSuccessVariant as y, type ErrorContext as z };
+export { type ResponseErrorContext as A, type BaseCallApiConfig as B, type CallApiPlugin as C, type DefaultPluginArray as D, type ErrorContext as E, HTTPError as H, type InferSchemaResult as I, type PluginInitContext as P, type ResultModeUnion as R, type SuccessContext as S, type ResponseTypeUnion as a, type CallApiSchemas as b, type CallApiConfig as c, type CallApiResult as d, type DefaultDataType as e, type DefaultThrowOnError as f, type DefaultMoreOptions as g, type CallApiParameters as h, definePlugin as i, type RetryOptions as j, type BaseCallApiExtraOptions as k, type CallApiExtraOptions as l, type PossibleJavaScriptError as m, type PossibleHTTPError as n, type CallApiRequestOptions as o, type CallApiRequestOptionsForHooks as p, type CallApiResultErrorVariant as q, type CallApiResultSuccessVariant as r, type CombinedCallApiExtraOptions as s, type Interceptors as t, type InterceptorsOrInterceptorArray as u, type PossibleJavascriptErrorNames as v, type Register as w, type RequestContext as x, type RequestErrorContext as y, type ResponseContext as z };

package/dist/cjs/index.cjs

@@ -205,6 +205,22 @@ var retryStatusCodesLookup = defineEnum({
 });
 var defaultRetryMethods = ["GET", "POST"];
 var defaultRetryStatusCodes = Object.keys(retryStatusCodesLookup).map(Number);
+var defaultExtraOptions = {
+  baseURL: "",
+  bodySerializer: JSON.stringify,
+  dedupeStrategy: "cancel",
+  defaultErrorMessage: "Failed to fetch data from server!",
+  mergedHooksExecutionMode: "parallel",
+  mergedHooksExecutionOrder: "mainHooksAfterPlugins",
+  responseType: "json",
+  resultMode: "all",
+  retryAttempts: 0,
+  retryDelay: 1e3,
+  retryMaxDelay: 1e4,
+  retryMethods: defaultRetryMethods,
+  retryStatusCodes: defaultRetryStatusCodes,
+  retryStrategy: "linear"
+};
 
 // src/utils/common.ts
 var omitKeys = (initialObject, keysToOmit) => {
@@ -375,7 +391,7 @@ var getPluginArray = (plugins) => {
   return plugins;
 };
 var initializePlugins = async (context) => {
-  const { baseConfig, config, initURL, options, request } = context;
+  const { baseConfig, config, defaultOptions, initURL, options, request } = context;
   const hookRegistries = structuredClone(hooksEnum);
   const addMainHooks = () => {
     for (const key of Object.keys(hooksEnum)) {
@@ -404,6 +420,7 @@ var initializePlugins = async (context) => {
     const initResult = await pluginInit({
       baseConfig,
       config,
+      defaultOptions,
       initURL,
       options,
       request
@@ -490,28 +507,30 @@ var getExponentialDelay = (currentAttemptCount, options) => {
   const exponentialDelay = (options.retryDelay ?? 1e3) * 2 ** currentAttemptCount;
   return Math.min(exponentialDelay, maxDelay);
 };
-var createRetryStrategy = (options, ctx) => {
-  const currentRetryCount = options["~retryCount"] ?? 0;
+var createRetryStrategy = (ctx) => {
+  const currentRetryCount = ctx.options["~retryCount"] ?? 0;
   const getDelay = () => {
-    if (options.retryStrategy === "exponential") {
-      return getExponentialDelay(currentRetryCount, options);
+    if (ctx.options.retryStrategy === "exponential") {
+      return getExponentialDelay(currentRetryCount, ctx.options);
     }
-    return getLinearDelay(options);
+    return getLinearDelay(ctx.options);
   };
   const shouldAttemptRetry = async () => {
-    const customRetryCondition = await options.retryCondition?.(ctx) ?? true;
-    const maxRetryAttempts = options.retryAttempts ?? 0;
+    const customRetryCondition = await ctx.options.retryCondition?.(ctx) ?? true;
+    const maxRetryAttempts = ctx.options.retryAttempts ?? 0;
     const baseRetryCondition = maxRetryAttempts > currentRetryCount && customRetryCondition;
     if (ctx.error.name !== "HTTPError") {
       return baseRetryCondition;
     }
+    const resolvedRetryMethods = isFunction(ctx.options.retryMethods) ? ctx.options.retryMethods(ctx) : ctx.options.retryMethods;
+    const resolvedRetryStatusCodes = isFunction(ctx.options.retryStatusCodes) ? ctx.options.retryStatusCodes(ctx) : ctx.options.retryStatusCodes;
     const includesMethod = (
       // eslint-disable-next-line no-implicit-coercion -- Boolean doesn't narrow
-      !!ctx.request.method && options.retryMethods?.includes(ctx.request.method)
+      !!ctx.request.method && resolvedRetryMethods?.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)
+      !!ctx.response?.status && resolvedRetryStatusCodes?.includes(ctx.response.status)
     );
     return includesCodes && includesMethod && baseRetryCondition;
   };
@@ -595,7 +614,12 @@ var createFetchClient = (baseConfig = {}) => {
   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 resolvedBaseConfig = isFunction(baseConfig) ? baseConfig({
+      defaultOptions: defaultExtraOptions,
+      initURL: initURL.toString(),
+      options: extraOptions,
+      request: fetchOptions
+    }) : baseConfig;
     const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(resolvedBaseConfig);
     const initCombinedHooks = {};
     for (const key of Object.keys(hooksEnum)) {
@@ -605,35 +629,22 @@ var createFetchClient = (baseConfig = {}) => {
       );
       initCombinedHooks[key] = combinedHook;
     }
-    const defaultExtraOptions = {
-      baseURL: "",
-      bodySerializer: JSON.stringify,
-      dedupeStrategy: "cancel",
-      defaultErrorMessage: "Failed to fetch data from server!",
-      mergedHooksExecutionMode: "parallel",
-      mergedHooksExecutionOrder: "mainHooksAfterPlugins",
-      responseType: "json",
-      resultMode: "all",
-      retryAttempts: 0,
-      retryDelay: 1e3,
-      retryMaxDelay: 1e4,
-      retryMethods: defaultRetryMethods,
-      retryStatusCodes: defaultRetryStatusCodes,
-      retryStrategy: "linear",
+    const mergedExtraOptions = {
+      ...defaultExtraOptions,
       ...baseExtraOptions,
-      ...extraOptions,
-      ...initCombinedHooks
+      ...extraOptions
     };
-    const defaultRequestOptions = {
+    const mergedRequestOptions = {
       ...baseFetchOptions,
       ...fetchOptions
     };
     const { resolvedHooks, resolvedOptions, resolvedRequestOptions, url } = await initializePlugins({
       baseConfig: resolvedBaseConfig,
       config,
+      defaultOptions: defaultExtraOptions,
       initURL,
-      options: defaultExtraOptions,
-      request: defaultRequestOptions
+      options: mergedExtraOptions,
+      request: mergedRequestOptions
     });
     const fullURL = `${resolvedOptions.baseURL}${mergeUrlWithParamsAndQuery(url, resolvedOptions.params, resolvedOptions.query)}`;
     const options = {
@@ -666,7 +677,6 @@ var createFetchClient = (baseConfig = {}) => {
       await executeHooks(options.onRequest({ options, request }));
       request.headers = mergeAndResolveHeaders({
         auth: options.auth,
-        baseHeaders: baseFetchOptions.headers,
         body: request.body,
         headers: request.headers
       });
@@ -724,9 +734,11 @@ var createFetchClient = (baseConfig = {}) => {
         request,
         response: apiDetails.response
       };
-      const { getDelay, shouldAttemptRetry } = createRetryStrategy(options, errorContext);
-      const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
-      if (shouldRetry) {
+      const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
+      const handleRetry = async () => {
+        const { getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
+        const shouldRetry = !combinedSignal.aborted && await shouldAttemptRetry();
+        if (!shouldRetry) return;
         await executeHooks(options.onRetry(errorContext));
         const delay = getDelay();
         await waitUntil(delay);
@@ -734,9 +746,8 @@ var createFetchClient = (baseConfig = {}) => {
           ...config,
           "~retryCount": (options["~retryCount"] ?? 0) + 1
         };
-        return await callApi2(initURL, updatedOptions);
-      }
-      const shouldThrowOnError = isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError;
+        return callApi2(initURL, updatedOptions);
+      };
       const handleThrowOnError = () => {
         if (!shouldThrowOnError) return;
         throw apiDetails.error;
@@ -747,18 +758,21 @@ var createFetchClient = (baseConfig = {}) => {
           options.onError(errorContext),
           options.onResponse({ ...errorContext, data: null })
         );
+        await handleRetry();
         handleThrowOnError();
         return getErrorResult();
       }
       if (error instanceof DOMException && error.name === "AbortError") {
         const { message, name } = error;
         console.error(`${name}:`, message);
+        await handleRetry();
         handleThrowOnError();
         return getErrorResult();
       }
       if (error instanceof DOMException && error.name === "TimeoutError") {
         const message = `Request timed out after ${options.timeout}ms`;
         console.error(`${error.name}:`, message);
+        await handleRetry();
         handleThrowOnError();
         return getErrorResult({ message });
       }
@@ -768,6 +782,7 @@ var createFetchClient = (baseConfig = {}) => {
         // == Also call the onError interceptor
         options.onError(errorContext)
       );
+      await handleRetry();
       handleThrowOnError();
       return getErrorResult();
     } finally {