@zayne-labs/callapi 1.8.21 → 1.9.0

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, dedupeDefaults, defineEnum, deterministicHashFn, getBody, getFetchImpl, getHeaders, hookDefaults, isArray, isFunction, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, requestOptionDefaults, responseDefaults, retryDefaults, splitBaseConfig, splitConfig, toQueryString, waitFor } from "./utils-DZe23qYR.js";
+import { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, defineEnum, deterministicHashFn, extraOptionDefaults, getBody, getFetchImpl, getHeaders, isArray, isFunction, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, requestOptionDefaults, splitBaseConfig, splitConfig, toQueryString, waitFor } from "./utils-DUbIqsYh.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -13,8 +13,8 @@ const getResponseType = (response, parser) => ({
 	text: () => response.text()
 });
 const resolveResponseData = (response, responseType, parser) => {
-	const selectedParser = parser ?? responseDefaults.responseParser;
-	const selectedResponseType = responseType ?? responseDefaults.responseType;
+	const selectedParser = parser ?? extraOptionDefaults().responseParser;
+	const selectedResponseType = responseType ?? extraOptionDefaults().responseType;
 	const RESPONSE_TYPE_LOOKUP = getResponseType(response, selectedParser);
 	if (!Object.hasOwn(RESPONSE_TYPE_LOOKUP, selectedResponseType)) throw new Error(`Invalid response type: ${responseType}`);
 	return RESPONSE_TYPE_LOOKUP[selectedResponseType]();
@@ -241,71 +241,25 @@ const toStreamableResponse = async (context) => {
 
 //#endregion
 //#region src/dedupe.ts
-const resolveDedupeKey = (dedupeKey, context) => {
-	if (isFunction(dedupeKey)) return dedupeKey(context);
-	return dedupeKey ?? null;
-};
-const getAbortErrorMessage = (dedupeKey, context) => {
-	if (dedupeKey) return `Duplicate request detected - Aborted previous request with key '${resolveDedupeKey(dedupeKey, context)}' as a new request was initiated`;
-	return `Duplicate request detected - Aborted previous request to '${context.options.fullURL}' as a new request with identical options was initiated`;
-};
-/**
-* @description Creates and manages the deduplication strategy for a request.
-*
-* This is the core function that implements request deduplication logic. It handles
-* cache management, key generation, and provides strategy-specific handlers for
-* cancel and defer operations.
-*
-* **Key Responsibilities:**
-* - Generates or resolves deduplication keys
-* - Manages cache scope (local vs global)
-* - Provides strategy handlers (cancel, defer)
-* - Handles cache cleanup operations
-*
-* **Performance Optimizations:**
-* - Includes a small delay (0.1ms) for simultaneous request handling
-* - Lazy cache creation for global scopes
-* - Efficient cache key resolution
-*
-* **Internal Usage:**
-* This function is used internally by the CallApi system and is not intended
-* for direct use in application code. It's called automatically during request
-* processing when deduplication is enabled.
-*
-* @param context - Extended request context with deduplication-specific properties
-* @returns Promise resolving to deduplication strategy handlers and metadata
-*
-* @example
-* ```ts
-* // This is used internally, but conceptually:
-* const strategy = await createDedupeStrategy({
-*   ...requestContext,
-*   $GlobalRequestInfoCache: globalCache,
-*   $LocalRequestInfoCache: localCache,
-*   newFetchController: new AbortController()
-* });
-*
-* // Use the returned strategy
-* await strategy.handleRequestCancelStrategy();
-* const response = await strategy.handleRequestDeferStrategy({ options, request });
-* strategy.removeDedupeKeyFromCache();
-* ```
-*/
 const createDedupeStrategy = async (context) => {
 	const { $GlobalRequestInfoCache: $GlobalRequestInfoCache$1, $LocalRequestInfoCache, baseConfig, config, newFetchController, options: globalOptions, request: globalRequest } = context;
-	const dedupeStrategy = globalOptions.dedupeStrategy ?? dedupeDefaults.dedupeStrategy;
+	const dedupeStrategy = globalOptions.dedupeStrategy ?? extraOptionDefaults().dedupeStrategy;
+	const resolvedDedupeStrategy = isFunction(dedupeStrategy) ? dedupeStrategy(context) : dedupeStrategy;
 	const getDedupeKey = () => {
-		const shouldHaveDedupeKey = dedupeStrategy === "cancel" || dedupeStrategy === "defer";
+		const shouldHaveDedupeKey = resolvedDedupeStrategy === "cancel" || resolvedDedupeStrategy === "defer";
 		if (!shouldHaveDedupeKey) return null;
-		if (globalOptions.dedupeKey) return resolveDedupeKey(globalOptions.dedupeKey, context);
+		if (globalOptions.dedupeKey) {
+			const resolvedDedupeKey = isFunction(globalOptions.dedupeKey) ? globalOptions.dedupeKey(context) : globalOptions.dedupeKey;
+			return resolvedDedupeKey;
+		}
 		return `${globalOptions.fullURL}-${deterministicHashFn({
 			options: globalOptions,
 			request: globalRequest
 		})}`;
 	};
 	const dedupeKey = getDedupeKey();
-	const dedupeCacheScope = globalOptions.dedupeCacheScope ?? dedupeDefaults.dedupeCacheScope;
-	const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? dedupeDefaults.dedupeCacheScopeKey;
+	const dedupeCacheScope = globalOptions.dedupeCacheScope ?? extraOptionDefaults().dedupeCacheScope;
+	const dedupeCacheScopeKey = globalOptions.dedupeCacheScopeKey ?? 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;
@@ -315,10 +269,14 @@ 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`;
+	};
 	const handleRequestCancelStrategy = () => {
-		const shouldCancelRequest = prevRequestInfo && dedupeStrategy === "cancel";
+		const shouldCancelRequest = prevRequestInfo && resolvedDedupeStrategy === "cancel";
 		if (!shouldCancelRequest) return;
-		const message = getAbortErrorMessage(globalOptions.dedupeKey, context);
+		const message = getAbortErrorMessage();
 		const reason = new DOMException(message, "AbortError");
 		prevRequestInfo.controller.abort(reason);
 		return Promise.resolve();
@@ -326,7 +284,7 @@ const createDedupeStrategy = async (context) => {
 	const handleRequestDeferStrategy = async (deferContext) => {
 		const { options: localOptions, request: localRequest } = deferContext;
 		const fetchApi = getFetchImpl(localOptions.customFetchImpl);
-		const shouldUsePromiseFromCache = prevRequestInfo && dedupeStrategy === "defer";
+		const shouldUsePromiseFromCache = prevRequestInfo && resolvedDedupeStrategy === "defer";
 		const streamableContext = {
 			baseConfig,
 			config,
@@ -349,10 +307,11 @@ const createDedupeStrategy = async (context) => {
 		$RequestInfoCacheOrNull?.delete(dedupeKey);
 	};
 	return {
-		dedupeStrategy,
+		getAbortErrorMessage,
 		handleRequestCancelStrategy,
 		handleRequestDeferStrategy,
-		removeDedupeKeyFromCache
+		removeDedupeKeyFromCache,
+		resolvedDedupeStrategy
 	};
 };
 
@@ -534,7 +493,7 @@ const initializePlugins = async (context) => {
 			clonedHookRegistries[key].add(pluginHook);
 		}
 	};
-	const hookRegistrationOrder = options.hooksRegistrationOrder ?? hookDefaults.hooksRegistrationOrder;
+	const hookRegistrationOrder = options.hooksRegistrationOrder ?? extraOptionDefaults().hooksRegistrationOrder;
 	if (hookRegistrationOrder === "mainFirst") addMainHooks();
 	const { currentRouteSchemaKey, mainInitURL } = getCurrentRouteSchemaKeyAndMainInitURL({
 		baseExtraOptions: baseConfig,
@@ -545,9 +504,9 @@ const initializePlugins = async (context) => {
 	let resolvedInitURL = mainInitURL;
 	let resolvedOptions = options;
 	let resolvedRequestOptions = request;
-	const executePluginInit = async (pluginInit) => {
-		if (!pluginInit) return;
-		const initResult = await pluginInit({
+	const executePluginSetupFn = async (pluginSetupFn) => {
+		if (!pluginSetupFn) return;
+		const initResult = await pluginSetupFn({
 			baseConfig,
 			config,
 			initURL,
@@ -573,7 +532,7 @@ const initializePlugins = async (context) => {
 		options
 	});
 	for (const plugin of resolvedPlugins) {
-		await executePluginInit(plugin.init);
+		await executePluginSetupFn(plugin.setup);
 		if (!plugin.hooks) continue;
 		addPluginHooks(plugin.hooks);
 	}
@@ -583,7 +542,7 @@ const initializePlugins = async (context) => {
 		if (hookRegistry.size === 0) continue;
 		const flattenedHookArray = [...hookRegistry].flat();
 		if (flattenedHookArray.length === 0) continue;
-		const hooksExecutionMode = options.hooksExecutionMode ?? hookDefaults.hooksExecutionMode;
+		const hooksExecutionMode = options.hooksExecutionMode ?? extraOptionDefaults().hooksExecutionMode;
 		const composedHook = composeAllHooks(flattenedHookArray, hooksExecutionMode);
 		resolvedHooks[key] = composedHook;
 	}
@@ -600,20 +559,20 @@ const initializePlugins = async (context) => {
 //#region src/retry.ts
 const getLinearDelay = (currentAttemptCount, options) => {
 	const retryDelay = options.retryDelay ?? options.retry?.delay;
-	const resolveRetryDelay = (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? retryDefaults.delay;
+	const resolveRetryDelay = (isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay) ?? extraOptionDefaults().retryDelay;
 	return resolveRetryDelay;
 };
 const getExponentialDelay = (currentAttemptCount, options) => {
-	const retryDelay = options.retryDelay ?? options.retry?.delay ?? retryDefaults.delay;
+	const retryDelay = options.retryDelay ?? options.retry?.delay ?? extraOptionDefaults().retryDelay;
 	const resolvedRetryDelay = isFunction(retryDelay) ? retryDelay(currentAttemptCount) : retryDelay;
-	const maxDelay = options.retryMaxDelay ?? options.retry?.maxDelay ?? retryDefaults.maxDelay;
+	const maxDelay = options.retryMaxDelay ?? options.retry?.maxDelay ?? extraOptionDefaults().retryMaxDelay;
 	const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
 	return Math.min(exponentialDelay, maxDelay);
 };
 const createRetryStrategy = (ctx) => {
 	const { options } = ctx;
 	const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
-	const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? retryDefaults.strategy;
+	const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? extraOptionDefaults().retryStrategy;
 	const getDelay = () => {
 		switch (retryStrategy) {
 			case "exponential": return getExponentialDelay(currentAttemptCount, options);
@@ -622,14 +581,13 @@ const createRetryStrategy = (ctx) => {
 		}
 	};
 	const shouldAttemptRetry = async () => {
-		const retryCondition = options.retryCondition ?? options.retry?.condition ?? retryDefaults.condition;
-		const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? retryDefaults.attempts;
+		const retryCondition = options.retryCondition ?? options.retry?.condition ?? extraOptionDefaults().retryCondition;
+		const maximumRetryAttempts = options.retryAttempts ?? options.retry?.attempts ?? extraOptionDefaults().retryAttempts;
 		const customRetryCondition = await retryCondition(ctx);
 		const baseShouldRetry = maximumRetryAttempts >= currentAttemptCount && customRetryCondition;
 		if (!baseShouldRetry) return false;
-		const retryMethods = new Set(options.retryMethods ?? options.retry?.methods ?? retryDefaults.methods);
-		const resolvedMethod = ctx.request.method ?? requestOptionDefaults.method;
-		const includesMethod = retryMethods.has(resolvedMethod);
+		const retryMethods = new Set(options.retryMethods ?? options.retry?.methods ?? extraOptionDefaults().retryMethods);
+		const includesMethod = retryMethods.has(ctx.request.method);
 		const retryStatusCodes = new Set(options.retryStatusCodes ?? options.retry?.statusCodes ?? []);
 		const includesStatusCodes = Boolean(ctx.response?.status) && (retryStatusCodes.size > 0 ? retryStatusCodes.has(ctx.response.status) : true);
 		const shouldRetry = includesMethod && includesStatusCodes;
@@ -645,19 +603,28 @@ const createRetryStrategy = (ctx) => {
 //#endregion
 //#region src/url.ts
 const slash = "/";
-const column = ":";
+const colon = ":";
+const openBrace = "{";
+const closeBrace = "}";
 const mergeUrlWithParams = (url, params) => {
 	if (!params) return url;
 	let newUrl = url;
 	if (isArray(params)) {
-		const matchedParamArray = newUrl.split(slash).filter((param) => param.startsWith(column));
-		for (const [index, matchedParam] of matchedParamArray.entries()) {
+		const urlParts = newUrl.split(slash);
+		const matchedParamsArray = urlParts.filter((part) => part.startsWith(colon) || part.startsWith(openBrace) && part.endsWith(closeBrace));
+		for (const [index, matchedParam] of matchedParamsArray.entries()) {
 			const realParam = params[index];
 			newUrl = newUrl.replace(matchedParam, realParam);
 		}
 		return newUrl;
 	}
-	for (const [key, value] of Object.entries(params)) newUrl = newUrl.replace(`${column}${key}`, String(value));
+	for (const [key, value] of Object.entries(params)) {
+		const stringValue = String(value);
+		const colonPattern = `${colon}${key}`;
+		const bracePattern = `${openBrace}${key}${closeBrace}`;
+		if (newUrl.includes(colonPattern)) newUrl = newUrl.replace(colonPattern, stringValue);
+		else if (newUrl.includes(bracePattern)) newUrl = newUrl.replace(bracePattern, stringValue);
+	}
 	return newUrl;
 };
 const questionMark = "?";
@@ -708,10 +675,9 @@ const extractMethodFromURL = (initURL) => {
 	if (!method || !routeKeyMethods.includes(method)) return;
 	return method;
 };
-const getMethod = (options) => {
-	const { initURL, method, schemaConfig } = options;
-	if (schemaConfig?.requireMethodProvision === true) return method?.toUpperCase() ?? requestOptionDefaults.method;
-	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults.method;
+const getMethod = (ctx) => {
+	const { initURL, method } = ctx;
+	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults().method;
 };
 const normalizeURL = (initURL) => {
 	const methodFromURL = extractMethodFromURL(initURL);
@@ -724,8 +690,8 @@ const getFullAndNormalizedURL = (options) => {
 	const normalizedInitURL = normalizeURL(initURL);
 	const urlWithMergedParams = mergeUrlWithParams(normalizedInitURL, params);
 	const urlWithMergedQueryAndParams = mergeUrlWithQuery(urlWithMergedParams, query);
-	const shouldNotPrependBaseURL = urlWithMergedQueryAndParams.startsWith("http") || !baseURL;
-	const fullURL = shouldNotPrependBaseURL ? urlWithMergedQueryAndParams : `${baseURL}${urlWithMergedQueryAndParams}`;
+	const shouldPrependBaseURL = !urlWithMergedQueryAndParams.startsWith("http") && baseURL;
+	const fullURL = shouldPrependBaseURL ? `${baseURL}${urlWithMergedQueryAndParams}` : urlWithMergedQueryAndParams;
 	return {
 		fullURL,
 		normalizedInitURL
@@ -786,7 +752,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			...resolvedRequestOptions,
 			signal: combinedSignal
 		};
-		const { dedupeStrategy, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
+		const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
 			$GlobalRequestInfoCache,
 			$LocalRequestInfoCache,
 			baseConfig,
@@ -839,7 +805,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 				options,
 				request
 			});
-			const shouldCloneResponse = dedupeStrategy === "defer" || options.cloneResponse;
+			const shouldCloneResponse = resolvedDedupeStrategy === "defer" || options.cloneResponse;
 			if (!response.ok) {
 				const errorData = await resolveResponseData(shouldCloneResponse ? response.clone() : response, options.responseType, options.responseParser);
 				const validErrorData = await handleValidation(resolvedSchema?.errorData, {
@@ -937,7 +903,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			}
 			let message = error?.message;
 			if (error instanceof DOMException && error.name === "AbortError") {
-				message = getAbortErrorMessage(options.dedupeKey, errorContext);
+				message = getAbortErrorMessage();
 				!shouldThrowOnError && console.error(`${error.name}:`, message);
 			}
 			if (error instanceof DOMException && error.name === "TimeoutError") {
@@ -958,8 +924,8 @@ const callApi = createFetchClient();
 //#region src/defineHelpers.ts
 const defineSchema = (routes, config) => {
 	return {
-		config,
-		routes
+		config: defineSchemaConfig(config),
+		routes: defineSchemaRoutes(routes)
 	};
 };
 const defineSchemaConfig = (config) => {