@zayne-labs/callapi 1.11.5 → 1.11.6

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-CfCB_X1k.js";
+import { C as defineEnum, S as requestOptionDefaults, a as isFunction, b as ValidationError, d as isPromise, f as isQueryString, g as isValidJsonString, h as isString, i as isBoolean, l as isObject, m as isSerializable, n as toQueryString, p as isReadableStream, r as isArray, s as isHTTPErrorInstance, u as isPlainObject, v as isValidationErrorInstance, x as extraOptionDefaults, y as HTTPError } from "./utils-DOVvfarH.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -262,6 +262,427 @@ const toStreamableResponse = async (context) => {
 	return new Response(stream, response);
 };
 
+//#endregion
+//#region src/auth.ts
+const resolveAuthValue = (value) => isFunction(value) ? value() : value;
+const getAuthHeader = async (auth) => {
+	if (auth === void 0) return;
+	if (isPromise(auth) || isFunction(auth) || !isObject(auth)) {
+		const authValue = await resolveAuthValue(auth);
+		if (authValue === void 0) return;
+		return { Authorization: `Bearer ${authValue}` };
+	}
+	switch (auth.type) {
+		case "Basic": {
+			const [username, password] = await Promise.all([resolveAuthValue(auth.username), resolveAuthValue(auth.password)]);
+			if (username === void 0 || password === void 0) return;
+			return { Authorization: `Basic ${globalThis.btoa(`${username}:${password}`)}` };
+		}
+		case "Custom": {
+			const [prefix, value] = await Promise.all([resolveAuthValue(auth.prefix), resolveAuthValue(auth.value)]);
+			if (value === void 0) return;
+			return { Authorization: `${prefix} ${value}` };
+		}
+		default: {
+			const [bearer, token] = await Promise.all([resolveAuthValue(auth.bearer), resolveAuthValue(auth.token)]);
+			if (bearer !== void 0) return { Authorization: `Bearer ${bearer}` };
+			if (token === void 0) return;
+			return { Authorization: `Token ${token}` };
+		}
+	}
+};
+
+//#endregion
+//#region src/constants/common.ts
+const fetchSpecificKeys = defineEnum([
+	"body",
+	"integrity",
+	"duplex",
+	"method",
+	"headers",
+	"signal",
+	"cache",
+	"redirect",
+	"window",
+	"credentials",
+	"keepalive",
+	"referrer",
+	"priority",
+	"mode",
+	"referrerPolicy"
+]);
+
+//#endregion
+//#region src/validation.ts
+const handleValidatorFunction = async (validator, inputData) => {
+	try {
+		return {
+			issues: void 0,
+			value: await validator(inputData)
+		};
+	} catch (error) {
+		return {
+			issues: toArray(error),
+			value: void 0
+		};
+	}
+};
+const standardSchemaParser = async (fullSchema, schemaName, inputData, response) => {
+	const schema = fullSchema?.[schemaName];
+	if (!schema) return inputData;
+	const result = isFunction(schema) ? await handleValidatorFunction(schema, inputData) : await schema["~standard"].validate(inputData);
+	if (result.issues) throw new ValidationError({
+		issueCause: schemaName,
+		issues: result.issues,
+		response: response ?? null
+	});
+	return result.value;
+};
+const routeKeyMethods = defineEnum([
+	"delete",
+	"get",
+	"patch",
+	"post",
+	"put"
+]);
+const handleSchemaValidation = async (fullSchema, schemaName, validationOptions) => {
+	const { inputValue, response, schemaConfig } = validationOptions;
+	if (schemaConfig?.disableRuntimeValidation) return inputValue;
+	return await standardSchemaParser(fullSchema, schemaName, inputValue, response);
+};
+const extraOptionsToBeValidated = [
+	"meta",
+	"params",
+	"query"
+];
+const handleExtraOptionsValidation = async (validationOptions) => {
+	const { options, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(extraOptionsToBeValidated.map((schemaName) => handleSchemaValidation(schema, schemaName, {
+		inputValue: options[schemaName],
+		schemaConfig
+	})));
+	const validatedResultObject = {};
+	for (const [index, schemaName] of extraOptionsToBeValidated.entries()) {
+		const validationResult = validationResultArray[index];
+		if (validationResult === void 0) continue;
+		validatedResultObject[schemaName] = validationResult;
+	}
+	return validatedResultObject;
+};
+const requestOptionsToBeValidated = [
+	"body",
+	"headers",
+	"method"
+];
+const handleRequestOptionsValidation = async (validationOptions) => {
+	const { requestOptions, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(requestOptionsToBeValidated.map((schemaName) => handleSchemaValidation(schema, schemaName, {
+		inputValue: requestOptions[schemaName],
+		schemaConfig
+	})));
+	const validatedResultObject = {};
+	for (const [index, propertyKey] of requestOptionsToBeValidated.entries()) {
+		const validationResult = validationResultArray[index];
+		if (validationResult === void 0) continue;
+		validatedResultObject[propertyKey] = validationResult;
+	}
+	return validatedResultObject;
+};
+const handleConfigValidation = async (validationOptions) => {
+	const { baseExtraOptions, currentRouteSchemaKey, extraOptions, options, requestOptions } = validationOptions;
+	const { currentRouteSchema, resolvedSchema } = getResolvedSchema({
+		baseExtraOptions,
+		currentRouteSchemaKey,
+		extraOptions
+	});
+	const resolvedSchemaConfig = getResolvedSchemaConfig({
+		baseExtraOptions,
+		extraOptions
+	});
+	if (resolvedSchemaConfig?.strict === true && !currentRouteSchema) throw new ValidationError({
+		issueCause: "schemaConfig-(strict)",
+		issues: [{ message: `Strict Mode - No schema found for route '${currentRouteSchemaKey}' ` }],
+		response: null
+	});
+	if (resolvedSchemaConfig?.disableRuntimeValidation) return {
+		extraOptionsValidationResult: null,
+		requestOptionsValidationResult: null,
+		resolvedSchema,
+		resolvedSchemaConfig,
+		shouldApplySchemaOutput: false
+	};
+	const [extraOptionsValidationResult, requestOptionsValidationResult] = await Promise.all([handleExtraOptionsValidation({
+		options,
+		schema: resolvedSchema,
+		schemaConfig: resolvedSchemaConfig
+	}), handleRequestOptionsValidation({
+		requestOptions,
+		schema: resolvedSchema,
+		schemaConfig: resolvedSchemaConfig
+	})]);
+	return {
+		extraOptionsValidationResult,
+		requestOptionsValidationResult,
+		resolvedSchema,
+		resolvedSchemaConfig,
+		shouldApplySchemaOutput: (Boolean(extraOptionsValidationResult) || Boolean(requestOptionsValidationResult)) && !resolvedSchemaConfig?.disableValidationOutputApplication
+	};
+};
+const fallBackRouteSchemaKey = ".";
+const getResolvedSchema = (context) => {
+	const { baseExtraOptions, currentRouteSchemaKey, extraOptions } = context;
+	const fallbackRouteSchema = baseExtraOptions.schema?.routes[fallBackRouteSchemaKey];
+	const currentRouteSchema = baseExtraOptions.schema?.routes[currentRouteSchemaKey];
+	const resolvedRouteSchema = {
+		...fallbackRouteSchema,
+		...currentRouteSchema
+	};
+	return {
+		currentRouteSchema,
+		resolvedSchema: isFunction(extraOptions.schema) ? extraOptions.schema({
+			baseSchemaRoutes: baseExtraOptions.schema?.routes ?? {},
+			currentRouteSchema: resolvedRouteSchema ?? {}
+		}) : extraOptions.schema ?? resolvedRouteSchema
+	};
+};
+const getResolvedSchemaConfig = (context) => {
+	const { baseExtraOptions, extraOptions } = context;
+	return isFunction(extraOptions.schemaConfig) ? extraOptions.schemaConfig({ baseSchemaConfig: baseExtraOptions.schema?.config ?? {} }) : extraOptions.schemaConfig ?? baseExtraOptions.schema?.config;
+};
+const getCurrentRouteSchemaKeyAndMainInitURL = (context) => {
+	const { baseExtraOptions, extraOptions, initURL } = context;
+	const schemaConfig = getResolvedSchemaConfig({
+		baseExtraOptions,
+		extraOptions
+	});
+	let currentRouteSchemaKey = initURL;
+	let mainInitURL = initURL;
+	if (schemaConfig?.prefix && currentRouteSchemaKey.startsWith(schemaConfig.prefix)) {
+		currentRouteSchemaKey = currentRouteSchemaKey.replace(schemaConfig.prefix, "");
+		mainInitURL = mainInitURL.replace(schemaConfig.prefix, schemaConfig.baseURL ?? "");
+	}
+	if (schemaConfig?.baseURL && currentRouteSchemaKey.startsWith(schemaConfig.baseURL)) currentRouteSchemaKey = currentRouteSchemaKey.replace(schemaConfig.baseURL, "");
+	return {
+		currentRouteSchemaKey,
+		mainInitURL
+	};
+};
+
+//#endregion
+//#region src/url.ts
+const slash = "/";
+const colon = ":";
+const openBrace = "{";
+const closeBrace = "}";
+const mergeUrlWithParams = (url, params) => {
+	if (!params) return url;
+	let newUrl = url;
+	if (isArray(params)) {
+		const matchedParamsArray = newUrl.split(slash).filter((part) => part.startsWith(colon) || part.startsWith(openBrace) && part.endsWith(closeBrace));
+		for (const [paramIndex, matchedParam] of matchedParamsArray.entries()) {
+			const stringParamValue = String(params[paramIndex]);
+			newUrl = newUrl.replace(matchedParam, stringParamValue);
+		}
+		return newUrl;
+	}
+	for (const [paramKey, paramValue] of Object.entries(params)) {
+		const colonPattern = `${colon}${paramKey}`;
+		const bracePattern = `${openBrace}${paramKey}${closeBrace}`;
+		const stringValue = String(paramValue);
+		newUrl = newUrl.replace(colonPattern, stringValue);
+		newUrl = newUrl.replace(bracePattern, stringValue);
+	}
+	return newUrl;
+};
+const questionMark = "?";
+const ampersand = "&";
+const mergeUrlWithQuery = (url, query) => {
+	if (!query) return url;
+	const queryString = toQueryString(query);
+	if (queryString?.length === 0) return url;
+	if (url.endsWith(questionMark)) return `${url}${queryString}`;
+	if (url.includes(questionMark)) return `${url}${ampersand}${queryString}`;
+	return `${url}${questionMark}${queryString}`;
+};
+/**
+* @description Extracts the HTTP method from method-prefixed route patterns.
+*
+* Analyzes URLs that start with method modifiers (e.g., "@get/", "@post/") and extracts
+* the HTTP method for use in API requests. This enables method specification directly
+* in route definitions.
+*
+* @param initURL - The URL string to analyze for method modifiers
+* @returns The extracted HTTP method (lowercase) if found, otherwise undefined
+*
+* @example
+* ```typescript
+* // Method extraction from prefixed routes
+* extractMethodFromURL("@get/users");        // Returns: "get"
+* extractMethodFromURL("@post/users");       // Returns: "post"
+* extractMethodFromURL("@put/users/:id");    // Returns: "put"
+* extractMethodFromURL("@delete/users/:id"); // Returns: "delete"
+* extractMethodFromURL("@patch/users/:id");  // Returns: "patch"
+*
+* // No method modifier
+* extractMethodFromURL("/users");            // Returns: undefined
+* extractMethodFromURL("users");             // Returns: undefined
+*
+* // Invalid or unsupported methods
+* extractMethodFromURL("@invalid/users");    // Returns: undefined
+* extractMethodFromURL("@/users");           // Returns: undefined
+*
+* // Edge cases
+* extractMethodFromURL(undefined);           // Returns: undefined
+* extractMethodFromURL("");                  // Returns: undefined
+* ```
+*/
+const extractMethodFromURL = (initURL) => {
+	if (!initURL?.startsWith("@")) return;
+	const method = initURL.split("@")[1]?.split("/")[0];
+	if (!method || !routeKeyMethods.includes(method)) return;
+	return method;
+};
+const normalizeURL = (initURL) => {
+	const methodFromURL = extractMethodFromURL(initURL);
+	if (!methodFromURL) return initURL;
+	return initURL.replace(`@${methodFromURL}/`, "/");
+};
+const getFullAndNormalizedURL = (options) => {
+	const { baseURL, initURL, params, query } = options;
+	const normalizedInitURL = normalizeURL(initURL);
+	const urlWithMergedQueryAndParams = mergeUrlWithQuery(mergeUrlWithParams(normalizedInitURL, params), query);
+	return {
+		fullURL: !urlWithMergedQueryAndParams.startsWith("http") && baseURL ? `${baseURL}${urlWithMergedQueryAndParams}` : urlWithMergedQueryAndParams,
+		normalizedInitURL
+	};
+};
+
+//#endregion
+//#region src/utils/polyfills/combinedSignal.ts
+const createCombinedSignalPolyfill = (signals) => {
+	const controller = new AbortController();
+	const handleAbort = (actualSignal) => {
+		if (controller.signal.aborted) return;
+		controller.abort(actualSignal.reason);
+	};
+	for (const actualSignal of signals) {
+		if (actualSignal.aborted) {
+			handleAbort(actualSignal);
+			break;
+		}
+		actualSignal.addEventListener("abort", () => handleAbort(actualSignal), { signal: controller.signal });
+	}
+	return controller.signal;
+};
+
+//#endregion
+//#region src/utils/polyfills/timeoutSignal.ts
+const createTimeoutSignalPolyfill = (milliseconds) => {
+	const controller = new AbortController();
+	const reason = new DOMException("Request timed out", "TimeoutError");
+	const timeout = setTimeout(() => controller.abort(reason), milliseconds);
+	controller.signal.addEventListener("abort", () => clearTimeout(timeout));
+	return controller.signal;
+};
+
+//#endregion
+//#region src/utils/common.ts
+const omitKeys = (initialObject, keysToOmit) => {
+	const updatedObject = {};
+	const keysToOmitSet = new Set(keysToOmit);
+	for (const [key, value] of Object.entries(initialObject)) if (!keysToOmitSet.has(key)) updatedObject[key] = value;
+	return updatedObject;
+};
+const pickKeys = (initialObject, keysToPick) => {
+	const updatedObject = {};
+	const keysToPickSet = new Set(keysToPick);
+	for (const [key, value] of Object.entries(initialObject)) if (keysToPickSet.has(key)) updatedObject[key] = value;
+	return updatedObject;
+};
+const splitBaseConfig = (baseConfig) => [pickKeys(baseConfig, fetchSpecificKeys), omitKeys(baseConfig, fetchSpecificKeys)];
+const splitConfig = (config) => [pickKeys(config, fetchSpecificKeys), omitKeys(config, fetchSpecificKeys)];
+const objectifyHeaders = (headers) => {
+	if (!headers || isPlainObject(headers)) return headers;
+	return Object.fromEntries(headers);
+};
+const getHeaders = async (options) => {
+	const { auth, body, headers } = options;
+	if (!(Boolean(headers) || Boolean(body) || Boolean(auth))) return;
+	const headersObject = {
+		...await getAuthHeader(auth),
+		...objectifyHeaders(headers)
+	};
+	if (isQueryString(body)) {
+		headersObject["Content-Type"] = "application/x-www-form-urlencoded";
+		return headersObject;
+	}
+	if (isSerializable(body) || isValidJsonString(body)) {
+		headersObject["Content-Type"] = "application/json";
+		headersObject.Accept = "application/json";
+	}
+	return headersObject;
+};
+const getMethod = (ctx) => {
+	const { initURL, method } = ctx;
+	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults.method;
+};
+const getBody = (options) => {
+	const { body, bodySerializer } = options;
+	if (isSerializable(body)) return (bodySerializer ?? extraOptionDefaults.bodySerializer)(body);
+	return body;
+};
+const getInitFetchImpl = (customFetchImpl) => {
+	if (customFetchImpl) return customFetchImpl;
+	if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) return globalThis.fetch;
+	throw new Error("No fetch implementation found");
+};
+const getFetchImpl = (context) => {
+	const { customFetchImpl, fetchMiddleware, requestContext } = context;
+	const initFetchImpl = getInitFetchImpl(customFetchImpl);
+	return fetchMiddleware ? fetchMiddleware({
+		...requestContext,
+		fetchImpl: initFetchImpl
+	}) : initFetchImpl;
+};
+const PromiseWithResolvers = () => {
+	let reject;
+	let resolve;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		reject,
+		resolve
+	};
+};
+const waitFor = (delay) => {
+	if (delay === 0) return;
+	const { promise, resolve } = PromiseWithResolvers();
+	setTimeout(resolve, delay);
+	return promise;
+};
+const createCombinedSignal = (...signals) => {
+	const cleanedSignals = signals.filter((signal) => signal != null);
+	if (!("any" in AbortSignal)) return createCombinedSignalPolyfill(cleanedSignals);
+	return AbortSignal.any(cleanedSignals);
+};
+const createTimeoutSignal = (milliseconds) => {
+	if (milliseconds == null) return null;
+	if (!("timeout" in AbortSignal)) return createTimeoutSignalPolyfill(milliseconds);
+	return AbortSignal.timeout(milliseconds);
+};
+const deterministicHashFn = (value) => {
+	return JSON.stringify(value, (_, val) => {
+		if (!isPlainObject(val)) return val;
+		const sortedKeys = Object.keys(val).toSorted();
+		const result = {};
+		for (const key of sortedKeys) result[key] = val[key];
+		return result;
+	});
+};
+const toArray = (value) => isArray(value) ? value : [value];
+
 //#endregion
 //#region src/dedupe.ts
 const createDedupeStrategy = async (context) => {
@@ -272,16 +693,16 @@ const createDedupeStrategy = async (context) => {
 		if (!(resolvedDedupeStrategy === "cancel" || resolvedDedupeStrategy === "defer")) return null;
 		const dedupeKey$1 = globalOptions.dedupeKey ?? globalOptions.dedupe?.key;
 		const resolvedDedupeKey = isFunction(dedupeKey$1) ? dedupeKey$1(context) : dedupeKey$1;
-		if (resolvedDedupeKey !== void 0) return resolvedDedupeKey;
-		return `${globalOptions.fullURL}-${deterministicHashFn({
+		if (resolvedDedupeKey === void 0) return `${globalOptions.fullURL}-${deterministicHashFn({
 			options: globalOptions,
 			request: globalRequest
 		})}`;
+		return resolvedDedupeKey;
 	};
 	const getDedupeCacheScopeKey = () => {
-		const dedupeCacheScopeKey$1 = globalOptions.dedupeCacheScopeKey ?? globalOptions.dedupe?.cacheScopeKey ?? extraOptionDefaults.dedupeCacheScopeKey;
+		const dedupeCacheScopeKey$1 = globalOptions.dedupeCacheScopeKey ?? globalOptions.dedupe?.cacheScopeKey;
 		const resolvedDedupeCacheScopeKey = isFunction(dedupeCacheScopeKey$1) ? dedupeCacheScopeKey$1(context) : dedupeCacheScopeKey$1;
-		if (resolvedDedupeCacheScopeKey !== void 0) return resolvedDedupeCacheScopeKey;
+		if (resolvedDedupeCacheScopeKey === void 0) return extraOptionDefaults.dedupeCacheScopeKey;
 		return resolvedDedupeCacheScopeKey;
 	};
 	const dedupeKey = getDedupeKey();
@@ -595,8 +1016,7 @@ const createFetchClient = (initBaseConfig = {}) => {
 			initURLNormalized: normalizedInitURL
 		};
 		const newFetchController = new AbortController();
-		const timeoutSignal = options.timeout != null ? createTimeoutSignal(options.timeout) : null;
-		const combinedSignal = createCombinedSignal(resolvedRequestOptions.signal, timeoutSignal, newFetchController.signal);
+		const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequestOptions.signal, newFetchController.signal);
 		const initMethod = getMethod({
 			initURL: resolvedInitURL,
 			method: resolvedRequestOptions.method