@webergency-utils/typechecker 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export interface IValidation<T> {
+    success: boolean;
+    data?: T;
+    errors?: any[];
+}
+export type ValidationMode = 'strict' | 'relaxed' | 'strip';
+export interface ValidationOptions {
+    mode?: ValidationMode;
+    tryConvert?: boolean;
+    wrapArrays?: boolean;
+    schema?: any;
+    errorFactory?: (errors: any[]) => Error;
+}
+export declare function is<T>(input: unknown, options?: ValidationMode | ValidationOptions): input is T;
+export declare function assert<T>(input: unknown, options?: ValidationMode | ValidationOptions): T;
+export declare function assertGuard<T>(input: unknown, options?: ValidationMode | ValidationOptions): asserts input is T;
+export declare function validate<T>(input: unknown, options?: ValidationMode | ValidationOptions): IValidation<T>;
+export declare function jsonSchema<T>(): any;
+export * from './runtime/validators.js';
+export * from './runtime/tags.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './runtime/validators.js';
+export * from './runtime/tags.js';

package/dist/runtime/tags/constraint.d.ts

@@ -0,0 +1,61 @@
+export type MinLength<N extends number, Msg extends string = string> = {
+    readonly __minLength: N;
+    readonly __minLength_message?: Msg;
+};
+export type MaxLength<N extends number, Msg extends string = string> = {
+    readonly __maxLength: N;
+    readonly __maxLength_message?: Msg;
+};
+export type Pattern<S extends string, Msg extends string = string> = {
+    readonly __pattern: S;
+    readonly __pattern_message?: Msg;
+};
+export type Format<S extends 'email' | 'uuid' | 'url' | 'ipv4' | 'ipv6' | 'date' | 'date-time' | 'byte' | 'password' | 'regex' | 'hostname' | 'idn-email' | 'idn-hostname' | 'iri' | 'iri-reference' | 'uri' | 'uri-reference' | 'uri-template' | 'time' | 'duration' | 'objectId', Msg extends string = string> = {
+    readonly __format: S;
+    readonly __format_message?: Msg;
+};
+export type Length<Min extends number, Max extends number> = MinLength<Min> & MaxLength<Max>;
+export type Minimum<N extends number | bigint, Msg extends string = string> = {
+    readonly __minimum: N;
+    readonly __minimum_message?: Msg;
+};
+export type Maximum<N extends number | bigint, Msg extends string = string> = {
+    readonly __maximum: N;
+    readonly __maximum_message?: Msg;
+};
+export type ExclusiveMinimum<N extends number | bigint, Msg extends string = string> = {
+    readonly __exclusiveMinimum: N;
+    readonly __exclusiveMinimum_message?: Msg;
+};
+export type ExclusiveMaximum<N extends number | bigint, Msg extends string = string> = {
+    readonly __exclusiveMaximum: N;
+    readonly __exclusiveMaximum_message?: Msg;
+};
+export type MultipleOf<N extends number | bigint, Msg extends string = string> = {
+    readonly __multipleOf: N;
+    readonly __multipleOf_message?: Msg;
+};
+export type Range<Min extends number | bigint, Max extends number | bigint> = Minimum<Min> & Maximum<Max>;
+export type MinItems<N extends number, Msg extends string = string> = {
+    readonly __minItems: N;
+    readonly __minItems_message?: Msg;
+};
+export type MaxItems<N extends number, Msg extends string = string> = {
+    readonly __maxItems: N;
+    readonly __maxItems_message?: Msg;
+};
+export type UniqueItems<Msg extends string = string> = {
+    readonly __uniqueItems: true;
+    readonly __uniqueItems_message?: Msg;
+};
+export type Custom<Fn extends (...args: any[]) => boolean, Msg extends string = string> = {
+    readonly __custom: Fn;
+    readonly __custom_message?: Msg;
+};
+export type Requires<Paths extends string | readonly string[], Msg extends string = string> = {
+    readonly __requires: Paths;
+    readonly __requires_message?: Msg;
+};
+export type Message<Msg extends string> = {
+    readonly __message: Msg;
+};

package/dist/runtime/tags/constraint.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tags/format.d.ts

@@ -0,0 +1,15 @@
+import type { Format } from './constraint.js';
+export type Email = Format<'email'>;
+export type UUID = Format<'uuid'>;
+export type URL = Format<'url'>;
+export type IPv4 = Format<'ipv4'>;
+export type IPv6 = Format<'ipv6'>;
+export type Date = Format<'date'>;
+export type DateTime = Format<'date-time'>;
+export type Byte = Format<'byte'>;
+export type Password = Format<'password'>;
+export type Regex = Format<'regex'>;
+export type Hostname = Format<'hostname'>;
+export type Time = Format<'time'>;
+export type Duration = Format<'duration'>;
+export type ObjectId = Format<'objectId'>;

package/dist/runtime/tags/format.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tags/tag.d.ts

@@ -0,0 +1,3 @@
+export type Default<V extends string | number | boolean | null> = {
+    readonly __default: V;
+};

package/dist/runtime/tags/tag.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tags/transform.d.ts

@@ -0,0 +1,24 @@
+export type LowerCase = {
+    readonly __transform_lowercase: true;
+};
+export type UpperCase = {
+    readonly __transform_uppercase: true;
+};
+export type Trim = {
+    readonly __transform_trim: true;
+};
+export type Capitalize = {
+    readonly __transform_capitalize: true;
+};
+export type ToNumber = {
+    readonly __transform_tonumber: true;
+};
+export type ToBoolean = {
+    readonly __transform_toboolean: true;
+};
+export type ToDate = {
+    readonly __transform_todate: true;
+};
+export type Custom<Fn extends (val: any) => any> = {
+    readonly __transform_custom: Fn;
+};

package/dist/runtime/tags/transform.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tags.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Validation Tags for AOT Typechecker
+ * These are used in intersection types to add constraints.
+ * Example: type Password = string & MinLength<8>;
+ */
+export * from './tags/constraint.js';
+export * as constraint from './tags/constraint.js';
+export * as tag from './tags/tag.js';
+export * as format from './tags/format.js';
+export * as transform from './tags/transform.js';
+export interface ITypeConstraints {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    minimum?: number | bigint;
+    maximum?: number | bigint;
+    exclusiveMinimum?: number | bigint;
+    exclusiveMaximum?: number | bigint;
+    multipleOf?: number | bigint;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    custom?: string;
+    default?: string | number | boolean | null;
+}
+type Split<S extends string, D extends string> = S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
+type ModifierPathTuple<T, Path extends string[], Modifiers> = Path extends [infer Key, ...infer Rest] ? Key extends keyof T ? {
+    [P in keyof T]: P extends Key ? Rest extends string[] ? Rest['length'] extends 0 ? T[P] & Modifiers : ModifierPathTuple<Exclude<T[P], undefined>, Rest, Modifiers> | (undefined extends T[P] ? undefined : never) : T[P] : T[P];
+} : T : T;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type LastOf<U> = UnionToIntersection<U extends any ? (f: U) => void : never> extends ((a: infer A) => void) ? A : never;
+type Push<T extends any[], V> = [...T, V];
+type TuplifyUnion<U, L = LastOf<U>> = [
+    U
+] extends [never] ? [] : Push<TuplifyUnion<Exclude<U, L>>, L>;
+type Entries<M> = {
+    [K in keyof M]: [K, M[K]];
+}[keyof M];
+type ApplyModifiers<T, EntriesList extends any[]> = EntriesList extends [[infer Path, infer Modifiers], ...infer Rest] ? Path extends string ? ApplyModifiers<ModifierPathTuple<T, Split<Path, '.'>, Modifiers>, Rest> : T : T;
+/**
+ * Utility type to decorate nested properties of a type with validation/transform modifiers without retyping the structure.
+ */
+export type WithModifiers<T, M> = ApplyModifiers<T, TuplifyUnion<Entries<M>>>;

package/dist/runtime/tags.js

@@ -0,0 +1,12 @@
+/**
+ * Validation Tags for AOT Typechecker
+ * These are used in intersection types to add constraints.
+ * Example: type Password = string & MinLength<8>;
+ */
+// Export root-level tags for backward compatibility
+export * from './tags/constraint.js';
+// Export namespace-like modules
+export * as constraint from './tags/constraint.js';
+export * as tag from './tags/tag.js';
+export * as format from './tags/format.js';
+export * as transform from './tags/transform.js';

package/dist/runtime/validators.d.ts

@@ -0,0 +1,89 @@
+export type ValidationMode = 'strict' | 'relaxed' | 'strip';
+export interface IValidationError {
+    path: string;
+    value: any;
+    error: string;
+}
+export interface ValidationContext {
+    success: boolean;
+    errors: IValidationError[];
+    mode: ValidationMode;
+    tryConvert?: boolean;
+    wrapArrays?: boolean;
+    root?: any;
+}
+export interface ValidationOptions {
+    mode?: ValidationMode;
+    tryConvert?: boolean;
+    wrapArrays?: boolean;
+    schema?: any;
+    errorFactory?: (errors: IValidationError[]) => Error;
+}
+export declare const validators: {
+    string: (v: any, path: string, ctx: ValidationContext) => any;
+    number: (v: any, path: string, ctx: ValidationContext) => any;
+    bigint: (v: any, path: string, ctx: ValidationContext) => any;
+    boolean: (v: any, path: string, ctx: ValidationContext) => any;
+    date: (v: any, path: string, ctx: ValidationContext) => any;
+    regexp: (v: any, path: string, ctx: ValidationContext) => any;
+    null: (v: any, path: string, ctx: ValidationContext) => null;
+    undefined: (v: any, path: string, ctx: ValidationContext) => undefined;
+    literal: (v: any, path: string, ctx: ValidationContext, expected: any) => any;
+    array: (v: any, path: string, ctx: ValidationContext, childValidator: Function) => any;
+    props: (v: any, data: any, path: string, ctx: ValidationContext, props: [string, boolean, Function][]) => void;
+    object: (v: any, path: string, ctx: ValidationContext, allowedKeys?: string[], expected?: string) => boolean;
+    templateLiteral: (v: any, path: string, ctx: ValidationContext, regex: RegExp, expected: string) => any;
+    minLength: (v: string, path: string, ctx: ValidationContext, min: number, message?: string) => string;
+    maxLength: (v: string, path: string, ctx: ValidationContext, max: number, message?: string) => string;
+    minimum: (v: number | bigint, path: string, ctx: ValidationContext, min: number | bigint, message?: string) => number | bigint;
+    maximum: (v: number | bigint, path: string, ctx: ValidationContext, max: number | bigint, message?: string) => number | bigint;
+    exclusiveMinimum: (v: number | bigint, path: string, ctx: ValidationContext, min: number | bigint, message?: string) => number | bigint;
+    exclusiveMaximum: (v: number | bigint, path: string, ctx: ValidationContext, max: number | bigint, message?: string) => number | bigint;
+    multipleOf: (v: number | bigint, path: string, ctx: ValidationContext, n: number | bigint, message?: string) => number | bigint;
+    pattern: (v: string, path: string, ctx: ValidationContext, regex: RegExp, expected: string, message?: string) => string;
+    format: (v: string, path: string, ctx: ValidationContext, format: string, message?: string) => string;
+    minItems: (v: any[], path: string, ctx: ValidationContext, min: number, message?: string) => any[];
+    maxItems: (v: any[], path: string, ctx: ValidationContext, max: number, message?: string) => any[];
+    uniqueItems: (v: any[], path: string, ctx: ValidationContext, message?: string) => any[];
+    custom: (v: any, path: string, ctx: ValidationContext, fn: Function, message?: string) => any;
+    union: (v: any, path: string, ctx: ValidationContext, checks: Function[], expected?: string) => any;
+    tuple: (v: any, path: string, ctx: ValidationContext, checks: Function[]) => any;
+    any: (v: any) => any;
+    requires: (v: any, path: string, ctx: ValidationContext, reqs: string[], message?: string) => any;
+    record: (v: any, path: string, ctx: ValidationContext, childValidator: Function) => any;
+    set: (v: any, path: string, ctx: ValidationContext, childValidator: Function, message?: string) => any;
+    map: (v: any, path: string, ctx: ValidationContext, keyValidator: Function, valueValidator: Function, message?: string) => any;
+};
+export declare class MetadataStoreClass {
+    private validators;
+    private schemas;
+    private compiledSchemas;
+    registerValidator(hash: string, validator: Function): void;
+    getValidator(hash: string): Function;
+    registerSchema(hash: string, schema: any): void;
+    getSchema(hash: string): any;
+    getOrCompileSchema(schema: any): Function;
+    is(validator: Function, value: any, options?: ValidationMode | ValidationOptions): boolean;
+    assert(validator: Function, value: any, options?: ValidationMode | ValidationOptions): any;
+    validate(validator: Function, value: any, options?: ValidationMode | ValidationOptions): {
+        success: boolean;
+        errors: IValidationError[];
+        data: any;
+    };
+}
+export declare function groupErrorsByPath(errors: IValidationError[]): Record<string, {
+    value: any;
+    errors: string[];
+}>;
+export declare const MetadataStore: MetadataStoreClass;
+export declare function compileSchema(schema: any): (v: any, path: string, ctx: any) => any;
+export declare function toZodIssues(errors: IValidationError[]): {
+    code: string;
+    path: (string | number)[];
+    message: string;
+    received: any;
+}[];
+export declare class ZodLikeError extends Error {
+    issues: any[];
+    constructor(errors: IValidationError[]);
+}