@zayne-labs/callapi 1.10.3 → 1.10.5

package/README.md

@@ -57,6 +57,6 @@ To do this, you first need to set your `script`'s type to `module`, then import
 
 <!-- Locked to a specific version -->
 <script type="module">
-	import { callApi } from "https://esm.run/@zayne-labs/callapi@1.8.9";
+	import { callApi } from "https://esm.run/@zayne-labs/callapi@1.10.3";
 </script>
 ```

package/dist/esm/common-BFea9qeg.js

@@ -0,0 +1,577 @@
+//#region src/types/type-helpers.ts
+const defineEnum = (value) => value;
+
+//#endregion
+//#region src/constants/default-options.ts
+const extraOptionDefaults = () => {
+	return defineEnum({
+		bodySerializer: JSON.stringify,
+		defaultHTTPErrorMessage: "An unexpected error occurred during the HTTP request.",
+		dedupeCacheScope: "local",
+		dedupeCacheScopeKey: "default",
+		dedupeStrategy: "cancel",
+		hooksExecutionMode: "parallel",
+		hooksRegistrationOrder: "pluginsFirst",
+		responseParser: JSON.parse,
+		responseType: "json",
+		resultMode: "all",
+		retryAttempts: 0,
+		retryCondition: () => true,
+		retryDelay: 1e3,
+		retryMaxDelay: 1e4,
+		retryMethods: ["GET", "POST"],
+		retryStatusCodes: [],
+		retryStrategy: "linear"
+	});
+};
+const requestOptionDefaults = () => {
+	return 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
+	})]);
+	const shouldApplySchemaOutput = (Boolean(extraOptionsValidationResult) || Boolean(requestOptionsValidationResult)) && !resolvedSchemaConfig?.disableValidationOutputApplication;
+	return {
+		extraOptionsValidationResult,
+		requestOptionsValidationResult,
+		resolvedSchema,
+		resolvedSchemaConfig,
+		shouldApplySchemaOutput
+	};
+};
+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
+	};
+	const resolvedSchema = isFunction(extraOptions.schema) ? extraOptions.schema({
+		baseSchemaRoutes: baseExtraOptions.schema?.routes ?? {},
+		currentRouteSchema: resolvedRouteSchema ?? {}
+	}) : extraOptions.schema ?? resolvedRouteSchema;
+	return {
+		currentRouteSchema,
+		resolvedSchema
+	};
+};
+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 urlWithMergedParams = mergeUrlWithParams(normalizedInitURL, params);
+	const urlWithMergedQueryAndParams = mergeUrlWithQuery(urlWithMergedParams, query);
+	return {
+		fullURL: !urlWithMergedQueryAndParams.startsWith("http") && baseURL ? `${baseURL}${urlWithMergedQueryAndParams}` : urlWithMergedQueryAndParams,
+		normalizedInitURL
+	};
+};
+
+//#endregion
+//#region src/utils/polyfills.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;
+};
+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 getFetchImpl = (customFetchImpl) => {
+	if (customFetchImpl) return customFetchImpl;
+	if (typeof globalThis !== "undefined" && isFunction(globalThis.fetch)) return globalThis.fetch;
+	throw new Error("No fetch implementation found");
+};
+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-BFea9qeg.js.map