@oscarpalmer/jhunal 0.21.0 → 0.23.0

package/src/schematic.ts

@@ -3,18 +3,18 @@ import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {error, ok} from '@oscarpalmer/atoms/result/misc';
 import type {Result} from '@oscarpalmer/atoms/result/models';
 import {PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE} from './constants';
-import {getParameters, isSchematic} from './helpers';
+import {getParameters, isSchematic} from './helpers/misc.helper';
 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,
+	type GetOptions,
+	type IsOptions,
 	type ValidationInformation,
-	type ValidationOptions,
+	type Validator,
 } from './models/validation.model';
-import {getProperties} from './validation/property.validation';
-import {validateObject} from './validation/value.validation';
+import {getObjectValidator} from './validator/object.validator';
 
 /**
  * A schematic for validating objects
@@ -22,16 +22,16 @@ import {validateObject} from './validation/value.validation';
 export class Schematic<Model> {
 	declare private readonly $schematic: true;
 
-	#properties: ValidatedProperty[];
+	#validator: Validator;
 
-	constructor(properties: ValidatedProperty[]) {
+	constructor(validator: Validator) {
 		Object.defineProperty(this, PROPERTY_SCHEMATIC, {
 			value: true,
 		});
 
-		this.#properties = properties;
+		this.#validator = validator;
 
-		schematicProperties.set(this, properties);
+		schematicValidator.set(this, validator);
 	}
 
 	/**
@@ -42,7 +42,7 @@ export class Schematic<Model> {
 	 * @param options Validation options
 	 * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
 	 */
-	get(value: unknown, options: ValidationOptions<'throw'>): Model;
+	get(value: unknown, options: GetOptions<'throw'>): Model;
 
 	/**
 	 * Parse a value according to the schema
@@ -62,7 +62,7 @@ export class Schematic<Model> {
 	 * @param options Validation options
 	 * @returns Result holding deeply cloned value or all validation information
 	 */
-	get(value: unknown, options: ValidationOptions<'all'>): Result<Model, ValidationInformation[]>;
+	get(value: unknown, options: GetOptions<'all'>): Result<Model, ValidationInformation[]>;
 
 	/**
 	 * Parse a value according to the schema
@@ -82,7 +82,7 @@ export class Schematic<Model> {
 	 * @param options Validation options
 	 * @returns Result holding deeply cloned value or all validation information
 	 */
-	get(value: unknown, options: ValidationOptions<'first'>): Result<Model, ValidationInformation>;
+	get(value: unknown, options: GetOptions<'first'>): Result<Model, ValidationInformation>;
 
 	/**
 	 * Parse a value according to the schema
@@ -94,6 +94,16 @@ export class Schematic<Model> {
 	 */
 	get(value: unknown, errors: 'first'): Result<Model, ValidationInformation>;
 
+	/**
+	 * Parse a value according to the schema
+	 *
+	 * Returns a deeply cloned version of the value or `undefined` if the value does not match the schema
+	 * @param value Value to parse
+	 * @param options Validation options
+	 * @returns Deeply cloned value, or `undefined` if it's invalid
+	 */
+	get(value: unknown, options: GetOptions<'none'>): Model | undefined;
+
 	/**
 	 * Parse a value according to the schema
 	 *
@@ -107,14 +117,16 @@ export class Schematic<Model> {
 	get(value: unknown, options?: unknown): unknown {
 		const parameters = getParameters(options);
 
-		const result = validateObject(value, this.#properties, parameters, true);
+		const result = this.#validator(value, parameters, true);
 
-		if (result == null) {
-			return;
+		if (result === true) {
+			return parameters.reporting.none || parameters.reporting.throw
+				? parameters.output
+				: ok(parameters.output);
 		}
 
-		if (!Array.isArray(result)) {
-			return parameters.reporting.none ? result : ok(result);
+		if (parameters.reporting.none) {
+			return;
 		}
 
 		return error(parameters.reporting.all ? result : result[0]);
@@ -128,7 +140,7 @@ export class Schematic<Model> {
 	 * @param options Validation options
 	 * @returns `true` if the value matches the schema, otherwise throws an error
 	 */
-	is(value: unknown, options: ValidationOptions<'throw'>): asserts value is Model;
+	is(value: unknown, options: IsOptions<'throw'>): asserts value is Model;
 
 	/**
 	 * Does the value match the schema?
@@ -148,7 +160,7 @@ export class Schematic<Model> {
 	 * @param options Validation options
 	 * @returns Result holding `true` or all validation information
 	 */
-	is(value: unknown, options: ValidationOptions<'all'>): Result<true, ValidationInformation[]>;
+	is(value: unknown, options: IsOptions<'all'>): Result<true, ValidationInformation[]>;
 
 	/**
 	 * Does the value match the schema?
@@ -168,7 +180,7 @@ export class Schematic<Model> {
 	 * @param options Validation options
 	 * @returns `true` if the value matches the schema, otherwise `false`
 	 */
-	is(value: unknown, options: ValidationOptions<'first'>): Result<true, ValidationInformation>;
+	is(value: unknown, options: IsOptions<'first'>): Result<true, ValidationInformation>;
 
 	/**
 	 * Does the value match the schema?
@@ -180,6 +192,16 @@ export class Schematic<Model> {
 	 */
 	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
+	 * @param options Validation options
+	 * @returns `true` if the value matches the schema, otherwise `false`
+	 */
+	is(value: unknown, options: IsOptions<'none'>): value is Model;
+
 	/**
 	 * Does the value match the schema?
 	 *
@@ -193,14 +215,14 @@ export class Schematic<Model> {
 	is(value: unknown, options?: unknown): unknown {
 		const parameters = getParameters(options);
 
-		const result = validateObject(value, this.#properties, parameters, false);
+		const result = this.#validator(value, parameters, false);
 
-		if (result == null) {
-			return false;
+		if (result === true) {
+			return parameters.reporting.none || parameters.reporting.throw ? result : ok(result);
 		}
 
-		if (!Array.isArray(result)) {
-			return parameters.reporting.none ? true : ok(true);
+		if (parameters.reporting.none) {
+			return false;
 		}
 
 		return error(parameters.reporting.all ? result : result[0]);
@@ -234,7 +256,7 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Model>
 		throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
 	}
 
-	return new Schematic<Model>(getProperties(schema));
+	return new Schematic<Model>(getObjectValidator(schema));
 }
 
-export const schematicProperties = new WeakMap<Schematic<unknown>, ValidatedProperty[]>();
+export const schematicValidator = new WeakMap<Schematic<unknown>, Validator>();

package/src/validator/base.validator.ts

@@ -0,0 +1,31 @@
+import type {ValidationInformation, Validator} from '../models/validation.model';
+
+export function getBaseValidator(validators: Validator[]): Validator {
+	const {length} = validators;
+
+	return (input, parameters, get) => {
+		const allInformation: ValidationInformation[] = [];
+
+		for (let index = 0; index < length; index += 1) {
+			const previousInformation = parameters.information;
+
+			const nextInformation: ValidationInformation[] = [];
+
+			parameters.information = nextInformation;
+
+			const result = validators[index](input, parameters, get);
+
+			parameters.information = previousInformation;
+
+			if (result === true) {
+				return true;
+			}
+
+			parameters.information?.push(...result);
+
+			allInformation.push(...result);
+		}
+
+		return allInformation;
+	};
+}

package/src/validator/function.validator.ts

@@ -0,0 +1,9 @@
+import {isConstructor} from '@oscarpalmer/atoms/is';
+import {instanceOf} from '../helpers/misc.helper';
+import type {Validator} from '../models/validation.model';
+
+export function getFunctionValidator(fn: Function): Validator {
+	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
+
+	return input => (validator(input) ? true : []);
+}

package/src/validator/named.handler.ts

@@ -0,0 +1,50 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE,
+	TEMPLATE_PATTERN,
+	TYPE_ALL,
+} from '../constants';
+import type {ValueName} from '../models/misc.model';
+import type {NamedValidatorHandlers} from '../models/validation.model';
+
+export function getNamedHandlers(original: unknown, prefix: string): NamedValidatorHandlers {
+	const handlers: NamedValidatorHandlers = {};
+
+	if (original == null) {
+		return handlers;
+	}
+
+	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 (!TYPE_ALL.has(key as never)) {
+			throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+		}
+
+		const value = original[key];
+
+		handlers[key as ValueName] = (Array.isArray(value) ? value : [value]).map(item => {
+			if (typeof item !== 'function') {
+				throw new TypeError(
+					SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key).replace(
+						TEMPLATE_PATTERN,
+						prefix,
+					),
+				);
+			}
+
+			return item;
+		});
+	}
+
+	return handlers;
+}

package/src/validator/named.validator.ts

@@ -0,0 +1,62 @@
+import {TYPE_OBJECT} from '../constants';
+import {getInvalidValidatorMessage} from '../helpers/message.helper';
+import type {ValueName} from '../models/misc.model';
+import type {
+	NamedValidatorHandlers,
+	NamedValidators,
+	ValidationInformation,
+	ValidationInformationKey,
+	Validator,
+} from '../models/validation.model';
+
+export function getNamedValidator(
+	key: ValidationInformationKey,
+	name: ValueName,
+	handlers: NamedValidatorHandlers,
+): Validator {
+	const validator = namedValidators[name];
+
+	const named = handlers[name] ?? [];
+	const {length} = named;
+
+	return (input, parameters) => {
+		if (!validator(input)) {
+			return [];
+		}
+
+		for (let index = 0; index < length; index += 1) {
+			const handler = named[index];
+
+			if (handler(input) === true) {
+				continue;
+			}
+
+			const information: ValidationInformation = {
+				key,
+				validator,
+				message: getInvalidValidatorMessage(key.full, name, index, length),
+				value: input,
+			};
+
+			parameters.information?.push(information);
+
+			return parameters.reporting.none ? [] : [information];
+		}
+
+		return true;
+	};
+}
+
+const namedValidators: NamedValidators = {
+	array: Array.isArray,
+	bigint: value => typeof value === 'bigint',
+	boolean: value => typeof value === 'boolean',
+	date: value => value instanceof Date,
+	function: value => typeof value === 'function',
+	null: value => value === null,
+	number: value => typeof value === 'number',
+	object: value => typeof value === TYPE_OBJECT && value !== null,
+	string: value => typeof value === 'string',
+	symbol: value => typeof value === 'symbol',
+	undefined: value => value === undefined,
+};

package/src/validator/object.validator.ts

@@ -0,0 +1,340 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {join} from '@oscarpalmer/atoms/string';
+import {clone} from '@oscarpalmer/atoms/value/clone';
+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,
+	TEMPLATE_PATTERN,
+	TYPE_ALL,
+	TYPE_UNDEFINED,
+} from '../constants';
+import {
+	getInvalidInputMessage,
+	getInvalidMissingMessage,
+	getInvalidTypeMessage,
+	getUnknownKeysMessage,
+} from '../helpers/message.helper';
+import {isSchematic} from '../helpers/misc.helper';
+import type {ValueName} from '../models/misc.model';
+import {
+	type NamedValidatorHandlers,
+	SchematicError,
+	ValidationError,
+	type ValidationInformation,
+	type ValidationInformationKey,
+	type Validator,
+	type ValidatorType,
+} from '../models/validation.model';
+import {getBaseValidator} from './base.validator';
+import {getFunctionValidator} from './function.validator';
+import {getNamedHandlers} from './named.handler';
+import {getNamedValidator} from './named.validator';
+import {getSchematicValidator} from './schematic.validator';
+
+function getDisallowedProperty(obj: PlainObject): string | undefined {
+	if (PROPERTY_REQUIRED in obj) {
+		return PROPERTY_REQUIRED;
+	}
+
+	if (PROPERTY_TYPE in obj) {
+		return PROPERTY_TYPE;
+	}
+
+	if (PROPERTY_VALIDATORS in obj) {
+		return PROPERTY_VALIDATORS;
+	}
+}
+
+export function getObjectValidator(
+	original: PlainObject,
+	origin?: ValidationInformationKey,
+	fromType?: boolean,
+): Validator {
+	const keys = Object.keys(original);
+	const keysLength = keys.length;
+
+	if (keysLength === 0) {
+		throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
+	}
+
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+
+		if (property != null) {
+			throw new SchematicError(
+				SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(
+					TEMPLATE_PATTERN,
+					origin!.full,
+				).replace(TEMPLATE_PATTERN, property),
+			);
+		}
+	}
+
+	const set = new Set<string>();
+
+	const items: {
+		key: ValidationInformationKey;
+		required: boolean;
+		types: ValidatorType[];
+		validator: Validator;
+	}[] = [];
+
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+		const value = original[key];
+
+		if (value == null) {
+			throw new SchematicError(
+				SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace(
+					TEMPLATE_PATTERN,
+					join([origin?.full, key], '.'),
+				),
+			);
+		}
+
+		const prefixedKey = origin == null ? key : join([origin.full, key], '.');
+
+		const fullKey: ValidationInformationKey = {
+			full: prefixedKey,
+			short: key,
+		};
+
+		let handlers: NamedValidatorHandlers = {};
+		let required = true;
+		let typed = false;
+		let types: ValidatorType[];
+
+		const validators: Validator[] = [];
+
+		if (isPlainObject(value)) {
+			typed = PROPERTY_TYPE in value;
+
+			const type = typed ? value[PROPERTY_TYPE] : value;
+
+			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey);
+			required = getRequired(key, value) ?? required;
+
+			types = Array.isArray(type) ? type : [type];
+		} else {
+			types = Array.isArray(value) ? value : [value];
+		}
+
+		if (types.length === 0) {
+			throw new SchematicError(
+				SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(
+					TEMPLATE_PATTERN,
+					prefixedKey,
+				).replace(TEMPLATE_PATTERN, String(value)),
+			);
+		}
+
+		const typesLength = types.length;
+
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			const type = types[typeIndex];
+
+			let validator: Validator;
+
+			switch (true) {
+				case typeof type === 'function':
+					validator = getFunctionValidator(type);
+					break;
+
+				case isPlainObject(type):
+					validator = getObjectValidator(type, fullKey, typed);
+					break;
+
+				case isSchematic(type):
+					validator = getSchematicValidator(type);
+					break;
+
+				case TYPE_ALL.has(type as ValueName):
+					validator = getNamedValidator(fullKey, type as ValueName, handlers);
+					break;
+
+				default:
+					throw new SchematicError(
+						SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(
+							TEMPLATE_PATTERN,
+							prefixedKey,
+						).replace(TEMPLATE_PATTERN, String(type)),
+					);
+			}
+
+			validators.push(validator);
+		}
+
+		set.add(key);
+
+		items.push({
+			types,
+			key: fullKey,
+			required: required && !types.includes(TYPE_UNDEFINED),
+			validator: getBaseValidator(validators),
+		});
+	}
+
+	const validatorsLength = items.length;
+
+	return (input, parameters, get) => {
+		if (!isPlainObject(input)) {
+			if (origin != null) {
+				return [];
+			}
+
+			const information: ValidationInformation = {
+				key: {
+					full: '',
+					short: '',
+				},
+				value: input,
+				message: getInvalidInputMessage(input),
+			};
+
+			if (parameters.reporting.throw) {
+				throw new ValidationError([information]);
+			}
+
+			parameters.information?.push(information);
+
+			return [information];
+		}
+
+		if (parameters.strict) {
+			const inputKeys = Object.keys(input);
+			const unknownKeys = inputKeys.filter(key => !set.has(key));
+
+			if (unknownKeys.length > 0) {
+				const information: ValidationInformation = {
+					key: origin ?? {
+						full: '',
+						short: '',
+					},
+					message: getUnknownKeysMessage(unknownKeys),
+					value: input,
+				};
+
+				if (parameters.reporting.throw) {
+					throw new ValidationError([information]);
+				}
+
+				parameters.information?.push(information);
+
+				return [information];
+			}
+		}
+
+		const allInformation: ValidationInformation[] = [];
+		const output: PlainObject = {};
+
+		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
+			const {key, required, types, validator} = items[validatorIndex];
+
+			const value = (input as PlainObject)[key.short];
+
+			if (value === undefined) {
+				if (required) {
+					if (parameters.reporting.none) {
+						return [];
+					}
+
+					const information: ValidationInformation = {
+						key,
+						value,
+						message: getInvalidMissingMessage(key.full, types),
+					};
+
+					if (parameters.reporting.throw) {
+						throw new ValidationError([information]);
+					}
+
+					parameters.information?.push(information);
+
+					if (parameters.reporting.all) {
+						allInformation.push(information);
+
+						continue;
+					}
+
+					return [information];
+				}
+
+				continue;
+			}
+
+			const previousOutput = parameters.output;
+
+			parameters.output = output;
+
+			const result = validator(value, parameters, get);
+
+			parameters.output = previousOutput;
+
+			if (result === true) {
+				if (get && !isPlainObject(value)) {
+					output[key.short] = parameters.clone ? clone(value) : value;
+				}
+
+				continue;
+			}
+
+			if (parameters.reporting.none) {
+				return [];
+			}
+
+			const information: ValidationInformation[] =
+				typeof result !== 'boolean' && result.length > 0
+					? result
+					: [
+							{
+								key,
+								value,
+								message: getInvalidTypeMessage(key.full, types, value),
+							},
+						];
+
+			if (parameters.reporting.throw) {
+				throw new ValidationError(information);
+			}
+
+			if (parameters.reporting.all) {
+				allInformation.push(...information);
+
+				continue;
+			}
+
+			return information;
+		}
+
+		if (get) {
+			if (origin == null) {
+				parameters.output = output;
+			} else {
+				parameters.output[origin.short] = output;
+			}
+		}
+
+		return allInformation.length === 0 ? true : allInformation;
+	};
+}
+
+function getRequired(key: string, obj: PlainObject): boolean | undefined {
+	if (!(PROPERTY_REQUIRED in obj)) {
+		return;
+	}
+
+	if (typeof obj[PROPERTY_REQUIRED] !== 'boolean') {
+		throw new SchematicError(
+			SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
+		);
+	}
+
+	return obj[PROPERTY_REQUIRED];
+}

package/src/validator/schematic.validator.ts

@@ -0,0 +1,25 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import type {Validator} from '../models/validation.model';
+import {Schematic, schematicValidator} from '../schematic';
+
+export function getSchematicValidator(schematic: Schematic<unknown>): Validator {
+	const validator = schematicValidator.get(schematic)!;
+
+	return (input, parameters, get) => {
+		let result: ReturnType<Validator>;
+
+		if (isPlainObject(input)) {
+			result = validator(input, parameters, get);
+		} else {
+			result = [];
+		}
+
+		if (result === true) {
+			return result;
+		}
+
+		parameters.information?.push(...result);
+
+		return result;
+	};
+}