@object-ui/core 0.5.0 → 2.0.0

package/src/validation/__tests__/schema-validator.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateSchema,
+  assertValidSchema,
+  isValidSchema,
+  formatValidationErrors,
+} from '../../validation/schema-validator';
+
+describe('schema-validator', () => {
+  describe('validateSchema', () => {
+    it('validates a minimal valid schema', () => {
+      const result = validateSchema({ type: 'form' });
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('rejects schema without type', () => {
+      const result = validateSchema({} as any);
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('validates CRUD schema with columns', () => {
+      const result = validateSchema({
+        type: 'crud',
+        columns: [{ name: 'id', label: 'ID' }],
+        api: '/api/users',
+      });
+      expect(result.valid).toBe(true);
+    });
+
+    it('warns about CRUD without columns', () => {
+      const result = validateSchema({ type: 'crud' });
+      const hasColumnsIssue = [...result.errors, ...result.warnings].some(
+        (e) => e.message.toLowerCase().includes('column'),
+      );
+      expect(hasColumnsIssue).toBe(true);
+    });
+
+    it('validates form with fields', () => {
+      const result = validateSchema({
+        type: 'form',
+        fields: [
+          { name: 'email', label: 'Email', type: 'string' },
+        ],
+      });
+      expect(result.valid).toBe(true);
+    });
+
+    it('detects duplicate field names in forms', () => {
+      const result = validateSchema({
+        type: 'form',
+        fields: [
+          { name: 'email', label: 'Email', type: 'string' },
+          { name: 'email', label: 'Email 2', type: 'string' },
+        ],
+      });
+      const hasDuplicateWarning = [...result.errors, ...result.warnings].some(
+        (e) => e.message.toLowerCase().includes('duplicate'),
+      );
+      expect(hasDuplicateWarning).toBe(true);
+    });
+
+    it('validates nested children', () => {
+      const result = validateSchema({
+        type: 'grid',
+        children: [
+          { type: 'button', label: 'OK' },
+        ],
+      });
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('isValidSchema', () => {
+    it('returns true for valid schema', () => {
+      expect(isValidSchema({ type: 'form' })).toBe(true);
+    });
+
+    it('returns false for invalid schema', () => {
+      expect(isValidSchema({})).toBe(false);
+    });
+
+    it('returns false for empty object', () => {
+      expect(isValidSchema({} as any)).toBe(false);
+    });
+
+    it('returns false for non-object values', () => {
+      expect(isValidSchema('string' as any)).toBe(false);
+      expect(isValidSchema(42 as any)).toBe(false);
+    });
+  });
+
+  describe('assertValidSchema', () => {
+    it('does not throw for valid schema', () => {
+      expect(() => assertValidSchema({ type: 'form' })).not.toThrow();
+    });
+
+    it('throws for invalid schema', () => {
+      expect(() => assertValidSchema({} as any)).toThrow();
+    });
+  });
+
+  describe('formatValidationErrors', () => {
+    it('formats validation errors', () => {
+      const result = validateSchema({} as any);
+      const formatted = formatValidationErrors(result);
+      expect(typeof formatted).toBe('string');
+      expect(formatted.length).toBeGreaterThan(0);
+    });
+
+    it('returns empty string for valid schemas', () => {
+      const result = validateSchema({ type: 'form' });
+      const formatted = formatValidationErrors(result);
+      expect(formatted).toBe('');
+    });
+  });
+});

package/src/validation/index.ts

@@ -2,7 +2,7 @@
  * @object-ui/core - Validation Module
  * 
  * Phase 3.5: Validation engine
- * ObjectStack Spec v0.7.1: Object-level validation
+ * ObjectStack Spec v2.0.1: Object-level validation
  */
 
 export * from './validation-engine.js';

package/src/validation/validation-engine.ts

@@ -34,6 +34,39 @@ import type {
  * 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
    */
@@ -80,7 +113,7 @@ export class ValidationEngine {
     rule: AdvancedValidationRule,
     context?: ValidationContext
   ): Promise<string | null> {
-    // Custom async validator
+    // Custom async validator (inline)
     if (rule.async_validator) {
       const result = await rule.async_validator(value, context);
       if (result === false) {
@@ -92,7 +125,7 @@ export class ValidationEngine {
       return null;
     }
 
-    // Custom sync validator
+    // Custom sync validator (inline)
     if (rule.validator) {
       const result = rule.validator(value, context);
       if (result === false) {
@@ -104,6 +137,32 @@ export class ValidationEngine {
       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);
   }

package/src/validation/validators/index.ts

@@ -9,7 +9,7 @@
 /**
  * @object-ui/core - Validators
  * 
- * ObjectStack Spec v0.7.1 compliant validators
+ * ObjectStack Spec v2.0.1 compliant validators
  * 
  * @module validators
  * @packageDocumentation

package/src/validation/validators/object-validation-engine.ts

@@ -9,7 +9,7 @@
 /**
  * @object-ui/core - Object-Level Validation Engine
  * 
- * ObjectStack Spec v0.7.1 compliant validation engine for object-level validation rules.
+ * ObjectStack Spec v2.0.1 compliant validation engine for object-level validation rules.
  * Supports all 9 validation types from the specification:
  * - ScriptValidation
  * - UniquenessValidation
@@ -256,7 +256,7 @@ class SimpleExpressionEvaluator implements ValidationExpressionEvaluator {
 
 /**
  * Object-Level Validation Engine
- * Implements ObjectStack Spec v0.7.1 validation framework
+ * Implements ObjectStack Spec v2.0.1 validation framework
  */
 export class ObjectValidationEngine {
   private expressionEvaluator: ValidationExpressionEvaluator;