@zayne-labs/callapi 1.11.4 → 1.11.6

package/dist/esm/common-CfCB_X1k.js

@@ -1,580 +0,0 @@
-//#region src/types/type-helpers.ts
-const defineEnum = (value) => Object.freeze(value);
-
-//#endregion
-//#region src/constants/defaults.ts
-const extraOptionDefaults = Object.freeze(defineEnum({
-	bodySerializer: JSON.stringify,
-	defaultHTTPErrorMessage: "HTTP request failed unexpectedly",
-	dedupeCacheScope: "local",
-	dedupeCacheScopeKey: "default",
-	dedupeStrategy: "cancel",
-	hooksExecutionMode: "parallel",
-	responseParser: JSON.parse,
-	responseType: "json",
-	resultMode: "all",
-	retryAttempts: 0,
-	retryCondition: () => true,
-	retryDelay: 1e3,
-	retryMaxDelay: 1e4,
-	retryMethods: ["GET", "POST"],
-	retryStatusCodes: [],
-	retryStrategy: "linear"
-}));
-const requestOptionDefaults = defineEnum({ method: "GET" });
-
-//#endregion
-//#region src/error.ts
-const httpErrorSymbol = Symbol("HTTPError");
-var HTTPError = class HTTPError extends Error {
-	errorData;
-	httpErrorSymbol = httpErrorSymbol;
-	name = "HTTPError";
-	response;
-	constructor(errorDetails, errorOptions) {
-		const { defaultHTTPErrorMessage, errorData, response } = errorDetails;
-		const selectedDefaultErrorMessage = (isString(defaultHTTPErrorMessage) ? defaultHTTPErrorMessage : defaultHTTPErrorMessage?.({
-			errorData,
-			response
-		})) ?? (response.statusText || extraOptionDefaults.defaultHTTPErrorMessage);
-		const message = errorData?.message ?? selectedDefaultErrorMessage;
-		super(message, errorOptions);
-		this.errorData = errorData;
-		this.response = response;
-	}
-	/**
-	* @description Checks if the given error is an instance of HTTPError
-	* @param error - The error to check
-	* @returns true if the error is an instance of HTTPError, false otherwise
-	*/
-	static isError(error) {
-		if (!isObject(error)) return false;
-		if (error instanceof HTTPError) return true;
-		const actualError = error;
-		return actualError.httpErrorSymbol === httpErrorSymbol && actualError.name === "HTTPError";
-	}
-};
-const prettifyPath = (path) => {
-	if (!path || path.length === 0) return "";
-	return ` → at ${path.map((segment) => isObject(segment) ? segment.key : segment).join(".")}`;
-};
-const prettifyValidationIssues = (issues) => {
-	return issues.map((issue) => `✖ ${issue.message}${prettifyPath(issue.path)}`).join(" | ");
-};
-const validationErrorSymbol = Symbol("ValidationErrorSymbol");
-var ValidationError = class ValidationError extends Error {
-	errorData;
-	issueCause;
-	name = "ValidationError";
-	response;
-	validationErrorSymbol = validationErrorSymbol;
-	constructor(details, errorOptions) {
-		const { issueCause, issues, response } = details;
-		const message = prettifyValidationIssues(issues);
-		super(message, errorOptions);
-		this.errorData = issues;
-		this.response = response;
-		this.issueCause = issueCause;
-	}
-	/**
-	* @description Checks if the given error is an instance of ValidationError
-	* @param error - The error to check
-	* @returns true if the error is an instance of ValidationError, false otherwise
-	*/
-	static isError(error) {
-		if (!isObject(error)) return false;
-		if (error instanceof ValidationError) return true;
-		const actualError = error;
-		return actualError.validationErrorSymbol === validationErrorSymbol && actualError.name === "ValidationError";
-	}
-};
-
-//#endregion
-//#region src/utils/guards.ts
-const isHTTPError = (error) => {
-	return isObject(error) && error.name === "HTTPError";
-};
-const isHTTPErrorInstance = (error) => {
-	return HTTPError.isError(error);
-};
-const isValidationError = (error) => {
-	return isObject(error) && error.name === "ValidationError";
-};
-const isValidationErrorInstance = (error) => {
-	return ValidationError.isError(error);
-};
-const isJavascriptError = (error) => {
-	return isObject(error) && !isHTTPError(error) && !isValidationError(error);
-};
-const isArray = (value) => Array.isArray(value);
-const isBoolean = (value) => typeof value === "boolean";
-const isObject = (value) => {
-	return typeof value === "object" && value !== null;
-};
-const hasObjectPrototype = (value) => {
-	return Object.prototype.toString.call(value) === "[object Object]";
-};
-/**
-* @description Copied from TanStack Query's isPlainObject
-* @see https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L321
-*/
-const isPlainObject = (value) => {
-	if (!hasObjectPrototype(value)) return false;
-	const constructor = value?.constructor;
-	if (constructor === void 0) return true;
-	const prototype = constructor.prototype;
-	if (!hasObjectPrototype(prototype)) return false;
-	if (!Object.hasOwn(prototype, "isPrototypeOf")) return false;
-	if (Object.getPrototypeOf(value) !== Object.prototype) return false;
-	return true;
-};
-const isValidJsonString = (value) => {
-	if (!isString(value)) return false;
-	try {
-		JSON.parse(value);
-		return true;
-	} catch {
-		return false;
-	}
-};
-const isSerializable = (value) => {
-	return isPlainObject(value) || isArray(value) || typeof value?.toJSON === "function";
-};
-const isFunction = (value) => typeof value === "function";
-const isQueryString = (value) => isString(value) && value.includes("=");
-const isString = (value) => typeof value === "string";
-const isPromise = (value) => value instanceof Promise;
-const isReadableStream = (value) => {
-	return value instanceof ReadableStream;
-};
-
-//#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 toQueryString = (params) => {
-	if (!params) {
-		console.error("toQueryString:", "No query params provided!");
-		return null;
-	}
-	return new URLSearchParams(params).toString();
-};
-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 (!("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
-export { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, deterministicHashFn, extraOptionDefaults, fallBackRouteSchemaKey, getBody, getCurrentRouteSchemaKeyAndMainInitURL, getFetchImpl, getFullAndNormalizedURL, getHeaders, getMethod, handleConfigValidation, handleSchemaValidation, isArray, isBoolean, isFunction, isHTTPError, isHTTPErrorInstance, isJavascriptError, isObject, isPlainObject, isReadableStream, isString, isValidationError, isValidationErrorInstance, splitBaseConfig, splitConfig, toQueryString, waitFor };
-//# sourceMappingURL=common-CfCB_X1k.js.map