@zayne-labs/callapi 1.8.22 → 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]();
@@ -243,9 +243,10 @@ 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 ?? 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) {
 			const resolvedDedupeKey = isFunction(globalOptions.dedupeKey) ? globalOptions.dedupeKey(context) : globalOptions.dedupeKey;
@@ -257,8 +258,8 @@ const createDedupeStrategy = async (context) => {
 		})}`;
 	};
 	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;
@@ -269,11 +270,11 @@ const createDedupeStrategy = async (context) => {
 	if (dedupeKey !== null) await waitFor(.1);
 	const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
 	const getAbortErrorMessage = () => {
-		if (dedupeKey) return `Duplicate request detected - Aborted previous request with key '${dedupeKey}' as a new request was initiated`;
+		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();
 		const reason = new DOMException(message, "AbortError");
@@ -283,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,
@@ -306,11 +307,11 @@ const createDedupeStrategy = async (context) => {
 		$RequestInfoCacheOrNull?.delete(dedupeKey);
 	};
 	return {
-		dedupeStrategy,
 		getAbortErrorMessage,
 		handleRequestCancelStrategy,
 		handleRequestDeferStrategy,
-		removeDedupeKeyFromCache
+		removeDedupeKeyFromCache,
+		resolvedDedupeStrategy
 	};
 };
 
@@ -492,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,
@@ -503,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,
@@ -531,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);
 	}
@@ -541,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;
 	}
@@ -558,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);
@@ -580,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;
@@ -603,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 = "?";
@@ -666,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);
@@ -682,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
@@ -744,7 +752,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			...resolvedRequestOptions,
 			signal: combinedSignal
 		};
-		const { dedupeStrategy, getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache } = await createDedupeStrategy({
+		const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
 			$GlobalRequestInfoCache,
 			$LocalRequestInfoCache,
 			baseConfig,
@@ -797,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, {