@zayne-labs/callapi 1.12.6 → 1.14.0

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-CQmUuQDT.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,30 +710,31 @@ const createFetchClientWithContext = () => {
 					request
 				});
 				Object.assign(options, extraOptionsValidationResult);
-				const modifiedRequestOptionsValidationResult = {
-					body: getBody({
-						body: requestOptionsValidationResult.body,
-						bodySerializer: options.bodySerializer,
-						resolvedHeaders: requestOptionsValidationResult.headers
-					}),
+				const resolvedBody = getBody({
+					body: requestOptionsValidationResult.body,
+					bodySerializer: options.bodySerializer,
+					bodyTransformer: options.bodyTransformer,
+					resolvedHeaders: requestOptionsValidationResult.headers
+				});
+				Object.assign(request, {
+					body: resolvedBody,
 					headers: await getHeaders({
 						auth: options.auth,
-						body: requestOptionsValidationResult.body,
+						body: resolvedBody,
 						resolvedHeaders: requestOptionsValidationResult.headers
 					}),
 					method: getMethod({
 						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 +776,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 +797,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 +808,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;