@object-ui/core 0.3.1 → 2.0.0

package/src/validation/__tests__/validation-engine.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @object-ui/core - Validation Engine Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { ValidationEngine } from '../validation-engine';
+import type { AdvancedValidationSchema } from '@object-ui/types';
+
+describe('ValidationEngine', () => {
+  const engine = new ValidationEngine();
+
+  describe('Basic Validation', () => {
+    it('should validate required field', async () => {
+      const schema: AdvancedValidationSchema = {
+        field: 'email',
+        rules: [
+          {
+            type: 'required',
+            message: 'Email is required',
+          },
+        ],
+      };
+
+      const result1 = await engine.validate('', schema);
+      expect(result1.valid).toBe(false);
+      expect(result1.errors).toHaveLength(1);
+      expect(result1.errors[0].message).toBe('Email is required');
+
+      const result2 = await engine.validate('test@example.com', schema);
+      expect(result2.valid).toBe(true);
+      expect(result2.errors).toHaveLength(0);
+    });
+
+    it('should validate email format', async () => {
+      const schema: AdvancedValidationSchema = {
+        field: 'email',
+        rules: [
+          {
+            type: 'email',
+          },
+        ],
+      };
+
+      const result1 = await engine.validate('invalid-email', schema);
+      expect(result1.valid).toBe(false);
+
+      const result2 = await engine.validate('valid@example.com', schema);
+      expect(result2.valid).toBe(true);
+    });
+
+    it('should validate phone format', async () => {
+      const schema: AdvancedValidationSchema = {
+        field: 'phone',
+        rules: [
+          {
+            type: 'phone',
+          },
+        ],
+      };
+
+      // Valid phone numbers with various formats
+      const validResult1 = await engine.validate('123-456-7890', schema);
+      expect(validResult1.valid).toBe(true);
+
+      const validResult2 = await engine.validate('+1 (234) 567-8900', schema);
+      expect(validResult2.valid).toBe(true);
+
+      const validResult3 = await engine.validate('1234567890', schema);
+      expect(validResult3.valid).toBe(true);
+
+      // Invalid phone number with letters
+      const invalidResult = await engine.validate('123-abc-7890', schema);
+      expect(invalidResult.valid).toBe(false);
+    });
+  });
+
+  describe('Custom Validation', () => {
+    it('should validate with custom sync function', async () => {
+      const schema: AdvancedValidationSchema = {
+        field: 'custom',
+        rules: [
+          {
+            type: 'custom',
+            validator: (value) => {
+              if (value === 'forbidden') {
+                return 'This value is forbidden';
+              }
+              return true;
+            },
+          },
+        ],
+      };
+
+      const result1 = await engine.validate('forbidden', schema);
+      expect(result1.valid).toBe(false);
+      expect(result1.errors[0].message).toBe('This value is forbidden');
+
+      const result2 = await engine.validate('allowed', schema);
+      expect(result2.valid).toBe(true);
+    });
+  });
+});

package/src/validation/index.ts

@@ -0,0 +1,10 @@
+/**
+ * @object-ui/core - Validation Module
+ * 
+ * Phase 3.5: Validation engine
+ * ObjectStack Spec v2.0.1: Object-level validation
+ */
+
+export * from './validation-engine.js';
+export * from './schema-validator.js';
+export * from './validators/index.js';

package/src/validation/validation-engine.ts

@@ -0,0 +1,520 @@
+/**
+ * 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 - Validation Engine
+ * 
+ * Phase 3.5: Complete validation engine implementation with support for:
+ * - Sync and async validation
+ * - Cross-field validation
+ * - Custom validation functions
+ * - Improved error messages
+ * 
+ * @module validation-engine
+ * @packageDocumentation
+ */
+
+import type {
+  AdvancedValidationSchema,
+  AdvancedValidationRule,
+  ValidationRuleType,
+  ValidationFunction,
+  AsyncValidationFunction,
+  ValidationContext,
+  AdvancedValidationResult,
+  AdvancedValidationError,
+} from '@object-ui/types';
+
+/**
+ * Validation Engine - Executes validation rules
+ */
+export class ValidationEngine {
+  private customValidators = new Map<string, ValidationFunction>();
+  private customAsyncValidators = new Map<string, AsyncValidationFunction>();
+
+  /**
+   * Register a custom synchronous validator by name
+   */
+  registerValidator(name: string, fn: ValidationFunction): void {
+    this.customValidators.set(name, fn);
+  }
+
+  /**
+   * Register a custom asynchronous validator by name
+   */
+  registerAsyncValidator(name: string, fn: AsyncValidationFunction): void {
+    this.customAsyncValidators.set(name, fn);
+  }
+
+  /**
+   * Check if a custom validator is registered
+   */
+  hasValidator(name: string): boolean {
+    return this.customValidators.has(name) || this.customAsyncValidators.has(name);
+  }
+
+  /**
+   * Get all registered custom validator names
+   */
+  getValidatorNames(): string[] {
+    return [
+      ...Array.from(this.customValidators.keys()),
+      ...Array.from(this.customAsyncValidators.keys()),
+    ];
+  }
+  /**
+   * Validate a value against validation schema
+   */
+  async validate(
+    value: any,
+    schema: AdvancedValidationSchema,
+    context?: ValidationContext
+  ): Promise<AdvancedValidationResult> {
+    const errors: AdvancedValidationError[] = [];
+    const warnings: AdvancedValidationError[] = [];
+
+    for (const rule of schema.rules) {
+      const result = await this.validateRule(value, rule, context);
+      
+      if (result) {
+        const error: AdvancedValidationError = {
+          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
+   */
+  private async validateRule(
+    value: any,
+    rule: AdvancedValidationRule,
+    context?: ValidationContext
+  ): Promise<string | null> {
+    // 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
+   */
+  private async validateBuiltInRule(
+    value: any,
+    rule: AdvancedValidationRule,
+    context?: ValidationContext
+  ): Promise<string | null> {
+    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.
+   */
+  private evaluateCondition(condition: any, values: Record<string, any>): boolean {
+    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: Record<string, any>,
+    schemas: Record<string, AdvancedValidationSchema>
+  ): Promise<Record<string, AdvancedValidationResult>> {
+    const results: Record<string, AdvancedValidationResult> = {};
+    
+    const context: ValidationContext = {
+      values,
+    };
+
+    for (const [field, schema] of Object.entries(schemas)) {
+      const value = values[field];
+      const schemaWithField: AdvancedValidationSchema = {
+        ...schema,
+        field: schema.field ?? field,
+      };
+      results[field] = await this.validate(value, schemaWithField, context);
+    }
+
+    return results;
+  }
+
+  /**
+   * Check if all fields are valid
+   */
+  isValid(results: Record<string, AdvancedValidationResult>): boolean {
+    return Object.values(results).every(result => result.valid);
+  }
+
+  /**
+   * Get all errors from validation results
+   */
+  getAllErrors(results: Record<string, AdvancedValidationResult>): AdvancedValidationError[] {
+    const errors: AdvancedValidationError[] = [];
+    
+    for (const result of Object.values(results)) {
+      errors.push(...result.errors);
+    }
+    
+    return errors;
+  }
+
+  /**
+   * Get all warnings from validation results
+   */
+  getAllWarnings(results: Record<string, AdvancedValidationResult>): AdvancedValidationError[] {
+    const warnings: AdvancedValidationError[] = [];
+    
+    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: any,
+  schema: AdvancedValidationSchema,
+  context?: ValidationContext
+): Promise<AdvancedValidationResult> {
+  return defaultValidationEngine.validate(value, schema, context);
+}
+
+/**
+ * Convenience function to validate multiple fields
+ */
+export async function validateFields(
+  values: Record<string, any>,
+  schemas: Record<string, AdvancedValidationSchema>
+): Promise<Record<string, AdvancedValidationResult>> {
+  return defaultValidationEngine.validateFields(values, schemas);
+}

package/src/validation/validators/index.ts

@@ -0,0 +1,25 @@
+/**
+ * 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';