@zayne-labs/callapi 1.11.11 → 1.11.12

package/dist/esm/index.d.ts

@@ -1,8 +1,9 @@
-import { $ as GetResponseType, A as RequestStreamContext, C as RetryOptions, D as HooksOrHooksArray, E as Hooks, G as CallApiPlugin, J as PluginSetupContext, K as PluginHooks, M as ResponseErrorContext, N as ResponseStreamContext, O as PluginExtraOptions, P as SuccessContext, Q as GetCallApiResult, S as ThrowOnErrorUnion, St as AnyString, T as ErrorContext, X as CallApiResultSuccessVariant, Y as CallApiResultErrorVariant, Z as CallApiSuccessOrErrorVariant, _ as GetCurrentRouteSchema, _t as CallApiSchema, a as CallApiExtraOptions, at as ResponseTypeUnion, b as InferParamsFromRoute, c as CallApiRequestOptions, d as GetBaseSchemaConfig, dt as DefaultPluginArray, et as PossibleHTTPError, f as GetBaseSchemaRoutes, ft as DefaultThrowOnError, g as ApplyURLBasedConfig, gt as BaseCallApiSchemaRoutes, h as ApplyStrictConfig, ht as BaseCallApiSchemaAndConfig, i as CallApiConfig, it as ResponseTypeMap, j as ResponseContext, k as RequestContext, l as CallApiRequestOptionsForHooks, m as InferExtendSchemaContext, n as BaseCallApiExtraOptions, nt as PossibleJavaScriptOrValidationError, o as CallApiExtraOptionsForHooks, ot as ResultModeMap, p as InferExtendSchemaConfigContext, q as PluginHooksWithMoreOptions, r as BaseInstanceContext, rt as PossibleValidationError, s as CallApiParameters, st as ResultModeUnion, t as BaseCallApiConfig, tt as PossibleJavaScriptError, u as CallApiResult, ut as DefaultDataType, v as GetCurrentRouteSchemaKey, vt as CallApiSchemaConfig, w as DedupeOptions, x as Register, xt as URLOptions, y as InferInitURL, yt as InferSchemaOutputResult } from "./common-7RMbhCz1.js";
+import "./validation-uPnlxhfx.js";
+import { $ as GetResponseType, A as RequestStreamContext, C as RetryOptions, Ct as AnyFunction, D as HooksOrHooksArray, E as Hooks, G as CallApiPlugin, J as PluginSetupContext, K as PluginHooks, M as ResponseErrorContext, N as ResponseStreamContext, O as PluginExtraOptions, P as SuccessContext, Q as GetCallApiResult, S as ThrowOnErrorUnion, T as ErrorContext, X as CallApiResultSuccessVariant, Y as CallApiResultErrorVariant, Z as CallApiSuccessOrErrorVariant, _ as GetCurrentRouteSchema, _t as StandardSchemaV1, a as CallApiExtraOptions, at as ResponseTypeUnion, b as InferParamsFromRoute, bt as DefaultThrowOnError, c as CallApiRequestOptions, d as GetBaseSchemaConfig, dt as BaseCallApiSchemaRoutes, et as PossibleHTTPError, f as GetBaseSchemaRoutes, ft as CallApiSchema, g as ApplyURLBasedConfig, gt as URLOptions, h as ApplyStrictConfig, ht as InferSchemaOutput, i as CallApiConfig, it as ResponseTypeMap, j as ResponseContext, k as RequestContext, l as CallApiRequestOptionsForHooks, m as InferExtendSchemaContext, mt as InferSchemaInput, n as BaseCallApiExtraOptions, nt as PossibleJavaScriptOrValidationError, o as CallApiExtraOptionsForHooks, ot as ResultModeMap, p as InferExtendSchemaConfigContext, pt as CallApiSchemaConfig, q as PluginHooksWithMoreOptions, r as BaseInstanceContext, rt as PossibleValidationError, s as CallApiParameters, st as ResultModeUnion, t as BaseCallApiConfig, tt as PossibleJavaScriptError, u as CallApiResult, ut as BaseCallApiSchemaAndConfig, v as GetCurrentRouteSchemaKey, vt as DefaultDataType, w as DedupeOptions, wt as AnyString, x as Register, y as InferInitURL, yt as DefaultPluginArray } from "./common-Clx7i8bR.js";
 
 //#region src/createFetchClient.d.ts
 
-declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedResult = CallApiResult<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>>(initURL: TInitURL, initConfig?: CallApiConfig<InferSchemaOutputResult<TSchema["data"], GetResponseType<TData, TResponseType>>, InferSchemaOutputResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
+declare const createFetchClient: <TBaseData = DefaultDataType, TBaseErrorData = DefaultDataType, TBaseResultMode extends ResultModeUnion = ResultModeUnion, TBaseThrowOnError extends ThrowOnErrorUnion = DefaultThrowOnError, TBaseResponseType extends ResponseTypeUnion = ResponseTypeUnion, const TBaseSchemaAndConfig extends BaseCallApiSchemaAndConfig = BaseCallApiSchemaAndConfig, const TBasePluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedBaseSchemaConfig extends CallApiSchemaConfig = GetBaseSchemaConfig<TBaseSchemaAndConfig>, TComputedBaseSchemaRoutes extends BaseCallApiSchemaRoutes = GetBaseSchemaRoutes<TBaseSchemaAndConfig>>(initBaseConfig?: BaseCallApiConfig<TBaseData, TBaseErrorData, TBaseResultMode, TBaseThrowOnError, TBaseResponseType, TBaseSchemaAndConfig, TBasePluginArray>) => <TData = TBaseData, TErrorData = TBaseErrorData, TResultMode extends ResultModeUnion = TBaseResultMode, TThrowOnError extends ThrowOnErrorUnion = TBaseThrowOnError, TResponseType extends ResponseTypeUnion = TBaseResponseType, const TSchemaConfig extends CallApiSchemaConfig = TComputedBaseSchemaConfig, TInitURL extends InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig> = InferInitURL<TComputedBaseSchemaRoutes, TSchemaConfig>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<TComputedBaseSchemaRoutes, TCurrentRouteSchemaKey>, const TPluginArray extends CallApiPlugin[] = TBasePluginArray, TComputedResult = CallApiResult<InferSchemaOutput<TSchema["data"], TData>, InferSchemaOutput<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType>>(initURL: TInitURL, initConfig?: CallApiConfig<InferSchemaOutput<TSchema["data"], GetResponseType<TData, TResponseType>>, InferSchemaOutput<TSchema["errorData"], GetResponseType<TErrorData, TResponseType>>, TResultMode, TThrowOnError, TResponseType, TComputedBaseSchemaRoutes, TSchema, TComputedBaseSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, TBasePluginArray, TPluginArray>) => Promise<TComputedResult>;
 declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode extends ResultModeUnion = ResultModeUnion, TThrowOnError extends ThrowOnErrorUnion = boolean, TResponseType extends ResponseTypeUnion = ResponseTypeUnion, const TSchemaConfig extends CallApiSchemaConfig = CallApiSchemaConfig, TInitURL extends ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">> = ApplyStrictConfig<TSchemaConfig, ApplyURLBasedConfig<TSchemaConfig, AnyString | "@delete/" | "@get/" | "@patch/" | "@post/" | "@put/">>, TCurrentRouteSchemaKey extends GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL> = GetCurrentRouteSchemaKey<TSchemaConfig, TInitURL>, const TSchema extends CallApiSchema = GetCurrentRouteSchema<{
   [x: AnyString]: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
@@ -31,11 +32,11 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   "@patch/"?: CallApiSchema | undefined;
   "@post/"?: CallApiSchema | undefined;
   "@put/"?: CallApiSchema | undefined;
-}[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedResult = GetCallApiResult<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResultMode, TThrowOnError, TResponseType, {
-  all: CallApiResultSuccessVariant<GetResponseType<InferSchemaOutputResult<TSchema["data"], TData>, TResponseType, ResponseTypeMap<InferSchemaOutputResult<TSchema["data"], TData>>>>;
-  onlyData: NoInfer<GetResponseType<InferSchemaOutputResult<TSchema["data"], TData>, TResponseType, ResponseTypeMap<InferSchemaOutputResult<TSchema["data"], TData>>>>;
+}[TCurrentRouteSchemaKey]>>, const TPluginArray extends CallApiPlugin[] = DefaultPluginArray, TComputedResult = GetCallApiResult<undefined extends TSchema["data"] ? TData : TSchema["data"] extends infer T ? T extends TSchema["data"] ? T extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T> : T extends AnyFunction<infer TResult> ? Awaited<TResult> : TData : never : never, undefined extends TSchema["errorData"] ? TErrorData : TSchema["errorData"] extends infer T_1 ? T_1 extends TSchema["errorData"] ? T_1 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_1> : T_1 extends AnyFunction<infer TResult> ? Awaited<TResult> : TErrorData : never : never, TResultMode, TThrowOnError, TResponseType, {
+  all: CallApiResultSuccessVariant<GetResponseType<undefined extends TSchema["data"] ? TData : TSchema["data"] extends infer T_2 ? T_2 extends TSchema["data"] ? T_2 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_2> : T_2 extends AnyFunction<infer TResult> ? Awaited<TResult> : TData : never : never, TResponseType, ResponseTypeMap<undefined extends TSchema["data"] ? TData : TSchema["data"] extends infer T_3 ? T_3 extends TSchema["data"] ? T_3 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_3> : T_3 extends AnyFunction<infer TResult> ? Awaited<TResult> : TData : never : never>>>;
+  onlyData: NoInfer<GetResponseType<undefined extends TSchema["data"] ? TData : TSchema["data"] extends infer T_4 ? T_4 extends TSchema["data"] ? T_4 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_4> : T_4 extends AnyFunction<infer TResult> ? Awaited<TResult> : TData : never : never, TResponseType, ResponseTypeMap<undefined extends TSchema["data"] ? TData : TSchema["data"] extends infer T_5 ? T_5 extends TSchema["data"] ? T_5 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_5> : T_5 extends AnyFunction<infer TResult> ? Awaited<TResult> : TData : never : never>>>;
   onlyResponse: Response;
-}, ResultModeMap<InferSchemaOutputResult<TSchema["data"], TData>, InferSchemaOutputResult<TSchema["errorData"], TErrorData>, TResponseType, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<InferSchemaOutputResult<TSchema["data"], GetResponseType<TData, TResponseType, ResponseTypeMap<TData>>>, InferSchemaOutputResult<TSchema["errorData"], GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>>>, TResultMode, TThrowOnError, TResponseType, {
+}, ResultModeMap<undefined extends TSchema["data"] ? TData : TSchema["data"] extends infer T_6 ? T_6 extends TSchema["data"] ? T_6 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_6> : T_6 extends AnyFunction<infer TResult> ? Awaited<TResult> : TData : never : never, undefined extends TSchema["errorData"] ? TErrorData : TSchema["errorData"] extends infer T_7 ? T_7 extends TSchema["errorData"] ? T_7 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_7> : T_7 extends AnyFunction<infer TResult> ? Awaited<TResult> : TErrorData : never : never, TResponseType, TThrowOnError>>>(initURL: TInitURL, initConfig?: CallApiConfig<undefined extends TSchema["data"] ? GetResponseType<TData, TResponseType, ResponseTypeMap<TData>> : TSchema["data"] extends infer T_8 ? T_8 extends TSchema["data"] ? T_8 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_8> : T_8 extends AnyFunction<infer TResult> ? Awaited<TResult> : GetResponseType<TData, TResponseType, ResponseTypeMap<TData>> : never : never, undefined extends TSchema["errorData"] ? GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>> : TSchema["errorData"] extends infer T_9 ? T_9 extends TSchema["errorData"] ? T_9 extends StandardSchemaV1<unknown, unknown> ? StandardSchemaV1.InferOutput<T_9> : T_9 extends AnyFunction<infer TResult> ? Awaited<TResult> : GetResponseType<TErrorData, TResponseType, ResponseTypeMap<TErrorData>> : never : never, TResultMode, TThrowOnError, TResponseType, {
   [x: AnyString]: CallApiSchema | undefined;
   "@delete/"?: CallApiSchema | undefined;
   "@get/"?: CallApiSchema | undefined;
@@ -44,5 +45,5 @@ declare const callApi: <TData = unknown, TErrorData = unknown, TResultMode exten
   "@put/"?: CallApiSchema | undefined;
 }, TSchema, CallApiSchemaConfig, TSchemaConfig, TInitURL, TCurrentRouteSchemaKey, DefaultPluginArray, TPluginArray>) => Promise<TComputedResult>;
 //#endregion
-export { type BaseCallApiConfig, type BaseCallApiExtraOptions, type BaseCallApiSchemaRoutes, type BaseInstanceContext, type CallApiConfig, type CallApiExtraOptions, type CallApiExtraOptionsForHooks, type CallApiParameters, type CallApiPlugin, type CallApiRequestOptions, type CallApiRequestOptionsForHooks, type CallApiResult, type CallApiResultErrorVariant, type CallApiResultSuccessVariant, type CallApiSchema, type CallApiSchemaConfig, type CallApiSuccessOrErrorVariant, type DedupeOptions, type ErrorContext, type Hooks, type HooksOrHooksArray, type InferExtendSchemaConfigContext, type InferExtendSchemaContext, type InferParamsFromRoute, type InferSchemaOutputResult, type PluginExtraOptions, type PluginHooks, type PluginHooksWithMoreOptions, type PluginSetupContext, type PossibleHTTPError, type PossibleJavaScriptError, type PossibleJavaScriptOrValidationError, type PossibleValidationError, type Register, type RequestContext, type RequestStreamContext, type ResponseContext, type ResponseErrorContext, type ResponseStreamContext, type ResponseTypeUnion, type ResultModeUnion, type RetryOptions, type SuccessContext, type URLOptions, callApi, createFetchClient };
+export { type BaseCallApiConfig, type BaseCallApiExtraOptions, type BaseCallApiSchemaRoutes, type BaseInstanceContext, type CallApiConfig, type CallApiExtraOptions, type CallApiExtraOptionsForHooks, type CallApiParameters, type CallApiPlugin, type CallApiRequestOptions, type CallApiRequestOptionsForHooks, type CallApiResult, type CallApiResultErrorVariant, type CallApiResultSuccessVariant, type CallApiSchema, type CallApiSchemaConfig, type CallApiSuccessOrErrorVariant, type DedupeOptions, type ErrorContext, type Hooks, type HooksOrHooksArray, type InferExtendSchemaConfigContext, type InferExtendSchemaContext, type InferParamsFromRoute, type InferSchemaInput, type InferSchemaOutput, type PluginExtraOptions, type PluginHooks, type PluginHooksWithMoreOptions, type PluginSetupContext, type PossibleHTTPError, type PossibleJavaScriptError, type PossibleJavaScriptOrValidationError, type PossibleValidationError, type Register, type RequestContext, type RequestStreamContext, type ResponseContext, type ResponseErrorContext, type ResponseStreamContext, type ResponseTypeUnion, type ResultModeUnion, type RetryOptions, type SuccessContext, type URLOptions, callApi, createFetchClient };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,4 +1,6 @@
-import { A as isReadableStream, C as HTTPError, D as isFunction, E as isBoolean, M as extraOptionDefaults, O as isObject, S as isValidationErrorInstance, T as isArray, a as getFetchImpl, c as splitBaseConfig, d as getFullAndNormalizedURL, h as handleSchemaValidation, i as getBody, j as isString, k as isPlainObject, l as splitConfig, m as handleConfigValidation, n as createTimeoutSignal, o as getHeaders, p as getCurrentRouteSchemaKeyAndMainInitURL, r as deterministicHashFn, s as getMethod, t as createCombinedSignal, u as waitFor, y as isHTTPErrorInstance } from "./common-CXyKVpND.js";
+import { n as requestOptionDefaults, r as defineEnum, t as extraOptionDefaults } from "./defaults-BD3B1uIH.js";
+import { _ as isReadableStream, b as isValidJsonString, c as HTTPError, d as isBoolean, f as isFunction, g as isQueryString, h as isPromise, i as isHTTPErrorInstance, l as ValidationError, m as isPlainObject, n as toQueryString, p as isObject, s as isValidationErrorInstance, u as isArray, v as isSerializable, y as isString } from "./body-B9WKokQt.js";
+import { n as fetchSpecificKeys, t as fallBackRouteSchemaKey } from "./validation-MjkoG9bG.js";
 
 //#region src/result.ts
 const getResponseType = (response, parser) => ({
@@ -149,9 +151,9 @@ const executeHooksInCatchBlock = async (hookResultsOrPromise, hookInfo) => {
 		await Promise.all(hookResultsOrPromise);
 		return null;
 	} catch (hookError) {
-		const { errorResult: hookErrorResult } = resolveErrorResult(hookError, errorInfo);
 		if (shouldThrowOnError) throw hookError;
-		return hookErrorResult;
+		const { errorResult } = resolveErrorResult(hookError, errorInfo);
+		return errorResult;
 	}
 };
 
@@ -262,6 +264,392 @@ 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/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 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 waitFor = (delay) => {
+	if (delay === 0) return;
+	return new Promise((resolve) => setTimeout(resolve, delay));
+};
+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) => {
@@ -290,11 +678,31 @@ const createDedupeStrategy = async (context) => {
 	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;
-	/******
-	* == Add a small delay to the execution to ensure proper request deduplication when multiple requests with the same key start simultaneously.
-	* == This gives time for the cache to be updated with the previous request info before the next request checks it.
-	******/
-	if (dedupeKey !== null) await waitFor(.1);
+	/**
+	* Force sequential execution of parallel requests to enable proper cache-based deduplication.
+	*
+	* Problem: When Promise.all([callApi(url), callApi(url)]) executes, both requests
+	* start synchronously and reach this point before either can populate the cache.
+	*
+	* Why `await Promise.resolve()` fails:
+	* - All microtasks in a batch resolve together at the next microtask checkpoint
+	* - Both requests resume execution simultaneously after the await
+	* - Both check `prevRequestInfo` at the same time → both see empty cache
+	* - Both proceed to populate cache → deduplication fails
+	*
+	* Why `wait new Promise(()=> setTimeout(resolve, number))` works:
+	* - Each setTimeout creates a separate task in the task queue
+	* - Tasks execute sequentially, not simultaneously
+	* - Request 1's task runs first: checks cache (empty) → continues → populates cache
+	* - Request 2's task runs after: checks cache (populated) → uses cached promise
+	* - Deduplication succeeds
+	*
+	* IMPORTANT: The delay must be non-zero. setTimeout(fn, 0) fails because JavaScript engines
+	* may optimize zero-delay timers by batching them together, causing all requests to resume
+	* simultaneously (same problem as microtasks). Any non-zero value (even 0.0000000001) forces
+	* proper sequential task queue scheduling, ensuring each request gets its own task slot.
+	*/
+	if (dedupeKey !== null) await waitFor(.001);
 	const prevRequestInfo = $RequestInfoCacheOrNull?.get(dedupeKey);
 	const getAbortErrorMessage = () => {
 		if (globalOptions.dedupeKey) return `Duplicate request detected - Aborted previous request with key '${dedupeKey}'`;
@@ -517,7 +925,7 @@ const getExponentialDelay = (currentAttemptCount, options) => {
 	const exponentialDelay = resolvedRetryDelay * 2 ** currentAttemptCount;
 	return Math.min(exponentialDelay, maxDelay);
 };
-const createRetryStrategy = (ctx) => {
+const createRetryManager = (ctx) => {
 	const { options, request } = ctx;
 	const currentAttemptCount = options["~retryAttemptCount"] ?? 1;
 	const retryStrategy = options.retryStrategy ?? options.retry?.strategy ?? extraOptionDefaults.retryStrategy;
@@ -540,9 +948,23 @@ const createRetryStrategy = (ctx) => {
 		const includesStatusCodes = ctx.response != null && retryStatusCodes.size > 0 ? retryStatusCodes.has(ctx.response.status) : true;
 		return includesMethod && includesStatusCodes;
 	};
+	const handleRetry = async (context) => {
+		const { callApi: callApi$1, callApiArgs, errorContext, hookInfo } = context;
+		const retryContext = {
+			...errorContext,
+			retryAttemptCount: currentAttemptCount
+		};
+		const hookError = await executeHooksInCatchBlock([options.onRetry?.(retryContext)], hookInfo);
+		if (hookError) return hookError;
+		await waitFor(getDelay());
+		const updatedOptions = {
+			...callApiArgs.config,
+			"~retryAttemptCount": currentAttemptCount + 1
+		};
+		return callApi$1(callApiArgs.initURL, updatedOptions);
+	};
 	return {
-		currentAttemptCount,
-		getDelay,
+		handleRetry,
 		shouldAttemptRetry
 	};
 };
@@ -716,21 +1138,17 @@ const createFetchClient = (initBaseConfig = {}) => {
 				errorInfo,
 				shouldThrowOnError
 			};
+			const { handleRetry, shouldAttemptRetry } = createRetryManager(errorContext);
 			const handleRetryOrGetErrorResult = async () => {
-				const { currentAttemptCount, getDelay, shouldAttemptRetry } = createRetryStrategy(errorContext);
-				if (await shouldAttemptRetry()) {
-					const retryContext = {
-						...errorContext,
-						retryAttemptCount: currentAttemptCount
-					};
-					const hookError = await executeHooksInCatchBlock([options.onRetry?.(retryContext)], hookInfo);
-					if (hookError) return hookError;
-					await waitFor(getDelay());
-					return callApi$1(initURL, {
-						...config,
-						"~retryAttemptCount": currentAttemptCount + 1
-					});
-				}
+				if (await shouldAttemptRetry()) return handleRetry({
+					callApi: callApi$1,
+					callApiArgs: {
+						config,
+						initURL
+					},
+					errorContext,
+					hookInfo
+				});
 				if (shouldThrowOnError) throw error;
 				return errorResult;
 			};