@zayne-labs/callapi 1.10.6 → 1.11.1

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, deterministicHashFn, extraOptionDefaults, fallBackRouteSchemaKey, getBody, getCurrentRouteSchemaKeyAndMainInitURL, getFetchImpl, getFullAndNormalizedURL, getHeaders, getMethod, handleConfigValidation, handleSchemaValidation, isArray, isBoolean, isFunction, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, splitBaseConfig, splitConfig, waitFor } from "./common-BFea9qeg.js";
+import { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, deterministicHashFn, extraOptionDefaults, fallBackRouteSchemaKey, getBody, getCurrentRouteSchemaKeyAndMainInitURL, getFetchImpl, getFullAndNormalizedURL, getHeaders, getMethod, handleConfigValidation, handleSchemaValidation, isArray, isBoolean, isFunction, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, splitBaseConfig, splitConfig, waitFor } from "./common-B2rPuIEQ.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -6,8 +6,7 @@ const getResponseType = (response, parser) => ({
 	blob: () => response.blob(),
 	formData: () => response.formData(),
 	json: async () => {
-		const text = await response.text();
-		return parser(text);
+		return parser(await response.text());
 	},
 	stream: () => response.body,
 	text: () => response.text()
@@ -21,14 +20,14 @@ const textTypes = new Set([
 const JSON_REGEX = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
 const detectResponseType = (response) => {
 	const initContentType = response.headers.get("content-type");
-	if (!initContentType) return extraOptionDefaults().responseType;
+	if (!initContentType) return extraOptionDefaults.responseType;
 	const contentType = initContentType.split(";")[0] ?? "";
 	if (JSON_REGEX.test(contentType)) return "json";
 	if (textTypes.has(contentType) || contentType.startsWith("text/")) return "text";
 	return "blob";
 };
 const resolveResponseData = (response, responseType, parser) => {
-	const selectedParser = parser ?? extraOptionDefaults().responseParser;
+	const selectedParser = parser ?? extraOptionDefaults.responseParser;
 	const selectedResponseType = responseType ?? detectResponseType(response);
 	const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
 	if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) throw new Error(`Invalid response type: ${responseType}`);
@@ -107,8 +106,8 @@ const getCustomizedErrorResult = (errorResult, customErrorInfo) => {
 
 //#endregion
 //#region src/hooks.ts
-const getHookRegistries = () => {
-	return {
+const getHookRegistriesAndKeys = () => {
+	const hookRegistries = {
 		onError: /* @__PURE__ */ new Set(),
 		onRequest: /* @__PURE__ */ new Set(),
 		onRequestError: /* @__PURE__ */ new Set(),
@@ -121,9 +120,13 @@ const getHookRegistries = () => {
 		onSuccess: /* @__PURE__ */ new Set(),
 		onValidationError: /* @__PURE__ */ new Set()
 	};
+	return {
+		hookRegistries,
+		hookRegistryKeys: Object.keys(hookRegistries)
+	};
 };
 const composeAllHooks = (hooksArray, hooksExecutionMode) => {
-	const mergedHook = async (ctx) => {
+	const composedHook = async (ctx) => {
 		switch (hooksExecutionMode) {
 			case "parallel":
 				await Promise.all(hooksArray.map((uniqueHook) => uniqueHook?.(ctx)));
@@ -134,9 +137,9 @@ const composeAllHooks = (hooksArray, hooksExecutionMode) => {
 			default:
 		}
 	};
-	return mergedHook;
+	return composedHook;
 };
-const executeHooksInTryBlock = async (...hookResultsOrPromise) => {
+const executeHooks = async (...hookResultsOrPromise) => {
 	await Promise.all(hookResultsOrPromise);
 };
 const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
@@ -195,11 +198,11 @@ const toStreamableRequest = async (context) => {
 			request,
 			requestInstance
 		};
-		await executeHooksInTryBlock(options.onRequestStream?.(requestStreamContext));
+		await executeHooks(options.onRequestStream?.(requestStreamContext));
 		for await (const chunk of body) {
 			transferredBytes += chunk.byteLength;
 			totalBytes = Math.max(totalBytes, transferredBytes);
-			await executeHooksInTryBlock(options.onRequestStream?.({
+			await executeHooks(options.onRequestStream?.({
 				...requestStreamContext,
 				event: createProgressEvent({
 					chunk,
@@ -239,11 +242,11 @@ const toStreamableResponse = async (context) => {
 			request,
 			response
 		};
-		await executeHooksInTryBlock(options.onResponseStream?.(responseStreamContext));
+		await executeHooks(options.onResponseStream?.(responseStreamContext));
 		for await (const chunk of body) {
 			transferredBytes += chunk.byteLength;
 			totalBytes = Math.max(totalBytes, transferredBytes);
-			await executeHooksInTryBlock(options.onResponseStream?.({
+			await executeHooks(options.onResponseStream?.({
 				...responseStreamContext,
 				event: createProgressEvent({
 					chunk,
@@ -262,19 +265,20 @@ const toStreamableResponse = async (context) => {
 //#region src/dedupe.ts
 const createDedupeStrategy = async (context) => {
 	const { $GlobalRequestInfoCache: $GlobalRequestInfoCache$1, $LocalRequestInfoCache, baseConfig, config, newFetchController, options: globalOptions, request: globalRequest } = context;
-	const dedupeStrategy = globalOptions.dedupeStrategy ?? extraOptionDefaults().dedupeStrategy;
+	const dedupeStrategy = globalOptions.dedupeStrategy ?? globalOptions.dedupe?.strategy ?? extraOptionDefaults.dedupeStrategy;
 	const resolvedDedupeStrategy = isFunction(dedupeStrategy) ? dedupeStrategy(context) : dedupeStrategy;
 	const getDedupeKey = () => {
 		if (!(resolvedDedupeStrategy === "cancel" || resolvedDedupeStrategy === "defer")) return null;
-		if (globalOptions.dedupeKey) return isFunction(globalOptions.dedupeKey) ? globalOptions.dedupeKey(context) : globalOptions.dedupeKey;
+		const dedupeKey$1 = globalOptions.dedupeKey ?? globalOptions.dedupe?.key;
+		if (dedupeKey$1) return isFunction(dedupeKey$1) ? dedupeKey$1(context) : dedupeKey$1;
 		return `${globalOptions.fullURL}-${deterministicHashFn({
 			options: globalOptions,
 			request: globalRequest
 		})}`;
 	};
 	const dedupeKey = getDedupeKey();
-	const dedupeCacheScope = globalOptions.dedupeCacheScope ?? extraOptionDefaults().dedupeCacheScope;
-	const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? extraOptionDefaults().dedupeCacheScopeKey;
+	const dedupeCacheScope = globalOptions.dedupeCacheScope ?? globalOptions.dedupe?.cacheScope ?? extraOptionDefaults.dedupeCacheScope;
+	const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? globalOptions.dedupe?.cacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
 	if (dedupeCacheScope === "global" && !$GlobalRequestInfoCache$1.has(dedupeCacheScopeKey)) $GlobalRequestInfoCache$1.set(dedupeCacheScopeKey, /* @__PURE__ */ new Map());
 	const $RequestInfoCache = dedupeCacheScope === "global" ? $GlobalRequestInfoCache$1.get(dedupeCacheScopeKey) : $LocalRequestInfoCache;
 	const $RequestInfoCacheOrNull = dedupeKey !== null ? $RequestInfoCache : null;
@@ -285,8 +289,8 @@ const createDedupeStrategy = async (context) => {
 	if (dedupeKey !== null) await waitFor(.1);
 	const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
 	const getAbortErrorMessage = () => {
-		if (globalOptions.dedupeKey) return `Duplicate request detected - Aborted previous request with key '${dedupeKey}' as a new request was initiated`;
-		return `Duplicate request detected - Aborted previous request to '${globalOptions.fullURL}' as a new request with identical options was initiated`;
+		if (globalOptions.dedupeKey) return `Duplicate request detected - Aborted previous request with key '${dedupeKey}'`;
+		return `Duplicate request aborted - Aborted previous request to '${globalOptions.fullURL}'`;
 	};
 	const handleRequestCancelStrategy = () => {
 		if (!(prevRequestInfo && resolvedDedupeStrategy === "cancel")) return;
@@ -296,8 +300,7 @@ const createDedupeStrategy = async (context) => {
 		return Promise.resolve();
 	};
 	const handleRequestDeferStrategy = async (deferContext) => {
-		const { options: localOptions, request: localRequest } = deferContext;
-		const fetchApi = getFetchImpl(localOptions.customFetchImpl);
+		const { fetchApi, options: localOptions, request: localRequest } = deferContext;
 		const shouldUsePromiseFromCache = prevRequestInfo && resolvedDedupeStrategy === "defer";
 		const streamableContext = {
 			baseConfig,
@@ -328,6 +331,25 @@ const createDedupeStrategy = async (context) => {
 	};
 };
 
+//#endregion
+//#region src/middlewares.ts
+const getMiddlewareRegistriesAndKeys = () => {
+	const middlewareRegistries = { fetchMiddleware: /* @__PURE__ */ new Set() };
+	return {
+		middlewareRegistries,
+		middlewareRegistryKeys: Object.keys(middlewareRegistries)
+	};
+};
+const composeAllMiddlewares = (middlewareArray) => {
+	let composedMiddleware;
+	for (const currentMiddleware of middlewareArray) {
+		if (!currentMiddleware) continue;
+		const previousMiddleware = composedMiddleware;
+		composedMiddleware = previousMiddleware ? (fetchImpl) => currentMiddleware(previousMiddleware(fetchImpl)) : currentMiddleware;
+	}
+	return composedMiddleware;
+};
+
 //#endregion
 //#region src/plugins.ts
 const getResolvedPlugins = (context) => {
@@ -336,27 +358,11 @@ const getResolvedPlugins = (context) => {
 };
 const initializePlugins = async (context) => {
 	const { baseConfig, config, initURL, options, request } = context;
-	const hookRegistries = getHookRegistries();
-	const hookRegistryKeyArray = Object.keys(hookRegistries);
-	const addMainHooks = () => {
-		for (const key of hookRegistryKeyArray) {
-			const overriddenHook = options[key];
-			const baseHook = baseConfig[key];
-			const instanceHook = config[key];
-			const mainHook = isArray(baseHook) && Boolean(instanceHook) ? [baseHook, instanceHook].flat() : overriddenHook;
-			if (!mainHook) continue;
-			hookRegistries[key].add(mainHook);
-		}
-	};
-	const addPluginHooks = (pluginHooks) => {
-		for (const key of hookRegistryKeyArray) {
-			const pluginHook = pluginHooks[key];
-			if (!pluginHook) continue;
-			hookRegistries[key].add(pluginHook);
-		}
-	};
-	const hookRegistrationOrder = options.hooksRegistrationOrder ?? extraOptionDefaults().hooksRegistrationOrder;
-	if (hookRegistrationOrder === "mainFirst") addMainHooks();
+	const { addMainHooks, addMainMiddlewares, addPluginHooks, addPluginMiddlewares, getResolvedHooks, getResolvedMiddlewares } = setupHooksAndMiddlewares({
+		baseConfig,
+		config,
+		options
+	});
 	const { currentRouteSchemaKey, mainInitURL } = getCurrentRouteSchemaKeyAndMainInitURL({
 		baseExtraOptions: baseConfig,
 		extraOptions: config,
@@ -366,15 +372,9 @@ const initializePlugins = async (context) => {
 	let resolvedInitURL = mainInitURL;
 	let resolvedOptions = options;
 	let resolvedRequestOptions = request;
-	const executePluginSetupFn = async (pluginSetupFn) => {
-		if (!pluginSetupFn) return;
-		const initResult = await pluginSetupFn({
-			baseConfig,
-			config,
-			initURL,
-			options,
-			request
-		});
+	const executePluginSetupFn = async (pluginSetup) => {
+		if (!pluginSetup) return;
+		const initResult = await pluginSetup(context);
 		if (!isPlainObject(initResult)) return;
 		const urlString = initResult.initURL?.toString();
 		if (isString(urlString)) {
@@ -386,53 +386,122 @@ const initializePlugins = async (context) => {
 			resolvedCurrentRouteSchemaKey = newResult.currentRouteSchemaKey;
 			resolvedInitURL = newResult.mainInitURL;
 		}
-		if (isPlainObject(initResult.request)) resolvedRequestOptions = initResult.request;
-		if (isPlainObject(initResult.options)) resolvedOptions = initResult.options;
+		if (isPlainObject(initResult.request)) resolvedRequestOptions = {
+			...resolvedRequestOptions,
+			...initResult.request
+		};
+		if (isPlainObject(initResult.options)) resolvedOptions = {
+			...resolvedOptions,
+			...initResult.options
+		};
 	};
 	const resolvedPlugins = getResolvedPlugins({
 		baseConfig,
 		options
 	});
 	for (const plugin of resolvedPlugins) {
-		await executePluginSetupFn(plugin.setup);
-		if (!plugin.hooks) continue;
-		addPluginHooks(plugin.hooks);
-	}
-	if (hookRegistrationOrder === "pluginsFirst") addMainHooks();
-	const resolvedHooks = {};
-	for (const [key, hookRegistry] of Object.entries(hookRegistries)) {
-		if (hookRegistry.size === 0) continue;
-		const flattenedHookArray = [...hookRegistry].flat();
-		if (flattenedHookArray.length === 0) continue;
-		const hooksExecutionMode = options.hooksExecutionMode ?? extraOptionDefaults().hooksExecutionMode;
-		resolvedHooks[key] = composeAllHooks(flattenedHookArray, hooksExecutionMode);
+		const [, pluginHooks, pluginMiddlewares] = await Promise.all([
+			executePluginSetupFn(plugin.setup),
+			isFunction(plugin.hooks) ? plugin.hooks(context) : plugin.hooks,
+			isFunction(plugin.middlewares) ? plugin.middlewares(context) : plugin.middlewares
+		]);
+		pluginHooks && addPluginHooks(pluginHooks);
+		pluginMiddlewares && addPluginMiddlewares(pluginMiddlewares);
 	}
+	addMainHooks();
+	addMainMiddlewares();
+	const resolvedHooks = getResolvedHooks();
+	const resolvedMiddlewares = getResolvedMiddlewares();
 	return {
 		resolvedCurrentRouteSchemaKey,
 		resolvedHooks,
 		resolvedInitURL,
+		resolvedMiddlewares,
 		resolvedOptions,
 		resolvedRequestOptions
 	};
 };
+const setupHooksAndMiddlewares = (context) => {
+	const { baseConfig, config, options } = context;
+	const { hookRegistries, hookRegistryKeys } = getHookRegistriesAndKeys();
+	const { middlewareRegistries, middlewareRegistryKeys } = getMiddlewareRegistriesAndKeys();
+	const addMainHooks = () => {
+		for (const hookName of hookRegistryKeys) {
+			const overriddenHook = options[hookName];
+			const baseHook = baseConfig[hookName];
+			const instanceHook = config[hookName];
+			const mainHook = isArray(baseHook) && instanceHook ? [baseHook, instanceHook].flat() : overriddenHook;
+			mainHook && hookRegistries[hookName].add(mainHook);
+		}
+	};
+	const addPluginHooks = (pluginHooks) => {
+		for (const hookName of hookRegistryKeys) {
+			const pluginHook = pluginHooks[hookName];
+			pluginHook && hookRegistries[hookName].add(pluginHook);
+		}
+	};
+	const addMainMiddlewares = () => {
+		for (const middlewareName of middlewareRegistryKeys) {
+			const baseMiddleware = baseConfig[middlewareName];
+			const instanceMiddleware = config[middlewareName];
+			baseMiddleware && middlewareRegistries[middlewareName].add(baseMiddleware);
+			instanceMiddleware && middlewareRegistries[middlewareName].add(instanceMiddleware);
+		}
+	};
+	const addPluginMiddlewares = (pluginMiddlewares) => {
+		for (const middlewareName of middlewareRegistryKeys) {
+			const pluginMiddleware = pluginMiddlewares[middlewareName];
+			if (!pluginMiddleware) continue;
+			middlewareRegistries[middlewareName].add(pluginMiddleware);
+		}
+	};
+	const getResolvedHooks = () => {
+		const resolvedHooks = {};
+		for (const [hookName, hookRegistry] of Object.entries(hookRegistries)) {
+			if (hookRegistry.size === 0) continue;
+			const flattenedHookArray = [...hookRegistry].flat();
+			if (flattenedHookArray.length === 0) continue;
+			resolvedHooks[hookName] = composeAllHooks(flattenedHookArray, options.hooksExecutionMode ?? extraOptionDefaults.hooksExecutionMode);
+		}
+		return resolvedHooks;
+	};
+	const getResolvedMiddlewares = () => {
+		const resolvedMiddlewares = {};
+		for (const [middlewareName, middlewareRegistry] of Object.entries(middlewareRegistries)) {
+			if (middlewareRegistry.size === 0) continue;
+			const middlewareArray = [...middlewareRegistry];
+			if (middlewareArray.length === 0) continue;
+			resolvedMiddlewares[middlewareName] = composeAllMiddlewares(middlewareArray);
+		}
+		return resolvedMiddlewares;
+	};
+	return {
+		addMainHooks,
+		addMainMiddlewares,
+		addPluginHooks,
+		addPluginMiddlewares,
+		getResolvedHooks,
+		getResolvedMiddlewares
+	};
+};
 
 //#endregion
 //#region src/retry.ts
 const getLinearDelay = (currentAttemptCount, options) => {
 	const retryDelay = options.retryDelay ?? options.retry?.delay;
-	return (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? extraOptionDefaults().retryDelay;
+	return (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? extraOptionDefaults.retryDelay;
 };
 const getExponentialDelay = (currentAttemptCount, options) => {
-	const retryDelay = options.retryDelay ?? options.retry?.delay ?? extraOptionDefaults().retryDelay;
+	const retryDelay = options.retryDelay ?? options.retry?.delay ?? extraOptionDefaults.retryDelay;
 	const resolvedRetryDelay = isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay;
-	const maxDelay = options.retryMaxDelay ?? options.retry?.maxDelay ?? extraOptionDefaults().retryMaxDelay;
+	const maxDelay = options.retryMaxDelay ?? options.retry?.maxDelay ?? extraOptionDefaults.retryMaxDelay;
 	const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
 	return Math.min(exponentialDelay, maxDelay);
 };
 const createRetryStrategy = (ctx) => {
 	const { options, request } = ctx;
 	const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
-	const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? extraOptionDefaults().retryStrategy;
+	const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? extraOptionDefaults.retryStrategy;
 	const getDelay = () => {
 		switch (retryStrategy) {
 			case "exponential": return getExponentialDelay(currentAttemptCount, options);
@@ -442,13 +511,13 @@ const createRetryStrategy = (ctx) => {
 	};
 	const shouldAttemptRetry = async () => {
 		if (isBoolean(request.signal) && request.signal.aborted) return false;
-		const retryCondition = options.retryCondition ?? options.retry?.condition ?? extraOptionDefaults().retryCondition;
-		const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? extraOptionDefaults().retryAttempts;
+		const retryCondition = options.retryCondition ?? options.retry?.condition ?? extraOptionDefaults.retryCondition;
+		const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? extraOptionDefaults.retryAttempts;
 		const customRetryCondition = await retryCondition(ctx);
 		if (!(currentAttemptCount <= maximumRetryAttempts && customRetryCondition)) return false;
-		const retryMethods = new Set(options.retryMethods ?? options.retry?.methods ?? extraOptionDefaults().retryMethods);
+		const retryMethods = new Set(options.retryMethods ?? options.retry?.methods ?? extraOptionDefaults.retryMethods);
 		const includesMethod = isString(ctx.request.method) && retryMethods.size > 0 ? retryMethods.has(ctx.request.method) : true;
-		const retryStatusCodes = new Set(options.retryStatusCodes ?? options.retry?.statusCodes ?? extraOptionDefaults().retryStatusCodes);
+		const retryStatusCodes = new Set(options.retryStatusCodes ?? options.retry?.statusCodes ?? extraOptionDefaults.retryStatusCodes);
 		const includesStatusCodes = ctx.response != null && retryStatusCodes.size > 0 ? retryStatusCodes.has(ctx.response.status) : true;
 		return includesMethod && includesStatusCodes;
 	};
@@ -485,7 +554,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			...baseFetchOptions,
 			...!shouldSkipAutoMergeForRequest && fetchOptions
 		};
-		const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
+		const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
 			baseConfig,
 			config,
 			initURL: initURLOrURLObject.toString(),
@@ -498,9 +567,10 @@ const createFetchClient = (initBaseConfig = {}) => {
 			params: resolvedOptions.params,
 			query: resolvedOptions.query
 		});
-		let options = {
+		const options = {
 			...resolvedOptions,
 			...resolvedHooks,
+			...resolvedMiddlewares,
 			fullURL,
 			initURL: resolvedInitURL,
 			initURLNormalized: normalizedInitURL
@@ -512,7 +582,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			initURL: resolvedInitURL,
 			method: resolvedRequestOptions.method
 		});
-		let request = {
+		const request = {
 			...resolvedRequestOptions,
 			method: initMethod,
 			signal: combinedSignal
@@ -528,7 +598,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 		});
 		try {
 			await handleRequestCancelStrategy();
-			await executeHooksInTryBlock(options.onRequest?.({
+			await executeHooks(options.onRequest?.({
 				baseConfig,
 				config,
 				options,
@@ -541,10 +611,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 				options,
 				requestOptions: request
 			});
-			if (shouldApplySchemaOutput) options = {
-				...options,
-				...extraOptionsValidationResult
-			};
+			if (shouldApplySchemaOutput) Object.assign(options, extraOptionsValidationResult);
 			const validMethod = getMethod({
 				initURL: resolvedInitURL,
 				method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method
@@ -559,27 +626,26 @@ const createFetchClient = (initBaseConfig = {}) => {
 				body: validBody,
 				headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
 			});
-			request = {
-				...request,
-				...Boolean(validBody) && { body: validBody },
-				...Boolean(validHeaders) && { headers: validHeaders },
-				...Boolean(validMethod) && { method: validMethod }
-			};
-			await executeHooksInTryBlock(options.onRequestReady?.({
+			Object.assign(request, {
+				...validBody && { body: validBody },
+				...validHeaders && { headers: validHeaders },
+				...validMethod && { method: validMethod }
+			});
+			await executeHooks(options.onRequestReady?.({
 				baseConfig,
 				config,
 				options,
 				request
 			}));
 			const response = await handleRequestDeferStrategy({
+				fetchApi: getFetchImpl(options.customFetchImpl, options.fetchMiddleware),
 				options,
 				request
 			});
 			const shouldCloneResponse = resolvedDedupeStrategy === "defer" || options.cloneResponse;
 			if (!response.ok) {
-				const errorData = await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser);
 				const validErrorData = await handleSchemaValidation(resolvedSchema, "errorData", {
-					inputValue: errorData,
+					inputValue: await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser),
 					response,
 					schemaConfig: resolvedSchemaConfig
 				});
@@ -589,21 +655,19 @@ const createFetchClient = (initBaseConfig = {}) => {
 					response
 				}, { cause: validErrorData });
 			}
-			const successData = await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser);
-			const validSuccessData = await handleSchemaValidation(resolvedSchema, "data", {
-				inputValue: successData,
-				response,
-				schemaConfig: resolvedSchemaConfig
-			});
 			const successContext = {
 				baseConfig,
 				config,
-				data: validSuccessData,
+				data: await handleSchemaValidation(resolvedSchema, "data", {
+					inputValue: await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser),
+					response,
+					schemaConfig: resolvedSchemaConfig
+				}),
 				options,
 				request,
 				response
 			};
-			await executeHooksInTryBlock(options.onSuccess?.(successContext), options.onResponse?.({
+			await executeHooks(options.onSuccess?.(successContext), options.onResponse?.({
 				...successContext,
 				error: null
 			}));
@@ -639,13 +703,11 @@ const createFetchClient = (initBaseConfig = {}) => {
 					};
 					const hookError = await executeHooksInCatchBlock([options.onRetry?.(retryContext)], hookInfo);
 					if (hookError) return hookError;
-					const delay = getDelay();
-					await waitFor(delay);
-					const updatedOptions = {
+					await waitFor(getDelay());
+					return callApi$1(initURLOrURLObject, {
 						...config,
 						"~retryAttemptCount": currentAttemptCount + 1
-					};
-					return callApi$1(initURLOrURLObject, updatedOptions);
+					});
 				}
 				if (shouldThrowOnError) throw error;
 				return generalErrorResult;