@oscarpalmer/jhunal 0.3.0 → 0.5.0

package/src/model.ts

@@ -1,90 +1,113 @@
-import type {
-	OptionalKeysOf,
-	RequiredKeysOf,
-	Simplify,
-	UnionToTuple,
-} from 'type-fest';
+import type {Simplify} from '@oscarpalmer/atoms/models';
+import type {Schematic} from './schematic';
 
-export type GetKey<Value> = {
-	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
-
-export type GetTypes<Value extends unknown[]> = Value extends [infer Single]
-	? Single
-	: Value;
-
-export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
+export type AutoInferExclude = 'date-like' | 'numerical';
 
 export type InferProperty<Value> = Value extends Property
-	? Value['type'] extends keyof Values
-		? Values[Value['type']]
-		: Value['type'] extends (keyof Values)[]
-			? Values[Value['type'][number]]
-			: never
+	? InferPropertyType<Value['type']>
+	: never;
+
+type InferPropertyType<Value> = Value extends (infer Type)[]
+	? InferPropertyTypeValue<Type>[]
+	: InferPropertyTypeValue<Value>;
+
+type InferPropertyTypeValue<Value> = Value extends PropertyType
+	? Value extends Schema
+		? Inferred<Value>
+		: Value extends Schematic<infer Model>
+			? Model
+			: Value extends ValueKey
+				? Values[Value]
+				: Value extends (infer NestedElementType)[]
+					? InferPropertyTypeValue<NestedElementType>[]
+					: Value
 	: never;
 
-export type InferValue<Value> = Value extends keyof Values
+export type InferValue<Value> = Value extends ValueKey
 	? Values[Value]
-	: Value extends (keyof Values)[]
+	: Value extends ValueKey[]
 		? Values[Value[number]]
 		: never;
 
-export type Inferred<Model extends Schema> = {
-	[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property
-		? InferProperty<Model[Key]>
-		: InferValue<Model[Key]>;
-} & {
-	[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property
-		? InferProperty<Model[Key]>
-		: never;
+export type Inferred<Model extends Schema> = Simplify<
+	{
+		[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property
+			? InferProperty<Model[Key]>
+			: InferValue<Model[Key]>;
+	} & {
+		[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property
+			? InferProperty<Model[Key]>
+			: never;
+	}
+>;
+
+export type InferredOptionalProperties<Model extends Schema> = keyof {
+	[Key in keyof Model as IsOptionalInSchema<Model[Key]> extends true ? Key : never]: never;
 };
 
-export type InferredOptionalProperties<Model extends Schema> = {
-	[Key in keyof Model]: Model[Key] extends Property
-		? Model[Key]['required'] extends false
-			? Key
-			: never
-		: never;
-}[keyof Model];
+export type InferredRequiredProperties<Model extends Schema> = keyof {
+	[Key in keyof Model as IsOptionalInSchema<Model[Key]> extends true ? never : Key]: never;
+};
 
-export type InferredRequiredProperties<Model extends Schema> = {
-	[Key in keyof Model]: Model[Key] extends Property
-		? Model[Key]['required'] extends false
-			? never
-			: Key
-		: Key;
-}[keyof Model];
+type IsNestedObject<Value> = Value extends object
+	? Value extends any[] | Date | Function
+		? false
+		: true
+	: false;
+
+type IsOptionalInSchema<Prop> = Prop extends Property
+	? Prop['required'] extends false
+		? true
+		: false
+	: false;
+
+export type OptionalKeys<Value> = {
+	[Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
+}[keyof Value];
 
 export type OptionalProperty<Type> = {
 	required: false;
-	type: GetType<Type>;
+	type: PropertyTypeFor<Type>;
 };
 
 export type Property = {
 	required?: boolean;
-	type: keyof Values | (keyof Values)[];
+	type: PropertyType | PropertyType[];
 };
 
+type PropertyType = Schema | Schematic<unknown> | ValueKey;
+
+type PropertyTypeFor<Value> =
+	IsNestedObject<Value> extends true
+		? Value extends Typed
+			? TypedSchema<Value>
+			: never
+		: ValueToType<Value>;
+
+type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
+
 export type RequiredProperty<Type> = {
 	required: true;
-	type: GetType<Type>;
+	type: PropertyTypeFor<Type>;
 };
 
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
-
-/**
- * A schematic for validating objects
- */
-export type Schematic<Model> = {
-	/**
-	 * Does the value match the schema?
-	 */
-	is(value: unknown): value is Model;
+export type Schema = {
+	[key: string]: Property | ValueKey | ValueKey[];
 };
 
+export type TypeToValueKey<Value> = {
+	[Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
+}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey
+	? SpecificKey extends never
+		? {
+				[Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+			}[AutoInferExclude]
+		: SpecificKey
+	: never;
+
 export type Typed = Record<string, unknown>;
 
 /**
@@ -92,34 +115,69 @@ export type Typed = Record<string, unknown>;
  */
 export type TypedSchema<Model extends Typed> = Simplify<
 	{
-		[Key in RequiredKeysOf<Model>]:
-			| GetType<Model[Key]>
-			| RequiredProperty<Model[Key]>;
+		[Key in RequiredKeys<Model>]: IsNestedObject<Model[Key]> extends true
+			? Model[Key] extends Typed
+				? TypedSchema<Model[Key]>
+				: never
+			: ValueToType<Model[Key]> | RequiredProperty<Model[Key]>;
 	} & {
-		[Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
+		[Key in OptionalKeys<Model>]: IsNestedObject<Model[Key]> extends true
+			? Exclude<Model[Key], undefined> extends Typed
+				? TypedSchema<Exclude<Model[Key], undefined>> | OptionalProperty<Model[Key]>
+				: never
+			: OptionalProperty<Model[Key]>;
 	}
 >;
 
+type UnionToIntersection<Value> = (Value extends any ? (value: Value) => void : never) extends (
+	item: infer Item,
+) => void
+	? Item
+	: never;
+
+type LastOfUnion<Value> =
+	UnionToIntersection<Value extends any ? () => Value : never> extends () => infer Item
+		? Item
+		: never;
+
+type UnionToTuple<Value, Values extends any[] = []> = [Value] extends [never]
+	? Values
+	: UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Values]>;
+
 export type ValidatedProperty = {
 	required: boolean;
-	types: (keyof Values)[];
+	types: ValidatedPropertyType[];
 };
 
+export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
+
 export type ValidatedSchema = {
 	keys: string[];
 	length: number;
-	properties: Record<string, ValidatedProperty>;
+	properties: ValidatedSchemaProperties;
 };
 
+type ValidatedSchemaProperties = {
+	[key: string]: ValidatedProperty;
+};
+
+export type ValueKey = keyof Values;
+
+export type ValueToType<Value> = ValueToTypes<UnionToTuple<TypeToValueKey<Value>>>;
+
+export type ValueToTypes<Value extends unknown[]> = Value extends [infer Type] ? Type : Value;
+
 export type Values = {
 	array: unknown[];
 	bigint: bigint;
 	boolean: boolean;
 	date: Date;
+	'date-like': number | string | Date;
 	// biome-ignore lint/complexity/noBannedTypes: it's the most basic value type, so I think it's ok
 	function: Function;
 	null: null;
 	number: number;
+	numerical: bigint | number;
 	object: object;
 	string: string;
 	symbol: symbol;

package/src/schematic.ts

@@ -1,26 +1,48 @@
-import type {Inferred, Schema, Schematic, Typed, TypedSchema} from './model';
-import {getValidatedSchema, validate} from './validation';
+import type {Inferred, Schema, Typed, TypedSchema, ValidatedSchema} from './model';
+import {validateSchema} from './validation/schema.validation';
+import {validateValue} from './validation/value.validation';
 
 /**
- * Create a schematic from a typed schema
+ * A schematic for validating objects
  */
-export function schematic<Model extends Typed>(
-	schema: TypedSchema<Model>,
-): Schematic<Model>;
+export class Schematic<Model> {
+	declare private readonly $schematic: true;
+
+	#schema: ValidatedSchema;
+	#validatable: boolean;
+
+	get validatable(): boolean {
+		return this.#validatable;
+	}
+
+	constructor(schema: Model) {
+		Object.defineProperty(this, '$schematic', {
+			value: true,
+		});
+
+		this.#schema = validateSchema(schema as unknown as Schema);
+
+		this.#validatable = this.#schema.length > 0;
+	}
+
+	/**
+	 * Does the value match the schema?
+	 */
+	is(value: unknown): value is Model {
+		return this.#validatable && validateValue(this.#schema, value);
+	}
+}
 
 /**
  * Create a schematic from a schema
  */
-export function schematic<Model extends Schema>(
-	schema: Model,
-): Schematic<Inferred<Model>>;
-
-export function schematic<Model extends Schema>(schema: Model) {
-	const validated = getValidatedSchema(schema);
+export function schematic<Model extends Schema>(schema: Model): Schematic<Inferred<Model>>;
 
-	const canValidate = validated.length > 0;
+/**
+ * Create a schematic from a typed schema
+ */
+export function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
 
-	return Object.freeze({
-		is: (value: unknown) => canValidate && validate(validated, value),
-	});
+export function schematic<Model extends Schema>(schema: Model): Schematic<Model> {
+	return new Schematic<Model>(schema);
 }

package/src/validation/schema.validation.ts

@@ -0,0 +1,63 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {getTypes} from '../helpers';
+import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../model';
+
+export function validateSchema(schema: unknown): ValidatedSchema {
+	if (validatedSchemas.has(schema as never)) {
+		return validatedSchemas.get(schema as never) as ValidatedSchema;
+	}
+
+	const validated: ValidatedSchema = {
+		keys: [],
+		length: 0,
+		properties: {},
+	};
+
+	if (typeof schema !== 'object' || schema === null) {
+		return validated;
+	}
+
+	const keys = Object.keys(schema);
+	const {length} = keys;
+
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const value = (schema as Schema)[key];
+
+		let required = true;
+		let types: ValidatedPropertyType[];
+
+		if (Array.isArray(value)) {
+			types = getTypes(value);
+		} else if (typeof value === 'object' && value !== null) {
+			if (typeof (value as PlainObject).required === 'boolean') {
+				required = (value as PlainObject).required as boolean;
+			}
+
+			types = getTypes((value as PlainObject).type);
+		} else {
+			types = getTypes(value);
+		}
+
+		if (types.length > 0) {
+			if (!required && !types.includes('undefined')) {
+				types.push('undefined');
+			}
+
+			validated.keys.push(key);
+
+			validated.properties[key] = {
+				required,
+				types,
+			};
+
+			validated.length += 1;
+		}
+	}
+
+	validatedSchemas.set(schema as never, validated);
+
+	return validated;
+}
+
+export const validatedSchemas = new WeakMap<Schema, ValidatedSchema>();

package/src/validation/value.validation.ts

@@ -0,0 +1,69 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {isDateLike, isSchematic} from '../is';
+import type {ValidatedPropertyType, ValidatedSchema, Values} from '../model';
+
+export function validateType(type: ValidatedPropertyType, value: unknown): boolean {
+	if (typeof type === 'string') {
+		return validators[type](value);
+	}
+
+	if (isSchematic(type)) {
+		return type.is(value);
+	}
+
+	return validateValue(type as ValidatedSchema, value);
+}
+
+export function validateValue(validated: ValidatedSchema, obj: unknown): boolean {
+	if (typeof obj !== 'object' || obj === null) {
+		return false;
+	}
+
+	outer: for (let keyIndex = 0; keyIndex < validated.length; keyIndex += 1) {
+		const key = validated.keys[keyIndex];
+		const property = validated.properties[key];
+		const value = (obj as PlainObject)[key];
+
+		if (value === undefined && property.required && !property.types.includes('undefined')) {
+			return false;
+		}
+
+		const typesLength = property.types.length;
+
+		if (typesLength === 1) {
+			if (!validateType(property.types[0], value)) {
+				return false;
+			}
+
+			continue;
+		}
+
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			if (validateType(property.types[typeIndex], value)) {
+				continue outer;
+			}
+		}
+
+		return false;
+	}
+
+	return true;
+}
+
+//
+
+const validators: Record<keyof Values, (value: unknown) => boolean> = {
+	array: Array.isArray,
+	bigint: value => typeof value === 'bigint',
+	boolean: value => typeof value === 'boolean',
+	date: value => value instanceof Date,
+	'date-like': isDateLike,
+	function: value => typeof value === 'function',
+	null: value => value === null,
+	number: value => typeof value === 'number',
+	numerical: value => validators.bigint(value) || validators.number(value),
+	object: value => typeof value === 'object' && value !== null,
+	string: value => typeof value === 'string',
+	symbol: value => typeof value === 'symbol',
+	undefined: value => value === undefined,
+};

package/types/helpers.d.ts

@@ -1,2 +1,2 @@
-import type { Values } from './model';
-export declare function getTypes(value: unknown): (keyof Values)[];
+import type { ValidatedPropertyType } from './model';
+export declare function getTypes(value: unknown): ValidatedPropertyType[];

package/types/index.d.ts

@@ -1,2 +1,2 @@
-export type { Schema, Schematic } from './model';
-export * from './schematic';
+export type { Schema, TypedSchema } from './model';
+export { schematic, type Schematic } from './schematic';

package/types/is.d.ts

@@ -0,0 +1,3 @@
+import type { Schematic } from './schematic';
+export declare function isDateLike(value: unknown): value is Date;
+export declare function isSchematic(value: unknown): value is Schematic<never>;

package/types/model.d.ts

@@ -1,75 +1,93 @@
-import type { OptionalKeysOf, RequiredKeysOf, Simplify, UnionToTuple } from 'type-fest';
-export type GetKey<Value> = {
-    [Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
-export type GetTypes<Value extends unknown[]> = Value extends [infer Single] ? Single : Value;
-export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-export type InferProperty<Value> = Value extends Property ? Value['type'] extends keyof Values ? Values[Value['type']] : Value['type'] extends (keyof Values)[] ? Values[Value['type'][number]] : never : never;
-export type InferValue<Value> = Value extends keyof Values ? Values[Value] : Value extends (keyof Values)[] ? Values[Value[number]] : never;
-export type Inferred<Model extends Schema> = {
+import type { Simplify } from '@oscarpalmer/atoms/models';
+import type { Schematic } from './schematic';
+export type AutoInferExclude = 'date-like' | 'numerical';
+export type InferProperty<Value> = Value extends Property ? InferPropertyType<Value['type']> : never;
+type InferPropertyType<Value> = Value extends (infer Type)[] ? InferPropertyTypeValue<Type>[] : InferPropertyTypeValue<Value>;
+type InferPropertyTypeValue<Value> = Value extends PropertyType ? Value extends Schema ? Inferred<Value> : Value extends Schematic<infer Model> ? Model : Value extends ValueKey ? Values[Value] : Value extends (infer NestedElementType)[] ? InferPropertyTypeValue<NestedElementType>[] : Value : never;
+export type InferValue<Value> = Value extends ValueKey ? Values[Value] : Value extends ValueKey[] ? Values[Value[number]] : never;
+export type Inferred<Model extends Schema> = Simplify<{
     [Key in InferredRequiredProperties<Model>]: Model[Key] extends Property ? InferProperty<Model[Key]> : InferValue<Model[Key]>;
 } & {
     [Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property ? InferProperty<Model[Key]> : never;
+}>;
+export type InferredOptionalProperties<Model extends Schema> = keyof {
+    [Key in keyof Model as IsOptionalInSchema<Model[Key]> extends true ? Key : never]: never;
+};
+export type InferredRequiredProperties<Model extends Schema> = keyof {
+    [Key in keyof Model as IsOptionalInSchema<Model[Key]> extends true ? never : Key]: never;
 };
-export type InferredOptionalProperties<Model extends Schema> = {
-    [Key in keyof Model]: Model[Key] extends Property ? Model[Key]['required'] extends false ? Key : never : never;
-}[keyof Model];
-export type InferredRequiredProperties<Model extends Schema> = {
-    [Key in keyof Model]: Model[Key] extends Property ? Model[Key]['required'] extends false ? never : Key : Key;
-}[keyof Model];
+type IsNestedObject<Value> = Value extends object ? Value extends any[] | Date | Function ? false : true : false;
+type IsOptionalInSchema<Prop> = Prop extends Property ? Prop['required'] extends false ? true : false : false;
+export type OptionalKeys<Value> = {
+    [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
+}[keyof Value];
 export type OptionalProperty<Type> = {
     required: false;
-    type: GetType<Type>;
+    type: PropertyTypeFor<Type>;
 };
 export type Property = {
     required?: boolean;
-    type: keyof Values | (keyof Values)[];
+    type: PropertyType | PropertyType[];
 };
+type PropertyType = Schema | Schematic<unknown> | ValueKey;
+type PropertyTypeFor<Value> = IsNestedObject<Value> extends true ? Value extends Typed ? TypedSchema<Value> : never : ValueToType<Value>;
+type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
 export type RequiredProperty<Type> = {
     required: true;
-    type: GetType<Type>;
+    type: PropertyTypeFor<Type>;
 };
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
-/**
- * A schematic for validating objects
- */
-export type Schematic<Model> = {
-    /**
-     * Does the value match the schema?
-     */
-    is(value: unknown): value is Model;
+export type Schema = {
+    [key: string]: Property | ValueKey | ValueKey[];
 };
+export type TypeToValueKey<Value> = {
+    [Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key] ? Key : never;
+}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey ? SpecificKey extends never ? {
+    [Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+}[AutoInferExclude] : SpecificKey : never;
 export type Typed = Record<string, unknown>;
 /**
  * A typed schema for validating objects
  */
 export type TypedSchema<Model extends Typed> = Simplify<{
-    [Key in RequiredKeysOf<Model>]: GetType<Model[Key]> | RequiredProperty<Model[Key]>;
+    [Key in RequiredKeys<Model>]: IsNestedObject<Model[Key]> extends true ? Model[Key] extends Typed ? TypedSchema<Model[Key]> : never : ValueToType<Model[Key]> | RequiredProperty<Model[Key]>;
 } & {
-    [Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
+    [Key in OptionalKeys<Model>]: IsNestedObject<Model[Key]> extends true ? Exclude<Model[Key], undefined> extends Typed ? TypedSchema<Exclude<Model[Key], undefined>> | OptionalProperty<Model[Key]> : never : OptionalProperty<Model[Key]>;
 }>;
+type UnionToIntersection<Value> = (Value extends any ? (value: Value) => void : never) extends (item: infer Item) => void ? Item : never;
+type LastOfUnion<Value> = UnionToIntersection<Value extends any ? () => Value : never> extends () => infer Item ? Item : never;
+type UnionToTuple<Value, Values extends any[] = []> = [Value] extends [never] ? Values : UnionToTuple<Exclude<Value, LastOfUnion<Value>>, [LastOfUnion<Value>, ...Values]>;
 export type ValidatedProperty = {
     required: boolean;
-    types: (keyof Values)[];
+    types: ValidatedPropertyType[];
 };
+export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
 export type ValidatedSchema = {
     keys: string[];
     length: number;
-    properties: Record<string, ValidatedProperty>;
+    properties: ValidatedSchemaProperties;
+};
+type ValidatedSchemaProperties = {
+    [key: string]: ValidatedProperty;
 };
+export type ValueKey = keyof Values;
+export type ValueToType<Value> = ValueToTypes<UnionToTuple<TypeToValueKey<Value>>>;
+export type ValueToTypes<Value extends unknown[]> = Value extends [infer Type] ? Type : Value;
 export type Values = {
     array: unknown[];
     bigint: bigint;
     boolean: boolean;
     date: Date;
+    'date-like': number | string | Date;
     function: Function;
     null: null;
     number: number;
+    numerical: bigint | number;
     object: object;
     string: string;
     symbol: symbol;
     undefined: undefined;
 };
+export {};

package/types/schematic.d.ts

@@ -1,9 +1,22 @@
-import type { Inferred, Schema, Schematic, Typed, TypedSchema } from './model';
+import type { Inferred, Schema, Typed, TypedSchema } from './model';
 /**
- * Create a schematic from a typed schema
+ * A schematic for validating objects
  */
-export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;
+export declare class Schematic<Model> {
+    #private;
+    private readonly $schematic;
+    get validatable(): boolean;
+    constructor(schema: Model);
+    /**
+     * Does the value match the schema?
+     */
+    is(value: unknown): value is Model;
+}
 /**
  * Create a schematic from a schema
  */
 export declare function schematic<Model extends Schema>(schema: Model): Schematic<Inferred<Model>>;
+/**
+ * Create a schematic from a typed schema
+ */
+export declare function schematic<Model extends Typed>(schema: TypedSchema<Model>): Schematic<Model>;

package/types/validation/schema.validation.d.ts

@@ -0,0 +1,3 @@
+import type { Schema, ValidatedSchema } from '../model';
+export declare function validateSchema(schema: unknown): ValidatedSchema;
+export declare const validatedSchemas: WeakMap<Schema, ValidatedSchema>;

package/types/validation/value.validation.d.ts

@@ -0,0 +1,3 @@
+import type { ValidatedPropertyType, ValidatedSchema } from '../model';
+export declare function validateType(type: ValidatedPropertyType, value: unknown): boolean;
+export declare function validateValue(validated: ValidatedSchema, obj: unknown): boolean;

package/dist/helpers.cjs

@@ -1,24 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-function getTypes(value) {
-  return (Array.isArray(value) ? value : [value]).filter(
-    (item) => types.has(item)
-  );
-}
-const types = /* @__PURE__ */ new Set([
-  "array",
-  "bigint",
-  "boolean",
-  "date",
-  "function",
-  "null",
-  "number",
-  "object",
-  "string",
-  "symbol",
-  "undefined"
-]);
-
-exports.getTypes = getTypes;

package/dist/index.cjs

@@ -1,9 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const schematic = require('./schematic.cjs');
-
-
-
-exports.schematic = schematic.schematic;

package/dist/model.cjs

@@ -1,2 +0,0 @@
-'use strict';
-