@zayne-labs/callapi 1.11.30 → 1.11.32

package/dist/index.js

@@ -67,11 +67,15 @@ const routeKeyMethods = defineEnum([
 ]);
 const handleSchemaValidation = async (fullSchema, schemaName, validationOptions) => {
 	const { inputValue, response, schemaConfig } = validationOptions;
-	if (schemaConfig?.disableRuntimeValidation) return inputValue;
-	return await standardSchemaParser(fullSchema, schemaName, {
+	const disableRuntimeValidationBooleanObject = isObject(schemaConfig?.disableRuntimeValidation) ? schemaConfig.disableRuntimeValidation : {};
+	if (schemaConfig?.disableRuntimeValidation === true || disableRuntimeValidationBooleanObject[schemaName] === true) return inputValue;
+	const validResult = await standardSchemaParser(fullSchema, schemaName, {
 		inputValue,
 		response
 	});
+	const disableResultApplicationBooleanObject = isObject(schemaConfig?.disableValidationOutputApplication) ? schemaConfig.disableValidationOutputApplication : {};
+	if (schemaConfig?.disableValidationOutputApplication === true || disableResultApplicationBooleanObject[schemaName] === true) return inputValue;
+	return validResult;
 };
 const extraOptionsToBeValidated = [
 	"meta",
@@ -98,11 +102,13 @@ const requestOptionsToBeValidated = [
 	"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 { request, schema, schemaConfig } = validationOptions;
+	const validationResultArray = await Promise.all(requestOptionsToBeValidated.map((schemaName) => {
+		return handleSchemaValidation(schema, schemaName, {
+			inputValue: request[schemaName],
+			schemaConfig
+		});
+	}));
 	const validatedResultObject = {};
 	for (const [index, propertyKey] of requestOptionsToBeValidated.entries()) {
 		const validationResult = validationResultArray[index];
@@ -112,7 +118,7 @@ const handleRequestOptionsValidation = async (validationOptions) => {
 	return validatedResultObject;
 };
 const handleConfigValidation = async (validationOptions) => {
-	const { baseExtraOptions, currentRouteSchemaKey, extraOptions, options, requestOptions } = validationOptions;
+	const { baseExtraOptions, currentRouteSchemaKey, extraOptions, options, request } = validationOptions;
 	const { currentRouteSchema, resolvedSchema } = getResolvedSchema({
 		baseExtraOptions,
 		currentRouteSchemaKey,
@@ -127,19 +133,12 @@ const handleConfigValidation = async (validationOptions) => {
 		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,
+		request,
 		schema: resolvedSchema,
 		schemaConfig: resolvedSchemaConfig
 	})]);
@@ -147,8 +146,7 @@ const handleConfigValidation = async (validationOptions) => {
 		extraOptionsValidationResult,
 		requestOptionsValidationResult,
 		resolvedSchema,
-		resolvedSchemaConfig,
-		shouldApplySchemaOutput: (Boolean(extraOptionsValidationResult) || Boolean(requestOptionsValidationResult)) && !resolvedSchemaConfig?.disableValidationOutputApplication
+		resolvedSchemaConfig
 	};
 };
 const getResolvedSchema = (context) => {
@@ -324,15 +322,19 @@ const pickKeys = (initialObject, keysToPick) => {
 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;
+	if (!headers) return {};
+	if (isPlainObject(headers)) return headers;
 	return Object.fromEntries(headers);
 };
+const getResolvedHeaders = (options) => {
+	const { baseHeaders, headers } = options;
+	return objectifyHeaders(isFunction(headers) ? headers({ baseHeaders: objectifyHeaders(baseHeaders) }) : headers ?? baseHeaders);
+};
 const getHeaders = async (options) => {
-	const { auth, body, headers } = options;
-	if (!(Boolean(headers) || Boolean(body) || Boolean(auth))) return;
+	const { auth, body, resolvedHeaders } = options;
 	const headersObject = {
 		...await getAuthHeader(auth),
-		...objectifyHeaders(headers)
+		...objectifyHeaders(resolvedHeaders)
 	};
 	if (isQueryString(body)) {
 		headersObject["Content-Type"] = "application/x-www-form-urlencoded";
@@ -788,8 +790,8 @@ const getResolvedPlugins = (context) => {
 	const { baseConfig, options } = context;
 	return isFunction(options.plugins) ? options.plugins({ basePlugins: baseConfig.plugins ?? [] }) : options.plugins ?? [];
 };
-const initializePlugins = async (context) => {
-	const { baseConfig, config, initURL, options, request } = context;
+const initializePlugins = async (setupContext) => {
+	const { baseConfig, config, initURL, options, request } = setupContext;
 	const { addMainHooks, addMainMiddlewares, addPluginHooks, addPluginMiddlewares, getResolvedHooks, getResolvedMiddlewares } = setupHooksAndMiddlewares({
 		baseConfig,
 		config,
@@ -802,12 +804,21 @@ const initializePlugins = async (context) => {
 	});
 	let resolvedCurrentRouteSchemaKey = currentRouteSchemaKey;
 	let resolvedInitURL = mainInitURL;
-	let resolvedOptions = options;
-	let resolvedRequestOptions = request;
+	const resolvedOptions = options;
+	const resolvedRequest = Object.assign(request, {
+		headers: getResolvedHeaders({
+			baseHeaders: baseConfig.headers,
+			headers: request.headers
+		}),
+		method: getMethod({
+			initURL: resolvedInitURL,
+			method: request.method
+		})
+	});
 	const executePluginSetupFn = async (pluginSetup) => {
 		if (!pluginSetup) return;
-		const initResult = await pluginSetup(context);
-		if (!isPlainObject(initResult)) return;
+		const initResult = await pluginSetup(setupContext);
+		if (!initResult) return;
 		const urlString = initResult.initURL?.toString();
 		if (isString(urlString)) {
 			const newResult = getCurrentRouteSchemaKeyAndMainInitURL({
@@ -818,14 +829,8 @@ const initializePlugins = async (context) => {
 			resolvedCurrentRouteSchemaKey = newResult.currentRouteSchemaKey;
 			resolvedInitURL = newResult.mainInitURL;
 		}
-		if (isPlainObject(initResult.request)) resolvedRequestOptions = {
-			...resolvedRequestOptions,
-			...initResult.request
-		};
-		if (isPlainObject(initResult.options)) resolvedOptions = {
-			...resolvedOptions,
-			...initResult.options
-		};
+		if (initResult.request) Object.assign(resolvedRequest, initResult.request);
+		if (initResult.options) Object.assign(resolvedOptions, initResult.options);
 	};
 	const resolvedPlugins = getResolvedPlugins({
 		baseConfig,
@@ -834,8 +839,8 @@ const initializePlugins = async (context) => {
 	for (const plugin of resolvedPlugins) {
 		const [, pluginHooks, pluginMiddlewares] = await Promise.all([
 			executePluginSetupFn(plugin.setup),
-			isFunction(plugin.hooks) ? plugin.hooks(context) : plugin.hooks,
-			isFunction(plugin.middlewares) ? plugin.middlewares(context) : plugin.middlewares
+			isFunction(plugin.hooks) ? plugin.hooks(setupContext) : plugin.hooks,
+			isFunction(plugin.middlewares) ? plugin.middlewares(setupContext) : plugin.middlewares
 		]);
 		pluginHooks && addPluginHooks(pluginHooks);
 		pluginMiddlewares && addPluginMiddlewares(pluginMiddlewares);
@@ -850,7 +855,7 @@ const initializePlugins = async (context) => {
 		resolvedInitURL,
 		resolvedMiddlewares,
 		resolvedOptions,
-		resolvedRequestOptions
+		resolvedRequest
 	};
 };
 const setupHooksAndMiddlewares = (context) => {
@@ -996,11 +1001,10 @@ const createFetchClientWithContext = () => {
 				...!shouldSkipAutoMergeForOptions && extraOptions
 			};
 			const mergedRequestOptions = {
-				headers: {},
 				...baseFetchOptions,
 				...!shouldSkipAutoMergeForRequest && fetchOptions
 			};
-			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequestOptions } = await initializePlugins({
+			const { resolvedCurrentRouteSchemaKey, resolvedHooks, resolvedInitURL, resolvedMiddlewares, resolvedOptions, resolvedRequest } = await initializePlugins({
 				baseConfig,
 				config,
 				initURL: initURL.toString(),
@@ -1022,14 +1026,9 @@ const createFetchClientWithContext = () => {
 				initURLNormalized: normalizedInitURL
 			};
 			const newFetchController = new AbortController();
-			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequestOptions.signal, newFetchController.signal);
-			const initMethod = getMethod({
-				initURL: resolvedInitURL,
-				method: resolvedRequestOptions.method
-			});
+			const combinedSignal = createCombinedSignal(createTimeoutSignal(options.timeout), resolvedRequest.signal, newFetchController.signal);
 			const request = {
-				...resolvedRequestOptions,
-				method: initMethod,
+				...resolvedRequest,
 				signal: combinedSignal
 			};
 			const { getAbortErrorMessage, handleRequestCancelStrategy, handleRequestDeferStrategy, removeDedupeKeyFromCache, resolvedDedupeStrategy } = await createDedupeStrategy({
@@ -1049,32 +1048,29 @@ const createFetchClientWithContext = () => {
 					options,
 					request
 				}));
-				const { extraOptionsValidationResult, requestOptionsValidationResult, resolvedSchema, resolvedSchemaConfig, shouldApplySchemaOutput } = await handleConfigValidation({
+				const { extraOptionsValidationResult, requestOptionsValidationResult, resolvedSchema, resolvedSchemaConfig } = await handleConfigValidation({
 					baseExtraOptions,
 					currentRouteSchemaKey: resolvedCurrentRouteSchemaKey,
 					extraOptions,
 					options,
-					requestOptions: request
-				});
-				if (shouldApplySchemaOutput) Object.assign(options, extraOptionsValidationResult);
-				const validMethod = getMethod({
-					initURL: resolvedInitURL,
-					method: shouldApplySchemaOutput ? requestOptionsValidationResult?.method : request.method
+					request
 				});
+				Object.assign(options, extraOptionsValidationResult);
 				const validBody = getBody({
-					body: shouldApplySchemaOutput ? requestOptionsValidationResult?.body : request.body,
+					body: requestOptionsValidationResult.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: validBody,
-					headers: shouldApplySchemaOutput ? requestOptionsValidationResult?.headers : resolvedHeaders
-				});
 				Object.assign(request, {
-					...validBody && { body: validBody },
-					...validHeaders && { headers: validHeaders },
-					...validMethod && { method: validMethod }
+					body: validBody,
+					headers: await getHeaders({
+						auth: options.auth,
+						body: validBody,
+						resolvedHeaders: requestOptionsValidationResult.headers
+					}),
+					method: getMethod({
+						initURL: resolvedInitURL,
+						method: requestOptionsValidationResult.method
+					})
 				});
 				const readyRequestContext = {
 					baseConfig,