unischema 1.0.1 → 1.2.0

package/dist/index-C17xs-fU.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Core types for the FormSchema validation engine
+ */
+type ValidationSeverity = 'hard' | 'soft';
+interface ValidationError {
+    /** Field path (e.g., "email" or "address.city") */
+    field: string;
+    /** Path as array (e.g., ["address", "city"]) */
+    path?: string[];
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Severity level - hard errors block submission, soft are warnings */
+    severity: ValidationSeverity;
+    /** Value that was received (for context) */
+    received?: unknown;
+    /** Expected value or constraints (for context) */
+    expected?: unknown;
+}
+interface ValidationResult {
+    /** True if no hard errors exist */
+    valid: boolean;
+    /** Errors that block form submission */
+    hardErrors: ValidationError[];
+    /** Warnings that don't block submission */
+    softErrors: ValidationError[];
+    /** Errors aggregated by field path */
+    errorsByField?: Record<string, ValidationError[]>;
+}
+/** Validation options */
+interface ValidationOptions {
+    /** Custom error message formatter */
+    errorMap?: (error: ValidationError) => ValidationError | {
+        message: string;
+    };
+    /** Stop validation on first error */
+    abortEarly?: boolean;
+    /** Aggregate errors by field */
+    aggregateByField?: boolean;
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+interface ValidationRule {
+    /** Rule type identifier */
+    type: string;
+    /** Rule parameters */
+    params?: Record<string, unknown>;
+    /** Custom error message */
+    message?: string;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Is this an async validation? */
+    async?: boolean;
+    /** Debounce delay in ms for async validators */
+    debounce?: number;
+    /** Timeout in ms for async validators */
+    timeout?: number;
+}
+interface FieldDefinition<T = unknown> {
+    /** The base type of this field */
+    type: FieldType;
+    /** Validation rules to apply */
+    rules: ValidationRule[];
+    /** Is this field required? */
+    required: boolean;
+    /** Default value */
+    defaultValue?: T;
+    /** For nested schemas */
+    schema?: SchemaDefinition;
+    /** For array items */
+    items?: FieldDefinition;
+    /** Field metadata */
+    meta?: Record<string, unknown>;
+    /** Transform functions to apply to value */
+    transforms?: Array<(value: unknown) => unknown>;
+    /** Preprocess function to apply before validation */
+    preprocess?: (value: unknown) => unknown;
+    /** Allow null values */
+    nullable?: boolean;
+    /** Allow null or undefined values */
+    nullish?: boolean;
+}
+interface SchemaDefinition {
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** Schema metadata */
+    meta?: Record<string, unknown>;
+    /** Allow unknown keys to pass through */
+    passthrough?: boolean;
+    /** Strict mode - reject unknown keys */
+    strict?: boolean;
+    /** Catchall field definition for unknown keys */
+    catchall?: FieldDefinition;
+}
+interface ValidatorContext {
+    /** Current field path */
+    path: string;
+    /** Full data object being validated */
+    root: unknown;
+    /** Parent object containing this field */
+    parent?: unknown;
+}
+type ValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => ValidationError | null;
+type AsyncValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => Promise<ValidationError | null>;
+/** Async refine function type - returns boolean or validation result object */
+type AsyncRefineFn<T = unknown> = (value: T) => Promise<boolean | {
+    valid: boolean;
+    message?: string;
+}>;
+/** Options for async validation */
+interface AsyncValidationOptions {
+    /** Custom error message */
+    message?: string;
+    /** Debounce delay in ms */
+    debounce?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Cache results (useful for expensive checks) */
+    cache?: boolean;
+    /** Cache TTL in seconds (default: 3600) */
+    cacheTTL?: number;
+}
+interface EnterpriseValidationResponse {
+    status: 'success' | 'validation_error';
+    data?: unknown;
+    errors: ValidationError[];
+    msg: string;
+    validation: {
+        hard_validations: ValidationError[];
+        soft_validations: ValidationError[];
+    };
+}
+/**
+ * Convert ValidationResult to enterprise-compatible response format
+ */
+declare function toEnterpriseResponse(result: ValidationResult, data?: unknown): EnterpriseValidationResponse;
+
+export { type AsyncRefineFn as A, type EnterpriseValidationResponse as E, type FieldDefinition as F, type SchemaDefinition as S, type ValidatorContext as V, type ValidationError as a, type ValidationResult as b, type ValidationRule as c, type AsyncValidationOptions as d, type ValidationOptions as e, type ValidatorFn as f, type ValidationSeverity as g, type FieldType as h, type AsyncValidatorFn as i, toEnterpriseResponse as t };

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { S as SchemaDefinition, V as ValidationResult, a as ValidatorFn } from './schema-D9DGC9E_.mjs';
-export { A as ArrayFieldBuilder, B as BaseFieldBuilder, h as BooleanFieldBuilder, D as DateFieldBuilder, q as EnterpriseValidationResponse, E as EnumFieldBuilder, l as FieldDefinition, F as FieldType, I as InferInput, c as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, d as SchemaBuilder, g as StringFieldBuilder, j as ValidationError, k as ValidationRule, i as ValidationSeverity, n as ValidatorContext, e as extend, f as field, m as merge, o as omit, b as partial, p as pick, s as schema, t as toEnterpriseResponse } from './schema-D9DGC9E_.mjs';
+import { S as SchemaDefinition, e as ValidationOptions, b as ValidationResult, f as ValidatorFn } from './index-C17xs-fU.mjs';
+export { A as AsyncRefineFn, d as AsyncValidationOptions, i as AsyncValidatorFn, E as EnterpriseValidationResponse, F as FieldDefinition, h as FieldType, a as ValidationError, c as ValidationRule, g as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-C17xs-fU.mjs';
+export { A as ArrayFieldBuilder, B as BaseFieldBuilder, l as BooleanFieldBuilder, n as DateFieldBuilder, D as DeepPartial, E as EnumFieldBuilder, I as InferInput, j as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, k as StringFieldBuilder, f as catchall, i as coerce, d as deepPartial, e as extend, h as field, m as merge, o as omit, g as optional, a as partial, b as passthrough, p as pick, r as required, s as schema, c as strict } from './schema-DYE8Wz8X.mjs';
 
 /**
  * Core validation engine - runs unchanged in browser and Node.js
@@ -8,19 +9,19 @@ export { A as ArrayFieldBuilder, B as BaseFieldBuilder, h as BooleanFieldBuilder
 /**
  * Validate data against a schema
  */
-declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): ValidationResult;
+declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown, options?: ValidationOptions): ValidationResult;
 /**
  * Main validation function
  */
-declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): ValidationResult;
+declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): ValidationResult;
 /**
  * Check if data is valid (no hard errors)
  */
-declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>): boolean;
+declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>, options?: ValidationOptions): boolean;
 /**
  * Validate and throw if invalid
  */
-declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): T;
+declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): T;
 /**
  * Merge multiple validation results
  */
@@ -34,6 +35,24 @@ declare function validResult(): ValidationResult;
  */
 declare function errorResult(field: string, code: string, message: string, soft?: boolean): ValidationResult;
 
+/**
+ * Async validation engine for handling asynchronous validators
+ */
+
+declare function validateSchemaAsync(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): Promise<ValidationResult>;
+/**
+ * Main async validation function
+ */
+declare function validateAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<ValidationResult>;
+/**
+ * Check if data is valid async (no hard errors)
+ */
+declare function isValidAsync(schema: SchemaDefinition, data: Record<string, unknown>): Promise<boolean>;
+/**
+ * Validate async and throw if invalid
+ */
+declare function assertValidAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<T>;
+
 /**
  * Built-in validators for common validation rules
  */
@@ -53,4 +72,4 @@ declare function getValidator(name: string): ValidatorFn | undefined;
  */
 declare function getTypeValidator(type: string): ValidatorFn | undefined;
 
-export { SchemaDefinition, ValidationResult, ValidatorFn, assertValid, errorResult, getTypeValidator, getValidator, isValid, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateSchema };
+export { SchemaDefinition, ValidationOptions, ValidationResult, ValidatorFn, assertValid, assertValidAsync, errorResult, getTypeValidator, getValidator, isValid, isValidAsync, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateAsync, validateSchema, validateSchemaAsync };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { S as SchemaDefinition, V as ValidationResult, a as ValidatorFn } from './schema-D9DGC9E_.js';
-export { A as ArrayFieldBuilder, B as BaseFieldBuilder, h as BooleanFieldBuilder, D as DateFieldBuilder, q as EnterpriseValidationResponse, E as EnumFieldBuilder, l as FieldDefinition, F as FieldType, I as InferInput, c as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, d as SchemaBuilder, g as StringFieldBuilder, j as ValidationError, k as ValidationRule, i as ValidationSeverity, n as ValidatorContext, e as extend, f as field, m as merge, o as omit, b as partial, p as pick, s as schema, t as toEnterpriseResponse } from './schema-D9DGC9E_.js';
+import { S as SchemaDefinition, e as ValidationOptions, b as ValidationResult, f as ValidatorFn } from './index-C17xs-fU.js';
+export { A as AsyncRefineFn, d as AsyncValidationOptions, i as AsyncValidatorFn, E as EnterpriseValidationResponse, F as FieldDefinition, h as FieldType, a as ValidationError, c as ValidationRule, g as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-C17xs-fU.js';
+export { A as ArrayFieldBuilder, B as BaseFieldBuilder, l as BooleanFieldBuilder, n as DateFieldBuilder, D as DeepPartial, E as EnumFieldBuilder, I as InferInput, j as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, k as StringFieldBuilder, f as catchall, i as coerce, d as deepPartial, e as extend, h as field, m as merge, o as omit, g as optional, a as partial, b as passthrough, p as pick, r as required, s as schema, c as strict } from './schema-Dtp-joeT.js';
 
 /**
  * Core validation engine - runs unchanged in browser and Node.js
@@ -8,19 +9,19 @@ export { A as ArrayFieldBuilder, B as BaseFieldBuilder, h as BooleanFieldBuilder
 /**
  * Validate data against a schema
  */
-declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): ValidationResult;
+declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown, options?: ValidationOptions): ValidationResult;
 /**
  * Main validation function
  */
-declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): ValidationResult;
+declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): ValidationResult;
 /**
  * Check if data is valid (no hard errors)
  */
-declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>): boolean;
+declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>, options?: ValidationOptions): boolean;
 /**
  * Validate and throw if invalid
  */
-declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): T;
+declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): T;
 /**
  * Merge multiple validation results
  */
@@ -34,6 +35,24 @@ declare function validResult(): ValidationResult;
  */
 declare function errorResult(field: string, code: string, message: string, soft?: boolean): ValidationResult;
 
+/**
+ * Async validation engine for handling asynchronous validators
+ */
+
+declare function validateSchemaAsync(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): Promise<ValidationResult>;
+/**
+ * Main async validation function
+ */
+declare function validateAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<ValidationResult>;
+/**
+ * Check if data is valid async (no hard errors)
+ */
+declare function isValidAsync(schema: SchemaDefinition, data: Record<string, unknown>): Promise<boolean>;
+/**
+ * Validate async and throw if invalid
+ */
+declare function assertValidAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<T>;
+
 /**
  * Built-in validators for common validation rules
  */
@@ -53,4 +72,4 @@ declare function getValidator(name: string): ValidatorFn | undefined;
  */
 declare function getTypeValidator(type: string): ValidatorFn | undefined;
 
-export { SchemaDefinition, ValidationResult, ValidatorFn, assertValid, errorResult, getTypeValidator, getValidator, isValid, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateSchema };
+export { SchemaDefinition, ValidationOptions, ValidationResult, ValidatorFn, assertValid, assertValidAsync, errorResult, getTypeValidator, getValidator, isValid, isValidAsync, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateAsync, validateSchema, validateSchemaAsync };