@oscarpalmer/jhunal 0.10.0 → 0.12.0

package/src/constants.ts

@@ -1,10 +1,31 @@
-import type {Values} from './models';
+import type {ValueName} from './models';
 
-export const EXPRESSION_HAS_NUMBER = /\d+/;
+export const ERROR_NAME = 'SchematicError';
 
 export const EXPRESSION_INDEX = /\.\d+$/;
 
-export const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
+export const EXPRESSION_KEY_PREFIX = /\.\w+$/;
+
+export const EXPRESSION_KEY_VALUE = /^.*\.(\w+)$/;
+
+export const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
+
+export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
+
+export const MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
+
+export const MESSAGE_SCHEMA_INVALID_TYPE = 'Schema must be an object';
+
+export const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
+
+export const MESSAGE_VALIDATOR_INVALID_TYPE = 'Validators must be an object';
+
+export const MESSAGE_VALIDATOR_INVALID_VALUE =
+	"Validator '<>' must be a function or an array of functions";
 
 export const PROPERTY_REQUIRED = '$required';
 
@@ -14,20 +35,22 @@ export const PROPERTY_VALIDATORS = '$validators';
 
 export const SCHEMATIC_NAME = '$schematic';
 
+export const TEMPLATE_PATTERN = '<>';
+
 export const TYPE_OBJECT = 'object';
 
 export const TYPE_UNDEFINED = 'undefined';
 
-export const TYPE_ALL = new Set<keyof Values>([
+export const VALIDATABLE_TYPES = new Set<ValueName>([
 	'array',
 	'bigint',
 	'boolean',
 	'date',
 	'function',
-	'null',
 	'number',
 	'string',
 	'symbol',
 	TYPE_OBJECT,
-	TYPE_UNDEFINED,
 ]);
+
+export const TYPE_ALL = new Set<ValueName>([...VALIDATABLE_TYPES, 'null', TYPE_UNDEFINED]);

package/src/index.ts

@@ -1,3 +1,3 @@
-export {isInstance} from './is';
-export type {Schema, TypedSchema} from './models';
+export {instanceOf} from './is';
+export {SchematicError, type Schema, type TypedSchema} from './models';
 export {schematic, type Schematic} from './schematic';

package/src/is.ts

@@ -1,13 +1,13 @@
 import {isConstructor} from '@oscarpalmer/atoms/is';
-import {SCHEMATIC_NAME} from './constants';
+import {MESSAGE_CONSTRUCTOR, SCHEMATIC_NAME} from './constants';
 import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
-export function isInstance<Instance>(
+export function instanceOf<Instance>(
 	constructor: Constructor<Instance>,
 ): (value: unknown) => value is Instance {
 	if (!isConstructor(constructor)) {
-		throw new TypeError('Expected a constructor function');
+		throw new TypeError(MESSAGE_CONSTRUCTOR);
 	}
 
 	return (value: unknown): value is Instance => {

package/src/models.ts

@@ -1,4 +1,5 @@
-import type {PlainObject, Simplify} from '@oscarpalmer/atoms/models';
+import type {GenericCallback, PlainObject, Simplify} from '@oscarpalmer/atoms/models';
+import {ERROR_NAME} from './constants';
 import type {Schematic} from './schematic';
 
 export type Constructor<Instance = any> = new (...args: any[]) => Instance;
@@ -65,17 +66,23 @@ type InferSchemaEntryValue<Value> =
 			? Model
 			: Value extends SchemaProperty
 				? InferPropertyType<Value['$type']>
-				: Value extends ValueName
-					? Values[Value & ValueName]
-					: Value extends Schema
-						? Infer<Value>
-						: never;
+				: Value extends NestedSchema
+					? Infer<Omit<Value, '$required'>>
+					: Value extends ValueName
+						? Values[Value & ValueName]
+						: Value extends Schema
+							? Infer<Value>
+							: never;
 
 type IsOptionalProperty<Value> = Value extends SchemaProperty
 	? Value['$required'] extends false
 		? true
 		: false
-	: false;
+	: Value extends {$required?: boolean}
+		? Value extends {$required: false}
+			? true
+			: false
+		: false;
 
 type LastOfUnion<Value> =
 	UnionToIntersection<Value extends unknown ? () => Value : never> extends () => infer Item
@@ -95,7 +102,8 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
  */
 export type NestedSchema = {
 	$required?: boolean;
-} & Schema;
+	[key: string]: any;
+};
 
 type OptionalKeys<Value> = {
 	[Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
@@ -114,10 +122,16 @@ type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
  */
 export type Schema = SchemaIndex;
 
-type SchemaEntry = Constructor | NestedSchema | SchemaProperty | Schematic<unknown> | ValueName;
+type SchemaEntry =
+	| Constructor
+	| Schema
+	| SchemaProperty
+	| Schematic<unknown>
+	| ValueName
+	| ((value: unknown) => boolean);
 
 interface SchemaIndex {
-	[key: string]: SchemaEntry | SchemaEntry[];
+	[key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
 }
 
 /**
@@ -129,15 +143,30 @@ export type SchemaProperty = {
 	$validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 
-type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
+type SchemaPropertyType =
+	| Constructor
+	| Schema
+	| Schematic<unknown>
+	| ValueName
+	| ((value: unknown) => boolean);
+
+export class SchematicError extends Error {
+	constructor(message: string) {
+		super(message);
+
+		this.name = ERROR_NAME;
+	}
+}
 
 type ToSchemaPropertyType<Value> = UnwrapSingle<
 	DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>
 >;
 
-type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject
-	? TypedSchema<Value>
-	: ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema
+	? Omit<Value, '$required'>
+	: Value extends PlainObject
+		? TypedSchema<Value>
+		: ToValueType<Value>;
 
 type ToSchemaType<Value> = UnwrapSingle<DeduplicateTuple<MapToValueTypes<UnionToTuple<Value>>>>;
 
@@ -149,21 +178,23 @@ type ToValueType<Value> = Value extends unknown[]
 			? 'boolean'
 			: Value extends Date
 				? 'date'
-				: Value extends Function
-					? 'function'
-					: Value extends null
-						? 'null'
-						: Value extends number
-							? 'number'
-							: Value extends object
-								? 'object' | ((value: unknown) => value is Value)
-								: Value extends string
-									? 'string'
-									: Value extends symbol
-										? 'symbol'
-										: Value extends undefined
-											? 'undefined'
-											: (value: unknown) => value is Value;
+				: Value extends Schematic<any>
+					? Value
+					: Value extends Function
+						? 'function'
+						: Value extends null
+							? 'null'
+							: Value extends number
+								? 'number'
+								: Value extends object
+									? 'object' | ((value: unknown) => value is Value)
+									: Value extends string
+										? 'string'
+										: Value extends symbol
+											? 'symbol'
+											: Value extends undefined
+												? 'undefined'
+												: (value: unknown) => value is Value;
 
 type TuplePermutations<
 	Tuple extends unknown[],
@@ -223,11 +254,13 @@ export type TypedPropertyRequired<Value> = {
 export type TypedSchema<Model extends PlainObject> = Simplify<
 	{
 		[Key in RequiredKeys<Model>]: Model[Key] extends PlainObject
-			? TypedSchemaRequired<Model[Key]>
+			? TypedSchemaRequired<Model[Key]> | Schematic<Model[Key]>
 			: ToSchemaType<Model[Key]> | TypedPropertyRequired<Model[Key]>;
 	} & {
 		[Key in OptionalKeys<Model>]: Exclude<Model[Key], undefined> extends PlainObject
-			? TypedSchemaOptional<Exclude<Model[Key], undefined>>
+			?
+					| TypedSchemaOptional<Exclude<Model[Key], undefined>>
+					| Schematic<Exclude<Model[Key], undefined>>
 			: TypedPropertyOptional<Model[Key]>;
 	}
 >;
@@ -257,26 +290,24 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
 		: Value;
 
 export type ValidatedProperty = {
+	key: ValidatedPropertyKey;
 	required: boolean;
 	types: ValidatedPropertyType[];
 	validators: ValidatedPropertyValidators;
 };
 
-export type ValidatedPropertyType = Schematic<unknown> | ValueName;
+export type ValidatedPropertyKey = {
+	full: string;
+	prefix: string | undefined;
+	value: string;
+};
+
+export type ValidatedPropertyType = GenericCallback | Schematic<unknown> | ValueName;
 
 export type ValidatedPropertyValidators = {
 	[Key in ValueName]?: Array<(value: unknown) => boolean>;
 };
 
-export type ValidatedSchema = {
-	enabled: boolean;
-	keys: {
-		array: string[];
-		set: Set<string>;
-	};
-	properties: Record<string, ValidatedProperty>;
-};
-
 /**
  * Valid type name strings
  */

package/src/schematic.ts

@@ -1,8 +1,16 @@
+import {isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {SCHEMATIC_NAME} from './constants';
-import type {Infer, Schema, TypedSchema, ValidatedSchema} from './models';
-import {getSchema} from './validation/schema.validation';
-import {validateValue} from './validation/value.validation';
+import {MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME} from './constants';
+import {isSchematic} from './is';
+import {
+	SchematicError,
+	type Infer,
+	type Schema,
+	type TypedSchema,
+	type ValidatedProperty,
+} from './models';
+import {getProperties} from './validation/property.validation';
+import {validateObject} from './validation/value.validation';
 
 /**
  * A schematic for validating objects
@@ -10,27 +18,21 @@ import {validateValue} from './validation/value.validation';
 export class Schematic<Model> {
 	declare private readonly $schematic: true;
 
-	#schema: ValidatedSchema;
+	#properties: ValidatedProperty[];
 
-	get enabled(): boolean {
-		return this.#schema.enabled;
-	}
-
-	constructor(schema: Model) {
+	constructor(properties: ValidatedProperty[]) {
 		Object.defineProperty(this, SCHEMATIC_NAME, {
 			value: true,
 		});
 
-		this.#schema = getSchema(schema);
-
-		this.#schema.enabled = this.#schema.keys.array.length > 0;
+		this.#properties = properties;
 	}
 
 	/**
 	 * Does the value match the schema?
 	 */
 	is(value: unknown): value is Model {
-		return this.#schema.enabled && validateValue(this.#schema, value);
+		return validateObject(value, this.#properties);
 	}
 }
 
@@ -45,5 +47,13 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Infer<
 export function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
 
 export function schematic<Model extends Schema>(schema: Model): Schematic<Model> {
-	return new Schematic<Model>(schema);
+	if (isSchematic(schema)) {
+		return schema;
+	}
+
+	if (!isPlainObject(schema)) {
+		throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
+	}
+
+	return new Schematic<Model>(getProperties(schema));
 }

package/src/validation/property.validation.ts

@@ -0,0 +1,190 @@
+import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {smush} from '@oscarpalmer/atoms/value/misc';
+import {
+	EXPRESSION_INDEX,
+	EXPRESSION_KEY_PREFIX,
+	EXPRESSION_KEY_VALUE,
+	EXPRESSION_PROPERTY,
+	MESSAGE_SCHEMA_INVALID_EMPTY,
+	MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
+	MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
+	MESSAGE_VALIDATOR_INVALID_KEY,
+	MESSAGE_VALIDATOR_INVALID_TYPE,
+	MESSAGE_VALIDATOR_INVALID_VALUE,
+	PROPERTY_REQUIRED,
+	PROPERTY_TYPE,
+	PROPERTY_VALIDATORS,
+	TEMPLATE_PATTERN,
+	TYPE_ALL,
+	TYPE_OBJECT,
+	TYPE_UNDEFINED,
+	VALIDATABLE_TYPES,
+} from '../constants';
+import {instanceOf, isSchematic} from '../is';
+import {
+	SchematicError,
+	type ValidatedProperty,
+	type ValidatedPropertyType,
+	type ValidatedPropertyValidators,
+	type ValueName,
+} from '../models';
+import {schematic} from '../schematic';
+
+function getKeyPrefix(key: string): string | undefined {
+	const prefix = key.replace(EXPRESSION_KEY_PREFIX, '');
+
+	return prefix === key ? undefined : prefix;
+}
+
+function getKeyValue(key: string): string {
+	return key.replace(EXPRESSION_KEY_VALUE, '$1');
+}
+
+export function getProperties(original: PlainObject): ValidatedProperty[] {
+	if (Object.keys(original).length === 0) {
+		throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
+	}
+
+	const smushed = smush(original);
+	const keys = Object.keys(smushed);
+	const keysLength = keys.length;
+
+	const properties: ValidatedProperty[] = [];
+
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+
+		if (EXPRESSION_INDEX.test(key) || EXPRESSION_PROPERTY.test(key)) {
+			continue;
+		}
+
+		const keyPrefix = getKeyPrefix(key);
+		const keyValue = getKeyValue(key);
+		const value = smushed[key];
+
+		const types: ValidatedPropertyType[] = [];
+
+		let required = true;
+		let validators: ValidatedPropertyValidators = {};
+
+		if (isPlainObject(value)) {
+			required = getRequired(key, value) ?? required;
+			validators = getValidators(value[PROPERTY_VALIDATORS]);
+
+			if (PROPERTY_TYPE in value) {
+				types.push(...getTypes(key, value[PROPERTY_TYPE]));
+			} else {
+				types.push(TYPE_OBJECT);
+			}
+		} else {
+			types.push(...getTypes(key, value));
+		}
+
+		if (!required && !types.includes(TYPE_UNDEFINED)) {
+			types.push(TYPE_UNDEFINED);
+		}
+
+		properties.push({
+			types,
+			validators,
+			key: {
+				full: key,
+				prefix: keyPrefix,
+				value: keyValue,
+			},
+			required: required && !types.includes(TYPE_UNDEFINED),
+		});
+	}
+
+	return properties;
+}
+
+function getRequired(key: string, value: PlainObject): boolean | undefined {
+	if (!(PROPERTY_REQUIRED in value)) {
+		return;
+	}
+
+	if (typeof value[PROPERTY_REQUIRED] !== 'boolean') {
+		throw new SchematicError(
+			MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key),
+		);
+	}
+
+	return value[PROPERTY_REQUIRED];
+}
+
+function getTypes(key: string, original: unknown): ValidatedPropertyType[] {
+	const array = Array.isArray(original) ? original : [original];
+	const {length} = array;
+
+	const types: ValidatedPropertyType[] = [];
+
+	for (let index = 0; index < length; index += 1) {
+		const value = array[index];
+
+		switch (true) {
+			case typeof value === 'function':
+				types.push(isConstructor(value) ? instanceOf(value) : value);
+				break;
+
+			case isPlainObject(value):
+				types.push(schematic(value as never));
+				break;
+
+			case isSchematic(value):
+				types.push(value);
+				break;
+
+			case TYPE_ALL.has(value as never):
+				types.push(value as never);
+				break;
+
+			default:
+				throw new SchematicError(
+					MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key),
+				);
+		}
+	}
+
+	if (types.length === 0) {
+		throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, key));
+	}
+
+	return types;
+}
+
+function getValidators(original: unknown): ValidatedPropertyValidators {
+	const validators: ValidatedPropertyValidators = {};
+
+	if (original == null) {
+		return validators;
+	}
+
+	if (!isPlainObject(original)) {
+		throw new TypeError(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 (!VALIDATABLE_TYPES.has(key as never)) {
+			throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+		}
+
+		const value = (original as PlainObject)[key];
+
+		validators[key as ValueName] = (Array.isArray(value) ? value : [value]).filter(item => {
+			if (typeof item !== 'function') {
+				throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key));
+			}
+
+			return true;
+		});
+	}
+
+	return validators;
+}

package/src/validation/value.validation.ts

@@ -1,73 +1,49 @@
-import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value/misc';
-import {TYPE_UNDEFINED} from '../constants';
-import type {ValidatedProperty, ValidatedPropertyType, ValidatedSchema, Values} from '../models';
+import {isPlainObject} from '@oscarpalmer/atoms/is';
+import {isSchematic} from '../is';
+import type {ValidatedProperty, ValidatedPropertyType, ValueName} from '../models';
 
-export function validateType(
-	type: ValidatedPropertyType,
-	property: ValidatedProperty,
-	value: unknown,
-): boolean {
-	switch (true) {
-		case typeof type === 'function':
-			return (type as any)(value);
-
-		case typeof type === 'string':
-			return (
-				validators[type](value) &&
-				(property.validators[type]?.every(validator => validator(value)) ?? true)
-			);
-
-		default:
-			return type.is(value);
-	}
-}
-
-export function validateValue(validated: ValidatedSchema, obj: unknown): boolean {
-	if (typeof obj !== 'object' || obj === null) {
+export function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean {
+	if (!isPlainObject(obj)) {
 		return false;
 	}
 
-	const {keys, properties} = validated;
-	const keysLength = keys.array.length;
+	const ignoredKeys = new Set<string>();
+	const propertiesLength = properties.length;
 
-	const ignore = new Set<string>();
+	let key!: string;
+	let value!: unknown;
 
-	const smushed = smush(obj as PlainObject);
+	outer: for (let propertyIndex = 0; propertyIndex < propertiesLength; propertyIndex += 1) {
+		const property = properties[propertyIndex];
 
-	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
-		const key = keys.array[keyIndex];
+		if (ignoredKeys.has(property.key.prefix!)) {
+			key = undefined as never;
 
-		const prefix = key.replace(EXPRESSION_SUFFIX, '');
+			ignoredKeys.add(property.key.full);
 
-		if (ignore.has(prefix)) {
 			continue;
 		}
 
-		const property = properties[key];
-		const value = smushed[key];
+		/* if (key == null || !property.key.full.startsWith(key)) {
+			value = obj[property.key.full];
+		} else {
+			value = (value as PlainObject)?.[property.key.value];
+		} */
+
+		key = property.key.full;
+		value = obj[key];
 
-		if (value === undefined && property.required && !property.types.includes(TYPE_UNDEFINED)) {
+		if (value === undefined && property.required) {
 			return false;
 		}
 
 		const typesLength = property.types.length;
 
-		if (typesLength === 1) {
-			if (!validateType(property.types[0], property, value)) {
-				return false;
-			}
-
-			continue;
-		}
-
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
 
-			if (validateType(type, property, value)) {
-				if ((type as never) !== 'object') {
-					ignore.add(key);
-				}
+			if (validateValue(type, property, value)) {
+				ignoredKeys.add(property.key.full);
 
 				continue outer;
 			}
@@ -79,20 +55,36 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 	return true;
 }
 
-//
+function validateValue(
+	type: ValidatedPropertyType,
+	property: ValidatedProperty,
+	value: unknown,
+): boolean {
+	switch (true) {
+		case typeof type === 'function':
+			return (type as (value: unknown) => boolean)(value);
+
+		case isSchematic(type):
+			return type.is(value);
 
-const EXPRESSION_SUFFIX = /\.\w+$/;
+		default:
+			return (
+				validators[type as ValueName](value) &&
+				(property.validators[type as ValueName]?.every(validator => validator(value)) ?? true)
+			);
+	}
+}
 
 //
 
-const validators: Record<keyof Values, (value: unknown) => boolean> = {
+const validators: Record<ValueName, (value: unknown) => boolean> = {
 	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' && !Number.isNaN(value),
+	number: value => typeof value === 'number',
 	object: value => typeof value === 'object' && value !== null,
 	string: value => typeof value === 'string',
 	symbol: value => typeof value === 'symbol',