@object-ui/core 3.3.0 → 3.3.2

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

@@ -1,118 +0,0 @@
-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/__tests__/validation-engine.test.ts

@@ -1,102 +0,0 @@
-/**
- * @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

@@ -1,10 +0,0 @@
-/**
- * @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/schema-validator.ts

@@ -1,344 +0,0 @@
-/**
- * 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 - Schema Validation
- * 
- * Runtime validation utilities for Object UI schemas.
- * These utilities help ensure schemas are valid before rendering.
- * 
- * @module validation
- * @packageDocumentation
- */
-
-import type { BaseSchema } from '@object-ui/types';
-
-/**
- * Validation error details
- */
-export interface ValidationError {
-  path: string;
-  message: string;
-  type: 'error' | 'warning';
-  code?: string;
-}
-
-/**
- * Validation result
- */
-export interface ValidationResult {
-  valid: boolean;
-  errors: ValidationError[];
-  warnings: ValidationError[];
-}
-
-/**
- * Validation rules for base schema
- */
-const BASE_SCHEMA_RULES = {
-  type: {
-    required: true,
-    validate: (value: any) => typeof value === 'string' && value.length > 0,
-    message: 'type must be a non-empty string'
-  },
-  id: {
-    required: false,
-    validate: (value: any) => typeof value === 'string',
-    message: 'id must be a string'
-  },
-  className: {
-    required: false,
-    validate: (value: any) => typeof value === 'string',
-    message: 'className must be a string'
-  },
-  visible: {
-    required: false,
-    validate: (value: any) => typeof value === 'boolean',
-    message: 'visible must be a boolean'
-  },
-  disabled: {
-    required: false,
-    validate: (value: any) => typeof value === 'boolean',
-    message: 'disabled must be a boolean'
-  }
-};
-
-/**
- * Validate a schema against base rules
- */
-function validateBaseSchema(schema: any, path: string = 'schema'): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  if (!schema || typeof schema !== 'object') {
-    errors.push({
-      path,
-      message: 'Schema must be an object',
-      type: 'error',
-      code: 'INVALID_SCHEMA'
-    });
-    return errors;
-  }
-
-  // Validate required and optional properties
-  Object.entries(BASE_SCHEMA_RULES).forEach(([key, rule]) => {
-    const value = schema[key];
-    
-    if (rule.required && value === undefined) {
-      errors.push({
-        path: `${path}.${key}`,
-        message: `${key} is required`,
-        type: 'error',
-        code: 'MISSING_REQUIRED'
-      });
-    }
-    
-    if (value !== undefined && !rule.validate(value)) {
-      errors.push({
-        path: `${path}.${key}`,
-        message: rule.message,
-        type: 'error',
-        code: 'INVALID_TYPE'
-      });
-    }
-  });
-
-  return errors;
-}
-
-/**
- * Validate CRUD schema specific properties
- */
-function validateCRUDSchema(schema: any, path: string = 'schema'): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  if (schema.type === 'crud') {
-    // Check required properties for CRUD
-    if (!schema.columns || !Array.isArray(schema.columns)) {
-      errors.push({
-        path: `${path}.columns`,
-        message: 'CRUD schema requires columns array',
-        type: 'error',
-        code: 'MISSING_COLUMNS'
-      });
-    }
-
-    if (!schema.api && !schema.dataSource) {
-      errors.push({
-        path: `${path}.api`,
-        message: 'CRUD schema requires api or dataSource',
-        type: 'warning',
-        code: 'MISSING_DATA_SOURCE'
-      });
-    }
-
-    // Validate columns
-    if (schema.columns && Array.isArray(schema.columns)) {
-      schema.columns.forEach((column: any, index: number) => {
-        if (!column.name) {
-          errors.push({
-            path: `${path}.columns[${index}]`,
-            message: 'Column requires name property',
-            type: 'error',
-            code: 'MISSING_COLUMN_NAME'
-          });
-        }
-      });
-    }
-
-    // Validate fields if present
-    if (schema.fields && Array.isArray(schema.fields)) {
-      schema.fields.forEach((field: any, index: number) => {
-        if (!field.name) {
-          errors.push({
-            path: `${path}.fields[${index}]`,
-            message: 'Field requires name property',
-            type: 'error',
-            code: 'MISSING_FIELD_NAME'
-          });
-        }
-      });
-    }
-  }
-
-  return errors;
-}
-
-/**
- * Validate form schema specific properties
- */
-function validateFormSchema(schema: any, path: string = 'schema'): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  if (schema.type === 'form') {
-    if (schema.fields && Array.isArray(schema.fields)) {
-      schema.fields.forEach((field: any, index: number) => {
-        if (!field.name) {
-          errors.push({
-            path: `${path}.fields[${index}]`,
-            message: 'Form field requires name property',
-            type: 'error',
-            code: 'MISSING_FIELD_NAME'
-          });
-        }
-
-        // Check for duplicate field names
-        const duplicates = schema.fields.filter((f: any) => f.name === field.name);
-        if (duplicates.length > 1) {
-          errors.push({
-            path: `${path}.fields[${index}]`,
-            message: `Duplicate field name: ${field.name}`,
-            type: 'warning',
-            code: 'DUPLICATE_FIELD_NAME'
-          });
-        }
-      });
-    }
-  }
-
-  return errors;
-}
-
-/**
- * Validate child schemas recursively
- */
-function validateChildren(schema: any, path: string = 'schema'): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  const children = schema.children || schema.body;
-  if (children) {
-    if (Array.isArray(children)) {
-      children.forEach((child: any, index: number) => {
-        if (typeof child === 'object' && child !== null) {
-          const childResult = validateSchema(child, `${path}.children[${index}]`);
-          errors.push(...childResult.errors, ...childResult.warnings);
-        }
-      });
-    } else if (typeof children === 'object' && children !== null) {
-      const childResult = validateSchema(children, `${path}.children`);
-      errors.push(...childResult.errors, ...childResult.warnings);
-    }
-  }
-
-  return errors;
-}
-
-/**
- * Validate a complete schema
- * 
- * @param schema - The schema to validate
- * @param options - Validation options
- * @returns Validation result with errors and warnings
- * 
- * @example
- * ```typescript
- * const result = validateSchema({
- *   type: 'form',
- *   fields: [
- *     { name: 'email', type: 'input' }
- *   ]
- * });
- * 
- * if (!result.valid) {
- *   console.error('Validation errors:', result.errors);
- * }
- * ```
- */
-export function validateSchema(
-  schema: any,
-  path: string = 'schema'
-): ValidationResult {
-  const allErrors: ValidationError[] = [];
-
-  // Validate base schema
-  allErrors.push(...validateBaseSchema(schema, path));
-
-  // Validate type-specific schemas
-  allErrors.push(...validateCRUDSchema(schema, path));
-  allErrors.push(...validateFormSchema(schema, path));
-
-  // Validate children recursively
-  allErrors.push(...validateChildren(schema, path));
-
-  const errors = allErrors.filter(e => e.type === 'error');
-  const warnings = allErrors.filter(e => e.type === 'warning');
-
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-
-/**
- * Assert that a schema is valid, throwing an error if not
- * 
- * @param schema - The schema to validate
- * @throws Error if schema is invalid
- * 
- * @example
- * ```typescript
- * try {
- *   assertValidSchema(schema);
- *   // Schema is valid, continue rendering
- * } catch (error) {
- *   console.error('Invalid schema:', error.message);
- * }
- * ```
- */
-export function assertValidSchema(schema: any): asserts schema is BaseSchema {
-  const result = validateSchema(schema);
-  
-  if (!result.valid) {
-    const errorMessages = result.errors.map(e => `${e.path}: ${e.message}`).join('\n');
-    throw new Error(`Schema validation failed:\n${errorMessages}`);
-  }
-}
-
-/**
- * Check if a value is a valid schema
- * 
- * @param value - The value to check
- * @returns True if the value is a valid schema
- * 
- * @example
- * ```typescript
- * if (isValidSchema(data)) {
- *   renderSchema(data);
- * }
- * ```
- */
-export function isValidSchema(value: any): value is BaseSchema {
-  const result = validateSchema(value);
-  return result.valid;
-}
-
-/**
- * Get a human-readable error summary
- * 
- * @param result - The validation result
- * @returns Formatted error summary
- */
-export function formatValidationErrors(result: ValidationResult): string {
-  const parts: string[] = [];
-
-  if (result.errors.length > 0) {
-    parts.push('Errors:');
-    result.errors.forEach(error => {
-      parts.push(`  - ${error.path}: ${error.message}`);
-    });
-  }
-
-  if (result.warnings.length > 0) {
-    parts.push('Warnings:');
-    result.warnings.forEach(warning => {
-      parts.push(`  - ${warning.path}: ${warning.message}`);
-    });
-  }
-
-  return parts.join('\n');
-}