@oscarpalmer/jhunal 0.22.0 → 0.24.0

package/src/validator/named.validator.ts

@@ -0,0 +1,61 @@
+import {getInputPropertyValidatorMessage} 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: getInputPropertyValidatorMessage(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 === '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,366 @@
+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_DEFAULT,
+	PROPERTY_REQUIRED,
+	PROPERTY_TYPE,
+	PROPERTY_VALIDATORS,
+	SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY,
+	TYPE_ALL,
+	TYPE_UNDEFINED,
+} from '../constants';
+import {
+	getDefaultRequiredMessage,
+	getDefaultTypeMessage,
+	getDisallowedMessage,
+	getInputPropertyMissingMessage,
+	getInputPropertyTypeMessage,
+	getInputTypeMessage,
+	getRequiredMessage,
+	getSchematicPropertyNullableMessage,
+	getSchematicPropertyTypeMessage,
+	getUnknownKeysMessage,
+} from '../helpers/message.helper';
+import {getParameters, isSchematic} from '../helpers/misc.helper';
+import type {ValueName} from '../models/misc.model';
+import {
+	type NamedValidatorHandlers,
+	SchematicError,
+	ValidationError,
+	type ValidationInformation,
+	type ValidationInformationKey,
+	type Validator,
+	type ValidatorDefaults,
+	type ValidatorItem,
+	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 getDefaults(
+	obj: PlainObject,
+	key: string,
+	allowed: boolean,
+): ValidatorDefaults | undefined {
+	if (!(PROPERTY_DEFAULT in obj)) {
+		return;
+	}
+
+	if (!allowed) {
+		throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
+	}
+
+	return {
+		value: obj[PROPERTY_DEFAULT],
+	};
+}
+
+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 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(getDisallowedMessage(origin!.full, property));
+		}
+	}
+
+	const set = new Set<string>();
+
+	const items: ValidatorItem[] = [];
+
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+		const value = original[key];
+
+		if (value == null) {
+			throw new SchematicError(getSchematicPropertyNullableMessage(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 defaults: ValidatorDefaults | undefined;
+
+		let types: ValidatorType[];
+
+		const validators: Validator[] = [];
+
+		if (isPlainObject(value)) {
+			typed = PROPERTY_TYPE in value;
+
+			const type = typed ? value[PROPERTY_TYPE] : value;
+
+			defaults = getDefaults(value, prefixedKey, typed);
+			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey, typed);
+			required = getRequired(value, prefixedKey, typed) ?? required;
+
+			types = Array.isArray(type) ? type : [type];
+		} else {
+			types = Array.isArray(value) ? value : [value];
+		}
+
+		if (types.length === 0) {
+			throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
+		}
+
+		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(getSchematicPropertyTypeMessage(prefixedKey));
+			}
+
+			validators.push(validator);
+		}
+
+		required = required && !types.includes(TYPE_UNDEFINED);
+
+		if (defaults != null && !required) {
+			throw new SchematicError(getDefaultRequiredMessage(prefixedKey));
+		}
+
+		const validator = getBaseValidator(validators);
+
+		if (defaults != null && Array.isArray(validator(defaults.value, getParameters(), false))) {
+			throw new SchematicError(getDefaultTypeMessage(prefixedKey, types));
+		}
+
+		items.push({
+			defaults,
+			required,
+			types,
+			validator,
+			key: fullKey,
+		});
+
+		set.add(key);
+	}
+
+	const validatorsLength = items.length;
+
+	return (input, parameters, get) => {
+		if (!isPlainObject(input)) {
+			if (origin != null) {
+				return [];
+			}
+
+			const information: ValidationInformation = {
+				key: {
+					full: '',
+					short: '',
+				},
+				value: input,
+				message: getInputTypeMessage(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 {defaults, key, required, types, validator} = items[validatorIndex];
+
+			const value = (input as PlainObject)[key.short];
+
+			if (value === undefined) {
+				if (required) {
+					if (get && defaults != null) {
+						output[key.short] = clone(defaults.value);
+
+						continue;
+					}
+
+					if (parameters.reporting.none) {
+						return [];
+					}
+
+					const information: ValidationInformation = {
+						key,
+						value,
+						message: getInputPropertyMissingMessage(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: getInputPropertyTypeMessage(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(obj: PlainObject, key: string, allowed: boolean): boolean | undefined {
+	if (!(PROPERTY_REQUIRED in obj)) {
+		return;
+	}
+
+	if (!allowed) {
+		throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
+	}
+
+	if (typeof obj[PROPERTY_REQUIRED] !== 'boolean') {
+		throw new SchematicError(getRequiredMessage(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;
+	};
+}

package/dist/helpers.d.mts

@@ -1,28 +0,0 @@
-import { ReportingInformation, ValidatorParameters, ValidatorType } from "./models/validation.model.mjs";
-import { Schematic } from "./schematic.mjs";
-import { ValueName } from "./models/misc.model.mjs";
-import { Constructor } from "@oscarpalmer/atoms/models";
-
-//#region src/helpers.d.ts
-declare function getInvalidInputMessage(actual: unknown): string;
-declare function getInvalidMissingMessage(key: string, types: ValidatorType[]): string;
-declare function getInvalidTypeMessage(key: string, types: ValidatorType[], actual: unknown): string;
-declare function getInvalidValidatorMessage(key: string, type: ValueName, index: number, length: number): string;
-declare function getParameters(input?: unknown): ValidatorParameters;
-declare function getReporting(value: unknown): ReportingInformation;
-declare function getUnknownKeysMessage(keys: string[]): string;
-/**
- * Creates a validator function for a given constructor
- * @param constructor - Constructor to check against
- * @throws Will throw a `TypeError` if the provided argument is not a valid constructor
- * @returns Validator function that checks if a value is an instance of the constructor
- */
-declare function instanceOf<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
-/**
- * Is the value a schematic?
- * @param value Value to check
- * @returns `true` if the value is a schematic, `false` otherwise
- */
-declare function isSchematic(value: unknown): value is Schematic<never>;
-//#endregion
-export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getParameters, getReporting, getUnknownKeysMessage, instanceOf, isSchematic };

package/dist/helpers.mjs

@@ -1,120 +0,0 @@
-import { CONJUNCTION_AND, CONJUNCTION_AND_COMMA, CONJUNCTION_OR, CONJUNCTION_OR_COMMA, MESSAGE_CONSTRUCTOR, NAME_SCHEMATIC, REPORTING_FIRST, REPORTING_NONE, REPORTING_THROW, REPORTING_TYPES, TYPE_ARRAY, TYPE_NULL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATION_MESSAGE_INVALID_INPUT, VALIDATION_MESSAGE_INVALID_REQUIRED, VALIDATION_MESSAGE_INVALID_TYPE, VALIDATION_MESSAGE_INVALID_VALUE, VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX, VALIDATION_MESSAGE_UNKNOWN_KEYS } from "./constants.mjs";
-import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-//#region src/helpers.ts
-function getInvalidInputMessage(actual) {
-	return VALIDATION_MESSAGE_INVALID_INPUT.replace("<>", getValueType(actual));
-}
-function getInvalidMissingMessage(key, types) {
-	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace("<>", renderTypes(types));
-	message = message.replace("<>", key);
-	return message;
-}
-function getInvalidTypeMessage(key, types, actual) {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace("<>", renderTypes(types));
-	message = message.replace("<>", key);
-	message = message.replace("<>", getValueType(actual));
-	return message;
-}
-function getInvalidValidatorMessage(key, type, index, length) {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace("<>", key);
-	message = message.replace("<>", type);
-	if (length > 1) message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace("<>", String(index));
-	return message;
-}
-function getParameters(input) {
-	if (typeof input === "boolean") return {
-		output: {},
-		reporting: getReporting(REPORTING_NONE),
-		strict: input
-	};
-	if (REPORTING_TYPES.has(input)) return {
-		output: {},
-		reporting: getReporting(input),
-		strict: false
-	};
-	const options = isPlainObject(input) ? input : {};
-	return {
-		output: {},
-		reporting: getReporting(options.errors),
-		strict: typeof options.strict === "boolean" ? options.strict : false
-	};
-}
-function getPropertyType(original) {
-	if (typeof original === "function") return "a validated value";
-	if (Array.isArray(original)) return `'array'`;
-	if (isPlainObject(original)) return `'${TYPE_OBJECT}'`;
-	if (isSchematic(original)) return `a ${NAME_SCHEMATIC}`;
-	return `'${String(original)}'`;
-}
-function getReporting(value) {
-	const type = REPORTING_TYPES.has(value) ? value : REPORTING_NONE;
-	return {
-		type,
-		["all"]: type === "all",
-		[REPORTING_FIRST]: type === REPORTING_FIRST,
-		[REPORTING_NONE]: type === REPORTING_NONE,
-		[REPORTING_THROW]: type === REPORTING_THROW
-	};
-}
-function getUnknownKeysMessage(keys) {
-	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace("<>", renderKeys(keys));
-}
-function getValueType(value) {
-	const valueType = typeof value;
-	switch (true) {
-		case value === null: return `'${TYPE_NULL}'`;
-		case value === void 0: return `'${TYPE_UNDEFINED}'`;
-		case valueType !== TYPE_OBJECT: return `'${valueType}'`;
-		case Array.isArray(value): return `'${TYPE_ARRAY}'`;
-		case isPlainObject(value): return `'${TYPE_OBJECT}'`;
-		case isSchematic(value): return `a ${NAME_SCHEMATIC}`;
-		default: return value.constructor.name;
-	}
-}
-/**
-* Creates a validator function for a given constructor
-* @param constructor - Constructor to check against
-* @throws Will throw a `TypeError` if the provided argument is not a valid constructor
-* @returns Validator function that checks if a value is an instance of the constructor
-*/
-function instanceOf(constructor) {
-	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
-	return (value) => {
-		return value instanceof constructor;
-	};
-}
-/**
-* Is the value a schematic?
-* @param value Value to check
-* @returns `true` if the value is a schematic, `false` otherwise
-*/
-function isSchematic(value) {
-	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
-}
-function renderKeys(keys) {
-	return renderParts(keys.map((key) => `'${key}'`), CONJUNCTION_AND, CONJUNCTION_AND_COMMA);
-}
-function renderParts(parts, delimiterShort, delimiterLong) {
-	const { length } = parts;
-	if (length === 1) return parts[0];
-	let rendered = "";
-	for (let index = 0; index < length; index += 1) {
-		rendered += parts[index];
-		if (index < length - 2) rendered += ", ";
-		else if (index === length - 2) rendered += parts.length > 2 ? delimiterLong : delimiterShort;
-	}
-	return rendered;
-}
-function renderTypes(types) {
-	const unique = /* @__PURE__ */ new Set();
-	const parts = [];
-	for (let index = 0; index < types.length; index += 1) {
-		const rendered = getPropertyType(types[index]);
-		if (unique.has(rendered)) continue;
-		unique.add(rendered);
-		parts.push(rendered);
-	}
-	return renderParts(parts, CONJUNCTION_OR, CONJUNCTION_OR_COMMA);
-}
-//#endregion
-export { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getParameters, getReporting, getUnknownKeysMessage, instanceOf, isSchematic };

package/dist/validation.d.mts

@@ -1,7 +0,0 @@
-import { ValidationInformationKey, Validator } from "./models/validation.model.mjs";
-import { PlainObject } from "@oscarpalmer/atoms";
-
-//#region src/validation.d.ts
-declare function getObjectValidator(original: PlainObject, origin?: ValidationInformationKey, fromType?: boolean): Validator;
-//#endregion
-export { getObjectValidator };