@zayne-labs/callapi 1.10.6 → 1.11.0

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-CEcqiR7c.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()
@@ -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,
@@ -296,8 +299,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 +330,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 +357,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 +371,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,35 +385,104 @@ 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
@@ -485,7 +553,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(),
@@ -501,6 +569,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 		let options = {
 			...resolvedOptions,
 			...resolvedHooks,
+			...resolvedMiddlewares,
 			fullURL,
 			initURL: resolvedInitURL,
 			initURLNormalized: normalizedInitURL
@@ -528,7 +597,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 		});
 		try {
 			await handleRequestCancelStrategy();
-			await executeHooksInTryBlock(options.onRequest?.({
+			await executeHooks(options.onRequest?.({
 				baseConfig,
 				config,
 				options,
@@ -565,21 +634,21 @@ const createFetchClient = (initBaseConfig = {}) => {
 				...Boolean(validHeaders) && { headers: validHeaders },
 				...Boolean(validMethod) && { method: validMethod }
 			};
-			await executeHooksInTryBlock(options.onRequestReady?.({
+			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 +658,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 +706,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;