@zayne-labs/callapi 1.12.5 → 1.13.0

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

@@ -1,4 +1,4 @@
-import { Ct as DistributiveOmit, E as CallApiResult, Et as Writeable, M as GlobalMeta, O as GetBaseSchemaConfig, S as CallApiContext, St as AnyString, _ as ResponseTypeType, _t as InferSchemaOutput, ct as ThrowOnErrorBoolean, d as GetResponseType, dt as BaseCallApiSchemaRoutes, et as ApplyStrictConfig, f as InferCallApiResult, g as ResponseTypeMap, i as CallApiPlugin, k as GetBaseSchemaRoutes, l as CallApiResultSuccessOrErrorVariant, mt as CallApiSchemaConfig, n as DefaultDataType, nt as GetCurrentRouteSchema, ot as InferInitURL, pt as CallApiSchema, r as DefaultPluginArray, rt as GetCurrentRouteSchemaKey, t as DefaultCallApiContext, tt as ApplyURLBasedConfig, u as CallApiResultSuccessVariant, ut as BaseCallApiSchemaAndConfig, v as ResultModeType, vt as InferSchemaResult, wt as NoInferUnMasked, x as CallApiConfig, y as BaseCallApiConfig } from "./default-types-CswfU2bI.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>;
@@ -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-DMCchZ0z.d.ts.map
+//# sourceMappingURL=index-WSyoCGJi.d.ts.map

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { $ as RetryOptions, A as GetCallApiContext, B as DedupeOptions, C as CallApiExtraOptions, D as CallApiResultLoose, G as HooksOrHooksArray, H as CallApiRequestOptionsForHooks, J as ResponseContext, K as RequestContext, L as FetchImpl, N as InstanceContext, P as Register, Q as RefetchOptions, R as FetchMiddlewareContext, T as CallApiRequestOptions, U as ErrorContext, V as CallApiExtraOptionsForHooks, W as Hooks, X as ResponseStreamContext, Y as ResponseErrorContext, Z as SuccessContext, _ as ResponseTypeType, _t as InferSchemaOutput, a as PluginHooks, at as InferAllMainRoutes, b as BaseCallApiExtraOptions, c as CallApiResultErrorVariant, dt as BaseCallApiSchemaRoutes, ft as BaseSchemaRouteKeyPrefixes, gt as InferSchemaInput, h as PossibleValidationError, i as CallApiPlugin, it as InferAllMainRouteKeys, j as GetCallApiContextRequired, l as CallApiResultSuccessOrErrorVariant, lt as URLOptions, m as PossibleJavaScriptError, mt as CallApiSchemaConfig, o as PluginMiddlewares, ot as InferInitURL, p as PossibleHTTPError, pt as CallApiSchema, q as RequestStreamContext, rt as GetCurrentRouteSchemaKey, s as PluginSetupContext, st as InferParamsFromRoute, t as DefaultCallApiContext, u as CallApiResultSuccessVariant, v as ResultModeType, w as CallApiParameters, x as CallApiConfig, y as BaseCallApiConfig, z as Middlewares } from "./default-types-CswfU2bI.js";
-import { n as createFetchClient, r as createFetchClientWithContext, t as callApi } from "./index-DMCchZ0z.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-D0QJmGE5.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 = () => {
@@ -143,16 +132,18 @@ const composeHooksFromArray = (hooksArray, hooksExecutionMode) => {
 	return composedHook;
 };
 const executeHooks = async (...hookResultsOrPromise) => {
-	await Promise.all(hookResultsOrPromise);
+	const validHooks = hookResultsOrPromise.filter(Boolean);
+	if (validHooks.length === 0) return;
+	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;
 	}
 };
@@ -285,25 +276,20 @@ 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 = () => {
-		if (!(resolvedDedupeStrategy === "cancel" || resolvedDedupeStrategy === "defer")) return null;
 		const dedupeKey = globalOptions.dedupeKey ?? extraOptionDefaults.dedupeKey;
 		return isFunction(dedupeKey) ? dedupeKey(context) : dedupeKey;
 	};
-	const getDedupeCacheScopeKey = () => {
-		const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
-		return isFunction(dedupeCacheScopeKey) ? dedupeCacheScopeKey(context) : dedupeCacheScopeKey;
-	};
-	const dedupeKey = getDedupeKey();
+	const dedupeKey = shouldDisableDedupe ? null : getDedupeKey();
 	const getRequestInfoCache = () => {
-		if (!dedupeKey) return;
+		if (dedupeKey == null) return;
 		const dedupeCacheScope = globalOptions.dedupeCacheScope ?? extraOptionDefaults.dedupeCacheScope;
-		const dedupeCacheScopeKey = getDedupeCacheScopeKey();
-		const $RequestInfoCache = dedupeCacheScope === "global" ? $GlobalRequestInfoCache.get(dedupeCacheScopeKey) ?? $GlobalRequestInfoCache.set(dedupeCacheScopeKey, /* @__PURE__ */ new Map()).get(dedupeCacheScopeKey) : $LocalRequestInfoCache;
+		const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
+		const resolvedDedupeCacheScopeKey = isFunction(dedupeCacheScopeKey) ? dedupeCacheScopeKey(context) : dedupeCacheScopeKey;
+		const $RequestInfoCache = dedupeCacheScope === "global" ? $GlobalRequestInfoCache.get(resolvedDedupeCacheScopeKey) ?? $GlobalRequestInfoCache.set(resolvedDedupeCacheScopeKey, /* @__PURE__ */ new Map()).get(resolvedDedupeCacheScopeKey) : $LocalRequestInfoCache;
 		return {
 			delete: () => $RequestInfoCache?.delete(dedupeKey),
 			get: () => $RequestInfoCache?.get(dedupeKey),
@@ -335,28 +321,27 @@ const createDedupeStrategy = async (context) => {
 	* simultaneously (same problem as microtasks). Any non-zero value (even 0.0000000001) forces
 	* proper sequential task queue scheduling, ensuring each request gets its own task slot.
 	*/
-	if (dedupeKey !== null) await waitFor(.01);
+	if (!shouldDisableDedupe) await waitFor(.01);
 	const prevRequestInfo = $RequestInfoCache?.get();
 	const getAbortErrorMessage = () => {
-		if (globalOptions.dedupeKey) return `Duplicate request detected - Aborted previous request with key '${dedupeKey}'`;
-		return `Duplicate request detected - Aborted previous request to '${globalOptions.fullURL}'`;
+		return globalOptions.dedupeKey != null ? `Duplicate request detected - Aborted previous request with key '${dedupeKey}'` : `Duplicate request detected - Aborted previous request to '${globalOptions.fullURL}'`;
 	};
 	const handleRequestCancelStrategy = () => {
-		if (!(prevRequestInfo && resolvedDedupeStrategy === "cancel")) return;
+		if (!(!shouldDisableDedupe && prevRequestInfo && resolvedDedupeStrategy === "cancel")) return;
 		const message = getAbortErrorMessage();
 		const reason = new DOMException(message, "AbortError");
-		prevRequestInfo.controller.abort(reason);
+		prevRequestInfo.controller?.abort(reason);
 	};
 	const handleRequestDeferStrategy = async (deferContext) => {
 		const { fetchApi, options: localOptions, request: localRequest } = deferContext;
-		const shouldUsePromiseFromCache = prevRequestInfo && resolvedDedupeStrategy === "defer";
+		const shouldDeferPromise = !shouldDisableDedupe && prevRequestInfo && resolvedDedupeStrategy === "defer";
 		const streamContext = {
 			baseConfig,
 			config,
 			options: localOptions,
 			request: localRequest
 		};
-		const responsePromise = shouldUsePromiseFromCache ? prevRequestInfo.responsePromise : fetchApi(localOptions.fullURL, toStreamableRequest(streamContext));
+		const responsePromise = shouldDeferPromise ? prevRequestInfo.responsePromise : fetchApi(localOptions.fullURL, toStreamableRequest(streamContext));
 		$RequestInfoCache?.set({
 			controller: newFetchController,
 			responsePromise
@@ -366,15 +351,11 @@ const createDedupeStrategy = async (context) => {
 			response: await responsePromise
 		});
 	};
-	const removeDedupeKeyFromCache = () => {
-		$RequestInfoCache?.delete();
-	};
 	return {
 		getAbortErrorMessage,
 		handleRequestCancelStrategy,
 		handleRequestDeferStrategy,
-		removeDedupeKeyFromCache,
-		resolvedDedupeStrategy
+		removeDedupeCacheEntry: () => $RequestInfoCache?.delete()
 	};
 };
 //#endregion
@@ -411,7 +392,7 @@ const getResolvedPlugins = (context) => {
 	const { baseConfig, options } = context;
 	return isFunction(options.plugins) ? options.plugins({ basePlugins: baseConfig.plugins ?? [] }) : options.plugins ?? [];
 };
-const initializePlugins = async (setupContext) => {
+const initializePluginsAndHooks = async (setupContext) => {
 	const { baseConfig, config, currentRouteSchemaKey, mainInitURL, options, request } = setupContext;
 	const { addMainHooks, addMainMiddlewares, addPluginHooks, addPluginMiddlewares, getResolvedHooks, getResolvedMiddlewares } = setupHooksAndMiddlewares({
 		baseConfig,
@@ -422,35 +403,37 @@ const initializePlugins = async (setupContext) => {
 	let resolvedInitURL = mainInitURL;
 	const resolvedOptions = options;
 	const resolvedRequest = request;
-	const executePluginSetupFn = async (pluginSetup) => {
-		if (!pluginSetup) return;
-		const initResult = await pluginSetup(setupContext);
-		if (!initResult) return;
-		const urlString = initResult.initURL?.toString();
-		if (isString(urlString)) {
-			const newURLResult = getCurrentRouteSchemaKeyAndMainInitURL({
-				baseExtraOptions: baseConfig,
-				extraOptions: config,
-				initURL: urlString
-			});
-			resolvedCurrentRouteSchemaKey = newURLResult.currentRouteSchemaKey;
-			resolvedInitURL = newURLResult.mainInitURL;
-		}
-		if (initResult.request) Object.assign(resolvedRequest, initResult.request, initResult.request.extraFetchOptions);
-		if (initResult.options) Object.assign(resolvedOptions, initResult.options);
-	};
 	const resolvedPlugins = getResolvedPlugins({
 		baseConfig,
 		options
 	});
-	for (const plugin of resolvedPlugins) {
-		const [, pluginHooks, pluginMiddlewares] = await Promise.all([
-			executePluginSetupFn(plugin.setup),
-			isFunction(plugin.hooks) ? plugin.hooks(setupContext) : plugin.hooks,
-			isFunction(plugin.middlewares) ? plugin.middlewares(setupContext) : plugin.middlewares
-		]);
-		pluginHooks && addPluginHooks(pluginHooks);
-		pluginMiddlewares && addPluginMiddlewares(pluginMiddlewares);
+	if (resolvedPlugins.length > 0) {
+		const executePluginSetupFn = async (pluginSetup) => {
+			if (!pluginSetup) return;
+			const initResult = await pluginSetup(setupContext);
+			if (!initResult) return;
+			const urlString = initResult.initURL?.toString();
+			if (isString(urlString)) {
+				const newURLResult = getCurrentRouteSchemaKeyAndMainInitURL({
+					baseExtraOptions: baseConfig,
+					extraOptions: config,
+					initURL: urlString
+				});
+				resolvedCurrentRouteSchemaKey = newURLResult.currentRouteSchemaKey;
+				resolvedInitURL = newURLResult.mainInitURL;
+			}
+			if (initResult.request) Object.assign(resolvedRequest, initResult.request, initResult.request.extraFetchOptions);
+			if (initResult.options) Object.assign(resolvedOptions, initResult.options);
+		};
+		for (const plugin of resolvedPlugins) {
+			const [, pluginHooks, pluginMiddlewares] = await Promise.all([
+				executePluginSetupFn(plugin.setup),
+				isFunction(plugin.hooks) ? plugin.hooks(setupContext) : plugin.hooks,
+				isFunction(plugin.middlewares) ? plugin.middlewares(setupContext) : plugin.middlewares
+			]);
+			pluginHooks && addPluginHooks(pluginHooks);
+			pluginMiddlewares && addPluginMiddlewares(pluginMiddlewares);
+		}
 	}
 	addMainHooks();
 	addMainMiddlewares();
@@ -501,17 +484,23 @@ const setupHooksAndMiddlewares = (context) => {
 	};
 	const getResolvedHooks = () => {
 		const resolvedHooks = {};
-		for (const [hookName, hookRegistry] of Object.entries(hookRegistries)) {
+		for (const hookName of hookRegistryKeys) {
+			const hookRegistry = hookRegistries[hookName];
 			if (hookRegistry.size === 0) continue;
 			const flattenedHookArray = [...hookRegistry].flat();
 			if (flattenedHookArray.length === 0) continue;
+			if (flattenedHookArray.length === 1) {
+				resolvedHooks[hookName] = flattenedHookArray[0];
+				continue;
+			}
 			resolvedHooks[hookName] = composeHooksFromArray(flattenedHookArray, options.hooksExecutionMode ?? extraOptionDefaults.hooksExecutionMode);
 		}
 		return resolvedHooks;
 	};
 	const getResolvedMiddlewares = () => {
 		const resolvedMiddlewares = {};
-		for (const [middlewareName, middlewareRegistry] of Object.entries(middlewareRegistries)) {
+		for (const middlewareName of middlewareRegistryKeys) {
+			const middlewareRegistry = middlewareRegistries[middlewareName];
 			if (middlewareRegistry.size === 0) continue;
 			const middlewareArray = [...middlewareRegistry];
 			if (middlewareArray.length === 0) continue;
@@ -530,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
@@ -640,7 +629,7 @@ const createFetchClientWithContext = () => {
 				extraOptions: config,
 				initURL: initURLString
 			});
-			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePlugins({
+			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePluginsAndHooks({
 				baseConfig,
 				config,
 				...initURLResult,
@@ -659,6 +648,7 @@ const createFetchClientWithContext = () => {
 			});
 			const { fullURL, normalizedInitURL } = getFullAndNormalizedURL({
 				baseURL: resolvedOptions.baseURL,
+				debugMode: resolvedOptions.debugMode,
 				initURL: resolvedInitURL,
 				params: resolvedOptions.params,
 				query: resolvedOptions.query
@@ -671,33 +661,42 @@ const createFetchClientWithContext = () => {
 				initURL: resolvedInitURL,
 				initURLNormalized: normalizedInitURL
 			};
-			const refetchFnResult = createRefetchManager({
-				callApi,
-				callApiArgs: {
-					config,
-					initURL
-				},
-				options
-			});
-			Object.assign(options, refetchFnResult);
-			const newFetchController = new AbortController();
-			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController.signal);
+			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,
@@ -711,7 +710,7 @@ const createFetchClientWithContext = () => {
 					request
 				});
 				Object.assign(options, extraOptionsValidationResult);
-				const modifiedRequestOptionsValidationResult = {
+				Object.assign(request, {
 					body: getBody({
 						body: requestOptionsValidationResult.body,
 						bodySerializer: options.bodySerializer,
@@ -726,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,
@@ -776,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,
@@ -800,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,
@@ -811,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;