@oscarpalmer/jhunal 0.25.0 → 0.27.0

package/src/validator.ts

@@ -0,0 +1,135 @@
+import type {Constructor} from '@oscarpalmer/atoms/models';
+import type {Result} from '@oscarpalmer/atoms/result/models';
+import {PROPERTY_VALIDATOR} from './constants';
+import {getValidatorHandler} from './handler/validator.handler';
+import {isResult} from './helpers/result.helper';
+import type {InferValidatorValue} from './models/infer.model';
+import type {Values, ValueType} from './models/misc.model';
+import type {
+	ValidationHandler,
+	ValidationHandlerType,
+	Validators,
+	ValueValidation,
+} from './models/validation.model';
+
+export class Validator<Value> {
+	declare private readonly $validator: true;
+
+	readonly #handler: ValidationHandler;
+
+	constructor(handler: ValidationHandler, types: ValidationHandlerType[]) {
+		Object.defineProperty(this, PROPERTY_VALIDATOR, {
+			value: true,
+		});
+
+		this.#handler = handler;
+
+		validatorHandlers.set(this, handler);
+		validatorTypes.set(this, types);
+	}
+
+	/**
+	 * Is the value valid?
+	 *
+	 * Will assert that the value is valid and throws an error if it does not
+	 * @param value Value to validate
+	 * @returns `true` if the value is valid, otherwise throws an error
+	 */
+	is(value: unknown, reporting: 'throw'): asserts value is Value;
+
+	/**
+	 * Is the value valid?
+	 *
+	 * Will validate that the value is valid and return a result of `true` or validation information for the first validation failure
+	 * @param value Value to validate
+	 * @return Result holding `true` or validation information
+	 */
+	is(value: unknown, reporting: 'result'): Result<Value, ValueValidation>;
+
+	/**
+	 * Is the value valid?
+	 * @param value Value to validate
+	 * @returns `true` if the value is valid, otherwise `false`
+	 */
+	is(value: unknown, reporting?: 'none'): value is Value;
+
+	is(value: unknown, options?: unknown): unknown {
+		return isResult(this.#handler, value, options);
+	}
+}
+
+/**
+ * Create a validator for value types
+ * @param types Types to validate against
+ * @param validators Custom validators to use for validation
+ * @returns Validator
+ */
+export function validator<
+	Types extends Array<Constructor | ((value: unknown) => boolean) | ValueType>,
+>(types: Types, validators?: Validators): Validator<InferValidatorValue<Types>>;
+
+/**
+ * Create a validator for a constructor
+ * @param constructor Constructor to validate against
+ * @returns Validator
+ */
+export function validator<Instance>(constructor: Constructor<Instance>): Validator<Instance>;
+
+/**
+ * Create a validator for a callback
+ * @param callback Callback for validation
+ * @returns Validator
+ */
+export function validator<Value>(callback: (value: unknown) => value is Value): Validator<Value>;
+
+/**
+ * Create a validator for a callback
+ * @param callback Callback for validation
+ * @returns Validator
+ */
+export function validator<Value>(callback: (value: unknown) => boolean): Validator<Value>;
+
+/**
+ * Create a validator for a type
+ * @param type Type to validate against
+ * @param validators Custom validators to use for validation
+ * @returns Validator
+ */
+export function validator<Type extends ValueType>(
+	type: Type,
+	validators?:
+		| ((value: Values[Type]) => boolean)
+		| Array<(value: Values[Type]) => boolean>
+		| Record<Type, ((value: Values[Type]) => boolean) | Array<(value: Values[Type]) => boolean>>,
+): Validator<Values[Type]>;
+
+/**
+ * Create a validator for value types
+ * @param types Types to validate against
+ * @param validators Custom validators to use for validation
+ * @returns Validator
+ */
+export function validator<Types extends ValueType[]>(
+	types: Types,
+	validators?: Validators,
+): Validator<unknown>;
+
+/**
+ * Create a validator for an array of items
+ * @param type Type of items in the array
+ * @returns Validator
+ */
+export function validator<Item>(type: 'array'): Validator<Item[]>;
+
+export function validator(value: unknown, validators?: unknown): Validator<unknown> {
+	if (value instanceof Validator) {
+		return value;
+	}
+
+	const {handler, types} = getValidatorHandler(value, validators);
+
+	return new Validator(handler, types);
+}
+
+export const validatorHandlers = new WeakMap<Validator<unknown>, ValidationHandler>();
+export const validatorTypes = new WeakMap<Validator<unknown>, ValidationHandlerType[]>();

package/dist/validator/base.validator.d.mts

@@ -1,6 +0,0 @@
-import { Validator } from "../models/validation.model.mjs";
-
-//#region src/validator/base.validator.d.ts
-declare function getBaseValidator(validators: Validator[]): Validator;
-//#endregion
-export { getBaseValidator };

package/dist/validator/function.validator.d.mts

@@ -1,6 +0,0 @@
-import { Validator } from "../models/validation.model.mjs";
-
-//#region src/validator/function.validator.d.ts
-declare function getFunctionValidator(fn: Function): Validator;
-//#endregion
-export { getFunctionValidator };

package/dist/validator/function.validator.mjs

@@ -1,9 +0,0 @@
-import { instanceOf } from "../helpers/misc.helper.mjs";
-import { isConstructor } from "@oscarpalmer/atoms/is";
-//#region src/validator/function.validator.ts
-function getFunctionValidator(fn) {
-	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
-	return (input) => validator(input) ? true : [];
-}
-//#endregion
-export { getFunctionValidator };

package/dist/validator/named.handler.d.mts

@@ -1,6 +0,0 @@
-import { NamedValidatorHandlers } from "../models/validation.model.mjs";
-
-//#region src/validator/named.handler.d.ts
-declare function getNamedHandlers(original: unknown, prefix: string, allowed: boolean): NamedValidatorHandlers;
-//#endregion
-export { getNamedHandlers };

package/dist/validator/named.handler.mjs

@@ -1,23 +0,0 @@
-import { PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "../constants.mjs";
-import { isPlainObject } from "@oscarpalmer/atoms/is";
-//#region src/validator/named.handler.ts
-function getNamedHandlers(original, prefix, allowed) {
-	const handlers = {};
-	if (original == null) return handlers;
-	if (!allowed) throw new TypeError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", prefix).replace("<>", PROPERTY_VALIDATORS));
-	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)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
-		const value = original[key];
-		handlers[key] = (Array.isArray(value) ? value : [value]).map((item) => {
-			if (typeof item !== "function") throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key).replace("<>", prefix));
-			return item;
-		});
-	}
-	return handlers;
-}
-//#endregion
-export { getNamedHandlers };

package/dist/validator/named.validator.d.mts

@@ -1,7 +0,0 @@
-import { NamedValidatorHandlers, ValidationInformationKey, Validator } from "../models/validation.model.mjs";
-import { ValueName } from "../models/misc.model.mjs";
-
-//#region src/validator/named.validator.d.ts
-declare function getNamedValidator(key: ValidationInformationKey, name: ValueName, handlers: NamedValidatorHandlers): Validator;
-//#endregion
-export { getNamedValidator };

package/dist/validator/named.validator.mjs

@@ -1,38 +0,0 @@
-import { getInputPropertyValidatorMessage } from "../helpers/message.helper.mjs";
-//#region src/validator/named.validator.ts
-function getNamedValidator(key, name, handlers) {
-	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 = {
-				key,
-				validator,
-				message: getInputPropertyValidatorMessage(key.full, name, index, length),
-				value: input
-			};
-			parameters.information?.push(information);
-			return parameters.reporting.none ? [] : [information];
-		}
-		return true;
-	};
-}
-const 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 === void 0
-};
-//#endregion
-export { getNamedValidator };

package/dist/validator/object.validator.d.mts

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

package/dist/validator/object.validator.mjs

@@ -1,185 +0,0 @@
-import { PROPERTY_DEFAULT, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, TYPE_ALL } from "../constants.mjs";
-import { getParameters, isSchema } from "../helpers/misc.helper.mjs";
-import { SchematicError, ValidationError } from "../models/validation.model.mjs";
-import { getDefaultRequiredMessage, getDefaultTypeMessage, getDisallowedMessage, getInputPropertyMissingMessage, getInputPropertyTypeMessage, getInputTypeMessage, getRequiredMessage, getSchematicPropertyNullableMessage, getSchematicPropertyTypeMessage, getUnknownKeysMessage } from "../helpers/message.helper.mjs";
-import { getBaseValidator } from "./base.validator.mjs";
-import { getFunctionValidator } from "./function.validator.mjs";
-import { getNamedHandlers } from "./named.handler.mjs";
-import { getNamedValidator } from "./named.validator.mjs";
-import { getSchemaValidator } from "./schematic.validator.mjs";
-import { isPlainObject } from "@oscarpalmer/atoms/is";
-import { join } from "@oscarpalmer/atoms/string";
-import { clone } from "@oscarpalmer/atoms/value/clone";
-//#region src/validator/object.validator.ts
-function getDefaults(obj, key, allowed) {
-	if (!("$default" in obj)) return;
-	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_DEFAULT));
-	return { value: obj[PROPERTY_DEFAULT] };
-}
-function getDisallowedProperty(obj) {
-	if ("$default" in obj) return PROPERTY_DEFAULT;
-	if ("$required" in obj) return PROPERTY_REQUIRED;
-	if ("$type" in obj) return PROPERTY_TYPE;
-	if ("$validators" in obj) return PROPERTY_VALIDATORS;
-}
-function getObjectValidator(original, origin, fromType) {
-	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 = /* @__PURE__ */ new Set();
-	const items = [];
-	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 = {
-			full: prefixedKey,
-			short: key
-		};
-		let handlers = {};
-		let required = true;
-		let typed = false;
-		let defaults;
-		let types;
-		const validators = [];
-		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;
-			switch (true) {
-				case typeof type === "function":
-					validator = getFunctionValidator(type);
-					break;
-				case isPlainObject(type):
-					validator = getObjectValidator(type, fullKey, typed);
-					break;
-				case isSchema(type):
-					validator = getSchemaValidator(type);
-					break;
-				case TYPE_ALL.has(type):
-					validator = getNamedValidator(fullKey, type, handlers);
-					break;
-				default: throw new SchematicError(getSchematicPropertyTypeMessage(prefixedKey));
-			}
-			validators.push(validator);
-		}
-		required = required && !types.includes("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 = {
-				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 unknownKeys = Object.keys(input).filter((key) => !set.has(key));
-			if (unknownKeys.length > 0) {
-				const information = {
-					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 = [];
-		const output = {};
-		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
-			const { defaults, key, required, types, validator } = items[validatorIndex];
-			const value = input[key.short];
-			if (value === void 0) {
-				if (required) {
-					if (get && defaults != null) {
-						output[key.short] = clone(defaults.value);
-						continue;
-					}
-					if (parameters.reporting.none) return [];
-					const information = {
-						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 = 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, key, allowed) {
-	if (!("$required" in obj)) return;
-	if (!allowed) throw new SchematicError(getDisallowedMessage(key, PROPERTY_REQUIRED));
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(getRequiredMessage(key));
-	return obj[PROPERTY_REQUIRED];
-}
-//#endregion
-export { getObjectValidator };

package/dist/validator/schematic.validator.d.mts

@@ -1,7 +0,0 @@
-import { Validator } from "../models/validation.model.mjs";
-import { Schema } from "../schema.mjs";
-
-//#region src/validator/schematic.validator.d.ts
-declare function getSchemaValidator(schematic: Schema<unknown>): Validator;
-//#endregion
-export { getSchemaValidator };

package/dist/validator/schematic.validator.mjs

@@ -1,16 +0,0 @@
-import { schemaValidators } from "../schema.mjs";
-import { isPlainObject } from "@oscarpalmer/atoms/is";
-//#region src/validator/schematic.validator.ts
-function getSchemaValidator(schematic) {
-	const validator = schemaValidators.get(schematic);
-	return (input, parameters, get) => {
-		let result;
-		if (isPlainObject(input)) result = validator(input, parameters, get);
-		else result = [];
-		if (result === true) return result;
-		parameters.information?.push(...result);
-		return result;
-	};
-}
-//#endregion
-export { getSchemaValidator };

package/src/validator/function.validator.ts

@@ -1,9 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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,
-	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,
-	allowed: boolean,
-): NamedValidatorHandlers {
-	const handlers: NamedValidatorHandlers = {};
-
-	if (original == null) {
-		return handlers;
-	}
-
-	if (!allowed) {
-		throw new TypeError(
-			SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(
-				TEMPLATE_PATTERN,
-				prefix,
-			).replace(TEMPLATE_PATTERN, PROPERTY_VALIDATORS),
-		);
-	}
-
-	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

@@ -1,61 +0,0 @@
-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,
-};