@oscarpalmer/jhunal 0.26.0 → 0.27.0

package/dist/validator.mjs

@@ -0,0 +1,25 @@
+import { PROPERTY_VALIDATOR } from "./constants.mjs";
+import { getValidatorHandler } from "./handler/validator.handler.mjs";
+import { isResult } from "./helpers/result.helper.mjs";
+//#region src/validator.ts
+var Validator = class {
+	#handler;
+	constructor(handler, types) {
+		Object.defineProperty(this, PROPERTY_VALIDATOR, { value: true });
+		this.#handler = handler;
+		validatorHandlers.set(this, handler);
+		validatorTypes.set(this, types);
+	}
+	is(value, options) {
+		return isResult(this.#handler, value, options);
+	}
+};
+function validator(value, validators) {
+	if (value instanceof Validator) return value;
+	const { handler, types } = getValidatorHandler(value, validators);
+	return new Validator(handler, types);
+}
+const validatorHandlers = /* @__PURE__ */ new WeakMap();
+const validatorTypes = /* @__PURE__ */ new WeakMap();
+//#endregion
+export { Validator, validator, validatorHandlers, validatorTypes };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/jhunal",
-	"version": "0.26.0",
+	"version": "0.27.0",
 	"description": "Flies free beneath the glistening moons…",
 	"keywords": [
 		"schema",
@@ -41,7 +41,7 @@
 		"@oscarpalmer/atoms": "^0.170"
 	},
 	"devDependencies": {
-		"@types/node": "^25.5",
+		"@types/node": "^25.6",
 		"@vitest/coverage-istanbul": "^4.1",
 		"jsdom": "^29.0",
 		"tsdown": "^0.21",

package/src/constants.ts

@@ -1,4 +1,4 @@
-import type {ValueName} from './models/misc.model';
+import type {ValueType} from './models/misc.model';
 import type {ReportingType} from './models/validation.model';
 
 // #region Grammar
@@ -31,6 +31,8 @@ export const NAME_ERROR_SCHEMATIC = 'SchematicError';
 
 export const NAME_ERROR_VALIDATION = 'ValidationError';
 
+export const NAME_ERROR_VALIDATOR = 'ValidatorError';
+
 // #endregion
 
 // #region Properties
@@ -43,22 +45,29 @@ export const PROPERTY_SCHEMA = '$schema';
 
 export const PROPERTY_TYPE = '$type';
 
+export const PROPERTY_VALIDATOR = '$validator';
+
 export const PROPERTY_VALIDATORS = '$validators';
 
 // #endregion
 
-// #region Property validation
+// #region Value validation
 
 export const VALIDATION_MESSAGE_INVALID_INPUT = 'Expected an object as input but received <>';
 
 export const VALIDATION_MESSAGE_INVALID_REQUIRED = "Expected <> for required property '<>'";
 
-export const VALIDATION_MESSAGE_INVALID_TYPE = "Expected <> for '<>' but received <>";
+export const VALIDATION_MESSAGE_INVALID_PROPERTY_TYPE = "Expected <> for '<>' but received <>";
 
-export const VALIDATION_MESSAGE_INVALID_VALUE =
+export const VALIDATION_MESSAGE_INVALID_PROPERTY_VALIDATOR =
 	"Value does not satisfy validator for '<>' and type '<>'";
 
-export const VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX = ' at index <>';
+export const VALIDATION_MESSAGE_INVALID_VALIDATOR_SUFFIX = ' at index <>';
+
+export const VALIDATION_MESSAGE_INVALID_VALUE_TYPE = 'Expected <> but received <>';
+
+export const VALIDATION_MESSAGE_INVALID_VALUE_VALIDATOR =
+	"Value does not satisfy validator for type '<>'";
 
 export const VALIDATION_MESSAGE_UNKNOWN_KEYS = 'Found keys that are not defined in the schema: <>';
 
@@ -72,12 +81,15 @@ export const REPORTING_FIRST: ReportingType = 'first';
 
 export const REPORTING_NONE: ReportingType = 'none';
 
+export const REPORTING_RESULT: ReportingType = 'result';
+
 export const REPORTING_THROW: ReportingType = 'throw';
 
 export const REPORTING_TYPES = new Set<ReportingType>([
 	REPORTING_ALL,
 	REPORTING_FIRST,
 	REPORTING_NONE,
+	REPORTING_RESULT,
 	REPORTING_THROW,
 ]);
 
@@ -136,7 +148,7 @@ export const TYPE_OBJECT = 'object';
 
 export const TYPE_UNDEFINED = 'undefined';
 
-export const VALIDATABLE_TYPES = new Set<ValueName>([
+export const VALIDATABLE_TYPES = new Set<ValueType>([
 	TYPE_ARRAY,
 	'bigint',
 	'boolean',
@@ -148,9 +160,9 @@ export const VALIDATABLE_TYPES = new Set<ValueName>([
 	'symbol',
 ]);
 
-export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, TYPE_NULL, TYPE_UNDEFINED]);
+export const TYPES_ALL = new Set<ValueType>([...VALIDATABLE_TYPES, TYPE_NULL, TYPE_UNDEFINED]);
 
-export const PREFIXED_TYPES: Record<ValueName, string> = {
+export const TYPES_PREFIXED: Record<ValueType, string> = {
 	[TYPE_ARRAY]: `an ${TYPE_ARRAY}`,
 	bigint: `a bigint`,
 	boolean: `a boolean`,
@@ -165,3 +177,13 @@ export const PREFIXED_TYPES: Record<ValueName, string> = {
 };
 
 // #endregion
+
+// #region Validator validation
+
+export const VALIDATOR_MESSAGE_INVALID_PROPERTY_NULLABLE =
+	"Validator must not be 'null' or 'undefined'";
+
+export const VALIDATOR_MESSAGE_INVALID_PROPERTY_TYPE = 'Validator must be of a valid type';
+
+export const VALIDATOR_MESSAGE_INVALID_VALIDATOR =
+	'Validator must be a function or an array of functions';

package/src/{validator/base.validator.ts → handler/base.handler.ts}

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

package/src/handler/function.handler.ts

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

package/src/handler/object.handler.ts

@@ -0,0 +1,245 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {clone} from '@oscarpalmer/atoms/value/clone';
+import {
+	PROPERTY_DEFAULT,
+	PROPERTY_REQUIRED,
+	PROPERTY_TYPE,
+	PROPERTY_VALIDATORS,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY,
+} from '../constants';
+import {
+	getDisallowedMessage,
+	getInputPropertyMissingMessage,
+	getInputPropertyTypeMessage,
+	getInputTypeMessage,
+	getUnknownKeysMessage,
+} from '../helpers/message.helper';
+import {report} from '../helpers/report.helper';
+import {
+	SchematicError,
+	ValidationError,
+	type PropertyValidation,
+	type PropertyValidationKey,
+	type ValidationHandler,
+	type ValidationHandlerItem,
+} from '../models/validation.model';
+import {getValueHandler} from './value.handler';
+
+function getDisallowedProperty(obj: PlainObject): string | undefined {
+	if (PROPERTY_DEFAULT in obj) {
+		return PROPERTY_DEFAULT;
+	}
+
+	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 getObjectHandler(
+	original: PlainObject,
+	origin?: PropertyValidationKey,
+	fromType?: boolean,
+): ValidationHandler {
+	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(getDisallowedMessage(origin!.full, property));
+		}
+	}
+
+	const set = new Set<string>();
+
+	const items: ValidationHandlerItem[] = [];
+
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+
+		const {
+			defaults,
+			handler,
+			key: fullKey,
+			required,
+			types,
+		} = getValueHandler(
+			{
+				value: original[key],
+			},
+			{
+				key,
+				origin,
+			},
+		);
+
+		items.push({
+			defaults,
+			handler,
+			required,
+			types,
+			key: fullKey,
+		});
+
+		set.add(key);
+	}
+
+	const validatorsLength = items.length;
+
+	return (input, parameters, get) => {
+		if (!isPlainObject(input)) {
+			return origin == null
+				? report(
+						{
+							message: {
+								arguments: [input],
+								callback: getInputTypeMessage,
+							},
+							original: parameters,
+							value: input,
+						},
+						true,
+					)
+				: [];
+		}
+
+		if (parameters.strict) {
+			const inputKeys = Object.keys(input);
+			const unknownKeys = inputKeys.filter(key => !set.has(key));
+
+			if (unknownKeys.length > 0) {
+				const information: PropertyValidation = {
+					key: origin,
+					message: getUnknownKeysMessage(unknownKeys),
+					value: input,
+				};
+
+				if (parameters.reporting.throw) {
+					throw new ValidationError([information]);
+				}
+
+				parameters.information?.push(information);
+
+				return [information];
+			}
+		}
+
+		const getAndClone = get && parameters.clone;
+
+		const allInformation: PropertyValidation[] = [];
+		const output: PlainObject = {};
+
+		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
+			const {defaults, handler, key, required, types} = items[validatorIndex];
+
+			const value = (input as PlainObject)[key.short];
+
+			if (value === undefined) {
+				if (required) {
+					if (get && defaults != null) {
+						const defaultValue = clone(defaults.value);
+
+						if (parameters.clone) {
+							output[key.short] = defaultValue;
+						} else {
+							input[key.short] = defaultValue;
+						}
+
+						continue;
+					}
+
+					if (parameters.reporting.none) {
+						return [];
+					}
+
+					const reported = report({
+						key,
+						value,
+						information: {
+							all: allInformation,
+						},
+						message: {
+							arguments: [key.full, types],
+							callback: getInputPropertyMissingMessage,
+						},
+						original: parameters,
+					});
+
+					if (reported == null) {
+						continue;
+					}
+
+					return reported;
+				}
+
+				continue;
+			}
+
+			const previousOutput = parameters.output;
+
+			parameters.key = key.full;
+			parameters.output = output;
+
+			const result = handler(value, parameters, get);
+
+			parameters.output = previousOutput;
+
+			if (result === true) {
+				if (getAndClone && !isPlainObject(value)) {
+					output[key.short] = clone(value);
+				}
+
+				continue;
+			}
+
+			if (parameters.reporting.none) {
+				return [];
+			}
+
+			const reported = report({
+				key,
+				value,
+				extract: false,
+				information: {
+					all: allInformation,
+					existing: typeof result !== 'boolean' && result.length > 0 ? result : undefined,
+				},
+				message: {
+					arguments: [key.full, types, value],
+					callback: getInputPropertyTypeMessage,
+				},
+				original: parameters,
+			});
+
+			if (reported == null) {
+				continue;
+			}
+
+			return reported;
+		}
+
+		if (getAndClone) {
+			if (origin == null) {
+				parameters.output = output;
+			} else {
+				parameters.output[origin.short] = output;
+			}
+		}
+
+		return allInformation.length === 0 ? true : allInformation;
+	};
+}

package/src/handler/schema.handler.ts

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

package/src/handler/type.handler.ts

@@ -0,0 +1,160 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {
+	PROPERTY_VALIDATORS,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE,
+	SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE,
+	TEMPLATE_PATTERN,
+	TYPES_ALL,
+	VALIDATOR_MESSAGE_INVALID_VALIDATOR,
+} from '../constants';
+import {
+	getInputPropertyValidatorMessage,
+	getInputValueValidatorMessage,
+} from '../helpers/message.helper';
+import type {ValueType} from '../models/misc.model';
+import {
+	type PropertyValidation,
+	type PropertyValidationKey,
+	type TypeValidators,
+	type ValidationHandler,
+	type ValidationHandlerType,
+	type Validators,
+	SchematicError,
+	ValidatorError,
+} from '../models/validation.model';
+
+export function getTypeHandler(
+	type: ValueType,
+	validators: Validators,
+	key?: PropertyValidationKey,
+): ValidationHandler {
+	const validator = typeValidators[type];
+
+	const typedValidators = validators[type] ?? [];
+	const {length} = typedValidators;
+
+	return (input, parameters) => {
+		if (!validator(input)) {
+			return [];
+		}
+
+		for (let index = 0; index < length; index += 1) {
+			const validator = typedValidators[index];
+
+			if (validator(input) === true) {
+				continue;
+			}
+
+			const information: PropertyValidation = {
+				validator,
+				message:
+					key == null
+						? getInputValueValidatorMessage(type, index, length)
+						: getInputPropertyValidatorMessage(key.full, type, index, length),
+				value: input,
+			};
+
+			if (key != null) {
+				information.key = key;
+			}
+
+			parameters.information?.push(information);
+
+			return parameters.reporting.none ? [] : [information];
+		}
+
+		return true;
+	};
+}
+
+export function getTypeValidators(types: ValidationHandlerType[], original: unknown): Validators {
+	const values = types.filter(type => TYPES_ALL.has(type as ValueType)) as ValueType[];
+	const {length} = values;
+
+	const validators: Validators = {};
+
+	if (original == null || length === 0) {
+		return validators;
+	}
+
+	if (typeof original === 'function' || Array.isArray(original)) {
+		if (length > 1) {
+			throw new ValidatorError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
+		}
+
+		return getValidators({[values[0]]: original}, true);
+	}
+
+	return getValidators(original, true);
+}
+
+export function getValidators(original: unknown, allowed: boolean, prefix?: string): Validators {
+	const validators: Validators = {};
+
+	if (original == null) {
+		return validators;
+	}
+
+	if (!allowed) {
+		throw new SchematicError(
+			SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(
+				TEMPLATE_PATTERN,
+				prefix!,
+			).replace(TEMPLATE_PATTERN, PROPERTY_VALIDATORS),
+		);
+	}
+
+	if (!isPlainObject(original)) {
+		throw new SchematicError(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 (!TYPES_ALL.has(key as never)) {
+			throw new SchematicError(
+				SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key),
+			);
+		}
+
+		const value = original[key];
+
+		validators[key as ValueType] = (Array.isArray(value) ? value : [value]).map(item => {
+			if (typeof item !== 'function') {
+				if (prefix == null) {
+					throw new ValidatorError(VALIDATOR_MESSAGE_INVALID_VALIDATOR);
+				} else {
+					throw new SchematicError(
+						SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key).replace(
+							TEMPLATE_PATTERN,
+							prefix,
+						),
+					);
+				}
+			}
+
+			return item;
+		});
+	}
+
+	return validators;
+}
+
+const typeValidators: TypeValidators = {
+	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 === 'object' && value !== null,
+	string: value => typeof value === 'string',
+	symbol: value => typeof value === 'symbol',
+	undefined: value => value === undefined,
+};

package/src/handler/validator.handler.ts

@@ -0,0 +1,49 @@
+import {getInputValueTypeMessage} from '../helpers/message.helper';
+import {report} from '../helpers/report.helper';
+import type {ValidationHandler, ValidationHandlerType} from '../models/validation.model';
+import {getValueHandler} from './value.handler';
+
+type ValidatorHandler = {
+	handler: ValidationHandler;
+	types: ValidationHandlerType[];
+};
+
+export function getValidatorHandler(value: unknown, validators?: unknown): ValidatorHandler {
+	const {handler, types} = getValueHandler({
+		validators,
+		value,
+	});
+
+	const validator: ValidationHandler = (input, parameters, get) => {
+		const result = handler(input, parameters, get);
+
+		if (result === true) {
+			return true;
+		}
+
+		if (parameters.key != null) {
+			return [];
+		}
+
+		const reported = report({
+			value: input,
+			extract: false,
+			information: {
+				all: parameters.information ?? [],
+				existing: result.length > 0 ? result : undefined,
+			},
+			message: {
+				arguments: [types, input],
+				callback: getInputValueTypeMessage,
+			},
+			original: parameters,
+		})!;
+
+		return reported;
+	};
+
+	return {
+		types,
+		handler: validator,
+	};
+}