@zayne-labs/callapi 1.10.4 → 1.10.6

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { HTTPError, ValidationError, createCombinedSignal, createTimeoutSignal, defineEnum, deterministicHashFn, extraOptionDefaults, getBody, getFetchImpl, getHeaders, isArray, isBoolean, isFunction, isHTTPErrorInstance, isObject, isPlainObject, isReadableStream, isString, isValidationErrorInstance, requestOptionDefaults, splitBaseConfig, splitConfig, toArray, toQueryString, waitFor } from "./utils-Bm4Dvem6.js";
+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-BFea9qeg.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -112,6 +112,7 @@ const getHookRegistries = () => {
 		onError: /* @__PURE__ */ new Set(),
 		onRequest: /* @__PURE__ */ new Set(),
 		onRequestError: /* @__PURE__ */ new Set(),
+		onRequestReady: /* @__PURE__ */ new Set(),
 		onRequestStream: /* @__PURE__ */ new Set(),
 		onResponse: /* @__PURE__ */ new Set(),
 		onResponseError: /* @__PURE__ */ new Set(),
@@ -327,164 +328,6 @@ const createDedupeStrategy = async (context) => {
 	};
 };
 
-//#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/plugins.ts
 const getResolvedPlugins = (context) => {
@@ -616,100 +459,6 @@ const createRetryStrategy = (ctx) => {
 	};
 };
 
-//#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 getMethod = (ctx) => {
-	const { initURL, method } = ctx;
-	return method?.toUpperCase() ?? extractMethodFromURL(initURL)?.toUpperCase() ?? requestOptionDefaults().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/createFetchClient.ts
 const $GlobalRequestInfoCache = /* @__PURE__ */ new Map();
@@ -759,8 +508,13 @@ const createFetchClient = (initBaseConfig = {}) => {
 		const newFetchController = new AbortController();
 		const timeoutSignal = options.timeout != null ? createTimeoutSignal(options.timeout) : null;
 		const combinedSignal = createCombinedSignal(resolvedRequestOptions.signal, timeoutSignal, newFetchController.signal);
+		const initMethod = getMethod({
+			initURL: resolvedInitURL,
+			method: resolvedRequestOptions.method
+		});
 		let request = {
 			...resolvedRequestOptions,
+			method: initMethod,
 			signal: combinedSignal
 		};
 		const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
@@ -791,28 +545,32 @@ const createFetchClient = (initBaseConfig = {}) => {
 				...options,
 				...extraOptionsValidationResult
 			};
-			const rawBody = shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body;
+			const validMethod = getMethod({
+				initURL: resolvedInitURL,
+				method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method
+			});
 			const validBody = getBody({
-				body: rawBody,
+				body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
 				bodySerializer: options.bodySerializer
 			});
 			const resolvedHeaders = isFunction(fetchOptions.headers) ? fetchOptions.headers({ baseHeaders: baseFetchOptions.headers ?? {} }) : fetchOptions.headers ?? baseFetchOptions.headers;
 			const validHeaders = await getHeaders({
 				auth: options.auth,
-				body: rawBody,
+				body: validBody,
 				headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
 			});
-			const validMethod = getMethod({
-				initURL: resolvedInitURL,
-				method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method,
-				schemaConfig: resolvedSchemaConfig
-			});
 			request = {
 				...request,
 				...Boolean(validBody) && { body: validBody },
 				...Boolean(validHeaders) && { headers: validHeaders },
 				...Boolean(validMethod) && { method: validMethod }
 			};
+			await executeHooksInTryBlock(options.onRequestReady?.({
+				baseConfig,
+				config,
+				options,
+				request
+			}));
 			const response = await handleRequestDeferStrategy({
 				options,
 				request