@object-ui/core 0.3.1 → 2.0.0

package/dist/validation/validation-engine.js

@@ -0,0 +1,428 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Validation Engine - Executes validation rules
+ */
+export class ValidationEngine {
+    constructor() {
+        Object.defineProperty(this, "customValidators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "customAsyncValidators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Register a custom synchronous validator by name
+     */
+    registerValidator(name, fn) {
+        this.customValidators.set(name, fn);
+    }
+    /**
+     * Register a custom asynchronous validator by name
+     */
+    registerAsyncValidator(name, fn) {
+        this.customAsyncValidators.set(name, fn);
+    }
+    /**
+     * Check if a custom validator is registered
+     */
+    hasValidator(name) {
+        return this.customValidators.has(name) || this.customAsyncValidators.has(name);
+    }
+    /**
+     * Get all registered custom validator names
+     */
+    getValidatorNames() {
+        return [
+            ...Array.from(this.customValidators.keys()),
+            ...Array.from(this.customAsyncValidators.keys()),
+        ];
+    }
+    /**
+     * Validate a value against validation schema
+     */
+    async validate(value, schema, context) {
+        const errors = [];
+        const warnings = [];
+        for (const rule of schema.rules) {
+            const result = await this.validateRule(value, rule, context);
+            if (result) {
+                const error = {
+                    field: schema.field || 'unknown',
+                    message: result,
+                    code: rule.type,
+                    rule: rule.type,
+                    severity: rule.severity || 'error',
+                };
+                if (rule.severity === 'warning' || rule.severity === 'info') {
+                    warnings.push(error);
+                }
+                else {
+                    errors.push(error);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate a single rule
+     */
+    async validateRule(value, rule, context) {
+        // Custom async validator (inline)
+        if (rule.async_validator) {
+            const result = await rule.async_validator(value, context);
+            if (result === false) {
+                return rule.message || 'Async validation failed';
+            }
+            if (typeof result === 'string') {
+                return result;
+            }
+            return null;
+        }
+        // Custom sync validator (inline)
+        if (rule.validator) {
+            const result = rule.validator(value, context);
+            if (result === false) {
+                return rule.message || 'Validation failed';
+            }
+            if (typeof result === 'string') {
+                return result;
+            }
+            return null;
+        }
+        // Registered custom async validator (by name)
+        const registeredAsync = this.customAsyncValidators.get(rule.type);
+        if (registeredAsync) {
+            const result = await registeredAsync(value, context);
+            if (result === false) {
+                return rule.message || 'Async validation failed';
+            }
+            if (typeof result === 'string') {
+                return result;
+            }
+            return null;
+        }
+        // Registered custom sync validator (by name)
+        const registeredSync = this.customValidators.get(rule.type);
+        if (registeredSync) {
+            const result = registeredSync(value, context);
+            if (result === false) {
+                return rule.message || 'Validation failed';
+            }
+            if (typeof result === 'string') {
+                return result;
+            }
+            return null;
+        }
+        // Built-in validators
+        return this.validateBuiltInRule(value, rule, context);
+    }
+    /**
+     * Validate built-in rules
+     */
+    async validateBuiltInRule(value, rule, context) {
+        const { type, params, message } = rule;
+        switch (type) {
+            case 'required':
+                if (value === null || value === undefined || value === '') {
+                    return message || 'This field is required';
+                }
+                break;
+            case 'min_length':
+                if (typeof value === 'string' && value.length < params) {
+                    return message || `Minimum length is ${params} characters`;
+                }
+                break;
+            case 'max_length':
+                if (typeof value === 'string' && value.length > params) {
+                    return message || `Maximum length is ${params} characters`;
+                }
+                break;
+            case 'pattern':
+                if (typeof value === 'string') {
+                    try {
+                        const regex = typeof params === 'string' ? new RegExp(params) : params;
+                        if (!regex.test(value)) {
+                            return message || 'Invalid format';
+                        }
+                    }
+                    catch (error) {
+                        return message || 'Invalid pattern configuration';
+                    }
+                }
+                break;
+            case 'email':
+                if (typeof value === 'string') {
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    if (!emailRegex.test(value)) {
+                        return message || 'Invalid email address';
+                    }
+                }
+                break;
+            case 'url':
+                if (typeof value === 'string') {
+                    try {
+                        new URL(value);
+                    }
+                    catch {
+                        return message || 'Invalid URL';
+                    }
+                }
+                break;
+            case 'phone':
+                if (typeof value === 'string') {
+                    const phoneRegex = /^[\d\s\-+()]+$/;
+                    if (!phoneRegex.test(value)) {
+                        return message || 'Invalid phone number';
+                    }
+                }
+                break;
+            case 'min':
+                if (typeof value === 'number' && value < params) {
+                    return message || `Minimum value is ${params}`;
+                }
+                break;
+            case 'max':
+                if (typeof value === 'number' && value > params) {
+                    return message || `Maximum value is ${params}`;
+                }
+                break;
+            case 'integer':
+                if (typeof value === 'number' && !Number.isInteger(value)) {
+                    return message || 'Value must be an integer';
+                }
+                break;
+            case 'positive':
+                if (typeof value === 'number' && value <= 0) {
+                    return message || 'Value must be positive';
+                }
+                break;
+            case 'negative':
+                if (typeof value === 'number' && value >= 0) {
+                    return message || 'Value must be negative';
+                }
+                break;
+            case 'date_min':
+                if (value instanceof Date || typeof value === 'string') {
+                    const date = value instanceof Date ? value : new Date(value);
+                    const minDate = params instanceof Date ? params : new Date(params);
+                    if (date < minDate) {
+                        return message || `Date must be after ${minDate.toLocaleDateString()}`;
+                    }
+                }
+                break;
+            case 'date_max':
+                if (value instanceof Date || typeof value === 'string') {
+                    const date = value instanceof Date ? value : new Date(value);
+                    const maxDate = params instanceof Date ? params : new Date(params);
+                    if (date > maxDate) {
+                        return message || `Date must be before ${maxDate.toLocaleDateString()}`;
+                    }
+                }
+                break;
+            case 'date_future':
+                if (value instanceof Date || typeof value === 'string') {
+                    const date = value instanceof Date ? value : new Date(value);
+                    if (date <= new Date()) {
+                        return message || 'Date must be in the future';
+                    }
+                }
+                break;
+            case 'date_past':
+                if (value instanceof Date || typeof value === 'string') {
+                    const date = value instanceof Date ? value : new Date(value);
+                    if (date >= new Date()) {
+                        return message || 'Date must be in the past';
+                    }
+                }
+                break;
+            case 'min_items':
+                if (Array.isArray(value) && value.length < params) {
+                    return message || `Minimum ${params} items required`;
+                }
+                break;
+            case 'max_items':
+                if (Array.isArray(value) && value.length > params) {
+                    return message || `Maximum ${params} items allowed`;
+                }
+                break;
+            case 'unique_items':
+                if (Array.isArray(value)) {
+                    const unique = new Set(value);
+                    if (unique.size !== value.length) {
+                        return message || 'All items must be unique';
+                    }
+                }
+                break;
+            case 'field_match':
+                if (context?.values && params) {
+                    const otherValue = context.values[params];
+                    if (value !== otherValue) {
+                        return message || `Value must match ${params}`;
+                    }
+                }
+                break;
+            case 'field_compare':
+                if (context?.values && params) {
+                    const { field: otherField, operator } = params;
+                    const otherValue = context.values[otherField];
+                    switch (operator) {
+                        case '>':
+                            if (value <= otherValue) {
+                                return message || `Value must be greater than ${otherField}`;
+                            }
+                            break;
+                        case '<':
+                            if (value >= otherValue) {
+                                return message || `Value must be less than ${otherField}`;
+                            }
+                            break;
+                        case '>=':
+                            if (value < otherValue) {
+                                return message || `Value must be greater than or equal to ${otherField}`;
+                            }
+                            break;
+                        case '<=':
+                            if (value > otherValue) {
+                                return message || `Value must be less than or equal to ${otherField}`;
+                            }
+                            break;
+                    }
+                }
+                break;
+            case 'conditional':
+                if (context?.values && params) {
+                    const { condition, rules } = params;
+                    if (!Array.isArray(rules) || rules.length === 0) {
+                        break;
+                    }
+                    const conditionMet = this.evaluateCondition(condition, context.values);
+                    if (conditionMet) {
+                        for (const conditionalRule of rules) {
+                            const result = await this.validateRule(value, conditionalRule, context);
+                            if (result) {
+                                return result;
+                            }
+                        }
+                    }
+                }
+                break;
+            default:
+                // Unhandled validation rule type
+                console.warn(`Unsupported validation rule type: ${type}`);
+                return null;
+        }
+        return null;
+    }
+    /**
+     * Evaluate a condition
+     * Note: Conditions must be declarative objects, not functions, for security.
+     */
+    evaluateCondition(condition, values) {
+        if (typeof condition === 'function') {
+            console.warn('Function-based conditions are deprecated and will be removed. Use declarative conditions instead.');
+            return false; // Security: reject function-based conditions
+        }
+        if (typeof condition === 'object' && condition.field) {
+            const fieldValue = values[condition.field];
+            const { operator = '=', value } = condition;
+            switch (operator) {
+                case '=':
+                    return fieldValue === value;
+                case '!=':
+                    return fieldValue !== value;
+                case '>':
+                    return fieldValue > value;
+                case '<':
+                    return fieldValue < value;
+                case '>=':
+                    return fieldValue >= value;
+                case '<=':
+                    return fieldValue <= value;
+                case 'in':
+                    return Array.isArray(value) && value.includes(fieldValue);
+                default:
+                    return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Validate multiple fields
+     */
+    async validateFields(values, schemas) {
+        const results = {};
+        const context = {
+            values,
+        };
+        for (const [field, schema] of Object.entries(schemas)) {
+            const value = values[field];
+            const schemaWithField = {
+                ...schema,
+                field: schema.field ?? field,
+            };
+            results[field] = await this.validate(value, schemaWithField, context);
+        }
+        return results;
+    }
+    /**
+     * Check if all fields are valid
+     */
+    isValid(results) {
+        return Object.values(results).every(result => result.valid);
+    }
+    /**
+     * Get all errors from validation results
+     */
+    getAllErrors(results) {
+        const errors = [];
+        for (const result of Object.values(results)) {
+            errors.push(...result.errors);
+        }
+        return errors;
+    }
+    /**
+     * Get all warnings from validation results
+     */
+    getAllWarnings(results) {
+        const warnings = [];
+        for (const result of Object.values(results)) {
+            if (result.warnings) {
+                warnings.push(...result.warnings);
+            }
+        }
+        return warnings;
+    }
+}
+/**
+ * Default validation engine instance
+ */
+export const defaultValidationEngine = new ValidationEngine();
+/**
+ * Convenience function to validate a value
+ */
+export async function validate(value, schema, context) {
+    return defaultValidationEngine.validate(value, schema, context);
+}
+/**
+ * Convenience function to validate multiple fields
+ */
+export async function validateFields(values, schemas) {
+    return defaultValidationEngine.validateFields(values, schemas);
+}

package/dist/validation/validators/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/core - Validators
+ *
+ * ObjectStack Spec v2.0.1 compliant validators
+ *
+ * @module validators
+ * @packageDocumentation
+ */
+export { ObjectValidationEngine, defaultObjectValidationEngine, validateRecord, type ObjectValidationContext, type ObjectValidationResult, type ValidationExpressionEvaluator, } from './object-validation-engine.js';

package/dist/validation/validators/index.js

@@ -0,0 +1,16 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/core - Validators
+ *
+ * ObjectStack Spec v2.0.1 compliant validators
+ *
+ * @module validators
+ * @packageDocumentation
+ */
+export { ObjectValidationEngine, defaultObjectValidationEngine, validateRecord, } from './object-validation-engine.js';

package/dist/validation/validators/object-validation-engine.d.ts

@@ -0,0 +1,118 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @object-ui/core - Object-Level Validation Engine
+ *
+ * ObjectStack Spec v2.0.1 compliant validation engine for object-level validation rules.
+ * Supports all 9 validation types from the specification:
+ * - ScriptValidation
+ * - UniquenessValidation
+ * - StateMachineValidation
+ * - CrossFieldValidation
+ * - AsyncValidation
+ * - ConditionalValidation
+ * - FormatValidation
+ * - RangeValidation
+ *
+ * @module object-validation-engine
+ * @packageDocumentation
+ */
+import type { ObjectValidationRule } from '@object-ui/types';
+/**
+ * Validation context for object-level validations
+ */
+export interface ObjectValidationContext {
+    /** Current record data */
+    record: Record<string, any>;
+    /** Previous record data (for updates) */
+    oldRecord?: Record<string, any>;
+    /** Current user */
+    user?: Record<string, any>;
+    /** Additional context data */
+    [key: string]: any;
+}
+/**
+ * Validation result
+ */
+export interface ObjectValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Error message if validation failed */
+    message?: string;
+    /** Validation rule that failed */
+    rule?: string;
+    /** Severity */
+    severity?: 'error' | 'warning' | 'info';
+}
+/**
+ * Validation expression evaluator interface
+ */
+export interface ValidationExpressionEvaluator {
+    evaluate(expression: string, context: Record<string, any>): any;
+}
+/**
+ * Object-Level Validation Engine
+ * Implements ObjectStack Spec v2.0.1 validation framework
+ */
+export declare class ObjectValidationEngine {
+    private expressionEvaluator;
+    private uniquenessChecker?;
+    constructor(expressionEvaluator?: ValidationExpressionEvaluator, uniquenessChecker?: (fields: string[], values: Record<string, any>, scope?: string, context?: ObjectValidationContext) => Promise<boolean>);
+    /**
+     * Validate a record against a set of validation rules
+     */
+    validateRecord(rules: ObjectValidationRule[], context: ObjectValidationContext, event?: 'insert' | 'update' | 'delete'): Promise<ObjectValidationResult[]>;
+    /**
+     * Validate a single rule
+     */
+    private validateRule;
+    /**
+     * Validate script-based rule
+     */
+    private validateScript;
+    /**
+     * Validate uniqueness constraint
+     */
+    private validateUniqueness;
+    /**
+     * Validate state machine transitions
+     */
+    private validateStateMachine;
+    /**
+     * Validate cross-field constraints
+     */
+    private validateCrossField;
+    /**
+     * Validate async/remote validation
+     */
+    private validateAsync;
+    /**
+     * Validate conditional rules
+     */
+    private validateConditional;
+    /**
+     * Validate format/pattern
+     */
+    private validateFormat;
+    /**
+     * Validate range constraints
+     */
+    private validateRange;
+    /**
+     * Get predefined regex pattern
+     */
+    private getPredefinedPattern;
+}
+/**
+ * Default instance
+ */
+export declare const defaultObjectValidationEngine: ObjectValidationEngine;
+/**
+ * Convenience function to validate a record
+ */
+export declare function validateRecord(rules: ObjectValidationRule[], context: ObjectValidationContext, event?: 'insert' | 'update' | 'delete'): Promise<ObjectValidationResult[]>;