@oscarpalmer/jhunal 0.22.0 → 0.23.0

package/src/index.ts

@@ -1,10 +1,10 @@
-export {instanceOf, isSchematic} from './helpers';
+export {instanceOf, isSchematic} from './helpers/misc.helper';
 export type {Schema} from './models/schema.plain.model';
 export type {TypedSchema} from './models/schema.typed.model';
 export {
 	SchematicError,
 	ValidationError,
-	type ValidationInformation,
-	type ValidationOptions,
+	type GetOptions,
+	type IsOptions,
 } from './models/validation.model';
 export {schematic, type Schematic} from './schematic';

package/src/models/validation.model.ts

@@ -91,20 +91,32 @@ export type ValidationInformationKey = {
 
 // #region Options
 
-/**
- * Options for validation
- */
-export type ValidationOptions<Errors extends ReportingType> = {
+type BaseOptions<Errors extends ReportingType> = {
 	/**
 	 * How should validation failures be reported; see {@link ReportingType} _(defaults to `'none'`)_
 	 */
-	errors?: Errors;
+	errors: Errors;
 	/**
 	 * Validate if unknown keys are present in the object? _(defaults to `false`)_
 	 */
 	strict?: boolean;
 };
 
+/**
+ * Options for validating and getting a value from an input
+ */
+export type GetOptions<Errors extends ReportingType> = BaseOptions<Errors> & {
+	/**
+	 * Get a deeply cloned version of the input? _(defaults to `true`)_
+	 */
+	clone?: boolean;
+};
+
+/**
+ * Options for validation an input value
+ */
+export type IsOptions<Errors extends ReportingType> = BaseOptions<Errors>;
+
 // #endregion
 
 // #region Validator
@@ -113,9 +125,10 @@ export type Validator = (
 	input: unknown,
 	parameters: ValidatorParameters,
 	get: boolean,
-) => boolean | ValidationInformation[];
+) => true | ValidationInformation[];
 
 export type ValidatorParameters = {
+	clone: boolean;
 	information?: ValidationInformation[];
 	output: PlainObject;
 	reporting: ReportingInformation;

package/src/schematic.ts

@@ -3,17 +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 GetOptions,
+	type IsOptions,
 	type ValidationInformation,
-	type ValidationOptions,
 	type Validator,
 } from './models/validation.model';
-import {getObjectValidator} from './validation';
+import {getObjectValidator} from './validator/object.validator';
 
 /**
  * A schematic for validating objects
@@ -41,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
@@ -61,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
@@ -81,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
@@ -93,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
 	 *
@@ -108,14 +119,16 @@ export class Schematic<Model> {
 
 		const result = this.#validator(value, parameters, true);
 
-		if (typeof result === 'boolean') {
-			return parameters.reporting.none
-				? result
-					? parameters.output
-					: undefined
+		if (result === true) {
+			return parameters.reporting.none || parameters.reporting.throw
+				? parameters.output
 				: ok(parameters.output);
 		}
 
+		if (parameters.reporting.none) {
+			return;
+		}
+
 		return error(parameters.reporting.all ? result : result[0]);
 	}
 
@@ -127,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?
@@ -147,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?
@@ -167,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?
@@ -179,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?
 	 *
@@ -194,8 +217,12 @@ export class Schematic<Model> {
 
 		const result = this.#validator(value, parameters, false);
 
-		if (typeof result === 'boolean') {
-			return parameters.reporting.none ? result : ok(result);
+		if (result === true) {
+			return parameters.reporting.none || parameters.reporting.throw ? result : ok(result);
+		}
+
+		if (parameters.reporting.none) {
+			return false;
 		}
 
 		return error(parameters.reporting.all ? result : result[0]);

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/{validation.ts → validator/object.validator.ts}

@@ -1,5 +1,6 @@
-import {join, type PlainObject} from '@oscarpalmer/atoms';
-import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
+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,
@@ -10,35 +11,32 @@ import {
 	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,
 	TEMPLATE_PATTERN,
 	TYPE_ALL,
-	TYPE_OBJECT,
 	TYPE_UNDEFINED,
-} from './constants';
+} from '../constants';
 import {
 	getInvalidInputMessage,
 	getInvalidMissingMessage,
 	getInvalidTypeMessage,
-	getInvalidValidatorMessage,
 	getUnknownKeysMessage,
-	instanceOf,
-	isSchematic,
-} from './helpers';
-import type {ValueName} from './models/misc.model';
+} from '../helpers/message.helper';
+import {isSchematic} from '../helpers/misc.helper';
+import type {ValueName} from '../models/misc.model';
 import {
+	type NamedValidatorHandlers,
 	SchematicError,
 	ValidationError,
-	type NamedValidatorHandlers,
-	type NamedValidators,
 	type ValidationInformation,
 	type ValidationInformationKey,
 	type Validator,
 	type ValidatorType,
-} from './models/validation.model';
-import {schematicValidator, type Schematic} from './schematic';
+} 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) {
@@ -54,90 +52,6 @@ function getDisallowedProperty(obj: PlainObject): string | undefined {
 	}
 }
 
-function getFunctionValidator(fn: Function): Validator {
-	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
-
-	return input => validator(input) === true;
-}
-
-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 false;
-		}
-
-		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 ? false : [information];
-		}
-
-		return true;
-	};
-}
-
-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 as PlainObject)[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;
-}
-
 export function getObjectValidator(
 	original: PlainObject,
 	origin?: ValidationInformationKey,
@@ -263,7 +177,7 @@ export function getObjectValidator(
 			types,
 			key: fullKey,
 			required: required && !types.includes(TYPE_UNDEFINED),
-			validator: getValidator(validators),
+			validator: getBaseValidator(validators),
 		});
 	}
 
@@ -272,7 +186,7 @@ export function getObjectValidator(
 	return (input, parameters, get) => {
 		if (!isPlainObject(input)) {
 			if (origin != null) {
-				return false;
+				return [];
 			}
 
 			const information: ValidationInformation = {
@@ -290,7 +204,7 @@ export function getObjectValidator(
 
 			parameters.information?.push(information);
 
-			return parameters.reporting.none ? false : [information];
+			return [information];
 		}
 
 		if (parameters.strict) {
@@ -313,7 +227,7 @@ export function getObjectValidator(
 
 				parameters.information?.push(information);
 
-				return parameters.reporting.none ? false : [information];
+				return [information];
 			}
 		}
 
@@ -328,7 +242,7 @@ export function getObjectValidator(
 			if (value === undefined) {
 				if (required) {
 					if (parameters.reporting.none) {
-						return false;
+						return [];
 					}
 
 					const information: ValidationInformation = {
@@ -363,20 +277,16 @@ export function getObjectValidator(
 
 			parameters.output = previousOutput;
 
-			if (result === false) {
-				continue;
-			}
-
 			if (result === true) {
-				if (get) {
-					output[key.short] = clone(value);
+				if (get && !isPlainObject(value)) {
+					output[key.short] = parameters.clone ? clone(value) : value;
 				}
 
 				continue;
 			}
 
 			if (parameters.reporting.none) {
-				return false;
+				return [];
 			}
 
 			const information: ValidationInformation[] =
@@ -411,7 +321,7 @@ export function getObjectValidator(
 			}
 		}
 
-		return parameters.reporting.none || allInformation.length === 0 ? true : allInformation;
+		return allInformation.length === 0 ? true : allInformation;
 	};
 }
 
@@ -428,71 +338,3 @@ function getRequired(key: string, obj: PlainObject): boolean | undefined {
 
 	return obj[PROPERTY_REQUIRED];
 }
-
-function getSchematicValidator(schematic: Schematic<unknown>): Validator {
-	const validator = schematicValidator.get(schematic)!;
-
-	return (input, parameters, get) => {
-		let result: ReturnType<Validator> = 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: 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 === false) {
-				continue;
-			}
-
-			if (result === true) {
-				return true;
-			}
-
-			parameters.information?.push(...result);
-
-			allInformation.push(...result);
-		}
-
-		return allInformation;
-	};
-}
-
-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/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;
+	};
+}