@oscarpalmer/jhunal 0.19.0 → 0.21.0

package/src/validation/value.validation.ts

@@ -1,33 +1,32 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import type {GenericCallback, PlainObject} from '@oscarpalmer/atoms/models';
+import {join} from '@oscarpalmer/atoms/string';
+import {clone} from '@oscarpalmer/atoms/value/clone';
 import {TYPE_OBJECT} from '../constants';
 import {
 	getInvalidInputMessage,
 	getInvalidMissingMessage,
 	getInvalidTypeMessage,
 	getInvalidValidatorMessage,
+	getUnknownKeysMessage,
 	isSchematic,
 } from '../helpers';
 import type {ValueName} from '../models/misc.model';
 import {
 	ValidationError,
-	type ReportingInformation,
 	type ValidatedProperty,
 	type ValidatedPropertyType,
 	type ValidationInformation,
+	type ValidationParameters,
 } from '../models/validation.model';
+import {schematicProperties, type Schematic} from '../schematic';
 
-function validateNamed(
-	property: ValidatedProperty,
-	name: ValueName,
-	value: unknown,
-	validation: ValidationInformation[],
-): boolean {
+function validateNamed(name: ValueName, value: unknown, parameters: ValidationParameters): boolean {
 	if (!validators[name](value)) {
 		return false;
 	}
 
-	const propertyValidators = property.validators[name];
+	const propertyValidators = parameters.origin!.validators[name];
 
 	if (propertyValidators == null || propertyValidators.length === 0) {
 		return true;
@@ -39,10 +38,13 @@ function validateNamed(
 		const validator = propertyValidators[index];
 
 		if (!validator(value)) {
-			validation.push({
+			parameters.information!.push({
 				value,
-				key: {...property.key},
-				message: getInvalidValidatorMessage(property, name, index, length),
+				key: {
+					full: parameters.prefix!,
+					short: parameters.origin!.key,
+				},
+				message: getInvalidValidatorMessage(parameters.prefix!, name, index, length),
 				validator: validator as GenericCallback,
 			});
 
@@ -56,27 +58,74 @@ function validateNamed(
 export function validateObject(
 	obj: unknown,
 	properties: ValidatedProperty[],
-	reporting: ReportingInformation,
-	property?: ValidatedProperty,
-	validation?: ValidationInformation[],
-): boolean | ValidationInformation[] {
+	parameters: ValidationParameters,
+	get: boolean,
+): PlainObject | ValidationInformation[] | undefined {
 	if (!isPlainObject(obj)) {
+		const key =
+			parameters?.origin == null
+				? {full: '', short: ''}
+				: {
+						full: parameters.prefix!,
+						short: parameters.origin.key,
+					};
+
 		const information = {
-			key: {full: '', short: ''},
+			key,
 			message:
-				property == null ? getInvalidInputMessage(obj) : getInvalidTypeMessage(property, obj),
+				parameters?.origin == null
+					? getInvalidInputMessage(obj)
+					: getInvalidTypeMessage(key.full, parameters.origin.types, obj),
 			value: obj,
 		};
 
-		if (reporting.throw) {
+		if (parameters.reporting.throw) {
 			throw new ValidationError([information]);
 		}
 
-		return reporting.none ? false : [information];
+		parameters?.information?.push(information);
+
+		return parameters.reporting.none ? undefined : [information];
+	}
+
+	if (parameters.strict) {
+		const objKeys = Object.keys(obj);
+
+		const propertiesKeys = new Set(properties.map(property => property.key));
+
+		const unknownKeys = objKeys.filter(key => !propertiesKeys.has(key));
+
+		if (unknownKeys.length > 0) {
+			const key =
+				parameters?.origin == null
+					? {full: '', short: ''}
+					: {
+							full: join([parameters.prefix, parameters.origin?.key], '.'),
+							short: parameters.origin.key,
+						};
+
+			const information: ValidationInformation = {
+				key,
+				message: getUnknownKeysMessage(
+					unknownKeys.map(key => join([parameters?.prefix, key], '.')),
+				),
+				value: obj,
+			};
+
+			if (parameters.reporting.throw) {
+				throw new ValidationError([information]);
+			}
+
+			parameters?.information?.push(information);
+
+			return parameters.reporting.none ? undefined : [information];
+		}
 	}
 
 	const allInformation: ValidationInformation[] = [];
 
+	const output: PlainObject = {};
+
 	const propertiesLength = properties.length;
 
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
@@ -84,32 +133,43 @@ export function validateObject(
 
 		const {key, required, types} = property;
 
-		const value = obj[key.short];
+		const value = obj[key];
+
+		if (get && value === undefined && !required) {
+			// TODO: during get, respect a default value for the property
+
+			continue;
+		}
 
 		if (value === undefined && required) {
+			const prefixedKey = join([parameters.prefix, key], '.');
+
 			const information: ValidationInformation = {
 				value,
-				key: {...key},
-				message: getInvalidMissingMessage(property),
+				key: {
+					full: prefixedKey,
+					short: key,
+				},
+				message: getInvalidMissingMessage(prefixedKey, property.types),
 			};
 
-			if (reporting.throw && validation == null) {
+			if (parameters.reporting.throw) {
 				throw new ValidationError([information]);
 			}
 
-			if (validation != null) {
-				validation.push(information);
-			}
+			parameters?.information?.push(information);
 
-			if (reporting.all) {
+			if (parameters.reporting.all) {
 				allInformation.push(information);
 
 				continue;
 			}
 
-			return reporting.none ? false : [information];
+			return parameters.reporting.none ? undefined : [information];
 		}
 
+		const prefixedKey = join([parameters.prefix, key], '.');
+
 		const typesLength = types.length;
 
 		const information: ValidationInformation[] = [];
@@ -117,7 +177,25 @@ export function validateObject(
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
 
-			if (validateValue(type, property, value, reporting, information)) {
+			if (
+				validateValue(
+					type,
+					value,
+					{
+						information,
+						output,
+						origin: property,
+						prefix: prefixedKey,
+						reporting: parameters.reporting,
+						strict: parameters.strict,
+					},
+					get,
+				)
+			) {
+				if (get) {
+					output[key] = clone(value);
+				}
+
 				continue outer;
 			}
 		}
@@ -125,50 +203,76 @@ export function validateObject(
 		if (information.length === 0) {
 			information.push({
 				value,
-				key: {...key},
-				message: getInvalidTypeMessage(property, value),
+				key: {
+					full: prefixedKey,
+					short: key,
+				},
+				message: getInvalidTypeMessage(prefixedKey, property.types, value),
 			});
 		}
 
-		if (reporting.throw && validation == null) {
+		if (parameters.reporting.throw) {
 			throw new ValidationError(information);
 		}
 
-		validation?.push(...information);
+		parameters?.information?.push(...information);
 
-		if (reporting.all) {
+		if (parameters.reporting.all) {
 			allInformation.push(...information);
 
 			continue;
 		}
 
-		return reporting.none ? false : information;
+		return parameters.reporting.none ? undefined : information;
+	}
+
+	if (get) {
+		if (parameters.origin == null) {
+			parameters.output = output;
+		} else {
+			parameters.output[parameters.origin.key] = output;
+		}
 	}
 
-	return reporting.none ? true : allInformation.length === 0 ? true : allInformation;
+	return parameters.reporting.none || allInformation.length === 0
+		? parameters.output
+		: allInformation;
+}
+
+function validateSchematic(
+	schematic: Schematic<unknown>,
+	value: unknown,
+	parameters: ValidationParameters,
+	get: boolean,
+): boolean {
+	const properties = schematicProperties.get(schematic)!;
+
+	const result = validateObject(value, properties, parameters, get);
+
+	return result == null || Array.isArray(result) ? false : true;
 }
 
 function validateValue(
 	type: ValidatedPropertyType,
-	property: ValidatedProperty,
 	value: unknown,
-	reporting: ReportingInformation,
-	validation: ValidationInformation[],
+	parameters: ValidationParameters,
+	get: boolean,
 ): boolean {
 	switch (true) {
 		case typeof type === 'function':
 			return (type as GenericCallback)(value);
 
 		case Array.isArray(type): {
-			const nested = validateObject(value, type, reporting, property, validation);
-			return typeof nested !== 'boolean' ? false : nested;
+			const result = validateObject(value, type, parameters, get);
+
+			return result == null || Array.isArray(result) ? false : true;
 		}
 
 		case isSchematic(type):
-			return type.is(value, reporting as never) as unknown as boolean;
+			return validateSchematic(type, value, parameters, get);
 
 		default:
-			return validateNamed(property, type as ValueName, value, validation);
+			return validateNamed(type as ValueName, value, parameters);
 	}
 }