@oscarpalmer/jhunal 0.18.0 → 0.20.0

package/src/validation/value.validation.ts

@@ -1,20 +1,24 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import {join} from '@oscarpalmer/atoms/string';
+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 ValidationOptionsExtended,
 } from '../models/validation.model';
+import {schematicProperties, type Schematic} from '../schematic';
 
 function validateNamed(
 	property: ValidatedProperty,
@@ -39,6 +43,7 @@ function validateNamed(
 
 		if (!validator(value)) {
 			validation.push({
+				value,
 				key: {...property.key},
 				message: getInvalidValidatorMessage(property, name, index, length),
 				validator: validator as GenericCallback,
@@ -54,26 +59,77 @@ function validateNamed(
 export function validateObject(
 	obj: unknown,
 	properties: ValidatedProperty[],
-	reporting: ReportingInformation,
+	options: ValidationOptionsExtended,
+	origin?: ValidatedProperty,
 	validation?: ValidationInformation[],
-): boolean {
+): boolean | ValidationInformation[] {
 	if (!isPlainObject(obj)) {
-		if (reporting.throw && validation == null) {
-			throw new ValidationError([
-				{
-					key: {full: '', short: ''},
-					message: getInvalidInputMessage(obj),
-				},
-			]);
+		const key = origin == null ? {full: '', short: ''} : {...origin.key};
+
+		const information = {
+			key,
+			message:
+				origin == null
+					? getInvalidInputMessage(obj)
+					: getInvalidTypeMessage(
+							{
+								...origin,
+								key,
+							},
+							obj,
+						),
+			value: obj,
+		};
+
+		if (options.reporting.throw) {
+			throw new ValidationError([information]);
 		}
 
-		return false;
+		validation?.push(information);
+
+		return options.reporting.none ? false : [information];
 	}
 
+	if (options.strict) {
+		const objKeys = Object.keys(obj);
+
+		const propertiesKeys = new Set(properties.map(property => property.key.short));
+
+		const unknownKeys = objKeys.filter(key => !propertiesKeys.has(key));
+
+		if (unknownKeys.length > 0) {
+			const key = origin == null ? {full: '', short: ''} : {...origin.key};
+
+			const information: ValidationInformation = {
+				key,
+				message: getUnknownKeysMessage(unknownKeys.map(key => join([origin?.key.full, key], '.'))),
+				value: obj,
+			};
+
+			if (options.reporting.throw) {
+				throw new ValidationError([information]);
+			}
+
+			validation?.push(information);
+
+			return options.reporting.none ? false : [information];
+		}
+	}
+
+	const allInformation: ValidationInformation[] = [];
+
 	const propertiesLength = properties.length;
 
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
-		const property = properties[propertyIndex];
+		let property = properties[propertyIndex];
+
+		property = {
+			...property,
+			key: {
+				full: join([origin?.key.full, property.key.short], '.'),
+				short: property.key.short,
+			},
+		};
 
 		const {key, required, types} = property;
 
@@ -81,11 +137,12 @@ export function validateObject(
 
 		if (value === undefined && required) {
 			const information: ValidationInformation = {
+				value,
 				key: {...key},
 				message: getInvalidMissingMessage(property),
 			};
 
-			if (reporting.throw && validation == null) {
+			if (options.reporting.throw && validation == null) {
 				throw new ValidationError([information]);
 			}
 
@@ -93,7 +150,13 @@ export function validateObject(
 				validation.push(information);
 			}
 
-			return false;
+			if (options.reporting.all) {
+				allInformation.push(information);
+
+				continue;
+			}
+
+			return options.reporting.none ? false : [information];
 		}
 
 		const typesLength = types.length;
@@ -103,60 +166,74 @@ 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, property, value, options, information)) {
 				continue outer;
 			}
 		}
 
-		if (reporting.throw && validation == null) {
-			throw new ValidationError(
-				information.length === 0
-					? [
-							{
-								key: {...key},
-								message: getInvalidTypeMessage(property, value),
-							},
-						]
-					: information,
-			);
+		if (information.length === 0) {
+			information.push({
+				value,
+				key: {...key},
+				message: getInvalidTypeMessage(property, value),
+			});
+		}
+
+		if (options.reporting.throw && validation == null) {
+			throw new ValidationError(information);
 		}
 
 		validation?.push(...information);
 
-		return false;
+		if (options.reporting.all) {
+			allInformation.push(...information);
+
+			continue;
+		}
+
+		return options.reporting.none ? false : information;
 	}
 
-	return true;
+	return options.reporting.none || allInformation.length === 0 ? true : allInformation;
+}
+
+function validateSchematic(
+	property: ValidatedProperty,
+	schematic: Schematic<unknown>,
+	value: unknown,
+	options: ValidationOptionsExtended,
+	validation: ValidationInformation[],
+): boolean {
+	const properties = schematicProperties.get(schematic)!;
+
+	const result = validateObject(value, properties, options, property, validation);
+
+	return typeof result === 'boolean' ? result : result.length === 0;
 }
 
 function validateValue(
 	type: ValidatedPropertyType,
 	property: ValidatedProperty,
 	value: unknown,
-	reporting: ReportingInformation,
+	options: ValidationOptionsExtended,
 	validation: ValidationInformation[],
 ): boolean {
-	let result: boolean;
-
 	switch (true) {
 		case typeof type === 'function':
-			result = (type as GenericCallback)(value);
-			break;
+			return (type as GenericCallback)(value);
 
-		case Array.isArray(type):
-			result = validateObject(value, type, reporting, validation);
-			break;
+		case Array.isArray(type): {
+			const validated = validateObject(value, type, options, property, validation);
+
+			return typeof validated === 'boolean' ? validated : false;
+		}
 
 		case isSchematic(type):
-			result = type.is(value, reporting as never) as unknown as boolean;
-			break;
+			return validateSchematic(property, type, value, options, validation);
 
 		default:
-			result = validateNamed(property, type as ValueName, value, validation);
-			break;
+			return validateNamed(property, type as ValueName, value, validation);
 	}
-
-	return result;
 }
 
 //
@@ -169,7 +246,7 @@ const validators: Record<ValueName, (value: unknown) => boolean> = {
 	function: value => typeof value === 'function',
 	null: value => value === null,
 	number: value => typeof value === 'number',
-	object: value => typeof value === 'object' && value !== null,
+	object: value => typeof value === TYPE_OBJECT && value !== null,
 	string: value => typeof value === 'string',
 	symbol: value => typeof value === 'symbol',
 	undefined: value => value === undefined,