@oscarpalmer/jhunal 0.22.0 → 0.24.0

package/dist/validation.mjs

@@ -1,245 +0,0 @@
-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, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "./constants.mjs";
-import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage, instanceOf, isSchematic } from "./helpers.mjs";
-import { SchematicError, ValidationError } from "./models/validation.model.mjs";
-import { schematicValidator } from "./schematic.mjs";
-import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-import { join } from "@oscarpalmer/atoms";
-import { clone } from "@oscarpalmer/atoms/value/clone";
-//#region src/validation.ts
-function getDisallowedProperty(obj) {
-	if ("$required" in obj) return PROPERTY_REQUIRED;
-	if ("$type" in obj) return PROPERTY_TYPE;
-	if ("$validators" in obj) return PROPERTY_VALIDATORS;
-}
-function getFunctionValidator(fn) {
-	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
-	return (input) => validator(input) === true;
-}
-function getNamedValidator(key, name, handlers) {
-	const validator = namedValidators[name];
-	const named = handlers[name] ?? [];
-	const { length } = named;
-	return (input, parameters) => {
-		if (!validator(input)) return false;
-		for (let index = 0; index < length; index += 1) {
-			const handler = named[index];
-			if (handler(input) === true) continue;
-			const information = {
-				key,
-				validator,
-				message: getInvalidValidatorMessage(key.full, name, index, length),
-				value: input
-			};
-			parameters.information?.push(information);
-			return parameters.reporting.none ? false : [information];
-		}
-		return true;
-	};
-}
-function getNamedHandlers(original, prefix) {
-	const handlers = {};
-	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)) 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;
-}
-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(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", origin.full).replace("<>", 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(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", 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 types;
-		const validators = [];
-		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("<>", prefixedKey).replace("<>", String(value)));
-		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 isSchematic(type):
-					validator = getSchematicValidator(type);
-					break;
-				case TYPE_ALL.has(type):
-					validator = getNamedValidator(fullKey, type, handlers);
-					break;
-				default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(type)));
-			}
-			validators.push(validator);
-		}
-		set.add(key);
-		items.push({
-			types,
-			key: fullKey,
-			required: required && !types.includes("undefined"),
-			validator: getValidator(validators)
-		});
-	}
-	const validatorsLength = items.length;
-	return (input, parameters, get) => {
-		if (!isPlainObject(input)) {
-			if (origin != null) return false;
-			const information = {
-				key: {
-					full: "",
-					short: ""
-				},
-				value: input,
-				message: getInvalidInputMessage(input)
-			};
-			if (parameters.reporting.throw) throw new ValidationError([information]);
-			parameters.information?.push(information);
-			return parameters.reporting.none ? false : [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 parameters.reporting.none ? false : [information];
-			}
-		}
-		const allInformation = [];
-		const output = {};
-		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
-			const { key, required, types, validator } = items[validatorIndex];
-			const value = input[key.short];
-			if (value === void 0) {
-				if (required) {
-					if (parameters.reporting.none) return false;
-					const information = {
-						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 === false) continue;
-			if (result === true) {
-				if (get) output[key.short] = clone(value);
-				continue;
-			}
-			if (parameters.reporting.none) return false;
-			const information = 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 parameters.reporting.none || allInformation.length === 0 ? true : allInformation;
-	};
-}
-function getRequired(key, obj) {
-	if (!("$required" in obj)) return;
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
-	return obj[PROPERTY_REQUIRED];
-}
-function getSchematicValidator(schematic) {
-	const validator = schematicValidator.get(schematic);
-	return (input, parameters, get) => {
-		let result = false;
-		if (isPlainObject(input)) result = validator(input, parameters, get);
-		if (typeof result === "boolean") return result;
-		parameters.information?.push(...result);
-		return result.length === 0 ? true : result;
-	};
-}
-function getValidator(validators) {
-	const { length } = validators;
-	return (input, parameters, get) => {
-		const allInformation = [];
-		for (let index = 0; index < length; index += 1) {
-			const previousInformation = parameters.information;
-			parameters.information = [];
-			const result = validators[index](input, parameters, get);
-			parameters.information = previousInformation;
-			if (result === false) continue;
-			if (result === true) return true;
-			parameters.information?.push(...result);
-			allInformation.push(...result);
-		}
-		return allInformation;
-	};
-}
-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 { getObjectValidator };

package/src/helpers.ts

@@ -1,249 +0,0 @@
-import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
-import type {Constructor} from '@oscarpalmer/atoms/models';
-import {
-	COMMA,
-	CONJUNCTION_AND,
-	CONJUNCTION_AND_COMMA,
-	CONJUNCTION_OR,
-	CONJUNCTION_OR_COMMA,
-	MESSAGE_CONSTRUCTOR,
-	NAME_SCHEMATIC,
-	PROPERTY_SCHEMATIC,
-	REPORTING_ALL,
-	REPORTING_FIRST,
-	REPORTING_NONE,
-	REPORTING_THROW,
-	REPORTING_TYPES,
-	TEMPLATE_PATTERN,
-	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';
-import type {ValueName} from './models/misc.model';
-import type {
-	ReportingInformation,
-	ReportingType,
-	ValidatorParameters,
-	ValidatorType,
-} from './models/validation.model';
-import type {Schematic} from './schematic';
-
-export function getInvalidInputMessage(actual: unknown): string {
-	return VALIDATION_MESSAGE_INVALID_INPUT.replace(TEMPLATE_PATTERN, getValueType(actual));
-}
-
-export function getInvalidMissingMessage(key: string, types: ValidatorType[]): string {
-	let message = VALIDATION_MESSAGE_INVALID_REQUIRED.replace(TEMPLATE_PATTERN, renderTypes(types));
-
-	message = message.replace(TEMPLATE_PATTERN, key);
-
-	return message;
-}
-
-export function getInvalidTypeMessage(
-	key: string,
-	types: ValidatorType[],
-	actual: unknown,
-): string {
-	let message = VALIDATION_MESSAGE_INVALID_TYPE.replace(TEMPLATE_PATTERN, renderTypes(types));
-
-	message = message.replace(TEMPLATE_PATTERN, key);
-	message = message.replace(TEMPLATE_PATTERN, getValueType(actual));
-
-	return message;
-}
-
-export function getInvalidValidatorMessage(
-	key: string,
-	type: ValueName,
-	index: number,
-	length: number,
-): string {
-	let message = VALIDATION_MESSAGE_INVALID_VALUE.replace(TEMPLATE_PATTERN, key);
-
-	message = message.replace(TEMPLATE_PATTERN, type);
-
-	if (length > 1) {
-		message += VALIDATION_MESSAGE_INVALID_VALUE_SUFFIX.replace(TEMPLATE_PATTERN, String(index));
-	}
-
-	return message;
-}
-
-export function getParameters(input?: unknown): ValidatorParameters {
-	if (typeof input === 'boolean') {
-		return {
-			output: {},
-			reporting: getReporting(REPORTING_NONE),
-			strict: input,
-		};
-	}
-
-	if (REPORTING_TYPES.has(input as ReportingType)) {
-		return {
-			output: {},
-			reporting: getReporting(input as ReportingType),
-			strict: false,
-		};
-	}
-
-	const options = isPlainObject(input) ? input : {};
-
-	return {
-		output: {},
-		reporting: getReporting(options.errors),
-		strict: typeof options.strict === 'boolean' ? options.strict : false,
-	};
-}
-
-function getPropertyType(original: ValidatorType): string {
-	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)}'`;
-}
-
-export function getReporting(value: unknown): ReportingInformation {
-	const type = REPORTING_TYPES.has(value as ReportingType)
-		? (value as ReportingType)
-		: REPORTING_NONE;
-
-	return {
-		type,
-		[REPORTING_ALL]: type === REPORTING_ALL,
-		[REPORTING_FIRST]: type === REPORTING_FIRST,
-		[REPORTING_NONE]: type === REPORTING_NONE,
-		[REPORTING_THROW]: type === REPORTING_THROW,
-	} as ReportingInformation;
-}
-
-export function getUnknownKeysMessage(keys: string[]): string {
-	return VALIDATION_MESSAGE_UNKNOWN_KEYS.replace(TEMPLATE_PATTERN, renderKeys(keys));
-}
-
-function getValueType(value: unknown): string {
-	const valueType = typeof value;
-
-	switch (true) {
-		case value === null:
-			return `'${TYPE_NULL}'`;
-
-		case value === undefined:
-			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
- */
-export function instanceOf<Instance>(
-	constructor: Constructor<Instance>,
-): (value: unknown) => value is Instance {
-	if (!isConstructor(constructor)) {
-		throw new TypeError(MESSAGE_CONSTRUCTOR);
-	}
-
-	return (value: unknown): value is Instance => {
-		return value instanceof constructor;
-	};
-}
-
-/**
- * Is the value a schematic?
- * @param value Value to check
- * @returns `true` if the value is a schematic, `false` otherwise
- */
-export function isSchematic(value: unknown): value is Schematic<never> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		PROPERTY_SCHEMATIC in value &&
-		value[PROPERTY_SCHEMATIC] === true
-	);
-}
-
-function renderKeys(keys: string[]): string {
-	return renderParts(
-		keys.map(key => `'${key}'`),
-		CONJUNCTION_AND,
-		CONJUNCTION_AND_COMMA,
-	);
-}
-
-function renderParts(parts: string[], delimiterShort: string, delimiterLong: string): string {
-	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 += COMMA;
-		} else if (index === length - 2) {
-			rendered += parts.length > 2 ? delimiterLong : delimiterShort;
-		}
-	}
-
-	return rendered;
-}
-
-function renderTypes(types: ValidatorType[]): string {
-	const unique = new Set<string>();
-	const parts: string[] = [];
-
-	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);
-}