@oscarpalmer/jhunal 0.16.0 → 0.18.0

package/dist/models/schema.plain.model.d.mts

@@ -0,0 +1,92 @@
+import { Schematic } from "../schematic.mjs";
+import { ExtractValueNames, ValueName, Values } from "./misc.model.mjs";
+import { Constructor } from "@oscarpalmer/atoms/models";
+
+//#region src/models/schema.plain.model.d.ts
+/**
+ * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
+ */
+type PlainSchema = {
+  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[] | undefined;
+} & {
+  $required?: never;
+  $type?: never;
+  $validators?: never;
+};
+/**
+ * A schema for validating objects
+ *
+ * @example
+ * ```ts
+ * const schema: Schema = {
+ *   name: 'string',
+ *   age: 'number',
+ *   tags: ['string', 'number'],
+ * };
+ * ```
+ */
+type Schema = SchemaIndex;
+/**
+ * A union of all valid types for a single schema entry
+ *
+ * Can be a {@link Constructor}, nested {@link Schema}, {@link SchemaProperty}, {@link Schematic}, {@link ValueName} string, or a custom validator function
+ */
+type SchemaEntry = Constructor | PlainSchema | SchemaProperty | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+/**
+ * Index signature interface backing {@link Schema}, allowing string-keyed entries of {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry}
+ */
+interface SchemaIndex {
+  [key: string]: PlainSchema | SchemaEntry | SchemaEntry[];
+}
+/**
+ * A property definition with explicit type(s), an optional requirement flag, and optional validators
+ *
+ * @example
+ * ```ts
+ * const prop: SchemaProperty = {
+ *   $required: false,
+ *   $type: ['string', 'number'],
+ *   $validators: {
+ *     string: (v) => v.length > 0,
+ *     number: (v) => v > 0,
+ *   },
+ * };
+ * ```
+ */
+type SchemaProperty = {
+  /**
+   * Whether the property is required _(defaults to `true`)_
+   */
+  $required?: boolean;
+  /**
+   * The type(s) the property value must match; a single {@link SchemaPropertyType} or an array
+   */
+  $type: SchemaPropertyType | SchemaPropertyType[];
+  /**
+   * Optional validators keyed by {@link ValueName}, applied during validation
+   */
+  $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
+};
+/**
+ * A union of valid types for a {@link SchemaProperty}'s `$type` field
+ *
+ * Can be a {@link Constructor}, {@link PlainSchema}, {@link Schematic}, {@link ValueName} string, or a custom validator function
+ */
+type SchemaPropertyType = Constructor | PlainSchema | Schematic<unknown> | ValueName | ((value: unknown) => boolean);
+/**
+ * A map of optional validator functions keyed by {@link ValueName}, used to add custom validation to {@link SchemaProperty} definitions
+ *
+ * Each key may hold a single validator or an array of validators that receive the typed value
+ *
+ * @template Value - `$type` value(s) to derive validator keys from
+ *
+ * @example
+ * ```ts
+ * const validators: PropertyValidators<'string'> = {
+ *   string: (value) => value.length > 0,
+ * };
+ * ```
+ */
+type PropertyValidators<Value> = { [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean> };
+//#endregion
+export { PlainSchema, PropertyValidators, Schema, SchemaEntry, SchemaIndex, SchemaProperty, SchemaPropertyType };

package/dist/models/schema.plain.model.mjs

@@ -0,0 +1 @@
+export {};

package/dist/models/schema.typed.model.d.mts

@@ -0,0 +1,96 @@
+import { ToSchemaPropertyType, ToSchemaType } from "./transform.model.mjs";
+import { Schematic } from "../schematic.mjs";
+import { PropertyValidators } from "./schema.plain.model.mjs";
+import { OptionalKeys, RequiredKeys } from "./misc.model.mjs";
+import { PlainObject, Simplify } from "@oscarpalmer/atoms/models";
+
+//#region src/models/schema.typed.model.d.ts
+/**
+ * A typed optional property definition generated by {@link TypedSchema} for optional keys, with `$required` set to `false` and excludes `undefined` from the type
+ *
+ * @template Value - Property's type _(including `undefined`)_
+ *
+ * @example
+ * ```ts
+ * // For `{ name?: string }`, the `name` key produces:
+ * // TypedPropertyOptional<string | undefined>
+ * // => { $required: false; $type: 'string'; ... }
+ * ```
+ */
+type TypedPropertyOptional<Value> = {
+  /**
+   * The property is not required
+   */
+  $required: false;
+  /**
+   * The type(s) of the property
+   */
+  $type: ToSchemaPropertyType<Exclude<Value, undefined>>;
+  /**
+   * Custom validators for the property and its types
+   */
+  $validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
+};
+/**
+ * A typed required property definition generated by {@link TypedSchema} for required keys, with `$required` defaulting to `true`
+ *
+ * @template Value - Property's type
+ *
+ * @example
+ * ```ts
+ * // For `{ name: string }`, the `name` key produces:
+ * // TypedPropertyRequired<string>
+ * // => { $required?: true; $type: 'string'; ... }
+ * ```
+ */
+type TypedPropertyRequired<Value> = {
+  /**
+   * The property is required _(defaults to `true`)_
+   */
+  $required?: true;
+  /**
+   * The type(s) of the property
+   */
+  $type: ToSchemaPropertyType<Value>;
+  /**
+   * Custom validators for the property and its types
+   */
+  $validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
+};
+/**
+ * Creates a schema type constrained to match a TypeScript type
+ *
+ * Required keys map to {@link ToSchemaType} or {@link TypedPropertyRequired}; plain object values may also use {@link Schematic}. Optional keys map to {@link TypedPropertyOptional} or, for plain objects, {@link TypedSchemaOptional}
+ *
+ * @template Model - Object type to generate a schema for
+ *
+ * @example
+ * ```ts
+ * type User = { name: string; age: number; bio?: string };
+ *
+ * const schema: TypedSchema<User> = {
+ *   name: 'string',
+ *   age: 'number',
+ *   bio: { $required: false, $type: 'string' },
+ * };
+ * ```
+ */
+type TypedSchema<Model extends PlainObject> = Simplify<{ [Key in RequiredKeys<Model>]: Model[Key] extends PlainObject ? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]> : ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]> } & { [Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject ? TypedSchemaOptional<Exclude<Model[Key], undefined>> | Schematic<Exclude<Model[Key], undefined>> : TypedPropertyOptional<Model[Key]> }>;
+/**
+ * A {@link TypedSchema} variant for optional nested objects, with `$required` fixed to `false`
+ *
+ * @template Model - Nested object type
+ */
+type TypedSchemaOptional<Model extends PlainObject> = {
+  $required: false;
+} & TypedSchema<Model>;
+/**
+ * A {@link TypedSchema} variant for required nested objects, with `$required` defaulting to `true`
+ *
+ * @template Model - Nested object type
+ */
+type TypedSchemaRequired<Model extends PlainObject> = {
+  $required?: true;
+} & TypedSchema<Model>;
+//#endregion
+export { TypedPropertyOptional, TypedPropertyRequired, TypedSchema };

package/dist/models/schema.typed.model.mjs

@@ -0,0 +1 @@
+export {};

package/dist/models/transform.model.d.mts

@@ -0,0 +1,59 @@
+import { TypedSchema } from "./schema.typed.model.mjs";
+import { Schematic } from "../schematic.mjs";
+import { DeduplicateTuple, UnionToTuple, UnwrapSingle, Values } from "./misc.model.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/models/transform.model.d.ts
+/**
+ * Maps each element of a tuple through {@link ToValueType}
+ *
+ * @template Value - Tuple of types to map
+ */
+type MapToValueTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToValueType<Head>, ...MapToValueTypes<Tail>] : [];
+/**
+ * Maps each element of a tuple through {@link ToSchemaPropertyTypeEach}
+ *
+ * @template Value - Tuple of types to map
+ */
+type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer Head, ...infer Tail] ? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>] : [];
+/**
+ * Converts a type into its corresponding {@link SchemaPropertyType}-representation
+ *
+ * Deduplicates and unwraps single-element tuples via {@link UnwrapSingle}
+ *
+ * @template Value - type to convert
+ */
+type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
+/**
+ * Converts a single type to its schema property equivalent
+ *
+ * {@link NestedSchema} values have `$required` stripped, plain objects become {@link TypedSchema}, and primitives go through {@link ToValueType}
+ *
+ * @template Value - type to convert
+ */
+type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject ? TypedSchema<Value> : ToValueType<Value>;
+/**
+ * Converts a type into its corresponding {@link ValueName}-representation
+ *
+ * Deduplicates and unwraps single-element tuples via {@link UnwrapSingle}
+ *
+ * @template Value - type to convert
+ */
+type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
+/**
+ * Maps a type to its {@link ValueName} string equivalent
+ *
+ * Resolves {@link Schematic} types as-is, then performs a reverse-lookup against {@link Values} _(excluding `'object'`)_ to find a matching key. If no match is found, `object` types resolve to `'object'` or a type-guard function, and all other unrecognised types resolve to a type-guard function
+ *
+ * @template Value - type to map
+ *
+ * @example
+ * ```ts
+ * // ToValueType<string>    => 'string'
+ * // ToValueType<number[]>  => 'array'
+ * // ToValueType<Date>      => 'date'
+ * ```
+ */
+type ToValueType<Value> = Value extends Schematic<any> ? Value : { [Key in keyof Omit<Values, 'object'>]: Value extends Values[Key] ? Key : never }[keyof Omit<Values, 'object'>] extends infer Match ? [Match] extends [never] ? Value extends object ? 'object' | ((value: unknown) => value is Value) : (value: unknown) => value is Value : Match : never;
+//#endregion
+export { MapToSchemaPropertyTypes, MapToValueTypes, ToSchemaPropertyType, ToSchemaPropertyTypeEach, ToSchemaType, ToValueType };

package/dist/models/transform.model.mjs

@@ -0,0 +1 @@
+export {};

package/dist/models/validation.model.d.mts

@@ -0,0 +1,81 @@
+import { Schematic } from "../schematic.mjs";
+import { ValueName } from "./misc.model.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+
+//#region src/models/validation.model.d.ts
+type ReportingInformation = Record<ReportingType, boolean>;
+type ReportingType = 'all' | 'first' | 'none' | 'throw';
+/**
+ * A custom error class for schematic validation failures
+ */
+declare class SchematicError extends Error {
+  constructor(message: string);
+}
+/**
+ * The runtime representation of a parsed schema property, used internally during validation
+ *
+ * @example
+ * ```ts
+ * const parsed: ValidatedProperty = {
+ *   key: 'age',
+ *   required: true,
+ *   types: ['number'],
+ *   validators: { number: [(v) => v > 0] },
+ * };
+ * ```
+ */
+type ValidatedProperty = {
+  /**
+   * The property name in the schema
+   */
+  key: ValidatedPropertyKey;
+  /**
+   * Whether the property is required
+   */
+  required: boolean;
+  /**
+   * The allowed types for this property
+   */
+  types: ValidatedPropertyType[];
+  /**
+   * Custom validators grouped by {@link ValueName}
+   */
+  validators: ValidatedPropertyValidators;
+};
+/**
+ * Property name in schema
+ */
+type ValidatedPropertyKey = {
+  /**
+   * Full property key, including parent keys for nested properties _(e.g., `address.street`)_
+   */
+  full: string;
+  /**
+   * The last segment of the property key _(e.g., `street` for `address.street`)_
+   */
+  short: string;
+};
+/**
+ * A union of valid types for a {@link ValidatedProperty}'s `types` array
+ *
+ * Can be a callback _(custom validator)_, a {@link Schematic}, a nested {@link ValidatedProperty}, or a {@link ValueName} string
+ */
+type ValidatedPropertyType = GenericCallback | ValidatedProperty[] | Schematic<unknown> | ValueName;
+/**
+ * A map of validator functions keyed by {@link ValueName}, used at runtime in {@link ValidatedProperty}
+ *
+ * Each key holds an array of validator functions that receive an `unknown` value and return a `boolean`
+ */
+type ValidatedPropertyValidators = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
+declare class ValidationError extends Error {
+  readonly information: ValidationInformation[];
+  constructor(information: ValidationInformation[]);
+}
+type ValidationInformation = {
+  key: ValidationInformationKey;
+  message: string;
+  validator?: GenericCallback;
+};
+type ValidationInformationKey = ValidatedPropertyKey;
+//#endregion
+export { ReportingInformation, ReportingType, SchematicError, ValidatedProperty, ValidatedPropertyKey, ValidatedPropertyType, ValidatedPropertyValidators, ValidationError, ValidationInformation, ValidationInformationKey };

package/dist/models/validation.model.mjs

@@ -0,0 +1,21 @@
+import { NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION } from "../constants.mjs";
+import { join } from "@oscarpalmer/atoms/string";
+//#region src/models/validation.model.ts
+/**
+* A custom error class for schematic validation failures
+*/
+var SchematicError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = NAME_ERROR_SCHEMATIC;
+	}
+};
+var ValidationError = class extends Error {
+	constructor(information) {
+		super(join(information.map((item) => item.message), "; "));
+		this.information = information;
+		this.name = NAME_ERROR_VALIDATION;
+	}
+};
+//#endregion
+export { SchematicError, ValidationError };

package/dist/schematic.d.mts

@@ -1,4 +1,7 @@
-import { Infer, Schema, TypedSchema, ValidatedProperty } from "./models.mjs";
+import { Infer } from "./models/infer.model.mjs";
+import { TypedSchema } from "./models/schema.typed.model.mjs";
+import { ValidatedProperty } from "./models/validation.model.mjs";
+import { Schema } from "./models/schema.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 
 //#region src/schematic.d.ts
@@ -11,23 +14,34 @@ declare class Schematic<Model> {
   constructor(properties: ValidatedProperty[]);
   /**
    * Does the value match the schema?
-   * @param value - Value to validate
+   *
+   * 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 `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;
 }
 /**
  * Create a schematic from a schema
- * @template Model - Schema type
- * @param schema - Schema to create the schematic from
+ * @template Model Schema type
+ * @param schema Schema to create the schematic from
  * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
  * @returns A schematic for the given schema
  */
 declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
 /**
  * Create a schematic from a typed schema
- * @template Model - Existing type
- * @param schema - Typed schema to create the schematic from
+ * @template Model Existing type
+ * @param schema Typed schema to create the schematic from
  * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
  * @returns A schematic for the given typed schema
  */

package/dist/schematic.mjs

@@ -1,6 +1,6 @@
-import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.mjs";
-import { isSchematic } from "./helpers.mjs";
-import { SchematicError } from "./models.mjs";
+import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
+import { getReporting, isSchematic } from "./helpers.mjs";
+import { SchematicError } from "./models/validation.model.mjs";
 import { getProperties } from "./validation/property.validation.mjs";
 import { validateObject } from "./validation/value.validation.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
@@ -11,21 +11,16 @@ import { isPlainObject } from "@oscarpalmer/atoms/is";
 var Schematic = class {
 	#properties;
 	constructor(properties) {
-		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
+		Object.defineProperty(this, PROPERTY_SCHEMATIC, { value: true });
 		this.#properties = properties;
 	}
-	/**
-	* Does the value match the schema?
-	* @param value - Value to validate
-	* @returns `true` if the value matches the schema, otherwise `false`
-	*/
-	is(value) {
-		return validateObject(value, this.#properties);
+	is(value, errors) {
+		return validateObject(value, this.#properties, getReporting(errors));
 	}
 };
 function schematic(schema) {
 	if (isSchematic(schema)) return schema;
-	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
 //#endregion

package/dist/validation/property.validation.d.mts

@@ -1,4 +1,4 @@
-import { ValidatedProperty } from "../models.mjs";
+import { ValidatedProperty } from "../models/validation.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 
 //#region src/validation/property.validation.d.ts

package/dist/validation/property.validation.mjs

@@ -1,6 +1,6 @@
-import { EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.mjs";
+import { PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, 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, TYPE_ALL, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.mjs";
 import { instanceOf, isSchematic } from "../helpers.mjs";
-import { SchematicError } from "../models.mjs";
+import { SchematicError } from "../models/validation.model.mjs";
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
 import { join } from "@oscarpalmer/atoms/string";
 //#region src/validation/property.validation.ts
@@ -10,32 +10,36 @@ function getDisallowedProperty(obj) {
 	if ("$validators" in obj) return PROPERTY_VALIDATORS;
 }
 function getProperties(original, prefix, fromType) {
-	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
+	if (Object.keys(original).length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
 	if (fromType ?? false) {
 		const property = getDisallowedProperty(original);
-		if (property != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix).replace(TEMPLATE_PATTERN_PROPERTY, property));
+		if (property != null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", property));
 	}
 	const keys = Object.keys(original);
 	const keysLength = keys.length;
 	const properties = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
-		if (EXPRESSION_PROPERTY.test(key)) continue;
+		const prefixed = join([prefix, key], ".");
 		const value = original[key];
+		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", prefixed));
 		const types = [];
 		let required = true;
 		let validators = {};
 		if (isPlainObject(value)) {
 			required = getRequired(key, value) ?? required;
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
-			if ("$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));
 		if (!required && !types.includes("undefined")) types.push(TYPE_UNDEFINED);
 		properties.push({
-			key,
 			types,
 			validators,
+			key: {
+				full: prefixed,
+				short: key
+			},
 			required: required && !types.includes("undefined")
 		});
 	}
@@ -43,7 +47,7 @@ function getProperties(original, prefix, fromType) {
 }
 function getRequired(key, obj) {
 	if (!("$required" in obj)) return;
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
 	return obj[PROPERTY_REQUIRED];
 }
 function getTypes(key, original, prefix, fromType) {
@@ -57,7 +61,7 @@ function getTypes(key, original, prefix, fromType) {
 				types.push(isConstructor(value) ? instanceOf(value) : value);
 				break;
 			case isPlainObject(value):
-				types.push(...getProperties(value, join([prefix, key], "."), fromType));
+				types.push(getProperties(value, join([prefix, key], "."), fromType));
 				break;
 			case isSchematic(value):
 				types.push(value);
@@ -65,25 +69,25 @@ function getTypes(key, original, prefix, fromType) {
 			case TYPE_ALL.has(value):
 				types.push(value);
 				break;
-			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
+			default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 		}
 	}
-	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
+	if (types.length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 	return types;
 }
 function getValidators(original) {
 	const validators = {};
 	if (original == null) return validators;
-	if (!isPlainObject(original)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_TYPE);
+	if (!isPlainObject(original)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
 	const keys = Object.keys(original);
 	const { length } = keys;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		if (!VALIDATABLE_TYPES.has(key)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		if (!VALIDATABLE_TYPES.has(key)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
 		const value = original[key];
-		validators[key] = (Array.isArray(value) ? value : [value]).filter((item) => {
-			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key));
-			return true;
+		validators[key] = (Array.isArray(value) ? value : [value]).map((item) => {
+			if (typeof item !== "function") throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key));
+			return item;
 		});
 	}
 	return validators;

package/dist/validation/value.validation.d.mts

@@ -1,6 +1,6 @@
-import { ValidatedProperty } from "../models.mjs";
+import { ReportingInformation, ValidatedProperty, ValidationInformation } from "../models/validation.model.mjs";
 
 //#region src/validation/value.validation.d.ts
-declare function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean;
+declare function validateObject(obj: unknown, properties: ValidatedProperty[], reporting: ReportingInformation, validation?: ValidationInformation[]): boolean;
 //#endregion
 export { validateObject };

package/dist/validation/value.validation.mjs

@@ -1,30 +1,82 @@
-import { isSchematic } from "../helpers.mjs";
+import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, isSchematic } from "../helpers.mjs";
+import { ValidationError } from "../models/validation.model.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
 //#region src/validation/value.validation.ts
-function validateObject(obj, properties) {
-	if (!isPlainObject(obj)) return false;
+function validateNamed(property, name, value, validation) {
+	if (!validators[name](value)) return false;
+	const propertyValidators = property.validators[name];
+	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({
+				key: { ...property.key },
+				message: getInvalidValidatorMessage(property, name, index, length),
+				validator
+			});
+			return false;
+		}
+	}
+	return true;
+}
+function validateObject(obj, properties, reporting, validation) {
+	if (!isPlainObject(obj)) {
+		if (reporting.throw && validation == null) throw new ValidationError([{
+			key: {
+				full: "",
+				short: ""
+			},
+			message: getInvalidInputMessage(obj)
+		}]);
+		return false;
+	}
 	const propertiesLength = properties.length;
 	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
 		const property = properties[propertyIndex];
 		const { key, required, types } = property;
-		const value = obj[key];
-		if (value === void 0 && required) return false;
+		const value = obj[key.short];
+		if (value === void 0 && required) {
+			const information = {
+				key: { ...key },
+				message: getInvalidMissingMessage(property)
+			};
+			if (reporting.throw && validation == null) throw new ValidationError([information]);
+			if (validation != null) validation.push(information);
+			return false;
+		}
 		const typesLength = types.length;
+		const information = [];
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = types[typeIndex];
-			if (validateValue(type, property, value)) continue outer;
+			if (validateValue(type, property, value, reporting, information)) continue outer;
 		}
+		if (reporting.throw && validation == null) throw new ValidationError(information.length === 0 ? [{
+			key: { ...key },
+			message: getInvalidTypeMessage(property, value)
+		}] : information);
+		validation?.push(...information);
 		return false;
 	}
 	return true;
 }
-function validateValue(type, property, value) {
+function validateValue(type, property, value, reporting, validation) {
+	let result;
 	switch (true) {
-		case isSchematic(type): return type.is(value);
-		case typeof type === "function": return type(value);
-		case typeof type === "object": return validateObject(value, [type]);
-		default: return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
+		case typeof type === "function":
+			result = type(value);
+			break;
+		case Array.isArray(type):
+			result = validateObject(value, type, reporting, validation);
+			break;
+		case isSchematic(type):
+			result = type.is(value, reporting);
+			break;
+		default:
+			result = validateNamed(property, type, value, validation);
+			break;
 	}
+	return result;
 }
 const validators = {
 	array: Array.isArray,