@oscarpalmer/jhunal 0.17.0 → 0.19.0

package/src/schematic.ts

@@ -1,16 +1,19 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME} from './constants';
-import {isSchematic} from './helpers';
+import type {Result} from '@oscarpalmer/atoms/result/models';
+import {PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE} from './constants';
+import {getReporting, isSchematic} from './helpers';
+import type {Infer} from './models/infer.model';
+import type {Schema} from './models/schema.plain.model';
+import type {TypedSchema} from './models/schema.typed.model';
 import {
 	SchematicError,
-	type Infer,
-	type Schema,
-	type TypedSchema,
 	type ValidatedProperty,
-} from './models';
+	type ValidationInformation,
+} from './models/validation.model';
 import {getProperties} from './validation/property.validation';
 import {validateObject} from './validation/value.validation';
+import {error} from '@oscarpalmer/atoms/result/misc';
 
 /**
  * A schematic for validating objects
@@ -21,7 +24,7 @@ export class Schematic<Model> {
 	#properties: ValidatedProperty[];
 
 	constructor(properties: ValidatedProperty[]) {
-		Object.defineProperty(this, SCHEMATIC_NAME, {
+		Object.defineProperty(this, PROPERTY_SCHEMATIC, {
 			value: true,
 		});
 
@@ -30,11 +33,53 @@ export class Schematic<Model> {
 
 	/**
 	 * Does the value match the schema?
+	 *
+	 * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation.
 	 * @param value Value to validate
+	 * @param errors Throws an error for the first validation failure
+	 * @returns `true` if the value matches the schema, otherwise throws an error
+	 */
+	is(value: unknown, errors: 'throw'): asserts value is Model;
+
+	/**
+	 * Does the value match the schema?
+	 *
+	 * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the object.
+	 * @param value Value to validate
+	 * @param errors All
+	 * @returns `true` if the value matches the schema, otherwise `false`
+	 */
+	is(value: unknown, errors: 'all'): Result<true, ValidationInformation[]>;
+
+	/**
+	 * Does the value match the schema?
+	 *
+	 * Will validate that the value matches the schema and return a result of `true` or all validation information for the failing property.
+	 * @param value Value to validate
+	 * @param errors First
 	 * @returns `true` if the value matches the schema, otherwise `false`
 	 */
-	is(value: unknown): value is Model {
-		return validateObject(value, this.#properties);
+	is(value: unknown, errors: 'first'): Result<true, ValidationInformation>;
+
+	/**
+	 * Does the value match the schema?
+	 *
+	 * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures.
+	 * @param value Value to validate
+	 * @returns `true` if the value matches the schema, otherwise `false`
+	 */
+	is(value: unknown): value is Model;
+
+	is(value: unknown, errors?: unknown): unknown {
+		const reporting = getReporting(errors);
+
+		const result = validateObject(value, this.#properties, reporting);
+
+		if (typeof result === 'boolean') {
+			return result;
+		}
+
+		return error(reporting.all ? result : result[0]);
 	}
 }
 
@@ -62,7 +107,7 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Model>
 	}
 
 	if (!isPlainObject(schema)) {
-		throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+		throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
 	}
 
 	return new Schematic<Model>(getProperties(schema));

package/src/validation/property.validation.ts

@@ -2,33 +2,31 @@ import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {join} from '@oscarpalmer/atoms/string';
 import {
-	MESSAGE_SCHEMA_INVALID_EMPTY,
-	MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
-	MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE,
-	MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
-	MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
-	MESSAGE_VALIDATOR_INVALID_KEY,
-	MESSAGE_VALIDATOR_INVALID_TYPE,
-	MESSAGE_VALIDATOR_INVALID_VALUE,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE,
 	PROPERTY_REQUIRED,
 	PROPERTY_TYPE,
 	PROPERTY_VALIDATORS,
 	TEMPLATE_PATTERN,
-	TEMPLATE_PATTERN_KEY,
-	TEMPLATE_PATTERN_PROPERTY,
 	TYPE_ALL,
 	TYPE_OBJECT,
 	TYPE_UNDEFINED,
 	VALIDATABLE_TYPES,
 } from '../constants';
 import {instanceOf, isSchematic} from '../helpers';
+import type {ValueName} from '../models/misc.model';
 import {
 	SchematicError,
 	type ValidatedProperty,
 	type ValidatedPropertyType,
 	type ValidatedPropertyValidators,
-	type ValueName,
-} from '../models';
+} from '../models/validation.model';
 
 function getDisallowedProperty(obj: PlainObject): string | undefined {
 	if (PROPERTY_REQUIRED in obj) {
@@ -50,7 +48,7 @@ export function getProperties(
 	fromType?: boolean,
 ): ValidatedProperty[] {
 	if (Object.keys(original).length === 0) {
-		throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
+		throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
 	}
 
 	if (fromType ?? false) {
@@ -58,10 +56,10 @@ export function getProperties(
 
 		if (property != null) {
 			throw new SchematicError(
-				MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix!).replace(
-					TEMPLATE_PATTERN_PROPERTY,
-					property,
-				),
+				SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(
+					TEMPLATE_PATTERN,
+					prefix!,
+				).replace(TEMPLATE_PATTERN, property),
 			);
 		}
 	}
@@ -74,14 +72,12 @@ export function getProperties(
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 
+		const prefixed = join([prefix, key], '.');
 		const value = original[key];
 
 		if (value == null) {
 			throw new SchematicError(
-				MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace(
-					TEMPLATE_PATTERN,
-					join([prefix, key], '.'),
-				),
+				SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace(TEMPLATE_PATTERN, prefixed),
 			);
 		}
 
@@ -94,11 +90,9 @@ export function getProperties(
 			required = getRequired(key, value) ?? required;
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
 
-			if (PROPERTY_TYPE in value) {
-				types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
-			} else {
-				types.push(TYPE_OBJECT, ...getTypes(key, value, prefix));
-			}
+			const hasType = PROPERTY_TYPE in value;
+
+			types.push(...getTypes(key, hasType ? value[PROPERTY_TYPE] : value, prefix, hasType));
 		} else {
 			types.push(...getTypes(key, value, prefix));
 		}
@@ -108,9 +102,12 @@ export function getProperties(
 		}
 
 		properties.push({
-			key,
 			types,
 			validators,
+			key: {
+				full: prefixed,
+				short: key,
+			},
 			required: required && !types.includes(TYPE_UNDEFINED),
 		});
 	}
@@ -125,7 +122,7 @@ function getRequired(key: string, obj: PlainObject): boolean | undefined {
 
 	if (typeof obj[PROPERTY_REQUIRED] !== 'boolean') {
 		throw new SchematicError(
-			MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
+			SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
 		);
 	}
 
@@ -152,7 +149,7 @@ function getTypes(
 				break;
 
 			case isPlainObject(value):
-				types.push(...getProperties(value, join([prefix, key], '.'), fromType));
+				types.push(getProperties(value, join([prefix, key], '.'), fromType));
 				break;
 
 			case isSchematic(value):
@@ -165,14 +162,20 @@ function getTypes(
 
 			default:
 				throw new SchematicError(
-					MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], '.')),
+					SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(
+						TEMPLATE_PATTERN,
+						join([prefix, key], '.'),
+					),
 				);
 		}
 	}
 
 	if (types.length === 0) {
 		throw new SchematicError(
-			MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], '.')),
+			SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(
+				TEMPLATE_PATTERN,
+				join([prefix, key], '.'),
+			),
 		);
 	}
 
@@ -187,7 +190,7 @@ function getValidators(original: unknown): ValidatedPropertyValidators {
 	}
 
 	if (!isPlainObject(original)) {
-		throw new TypeError(MESSAGE_VALIDATOR_INVALID_TYPE);
+		throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
 	}
 
 	const keys = Object.keys(original);
@@ -197,17 +200,19 @@ function getValidators(original: unknown): ValidatedPropertyValidators {
 		const key = keys[index];
 
 		if (!VALIDATABLE_TYPES.has(key as never)) {
-			throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+			throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
 		}
 
 		const value = (original as PlainObject)[key];
 
-		validators[key as ValueName] = (Array.isArray(value) ? value : [value]).filter(item => {
+		validators[key as ValueName] = (Array.isArray(value) ? value : [value]).map(item => {
 			if (typeof item !== 'function') {
-				throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key));
+				throw new TypeError(
+					SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key),
+				);
 			}
 
-			return true;
+			return item;
 		});
 	}
 

package/src/validation/value.validation.ts

@@ -1,12 +1,82 @@
 import {isPlainObject} from '@oscarpalmer/atoms/is';
-import {isSchematic} from '../helpers';
-import type {ValidatedProperty, ValidatedPropertyType, ValueName} from '../models';
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import {TYPE_OBJECT} from '../constants';
+import {
+	getInvalidInputMessage,
+	getInvalidMissingMessage,
+	getInvalidTypeMessage,
+	getInvalidValidatorMessage,
+	isSchematic,
+} from '../helpers';
+import type {ValueName} from '../models/misc.model';
+import {
+	ValidationError,
+	type ReportingInformation,
+	type ValidatedProperty,
+	type ValidatedPropertyType,
+	type ValidationInformation,
+} from '../models/validation.model';
+
+function validateNamed(
+	property: ValidatedProperty,
+	name: ValueName,
+	value: unknown,
+	validation: ValidationInformation[],
+): boolean {
+	if (!validators[name](value)) {
+		return false;
+	}
+
+	const propertyValidators = property.validators[name];
 
-export function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean {
+	if (propertyValidators == null || propertyValidators.length === 0) {
+		return true;
+	}
+
+	const {length} = propertyValidators;
+
+	for (let index = 0; index < length; index += 1) {
+		const validator = propertyValidators[index];
+
+		if (!validator(value)) {
+			validation.push({
+				value,
+				key: {...property.key},
+				message: getInvalidValidatorMessage(property, name, index, length),
+				validator: validator as GenericCallback,
+			});
+
+			return false;
+		}
+	}
+
+	return true;
+}
+
+export function validateObject(
+	obj: unknown,
+	properties: ValidatedProperty[],
+	reporting: ReportingInformation,
+	property?: ValidatedProperty,
+	validation?: ValidationInformation[],
+): boolean | ValidationInformation[] {
 	if (!isPlainObject(obj)) {
-		return false;
+		const information = {
+			key: {full: '', short: ''},
+			message:
+				property == null ? getInvalidInputMessage(obj) : getInvalidTypeMessage(property, obj),
+			value: obj,
+		};
+
+		if (reporting.throw) {
+			throw new ValidationError([information]);
+		}
+
+		return reporting.none ? false : [information];
 	}
 
+	const allInformation: ValidationInformation[] = [];
+
 	const propertiesLength = properties.length;
 
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
@@ -14,48 +84,91 @@ export function validateObject(obj: unknown, properties: ValidatedProperty[]): b
 
 		const {key, required, types} = property;
 
-		const value = obj[key];
+		const value = obj[key.short];
 
 		if (value === undefined && required) {
-			return false;
+			const information: ValidationInformation = {
+				value,
+				key: {...key},
+				message: getInvalidMissingMessage(property),
+			};
+
+			if (reporting.throw && validation == null) {
+				throw new ValidationError([information]);
+			}
+
+			if (validation != null) {
+				validation.push(information);
+			}
+
+			if (reporting.all) {
+				allInformation.push(information);
+
+				continue;
+			}
+
+			return reporting.none ? false : [information];
 		}
 
 		const typesLength = types.length;
 
+		const information: ValidationInformation[] = [];
+
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
 
-			if (validateValue(type, property, value)) {
+			if (validateValue(type, property, value, reporting, information)) {
 				continue outer;
 			}
 		}
 
-		return false;
+		if (information.length === 0) {
+			information.push({
+				value,
+				key: {...key},
+				message: getInvalidTypeMessage(property, value),
+			});
+		}
+
+		if (reporting.throw && validation == null) {
+			throw new ValidationError(information);
+		}
+
+		validation?.push(...information);
+
+		if (reporting.all) {
+			allInformation.push(...information);
+
+			continue;
+		}
+
+		return reporting.none ? false : information;
 	}
 
-	return true;
+	return reporting.none ? true : allInformation.length === 0 ? true : allInformation;
 }
 
 function validateValue(
 	type: ValidatedPropertyType,
 	property: ValidatedProperty,
 	value: unknown,
+	reporting: ReportingInformation,
+	validation: ValidationInformation[],
 ): boolean {
 	switch (true) {
-		case isSchematic(type):
-			return type.is(value);
-
 		case typeof type === 'function':
-			return (type as (value: unknown) => boolean)(value);
+			return (type as GenericCallback)(value);
 
-		case typeof type === 'object':
-			return validateObject(value, [type] as ValidatedProperty[]);
+		case Array.isArray(type): {
+			const nested = validateObject(value, type, reporting, property, validation);
+			return typeof nested !== 'boolean' ? false : nested;
+		}
+
+		case isSchematic(type):
+			return type.is(value, reporting as never) as unknown as boolean;
 
 		default:
-			return (
-				validators[type as ValueName](value) &&
-				(property.validators[type as ValueName]?.every(validator => validator(value)) ?? true)
-			);
+			return validateNamed(property, type as ValueName, value, validation);
 	}
 }
 
@@ -69,7 +182,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,