@zayne-labs/callapi 1.12.6 → 1.13.0

package/dist/{index-CQfVY7gI.d.ts → index-WSyoCGJi.d.ts}

@@ -1,11 +1,11 @@
-import { A as CallApiConfig, Ct as DistributiveOmit, D as ThrowOnErrorBoolean, Et as Writeable, F as CallApiResult, L as GetBaseSchemaConfig, O as BaseCallApiConfig, R as GetBaseSchemaRoutes, S as GetCurrentRouteSchemaKey, St as AnyString, T as InferInitURL, V as GlobalMeta, _ as ResponseTypeType, _t as InferSchemaOutput, b as ApplyURLBasedConfig, d as GetResponseType, dt as BaseCallApiSchemaRoutes, f as InferCallApiResult, g as ResponseTypeMap, i as CallApiPlugin, j as CallApiContext, l as CallApiResultSuccessOrErrorVariant, mt as CallApiSchemaConfig, n as DefaultDataType, pt as CallApiSchema, r as DefaultPluginArray, t as DefaultCallApiContext, u as CallApiResultSuccessVariant, ut as BaseCallApiSchemaAndConfig, v as ResultModeType, vt as InferSchemaResult, wt as NoInferUnMasked, x as GetCurrentRouteSchema, y as ApplyStrictConfig } from "./default-types-CyPF_5eh.js";
+import { A as CallApiConfig, D as ThrowOnErrorBoolean, Et as BaseCallApiSchemaRoutes, F as CallApiResult, Ft as DistributiveOmit, It as NoInferUnMasked, L as GetBaseSchemaConfig, Lt as Writeable, Mt as InferSchemaResult, O as BaseCallApiConfig, Ot as CallApiSchema, Pt as AnyString, R as GetBaseSchemaRoutes, S as GetCurrentRouteSchemaKey, T as InferInitURL, Tt as BaseCallApiSchemaAndConfig, V as GlobalMeta, _ as ResponseTypeType, b as ApplyURLBasedConfig, d as GetResponseType, f as InferCallApiResult, g as ResponseTypeMap, i as CallApiPlugin, j as CallApiContext, jt as InferSchemaOutput, kt as CallApiSchemaConfig, l as CallApiResultSuccessOrErrorVariant, n as DefaultDataType, r as DefaultPluginArray, t as DefaultCallApiContext, u as CallApiResultSuccessVariant, v as ResultModeType, x as GetCurrentRouteSchema, y as ApplyStrictConfig } from "./default-types-Cn2QRN13.js";
 
 //#region src/createFetchClient.d.ts
 declare const createFetchClientWithContext: <TOuterCallApiContext extends CallApiContext = DefaultCallApiContext>() => <TBaseCallApiContext extends CallApiContext = TOuterCallApiContext, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorBoolean = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorBoolean = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaOutput<TSchema["data"], GetResponseType<TData, TResponseType>>, TComputedErrorData = InferSchemaOutput<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TComputedResult = CallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
 declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = {
+  InferredExtraOptions: unknown;
   Data: DefaultDataType;
   ErrorData: DefaultDataType;
-  InferredExtraOptions: unknown;
   ResultMode: ResultModeType;
   Meta: GlobalMeta;
 }, TBaseData = TBaseCallApiContext["Data"], TBaseErrorData = TBaseCallApiContext["ErrorData"], TBaseResultMode extends ResultModeType = (TBaseCallApiContext["ResultMode"] extends ResultModeType ? TBaseCallApiContext["ResultMode"] : ResultModeType), TBaseThrowOnError extends ThrowOnErrorBoolean = boolean, TBaseResponseType extends ResponseTypeType = ResponseTypeType, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = Writeable<NonNullable<TBaseSchemaAndConfig["config"]>, "deep">, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = Writeable<TBaseSchemaAndConfig["routes"], "deep">>(initBaseConfig?: BaseCallApiConfig<TBaseCallApiContext, TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeType = TBaseResultMode, TCallApiContext extends CallApiContext = TBaseCallApiContext, TThrowOnError extends ThrowOnErrorBoolean = TBaseThrowOnError, TResponseType extends ResponseTypeType = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey, TComputedBaseSchemaRoutes["@default"], TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey], NonNullable<Omit<TComputedBaseSchemaRoutes["@default"], keyof TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]> & TComputedBaseSchemaRoutes[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedData = InferSchemaResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>, "infer-output">, TComputedErrorData = InferSchemaResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>, "infer-output">, TComputedResult = InferCallApiResult<TComputedData, TComputedErrorData, TResultMode, TThrowOnError, {
@@ -25,9 +25,9 @@ declare const createFetchClient: <TBaseCallApiContext extends CallApiContext = {
   withoutResponse: DistributiveOmit<TThrowOnError extends true ? CallApiResultSuccessVariant<TComputedData> : CallApiResultSuccessOrErrorVariant<TComputedData, TComputedErrorData>, "response"> extends infer T ? { [Key in keyof T]: T[Key] } : never;
 }>>(initURL: TInitURL, initConfig?: CallApiConfig<TCallApiContext, TComputedData, TComputedErrorData, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
 declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeType = ResultModeType, TCallApiContext extends CallApiContext = {
+  InferredExtraOptions: unknown;
   Data: DefaultDataType;
   ErrorData: DefaultDataType;
-  InferredExtraOptions: unknown;
   ResultMode: ResultModeType;
   Meta: GlobalMeta;
 }, TThrowOnError extends ThrowOnErrorBoolean = boolean, TResponseType extends ResponseTypeType = ResponseTypeType, const TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<{
@@ -88,4 +88,4 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
 }, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray>) => Promise<TComputedResult>;
 //#endregion
 export { createFetchClient as n, createFetchClientWithContext as r, callApi as t };
-//# sourceMappingURL=index-CQfVY7gI.d.ts.map
+//# sourceMappingURL=index-WSyoCGJi.d.ts.map

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { $ as Hooks, A as CallApiConfig, B as GetCallApiContextRequired, C as InferAllMainRouteKeys, E as InferParamsFromRoute, H as InstanceContext, I as CallApiResultLoose, J as Middlewares, K as FetchImpl, M as CallApiExtraOptions, N as CallApiParameters, O as BaseCallApiConfig, P as CallApiRequestOptions, Q as ErrorContext, S as GetCurrentRouteSchemaKey, T as InferInitURL, U as Register, X as CallApiExtraOptionsForHooks, Y as DedupeOptions, Z as CallApiRequestOptionsForHooks, _ as ResponseTypeType, _t as InferSchemaOutput, a as PluginHooks, at as ResponseStreamContext, c as CallApiResultErrorVariant, ct as RetryOptions, dt as BaseCallApiSchemaRoutes, et as HooksOrHooksArray, ft as BaseSchemaRouteKeyPrefixes, gt as InferSchemaInput, h as PossibleValidationError, i as CallApiPlugin, it as ResponseErrorContext, k as BaseCallApiExtraOptions, l as CallApiResultSuccessOrErrorVariant, lt as URLOptions, m as PossibleJavaScriptError, mt as CallApiSchemaConfig, nt as RequestStreamContext, o as PluginMiddlewares, ot as SuccessContext, p as PossibleHTTPError, pt as CallApiSchema, q as FetchMiddlewareContext, rt as ResponseContext, s as PluginSetupContext, st as RefetchOptions, t as DefaultCallApiContext, tt as RequestContext, u as CallApiResultSuccessVariant, v as ResultModeType, w as InferAllMainRoutes, z as GetCallApiContext } from "./default-types-CyPF_5eh.js";
-import { n as createFetchClient, r as createFetchClientWithContext, t as callApi } from "./index-CQfVY7gI.js";
+import { $ as RequestContext, A as CallApiConfig, At as InferSchemaInput, B as GetCallApiContextRequired, C as InferAllMainRouteKeys, Dt as BaseSchemaRouteKeyPrefixes, E as InferParamsFromRoute, Et as BaseCallApiSchemaRoutes, G as FetchMiddlewareContext, H as InstanceContext, I as CallApiResultLoose, J as CallApiExtraOptionsForHooks, K as Middlewares, M as CallApiExtraOptions, N as CallApiParameters, Nt as URLOptions, O as BaseCallApiConfig, Ot as CallApiSchema, P as CallApiRequestOptions, Q as HooksOrHooksArray, S as GetCurrentRouteSchemaKey, T as InferInitURL, U as Register, W as FetchImpl, X as ErrorContext, Y as CallApiRequestOptionsForHooks, Z as Hooks, _ as ResponseTypeType, a as PluginHooks, at as RefetchOptions, c as CallApiResultErrorVariant, et as RequestStreamContext, h as PossibleValidationError, i as CallApiPlugin, it as SuccessContext, jt as InferSchemaOutput, k as BaseCallApiExtraOptions, kt as CallApiSchemaConfig, l as CallApiResultSuccessOrErrorVariant, m as PossibleJavaScriptError, nt as ResponseErrorContext, o as PluginMiddlewares, ot as RetryOptions, p as PossibleHTTPError, q as DedupeOptions, rt as ResponseStreamContext, s as PluginSetupContext, t as DefaultCallApiContext, tt as ResponseContext, u as CallApiResultSuccessVariant, v as ResultModeType, w as InferAllMainRoutes, z as GetCallApiContext } from "./default-types-Cn2QRN13.js";
+import { n as createFetchClient, r as createFetchClientWithContext, t as callApi } from "./index-WSyoCGJi.js";
 export { BaseCallApiConfig, BaseCallApiExtraOptions, BaseCallApiSchemaRoutes, BaseSchemaRouteKeyPrefixes, CallApiConfig, CallApiExtraOptions, CallApiExtraOptionsForHooks, CallApiParameters, CallApiPlugin, CallApiRequestOptions, CallApiRequestOptionsForHooks, CallApiResultLoose as CallApiResult, CallApiResultErrorVariant, CallApiResultSuccessOrErrorVariant, CallApiResultSuccessVariant, CallApiSchema, CallApiSchemaConfig, DedupeOptions, DefaultCallApiContext, ErrorContext, FetchImpl, FetchMiddlewareContext, GetCallApiContext, GetCallApiContextRequired, GetCurrentRouteSchemaKey, Hooks, HooksOrHooksArray, InferAllMainRouteKeys, InferAllMainRoutes, InferInitURL, InferParamsFromRoute, InferSchemaInput, InferSchemaOutput, InstanceContext, Middlewares, PluginHooks, PluginMiddlewares, PluginSetupContext, PossibleHTTPError, PossibleJavaScriptError, PossibleValidationError, RefetchOptions, Register, RequestContext, RequestStreamContext, ResponseContext, ResponseErrorContext, ResponseStreamContext, ResponseTypeType, ResultModeType, RetryOptions, SuccessContext, URLOptions, callApi, createFetchClient, createFetchClientWithContext };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as getCurrentRouteSchemaKeyAndMainInitURL, B as isString, L as isArray, M as handleSchemaValidation, N as HTTPError, R as isBoolean, a as getBody, c as getMethod, d as splitConfig, f as waitFor, h as isHTTPErrorInstance, i as createTimeoutSignal, j as handleConfigValidation, k as getFullAndNormalizedURL, l as getResolvedHeaders, o as getFetchImpl, r as createCombinedSignal, s as getHeaders, t as extraOptionDefaults, u as omitKeys, v as isValidationErrorInstance, z as isFunction } from "./defaults-IsBgvt90.js";
+import { A as getCurrentRouteSchemaKeyAndMainInitURL, I as isArray, L as isFunction, M as handleSchemaValidation, N as HTTPError, R as isString, a as getBody, c as getMethod, d as splitConfig, f as waitFor, h as isHTTPErrorInstance, i as createTimeoutSignal, j as handleConfigValidation, k as getFullAndNormalizedURL, l as getResolvedHeaders, o as getFetchImpl, r as createCombinedSignal, s as getHeaders, t as extraOptionDefaults, u as omitKeys, v as isValidationErrorInstance } from "./constants-Cj_bGg18.js";
 //#region src/result.ts
 const getResponseType = (response, responseParser) => ({
 	arrayBuffer: () => response.arrayBuffer(),
@@ -51,8 +51,8 @@ const resolveSuccessResult = (data, info) => {
 		response
 	})[resultMode ?? "all"]();
 };
-const resolveErrorResult = (error, info) => {
-	const { cloneResponse, message: customErrorMessage, resultMode } = info;
+const resolveErrorResult = (error, infoOptions) => {
+	const { cloneResponse, message: customErrorMessage, resultMode } = infoOptions;
 	let errorDetails = {
 		data: null,
 		error: {
@@ -96,17 +96,6 @@ const resolveErrorResult = (error, info) => {
 		errorResult
 	};
 };
-const getCustomizedErrorResult = (errorResult, customErrorInfo) => {
-	if (!errorResult) return null;
-	const { message = errorResult.error.message } = customErrorInfo;
-	return {
-		...errorResult,
-		error: {
-			...errorResult.error,
-			message
-		}
-	};
-};
 //#endregion
 //#region src/hooks.ts
 const getHookRegistriesAndKeys = () => {
@@ -148,13 +137,13 @@ const executeHooks = async (...hookResultsOrPromise) => {
 	await Promise.all(validHooks);
 };
 const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
-	const { errorInfo, shouldThrowOnError } = hookInfo;
+	const { errorInfoOptions, shouldThrowOnError } = hookInfo;
 	try {
 		await Promise.all(hookResultsOrPromise);
 		return null;
 	} catch (hookError) {
 		if (shouldThrowOnError) throw hookError;
-		const { errorResult } = resolveErrorResult(hookError, errorInfo);
+		const { errorResult } = resolveErrorResult(hookError, errorInfoOptions);
 		return errorResult;
 	}
 };
@@ -287,10 +276,8 @@ const toStreamableResponse = (context) => {
 };
 //#endregion
 //#region src/dedupe.ts
-const createDedupeStrategy = async (context) => {
-	const { $GlobalRequestInfoCache, $LocalRequestInfoCache, baseConfig, config, newFetchController, options: globalOptions } = context;
-	const dedupeStrategy = globalOptions.dedupeStrategy ?? extraOptionDefaults.dedupeStrategy;
-	const resolvedDedupeStrategy = isFunction(dedupeStrategy) ? dedupeStrategy(context) : dedupeStrategy;
+const createDedupeManager = async (context) => {
+	const { $GlobalRequestInfoCache, $LocalRequestInfoCache, baseConfig, config, newFetchController, options: globalOptions, resolvedDedupeStrategy } = context;
 	const shouldDisableDedupe = resolvedDedupeStrategy === "none";
 	const getDedupeKey = () => {
 		const dedupeKey = globalOptions.dedupeKey ?? extraOptionDefaults.dedupeKey;
@@ -337,7 +324,6 @@ const createDedupeStrategy = async (context) => {
 	if (!shouldDisableDedupe) await waitFor(.01);
 	const prevRequestInfo = $RequestInfoCache?.get();
 	const getAbortErrorMessage = () => {
-		if (shouldDisableDedupe) return;
 		return globalOptions.dedupeKey != null ? `Duplicate request detected - Aborted previous request with key '${dedupeKey}'` : `Duplicate request detected - Aborted previous request to '${globalOptions.fullURL}'`;
 	};
 	const handleRequestCancelStrategy = () => {
@@ -365,15 +351,11 @@ const createDedupeStrategy = async (context) => {
 			response: await responsePromise
 		});
 	};
-	const removeDedupeKeyFromCache = () => {
-		$RequestInfoCache?.delete();
-	};
 	return {
 		getAbortErrorMessage,
 		handleRequestCancelStrategy,
 		handleRequestDeferStrategy,
-		removeDedupeKeyFromCache,
-		resolvedDedupeStrategy
+		removeDedupeCacheEntry: () => $RequestInfoCache?.delete()
 	};
 };
 //#endregion
@@ -537,82 +519,82 @@ const setupHooksAndMiddlewares = (context) => {
 };
 //#endregion
 //#region src/refetch.ts
+const shouldAttemptRefetchSymbol = Symbol("shouldAttemptRefetch");
 const createRefetchManager = (ctx) => {
-	const { callApi, callApiArgs, options } = ctx;
-	const currentRefetchCount = options["~refetchCount"] ?? 1;
-	const refetch = async (refetchOptionOverrides) => {
-		const maxRefetchAttempts = refetchOptionOverrides?.refetchAttempts ?? options.refetchAttempts ?? extraOptionDefaults.refetchAttempts;
-		if (!(currentRefetchCount <= maxRefetchAttempts)) {
-			const message = `Maximum refetch attempts (${maxRefetchAttempts}) exceeded. This prevents infinite loops. Increase 'maxRefetchAttempts' if needed.`;
-			console.error(message);
-			return null;
+	const { callApi, callApiArgs, options, removeDedupeCacheEntry } = ctx;
+	const shouldAttemptRefetch = () => {
+		return options[shouldAttemptRefetchSymbol] ?? false;
+	};
+	const refetch = () => {
+		options[shouldAttemptRefetchSymbol] = true;
+	};
+	const handleRefetch = () => {
+		if (shouldAttemptRefetch()) {
+			removeDedupeCacheEntry();
+			return callApi(callApiArgs.initURL, {
+				...callApiArgs.config,
+				[shouldAttemptRefetchSymbol]: false
+			});
 		}
-		const updatedConfig = {
-			...callApiArgs.config,
-			...refetchOptionOverrides,
-			"~refetchCount": currentRefetchCount + 1
-		};
-		return callApi(callApiArgs.initURL, updatedConfig);
+		return null;
+	};
+	return {
+		handleRefetch,
+		refetch
 	};
-	return { refetch };
 };
 //#endregion
 //#region src/retry.ts
-const getLinearDelay = (currentAttemptCount, options) => {
-	const retryDelay = options.retryDelay ?? extraOptionDefaults.retryDelay;
-	return isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay;
-};
-const getExponentialDelay = (currentAttemptCount, options) => {
-	const retryDelay = options.retryDelay ?? extraOptionDefaults.retryDelay;
-	const resolvedRetryDelay = isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay;
-	const maxDelay = options.retryMaxDelay ?? extraOptionDefaults.retryMaxDelay;
-	const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
-	return Math.min(exponentialDelay, maxDelay);
-};
 const createRetryManager = (ctx) => {
-	const { callApi, callApiArgs, error, errorContext, errorResult, hookInfo } = ctx;
+	const { callApi, callApiArgs, error, errorContext, hookInfo, removeDedupeCacheEntry } = ctx;
 	const { options, request } = errorContext;
-	const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
-	const retryStrategy = options.retryStrategy ?? extraOptionDefaults.retryStrategy;
+	const currentRetryAttemptCount = options["~retryAttemptCount"] ?? 1;
+	const shouldAttemptRetry = async () => {
+		if (request.signal?.aborted) return false;
+		const maxRetryAttempts = options.retryAttempts ?? extraOptionDefaults.retryAttempts;
+		const retryCondition = options.retryCondition ?? extraOptionDefaults.retryCondition;
+		if (!(currentRetryAttemptCount <= maxRetryAttempts && await retryCondition(errorContext))) return false;
+		const retryMethods = options.retryMethods ?? extraOptionDefaults.retryMethods;
+		const includesMethod = request.method != null && retryMethods.length > 0 ? retryMethods.includes(request.method) : true;
+		const retryStatusCodes = options.retryStatusCodes ?? extraOptionDefaults.retryStatusCodes;
+		const includesStatusCodes = errorContext.response != null && retryStatusCodes.length > 0 ? retryStatusCodes.includes(errorContext.response.status) : true;
+		return includesMethod && includesStatusCodes;
+	};
 	const getDelay = () => {
+		const retryStrategy = options.retryStrategy ?? extraOptionDefaults.retryStrategy;
 		switch (retryStrategy) {
-			case "exponential": return getExponentialDelay(currentAttemptCount, options);
-			case "linear": return getLinearDelay(currentAttemptCount, options);
+			case "exponential": {
+				const retryDelay = options.retryDelay ?? extraOptionDefaults.retryDelay;
+				const resolvedRetryDelay = isFunction(retryDelay) ? retryDelay(currentRetryAttemptCount) : retryDelay;
+				const maxDelay = options.retryMaxDelay ?? extraOptionDefaults.retryMaxDelay;
+				const exponentialDelay = resolvedRetryDelay * 2 ** (currentRetryAttemptCount - 1);
+				return Math.min(exponentialDelay, maxDelay);
+			}
+			case "linear": {
+				const retryDelay = options.retryDelay ?? extraOptionDefaults.retryDelay;
+				return isFunction(retryDelay) ? retryDelay(currentRetryAttemptCount) : retryDelay;
+			}
 			default: throw new Error(`Invalid retry strategy: ${String(retryStrategy)}`);
 		}
 	};
-	const shouldAttemptRetry = async () => {
-		if (isBoolean(request.signal) && request.signal.aborted) return false;
-		const retryCondition = options.retryCondition ?? extraOptionDefaults.retryCondition;
-		const maxRetryAttempts = options.retryAttempts ?? extraOptionDefaults.retryAttempts;
-		const customRetryCondition = await retryCondition(errorContext);
-		if (!(currentAttemptCount <= maxRetryAttempts && customRetryCondition)) return false;
-		const retryMethods = new Set(options.retryMethods ?? extraOptionDefaults.retryMethods);
-		const includesMethod = isString(request.method) && retryMethods.size > 0 ? retryMethods.has(request.method) : true;
-		const retryStatusCodes = new Set(options.retryStatusCodes ?? extraOptionDefaults.retryStatusCodes);
-		const includesStatusCodes = errorContext.response != null && retryStatusCodes.size > 0 ? retryStatusCodes.has(errorContext.response.status) : true;
-		return includesMethod && includesStatusCodes;
-	};
 	const handleRetry = async () => {
-		const retryContext = {
-			...errorContext,
-			retryAttemptCount: currentAttemptCount
-		};
-		const hookError = await executeHooksInCatchBlock([options.onRetry?.(retryContext)], hookInfo);
-		if (hookError) return hookError;
-		await waitFor(getDelay());
-		const updatedConfig = {
-			...callApiArgs.config,
-			"~retryAttemptCount": currentAttemptCount + 1
-		};
-		return callApi(callApiArgs.initURL, updatedConfig);
-	};
-	const handleRetryOrGetErrorResult = async () => {
-		if (await shouldAttemptRetry()) return handleRetry();
+		if (await shouldAttemptRetry()) {
+			const hookError = await executeHooksInCatchBlock([options.onRetry?.({
+				...errorContext,
+				retryAttemptCount: currentRetryAttemptCount
+			})], hookInfo);
+			if (hookError) return hookError;
+			await waitFor(getDelay());
+			removeDedupeCacheEntry();
+			return callApi(callApiArgs.initURL, {
+				...callApiArgs.config,
+				"~retryAttemptCount": currentRetryAttemptCount + 1
+			});
+		}
 		if (hookInfo.shouldThrowOnError) throw error;
-		return errorResult;
+		return null;
 	};
-	return { handleRetryOrGetErrorResult };
+	return { handleRetry };
 };
 //#endregion
 //#region src/createFetchClient.ts
@@ -679,33 +661,42 @@ const createFetchClientWithContext = () => {
 				initURL: resolvedInitURL,
 				initURLNormalized: normalizedInitURL
 			};
-			const refetchFnResult = createRefetchManager({
-				callApi,
-				callApiArgs: {
-					config,
-					initURL
-				},
-				options
-			});
-			Object.assign(options, refetchFnResult);
-			const newFetchController = options.dedupeStrategy === "none" ? null : new AbortController();
+			const dedupeStrategy = options.dedupeStrategy ?? extraOptionDefaults.dedupeStrategy;
+			const resolvedDedupeStrategy = isFunction(dedupeStrategy) ? dedupeStrategy({
+				baseConfig,
+				config,
+				options,
+				request: resolvedRequest
+			}) : dedupeStrategy;
+			const newFetchController = resolvedDedupeStrategy === "none" ? null : new AbortController();
 			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController?.signal);
 			const request = {
 				...resolvedRequest,
 				signal: combinedSignal
 			};
-			const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
+			const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeCacheEntry } = await createDedupeManager({
 				$GlobalRequestInfoCache,
 				$LocalRequestInfoCache,
 				baseConfig,
 				config,
 				newFetchController,
 				options,
-				request
+				request,
+				resolvedDedupeStrategy
 			});
+			const { handleRefetch, refetch } = createRefetchManager({
+				callApi,
+				callApiArgs: {
+					config,
+					initURL
+				},
+				options,
+				removeDedupeCacheEntry
+			});
+			options.refetch = refetch;
 			try {
 				handleRequestCancelStrategy();
-				await executeHooks(options.onRequest?.({
+				if (options.onRequest) await executeHooks(options.onRequest({
 					baseConfig,
 					config,
 					options,
@@ -719,7 +710,7 @@ const createFetchClientWithContext = () => {
 					request
 				});
 				Object.assign(options, extraOptionsValidationResult);
-				const modifiedRequestOptionsValidationResult = {
+				Object.assign(request, {
 					body: getBody({
 						body: requestOptionsValidationResult.body,
 						bodySerializer: options.bodySerializer,
@@ -734,15 +725,14 @@ const createFetchClientWithContext = () => {
 						initURL: resolvedInitURL,
 						method: requestOptionsValidationResult.method
 					})
-				};
-				Object.assign(request, modifiedRequestOptionsValidationResult);
+				});
 				const readyRequestContext = {
 					baseConfig,
 					config,
 					options,
 					request
 				};
-				await executeHooks(options.onRequestReady?.(readyRequestContext));
+				if (options.onRequestReady) await executeHooks(options.onRequestReady(readyRequestContext));
 				const response = await handleRequestDeferStrategy({
 					fetchApi: getFetchImpl({
 						customFetchImpl: options.customFetchImpl,
@@ -784,20 +774,17 @@ const createFetchClientWithContext = () => {
 					request,
 					response
 				};
-				await executeHooks(options.onSuccess?.(successContext), options.onResponse?.({
+				if (options.onSuccess || options.onResponse) await executeHooks(options.onSuccess?.(successContext), options.onResponse?.({
 					...successContext,
 					error: null
 				}));
-				return resolveSuccessResult(successContext.data, {
+				const successResult = resolveSuccessResult(successContext.data, {
 					response: successContext.response,
 					resultMode: options.resultMode
 				});
+				return await handleRefetch() ?? successResult;
 			} catch (error) {
-				const errorInfo = {
-					cloneResponse: options.cloneResponse,
-					resultMode: options.resultMode
-				};
-				const { errorDetails, errorResult } = resolveErrorResult(error, errorInfo);
+				const { errorDetails, errorResult } = resolveErrorResult(error, options);
 				const errorContext = {
 					baseConfig,
 					config,
@@ -808,10 +795,10 @@ const createFetchClientWithContext = () => {
 				};
 				const shouldThrowOnError = Boolean(isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError);
 				const hookInfo = {
-					errorInfo,
+					errorInfoOptions: options,
 					shouldThrowOnError
 				};
-				const { handleRetryOrGetErrorResult } = createRetryManager({
+				const { handleRetry } = createRetryManager({
 					callApi,
 					callApiArgs: {
 						config,
@@ -819,39 +806,43 @@ const createFetchClientWithContext = () => {
 					},
 					error,
 					errorContext,
-					errorResult,
-					hookInfo
+					hookInfo,
+					removeDedupeCacheEntry
 				});
+				const handleRefetchThenRetryOrGetResult = async () => {
+					return await handleRefetch() ?? await handleRetry() ?? errorResult;
+				};
 				const responseContext = errorContext.response ? {
 					...errorContext,
 					data: null
 				} : null;
-				if (isValidationErrorInstance(error)) return await executeHooksInCatchBlock([
+				if (isValidationErrorInstance(error)) return (responseContext && options.onResponse || options.onValidationError || options.onError ? await executeHooksInCatchBlock([
 					responseContext && options.onResponse?.(responseContext),
 					options.onValidationError?.(errorContext),
 					options.onError?.(errorContext)
-				], hookInfo) ?? await handleRetryOrGetErrorResult();
-				if (isHTTPErrorInstance(error)) return await executeHooksInCatchBlock([
+				], hookInfo) : null) ?? await handleRefetchThenRetryOrGetResult();
+				if (isHTTPErrorInstance(error)) return (responseContext && options.onResponse || options.onResponseError || options.onError ? await executeHooksInCatchBlock([
 					responseContext && options.onResponse?.(responseContext),
 					options.onResponseError?.(errorContext),
 					options.onError?.(errorContext)
-				], hookInfo) ?? await handleRetryOrGetErrorResult();
-				let message = error?.message;
+				], hookInfo) : null) ?? await handleRefetchThenRetryOrGetResult();
 				if (error instanceof DOMException && error.name === "AbortError") {
-					message = getAbortErrorMessage();
+					const message = getAbortErrorMessage();
+					errorResult && (errorResult.error.message = message);
 					!shouldThrowOnError && console.error(`${error.name}:`, message);
 				}
 				if (error instanceof DOMException && error.name === "TimeoutError") {
-					message = `Request timed out after ${options.timeout}ms`;
+					const message = `Request timed out after ${options.timeout}ms`;
+					errorResult && (errorResult.error.message = message);
 					!shouldThrowOnError && console.error(`${error.name}:`, message);
 				}
-				return await executeHooksInCatchBlock([
+				return (responseContext && options.onResponse || options.onRequestError || options.onError ? await executeHooksInCatchBlock([
 					responseContext && options.onResponse?.(responseContext),
 					options.onRequestError?.(errorContext),
 					options.onError?.(errorContext)
-				], hookInfo) ?? getCustomizedErrorResult(await handleRetryOrGetErrorResult(), { message });
+				], hookInfo) : null) ?? await handleRefetchThenRetryOrGetResult();
 			} finally {
-				removeDedupeKeyFromCache();
+				removeDedupeCacheEntry();
 			}
 		};
 		return callApi;