@zayne-labs/callapi 1.11.24 → 1.11.26

package/dist/index.js

@@ -977,213 +977,217 @@ const createRetryManager = (ctx) => {
 //#endregion
 //#region src/createFetchClient.ts
 const $GlobalRequestInfoCache = /* @__PURE__ */ new Map();
-const createFetchClient = (initBaseConfig = {}) => {
-	const $LocalRequestInfoCache = /* @__PURE__ */ new Map();
-	const callApi$1 = async (initURL, initConfig = {}) => {
-		const [fetchOptions, extraOptions] = splitConfig(initConfig);
-		const baseConfig = isFunction(initBaseConfig) ? initBaseConfig({
-			initURL: initURL.toString(),
-			options: extraOptions,
-			request: fetchOptions
-		}) : initBaseConfig;
-		const config = initConfig;
-		const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(baseConfig);
-		const shouldSkipAutoMergeForOptions = baseExtraOptions.skipAutoMergeFor === "all" || baseExtraOptions.skipAutoMergeFor === "options";
-		const shouldSkipAutoMergeForRequest = baseExtraOptions.skipAutoMergeFor === "all" || baseExtraOptions.skipAutoMergeFor === "request";
-		const mergedExtraOptions = {
-			...baseExtraOptions,
-			...!shouldSkipAutoMergeForOptions && extraOptions
-		};
-		const mergedRequestOptions = {
-			headers: {},
-			...baseFetchOptions,
-			...!shouldSkipAutoMergeForRequest && fetchOptions
-		};
-		const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
-			baseConfig,
-			config,
-			initURL: initURL.toString(),
-			options: mergedExtraOptions,
-			request: mergedRequestOptions
-		});
-		const { fullURL, normalizedInitURL } = getFullAndNormalizedURL({
-			baseURL: resolvedOptions.baseURL,
-			initURL: resolvedInitURL,
-			params: resolvedOptions.params,
-			query: resolvedOptions.query
-		});
-		const options = {
-			...resolvedOptions,
-			...resolvedHooks,
-			...resolvedMiddlewares,
-			fullURL,
-			initURL: resolvedInitURL,
-			initURLNormalized: normalizedInitURL
-		};
-		const newFetchController = new AbortController();
-		const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequestOptions.signal, newFetchController.signal);
-		const initMethod = getMethod({
-			initURL: resolvedInitURL,
-			method: resolvedRequestOptions.method
-		});
-		const request = {
-			...resolvedRequestOptions,
-			method: initMethod,
-			signal: combinedSignal
-		};
-		const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
-			$GlobalRequestInfoCache,
-			$LocalRequestInfoCache,
-			baseConfig,
-			config,
-			newFetchController,
-			options,
-			request
-		});
-		try {
-			await handleRequestCancelStrategy();
-			await executeHooks(options.onRequest?.({
+const createFetchClientWithContext = () => {
+	const createFetchClient$1 = (initBaseConfig = {}) => {
+		const $LocalRequestInfoCache = /* @__PURE__ */ new Map();
+		const callApi$1 = async (initURL, initConfig = {}) => {
+			const [fetchOptions, extraOptions] = splitConfig(initConfig);
+			const baseConfig = isFunction(initBaseConfig) ? initBaseConfig({
+				initURL: initURL.toString(),
+				options: extraOptions,
+				request: fetchOptions
+			}) : initBaseConfig;
+			const config = initConfig;
+			const [baseFetchOptions, baseExtraOptions] = splitBaseConfig(baseConfig);
+			const shouldSkipAutoMergeForOptions = baseExtraOptions.skipAutoMergeFor === "all" || baseExtraOptions.skipAutoMergeFor === "options";
+			const shouldSkipAutoMergeForRequest = baseExtraOptions.skipAutoMergeFor === "all" || baseExtraOptions.skipAutoMergeFor === "request";
+			const mergedExtraOptions = {
+				...baseExtraOptions,
+				...!shouldSkipAutoMergeForOptions && extraOptions
+			};
+			const mergedRequestOptions = {
+				headers: {},
+				...baseFetchOptions,
+				...!shouldSkipAutoMergeForRequest && fetchOptions
+			};
+			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
 				baseConfig,
 				config,
-				options,
-				request
-			}));
-			const { extraOptionsValidationResult, requestOptionsValidationResult, resolvedSchema, resolvedSchemaConfig, shouldApplySchemaOutput } = await handleConfigValidation({
-				baseExtraOptions,
-				currentRouteSchemaKey: resolvedCurrentRouteSchemaKey,
-				extraOptions,
-				options,
-				requestOptions: request
+				initURL: initURL.toString(),
+				options: mergedExtraOptions,
+				request: mergedRequestOptions
 			});
-			if (shouldApplySchemaOutput) Object.assign(options, extraOptionsValidationResult);
-			const validMethod = getMethod({
+			const { fullURL, normalizedInitURL } = getFullAndNormalizedURL({
+				baseURL: resolvedOptions.baseURL,
 				initURL: resolvedInitURL,
-				method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method
+				params: resolvedOptions.params,
+				query: resolvedOptions.query
 			});
-			const validBody = getBody({
-				body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
-				bodySerializer: options.bodySerializer
-			});
-			const resolvedHeaders = isFunction(fetchOptions.headers) ? fetchOptions.headers({ baseHeaders: baseFetchOptions.headers ?? {} }) : fetchOptions.headers ?? baseFetchOptions.headers;
-			const validHeaders = await getHeaders({
-				auth: options.auth,
-				body: validBody,
-				headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
-			});
-			Object.assign(request, {
-				...validBody && { body: validBody },
-				...validHeaders && { headers: validHeaders },
-				...validMethod && { method: validMethod }
+			const options = {
+				...resolvedOptions,
+				...resolvedHooks,
+				...resolvedMiddlewares,
+				fullURL,
+				initURL: resolvedInitURL,
+				initURLNormalized: normalizedInitURL
+			};
+			const newFetchController = new AbortController();
+			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequestOptions.signal, newFetchController.signal);
+			const initMethod = getMethod({
+				initURL: resolvedInitURL,
+				method: resolvedRequestOptions.method
 			});
-			const readyRequestContext = {
+			const request = {
+				...resolvedRequestOptions,
+				method: initMethod,
+				signal: combinedSignal
+			};
+			const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
+				$GlobalRequestInfoCache,
+				$LocalRequestInfoCache,
 				baseConfig,
 				config,
-				options,
-				request
-			};
-			await executeHooks(options.onRequestReady?.(readyRequestContext));
-			const response = await handleRequestDeferStrategy({
-				fetchApi: getFetchImpl({
-					customFetchImpl: options.customFetchImpl,
-					fetchMiddleware: options.fetchMiddleware,
-					requestContext: readyRequestContext
-				}),
+				newFetchController,
 				options,
 				request
 			});
-			const shouldCloneResponse = resolvedDedupeStrategy === "defer" || options.cloneResponse;
-			if (!response.ok) {
-				const validErrorData = await handleSchemaValidation(resolvedSchema, "errorData", {
-					inputValue: await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser),
-					response,
-					schemaConfig: resolvedSchemaConfig
+			try {
+				await handleRequestCancelStrategy();
+				await executeHooks(options.onRequest?.({
+					baseConfig,
+					config,
+					options,
+					request
+				}));
+				const { extraOptionsValidationResult, requestOptionsValidationResult, resolvedSchema, resolvedSchemaConfig, shouldApplySchemaOutput } = await handleConfigValidation({
+					baseExtraOptions,
+					currentRouteSchemaKey: resolvedCurrentRouteSchemaKey,
+					extraOptions,
+					options,
+					requestOptions: request
+				});
+				if (shouldApplySchemaOutput) Object.assign(options, extraOptionsValidationResult);
+				const validMethod = getMethod({
+					initURL: resolvedInitURL,
+					method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method
+				});
+				const validBody = getBody({
+					body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
+					bodySerializer: options.bodySerializer
+				});
+				const resolvedHeaders = isFunction(fetchOptions.headers) ? fetchOptions.headers({ baseHeaders: baseFetchOptions.headers ?? {} }) : fetchOptions.headers ?? baseFetchOptions.headers;
+				const validHeaders = await getHeaders({
+					auth: options.auth,
+					body: validBody,
+					headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
+				});
+				Object.assign(request, {
+					...validBody && { body: validBody },
+					...validHeaders && { headers: validHeaders },
+					...validMethod && { method: validMethod }
 				});
-				throw new HTTPError({
-					defaultHTTPErrorMessage: options.defaultHTTPErrorMessage,
-					errorData: validErrorData,
+				const readyRequestContext = {
+					baseConfig,
+					config,
+					options,
+					request
+				};
+				await executeHooks(options.onRequestReady?.(readyRequestContext));
+				const response = await handleRequestDeferStrategy({
+					fetchApi: getFetchImpl({
+						customFetchImpl: options.customFetchImpl,
+						fetchMiddleware: options.fetchMiddleware,
+						requestContext: readyRequestContext
+					}),
+					options,
+					request
+				});
+				const shouldCloneResponse = resolvedDedupeStrategy === "defer" || options.cloneResponse;
+				if (!response.ok) {
+					const validErrorData = await handleSchemaValidation(resolvedSchema, "errorData", {
+						inputValue: await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser),
+						response,
+						schemaConfig: resolvedSchemaConfig
+					});
+					throw new HTTPError({
+						defaultHTTPErrorMessage: options.defaultHTTPErrorMessage,
+						errorData: validErrorData,
+						response
+					}, { cause: validErrorData });
+				}
+				const successContext = {
+					baseConfig,
+					config,
+					data: await handleSchemaValidation(resolvedSchema, "data", {
+						inputValue: await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser),
+						response,
+						schemaConfig: resolvedSchemaConfig
+					}),
+					options,
+					request,
 					response
-				}, { cause: validErrorData });
-			}
-			const successContext = {
-				baseConfig,
-				config,
-				data: await handleSchemaValidation(resolvedSchema, "data", {
-					inputValue: await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser),
-					response,
-					schemaConfig: resolvedSchemaConfig
-				}),
-				options,
-				request,
-				response
-			};
-			await executeHooks(options.onSuccess?.(successContext), options.onResponse?.({
-				...successContext,
-				error: null
-			}));
-			return resolveSuccessResult(successContext.data, {
-				response: successContext.response,
-				resultMode: options.resultMode
-			});
-		} catch (error) {
-			const errorInfo = {
-				cloneResponse: options.cloneResponse,
-				resultMode: options.resultMode
-			};
-			const { errorDetails, errorResult } = resolveErrorResult(error, errorInfo);
-			const errorContext = {
-				baseConfig,
-				config,
-				error: errorDetails.error,
-				options,
-				request,
-				response: errorDetails.response
-			};
-			const shouldThrowOnError = Boolean(isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError);
-			const hookInfo = {
-				errorInfo,
-				shouldThrowOnError
-			};
-			const { handleRetry, shouldAttemptRetry } = createRetryManager(errorContext);
-			const handleRetryOrGetErrorResult = async () => {
-				if (await shouldAttemptRetry()) return handleRetry({
-					callApi: callApi$1,
-					callApiArgs: {
-						config,
-						initURL
-					},
-					errorContext,
-					hookInfo
+				};
+				await executeHooks(options.onSuccess?.(successContext), options.onResponse?.({
+					...successContext,
+					error: null
+				}));
+				return resolveSuccessResult(successContext.data, {
+					response: successContext.response,
+					resultMode: options.resultMode
 				});
-				if (shouldThrowOnError) throw error;
-				return errorResult;
-			};
-			if (isValidationErrorInstance(error)) return await executeHooksInCatchBlock([options.onValidationError?.(errorContext), options.onError?.(errorContext)], hookInfo) ?? await handleRetryOrGetErrorResult();
-			if (isHTTPErrorInstance(error)) return await executeHooksInCatchBlock([
-				options.onResponseError?.(errorContext),
-				options.onError?.(errorContext),
-				options.onResponse?.({
-					...errorContext,
-					data: null
-				})
-			], hookInfo) ?? await handleRetryOrGetErrorResult();
-			let message = error?.message;
-			if (error instanceof DOMException && error.name === "AbortError") {
-				message = getAbortErrorMessage();
-				!shouldThrowOnError && console.error(`${error.name}:`, message);
+			} catch (error) {
+				const errorInfo = {
+					cloneResponse: options.cloneResponse,
+					resultMode: options.resultMode
+				};
+				const { errorDetails, errorResult } = resolveErrorResult(error, errorInfo);
+				const errorContext = {
+					baseConfig,
+					config,
+					error: errorDetails.error,
+					options,
+					request,
+					response: errorDetails.response
+				};
+				const shouldThrowOnError = Boolean(isFunction(options.throwOnError) ? options.throwOnError(errorContext) : options.throwOnError);
+				const hookInfo = {
+					errorInfo,
+					shouldThrowOnError
+				};
+				const { handleRetry, shouldAttemptRetry } = createRetryManager(errorContext);
+				const handleRetryOrGetErrorResult = async () => {
+					if (await shouldAttemptRetry()) return handleRetry({
+						callApi: callApi$1,
+						callApiArgs: {
+							config,
+							initURL
+						},
+						errorContext,
+						hookInfo
+					});
+					if (shouldThrowOnError) throw error;
+					return errorResult;
+				};
+				if (isValidationErrorInstance(error)) return await executeHooksInCatchBlock([options.onValidationError?.(errorContext), options.onError?.(errorContext)], hookInfo) ?? await handleRetryOrGetErrorResult();
+				if (isHTTPErrorInstance(error)) return await executeHooksInCatchBlock([
+					options.onResponseError?.(errorContext),
+					options.onError?.(errorContext),
+					options.onResponse?.({
+						...errorContext,
+						data: null
+					})
+				], hookInfo) ?? await handleRetryOrGetErrorResult();
+				let message = error?.message;
+				if (error instanceof DOMException && error.name === "AbortError") {
+					message = getAbortErrorMessage();
+					!shouldThrowOnError && console.error(`${error.name}:`, message);
+				}
+				if (error instanceof DOMException && error.name === "TimeoutError") {
+					message = `Request timed out after ${options.timeout}ms`;
+					!shouldThrowOnError && console.error(`${error.name}:`, message);
+				}
+				return await executeHooksInCatchBlock([options.onRequestError?.(errorContext), options.onError?.(errorContext)], hookInfo) ?? getCustomizedErrorResult(await handleRetryOrGetErrorResult(), { message });
+			} finally {
+				removeDedupeKeyFromCache();
 			}
-			if (error instanceof DOMException && error.name === "TimeoutError") {
-				message = `Request timed out after ${options.timeout}ms`;
-				!shouldThrowOnError && console.error(`${error.name}:`, message);
-			}
-			return await executeHooksInCatchBlock([options.onRequestError?.(errorContext), options.onError?.(errorContext)], hookInfo) ?? getCustomizedErrorResult(await handleRetryOrGetErrorResult(), { message });
-		} finally {
-			removeDedupeKeyFromCache();
-		}
+		};
+		return callApi$1;
 	};
-	return callApi$1;
+	return createFetchClient$1;
 };
+const createFetchClient = createFetchClientWithContext();
 const callApi = createFetchClient();
 
 //#endregion
-export { callApi, createFetchClient };
+export { callApi, createFetchClient, createFetchClientWithContext };
 //# sourceMappingURL=index.js.map