@oscarpalmer/jhunal 0.16.0 → 0.18.0

package/src/models/schema.plain.model.ts

@@ -0,0 +1,110 @@
+import type {Constructor} from '@oscarpalmer/atoms/models';
+import type {Schematic} from '../schematic';
+import type {ExtractValueNames, ValueName, Values} from './misc.model';
+
+/**
+ * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
+ */
+export 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'],
+ * };
+ * ```
+ */
+export 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
+ */
+export 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}
+ */
+export 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,
+ *   },
+ * };
+ * ```
+ */
+export 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
+ */
+export 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,
+ * };
+ * ```
+ */
+export type PropertyValidators<Value> = {
+	[Key in ExtractValueNames<Value>]?:
+		| ((value: Values[Key]) => boolean)
+		| Array<(value: Values[Key]) => boolean>;
+};

package/src/models/schema.typed.model.ts

@@ -0,0 +1,109 @@
+import type {PlainObject, Simplify} from '@oscarpalmer/atoms/models';
+import type {Schematic} from '../schematic';
+import type {OptionalKeys, RequiredKeys} from './misc.model';
+import type {PropertyValidators} from './schema.plain.model';
+import type {ToSchemaPropertyType, ToSchemaType} from './transform.model';
+
+/**
+ * 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'; ... }
+ * ```
+ */
+export 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'; ... }
+ * ```
+ */
+export 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' },
+ * };
+ * ```
+ */
+export 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>;

package/src/models/transform.model.ts

@@ -0,0 +1,85 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {Schematic} from '../schematic';
+import type {DeduplicateTuple, UnionToTuple, UnwrapSingle, Values} from './misc.model';
+import type {TypedSchema} from './schema.typed.model';
+
+/**
+ * Maps each element of a tuple through {@link ToValueType}
+ *
+ * @template Value - Tuple of types to map
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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'
+ * ```
+ */
+export 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;

package/src/models/validation.model.ts

@@ -0,0 +1,123 @@
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
+import {join} from '@oscarpalmer/atoms/string';
+import {NAME_ERROR_SCHEMATIC, NAME_ERROR_VALIDATION} from '../constants';
+import type {Schematic} from '../schematic';
+import type {ValueName} from './misc.model';
+
+// #region Reporting
+
+export type ReportingInformation = Record<ReportingType, boolean>;
+
+export type ReportingType = 'all' | 'first' | 'none' | 'throw';
+
+// #endregion
+
+// #region Schematic validation
+
+/**
+ * A custom error class for schematic validation failures
+ */
+export class SchematicError extends Error {
+	constructor(message: string) {
+		super(message);
+
+		this.name = NAME_ERROR_SCHEMATIC;
+	}
+}
+
+// #endregion
+
+// #region Validated property
+
+/**
+ * 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] },
+ * };
+ * ```
+ */
+export 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
+ */
+export 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
+ */
+export 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`
+ */
+export type ValidatedPropertyValidators = {
+	[Key in ValueName]?: Array<(value: unknown) => boolean>;
+};
+
+// #endregion
+
+// #region Property validation
+
+export class ValidationError extends Error {
+	constructor(readonly information: ValidationInformation[]) {
+		super(
+			join(
+				information.map(item => item.message),
+				'; ',
+			),
+		);
+
+		this.name = NAME_ERROR_VALIDATION;
+	}
+}
+
+export type ValidationInformation = {
+	key: ValidationInformationKey;
+	message: string;
+	validator?: GenericCallback;
+};
+
+export type ValidationInformationKey = ValidatedPropertyKey;
+
+// #endregion

package/src/schematic.ts

@@ -1,14 +1,11 @@
 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 {
-	SchematicError,
-	type Infer,
-	type Schema,
-	type TypedSchema,
-	type ValidatedProperty,
-} from './models';
+import {SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE, PROPERTY_SCHEMATIC} 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 ValidatedProperty} from './models/validation.model';
 import {getProperties} from './validation/property.validation';
 import {validateObject} from './validation/value.validation';
 
@@ -21,7 +18,7 @@ export class Schematic<Model> {
 	#properties: ValidatedProperty[];
 
 	constructor(properties: ValidatedProperty[]) {
-		Object.defineProperty(this, SCHEMATIC_NAME, {
+		Object.defineProperty(this, PROPERTY_SCHEMATIC, {
 			value: true,
 		});
 
@@ -30,18 +27,32 @@ export class Schematic<Model> {
 
 	/**
 	 * 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 {
-		return validateObject(value, this.#properties);
+	is(value: unknown): value is Model;
+
+	is(value: unknown, errors?: unknown): boolean {
+		return validateObject(value, this.#properties, getReporting(errors));
 	}
 }
 
 /**
  * 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
  */
@@ -49,8 +60,8 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Infer<
 
 /**
  * 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
  */
@@ -62,7 +73,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 {
-	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,
+	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,12 +72,15 @@ export function getProperties(
 	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(TEMPLATE_PATTERN, prefixed),
+			);
+		}
+
 		const types: ValidatedPropertyType[] = [];
 
 		let required = true;
@@ -89,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));
 		}
@@ -103,9 +102,12 @@ export function getProperties(
 		}
 
 		properties.push({
-			key,
 			types,
 			validators,
+			key: {
+				full: prefixed,
+				short: key,
+			},
 			required: required && !types.includes(TYPE_UNDEFINED),
 		});
 	}
@@ -120,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),
 		);
 	}
 
@@ -147,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):
@@ -160,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], '.'),
+			),
 		);
 	}
 
@@ -182,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);
@@ -192,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;
 		});
 	}