@objectql/core 4.0.2 → 4.0.4

package/test/formula-spec-compliance.test.ts

@@ -1,258 +0,0 @@
-/**
- * ObjectQL
- * Copyright (c) 2026-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.
- */
-
-/**
- * Formula Specification Compliance Tests
- * 
- * Ensures that formula fields work according to the latest specification,
- * supporting both 'expression' (spec-compliant) and 'formula' (legacy) properties.
- */
-
-import { FormulaEngine } from '../src/formula-engine';
-import { Repository } from '../src/repository';
-import type { ObjectConfig, FormulaContext } from '@objectql/types';
-
-describe('Formula Specification Compliance', () => {
-  let engine: FormulaEngine;
-  let baseContext: FormulaContext;
-
-  beforeEach(() => {
-    engine = new FormulaEngine();
-    
-    const now = new Date('2026-01-25T10:00:00Z');
-    baseContext = {
-      record: {
-        first_name: 'John',
-        last_name: 'Doe',
-        quantity: 10,
-        unit_price: 25.5,
-      },
-      system: {
-        today: new Date('2026-01-25'),
-        now: now,
-        year: 2026,
-        month: 1,
-        day: 25,
-        hour: 10,
-        minute: 0,
-        second: 0,
-      },
-      current_user: {
-        id: 'user-123',
-        name: 'Admin User',
-        email: 'admin@example.com',
-        role: 'admin',
-      },
-      is_new: false,
-      record_id: 'rec-456',
-    };
-  });
-
-  describe('Specification-compliant property: expression', () => {
-    it('should evaluate formula using "expression" property', () => {
-      const result = engine.evaluate(
-        'first_name + " " + last_name',
-        baseContext,
-        'text'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe('John Doe');
-    });
-
-    it('should calculate numeric formulas using "expression"', () => {
-      const result = engine.evaluate(
-        'quantity * unit_price',
-        baseContext,
-        'currency'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(255);
-    });
-
-    it('should support system variables in expression', () => {
-      const result = engine.evaluate(
-        '$year',
-        baseContext,
-        'number'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(2026);
-    });
-
-    it('should support conditional expressions', () => {
-      const result = engine.evaluate(
-        'quantity > 5 ? "High" : "Low"',
-        baseContext,
-        'text'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe('High');
-    });
-  });
-
-  describe('Specification examples from formula.mdx', () => {
-    it('should calculate full_name as per spec example', () => {
-      // From spec line 105-110
-      const result = engine.evaluate(
-        'first_name + " " + last_name',
-        baseContext,
-        'text'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe('John Doe');
-    });
-
-    it('should calculate total_amount with formula fields', () => {
-      // From spec: total_amount: expression: "quantity * unit_price"
-      const result = engine.evaluate(
-        'quantity * unit_price',
-        baseContext,
-        'currency'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(255);
-    });
-
-    it('should handle template literals', () => {
-      // From spec line 216-218
-      const result = engine.evaluate(
-        '`Hello, ${first_name}!`',
-        baseContext,
-        'text'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe('Hello, John!');
-    });
-
-    it('should support Math functions', () => {
-      // From spec line 435-438
-      const context = {
-        ...baseContext,
-        record: { ...baseContext.record, price: 99.7 }
-      };
-      
-      const result = engine.evaluate(
-        'Math.round(price)',
-        context,
-        'number'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(100);
-    });
-  });
-
-  describe('Error handling per specification', () => {
-    it('should handle division by zero safely', () => {
-      // From spec section 7.1
-      const context = {
-        ...baseContext,
-        record: { total: 100, count: 0 }
-      };
-      
-      const result = engine.evaluate(
-        'count !== 0 ? total / count : 0',
-        context,
-        'number'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(0);
-    });
-
-    it('should detect division by zero without guard', () => {
-      const context = {
-        ...baseContext,
-        record: { total: 100, count: 0 }
-      };
-      
-      const result = engine.evaluate(
-        'total / count',
-        context,
-        'number'
-      );
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Infinity');
-    });
-
-    it('should handle null values with optional chaining', () => {
-      // From spec section 7.2
-      const context = {
-        ...baseContext,
-        record: { account: null }
-      };
-      
-      const result = engine.evaluate(
-        'account?.name ?? "No Account"',
-        context,
-        'text'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe('No Account');
-    });
-  });
-
-  describe('Data type coercion per specification', () => {
-    it('should coerce to number type', () => {
-      const context = {
-        ...baseContext,
-        record: { text_value: '42' }
-      };
-      
-      const result = engine.evaluate(
-        'Number(text_value) || 0',
-        context,
-        'number'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(42);
-    });
-
-    it('should coerce to text type', () => {
-      const context = {
-        ...baseContext,
-        record: { numeric_value: 123 }
-      };
-      
-      const result = engine.evaluate(
-        'String(numeric_value)',
-        context,
-        'text'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe('123');
-    });
-
-    it('should coerce to boolean type', () => {
-      const context = {
-        ...baseContext,
-        record: { value: 1 }
-      };
-      
-      const result = engine.evaluate(
-        'Boolean(value)',
-        context,
-        'boolean'
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.value).toBe(true);
-    });
-  });
-});

package/test/validation-spec-compliance.test.ts

@@ -1,440 +0,0 @@
-/**
- * ObjectQL
- * Copyright (c) 2026-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 Specification Compliance Tests
- * 
- * Ensures that validation rules work according to the latest specification.
- */
-
-import { Validator } from '../src/validator';
-import type {
-    ValidationContext,
-    CrossFieldValidationRule,
-    StateMachineValidationRule,
-    FieldConfig,
-} from '@objectql/types';
-
-describe('Validation Specification Compliance', () => {
-    let validator: Validator;
-
-    beforeEach(() => {
-        validator = new Validator();
-    });
-
-    describe('Cross-field validation per specification', () => {
-        it('should validate date range as per spec example', async () => {
-            // From spec lines 219-235
-            const rule: CrossFieldValidationRule = {
-                name: 'end_after_start',
-                type: 'cross_field',
-                rule: {
-                    field: 'end_date',
-                    operator: '>=',
-                    compare_to: 'start_date',
-                },
-                message: 'End date must be on or after start date',
-                error_code: 'INVALID_DATE_RANGE',
-                severity: 'error',
-            };
-
-            const validContext: ValidationContext = {
-                operation: 'create',
-                record: {
-                    start_date: new Date('2026-01-01'),
-                    end_date: new Date('2026-12-31'),
-                },
-            };
-
-            const result = await validator.validate([rule], validContext);
-            expect(result.valid).toBe(true);
-        });
-
-        it('should reject invalid date range', async () => {
-            const rule: CrossFieldValidationRule = {
-                name: 'end_after_start',
-                type: 'cross_field',
-                rule: {
-                    field: 'end_date',
-                    operator: '>=',
-                    compare_to: 'start_date',
-                },
-                message: 'End date must be on or after start date',
-                error_code: 'INVALID_DATE_RANGE',
-            };
-
-            const invalidContext: ValidationContext = {
-                operation: 'create',
-                record: {
-                    start_date: new Date('2026-12-31'),
-                    end_date: new Date('2026-01-01'),
-                },
-            };
-
-            const result = await validator.validate([rule], invalidContext);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].error_code).toBe('INVALID_DATE_RANGE');
-        });
-
-        it('should validate conditional requirements as per spec', async () => {
-            // From spec lines 238-258
-            const rule: CrossFieldValidationRule = {
-                name: 'reason_required_for_rejection',
-                type: 'cross_field',
-                rule: {
-                    if: {
-                        field: 'status',
-                        operator: '=',
-                        value: 'rejected',
-                    },
-                    then: {
-                        field: 'rejection_reason',
-                        operator: '!=',
-                        value: null,
-                    },
-                },
-                message: 'Rejection reason is required when status is rejected',
-                error_code: 'REJECTION_REASON_REQUIRED',
-            };
-
-            const validContext: ValidationContext = {
-                operation: 'create',
-                record: {
-                    status: 'rejected',
-                    rejection_reason: 'Does not meet requirements',
-                },
-            };
-
-            const result = await validator.validate([rule], validContext);
-            expect(result.valid).toBe(true);
-        });
-    });
-
-    describe('State machine validation per specification', () => {
-        it('should validate state transitions as per spec example', async () => {
-            // From spec lines 446-497
-            const rule: StateMachineValidationRule = {
-                name: 'order_status_flow',
-                type: 'state_machine',
-                field: 'status',
-                message: 'Invalid status transition',
-                transitions: {
-                    draft: {
-                        allowed_next: ['submitted', 'cancelled'],
-                    },
-                    submitted: {
-                        allowed_next: ['approved', 'rejected'],
-                    },
-                    approved: {
-                        allowed_next: ['processing', 'cancelled'],
-                    },
-                },
-            };
-
-            const validContext: ValidationContext = {
-                operation: 'update',
-                record: { status: 'submitted' },
-                previousRecord: { status: 'draft' },
-            };
-
-            const result = await validator.validate([rule], validContext);
-            expect(result.valid).toBe(true);
-        });
-
-        it('should reject invalid state transitions', async () => {
-            const rule: StateMachineValidationRule = {
-                name: 'order_status_flow',
-                type: 'state_machine',
-                field: 'status',
-                message: 'Invalid status transition from {{old_status}} to {{new_status}}',
-                transitions: {
-                    draft: {
-                        allowed_next: ['submitted', 'cancelled'],
-                    },
-                    submitted: {
-                        allowed_next: ['approved', 'rejected'],
-                    },
-                },
-            };
-
-            const invalidContext: ValidationContext = {
-                operation: 'update',
-                record: { status: 'approved' },
-                previousRecord: { status: 'draft' },
-            };
-
-            const result = await validator.validate([rule], invalidContext);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain('draft');
-            expect(result.errors[0].message).toContain('approved');
-        });
-
-        it('should handle terminal states correctly', async () => {
-            const rule: StateMachineValidationRule = {
-                name: 'status_transition',
-                type: 'state_machine',
-                field: 'status',
-                message: 'Invalid status transition',
-                transitions: {
-                    completed: {
-                        allowed_next: [],
-                        is_terminal: true,
-                    },
-                },
-            };
-
-            const invalidContext: ValidationContext = {
-                operation: 'update',
-                record: { status: 'active' },
-                previousRecord: { status: 'completed' },
-            };
-
-            const result = await validator.validate([rule], invalidContext);
-            expect(result.valid).toBe(false);
-        });
-    });
-
-    describe('Field-level validation per specification', () => {
-        it('should validate email format as per spec', async () => {
-            // From spec lines 152-159
-            const fieldConfig: FieldConfig = {
-                type: 'email',
-                required: true,
-                validation: {
-                    format: 'email',
-                    message: 'Please enter a valid email address',
-                },
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { email: 'test@example.com' },
-            };
-
-            const results = await validator.validateField('email', fieldConfig, 'test@example.com', context);
-            expect(results.length).toBe(0);
-        });
-
-        it('should reject invalid email format', async () => {
-            const fieldConfig: FieldConfig = {
-                type: 'email',
-                required: true,
-                validation: {
-                    format: 'email',
-                    message: 'Please enter a valid email address',
-                },
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { email: 'invalid-email' },
-            };
-
-            const results = await validator.validateField('email', fieldConfig, 'invalid-email', context);
-            expect(results.length).toBeGreaterThan(0);
-            expect(results[0].valid).toBe(false);
-        });
-
-        it('should validate URL format with protocol restrictions', async () => {
-            // From spec lines 190-199
-            const fieldConfig: FieldConfig = {
-                type: 'url',
-                validation: {
-                    format: 'url',
-                    protocols: ['http', 'https'],
-                    message: 'Please enter a valid URL',
-                },
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { website: 'https://example.com' },
-            };
-
-            const results = await validator.validateField('website', fieldConfig, 'https://example.com', context);
-            expect(results.length).toBe(0);
-        });
-
-        it('should reject URL with invalid protocol', async () => {
-            const fieldConfig: FieldConfig = {
-                type: 'url',
-                validation: {
-                    format: 'url',
-                    protocols: ['http', 'https'],
-                    message: 'Please enter a valid URL',
-                },
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { website: 'ftp://example.com' },
-            };
-
-            const results = await validator.validateField('website', fieldConfig, 'ftp://example.com', context);
-            expect(results.length).toBeGreaterThan(0);
-            expect(results[0].valid).toBe(false);
-        });
-
-        it('should validate min/max range as per spec', async () => {
-            // From spec lines 160-170
-            const fieldConfig: FieldConfig = {
-                type: 'number',
-                validation: {
-                    min: 0,
-                    max: 150,
-                    message: 'Age must be between 0 and 150',
-                },
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { age: 25 },
-            };
-
-            const results = await validator.validateField('age', fieldConfig, 25, context);
-            expect(results.length).toBe(0);
-        });
-
-        it('should validate string length constraints', async () => {
-            // From spec lines 172-185
-            const fieldConfig: FieldConfig = {
-                type: 'text',
-                required: true,
-                validation: {
-                    min_length: 3,
-                    max_length: 20,
-                    message: 'Username must be 3-20 characters',
-                },
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { username: 'john_doe' },
-            };
-
-            const results = await validator.validateField('username', fieldConfig, 'john_doe', context);
-            expect(results.length).toBe(0);
-        });
-
-        it('should validate pattern matching', async () => {
-            const fieldConfig: FieldConfig = {
-                type: 'text',
-                validation: {
-                    pattern: '^[a-zA-Z0-9_]+$',
-                    message: 'Username must be alphanumeric',
-                },
-            };
-
-            const validContext: ValidationContext = {
-                operation: 'create',
-                record: { username: 'john_doe_123' },
-            };
-
-            const results = await validator.validateField('username', fieldConfig, 'john_doe_123', validContext);
-            expect(results.length).toBe(0);
-        });
-
-        it('should reject invalid pattern', async () => {
-            const fieldConfig: FieldConfig = {
-                type: 'text',
-                validation: {
-                    pattern: '^[a-zA-Z0-9_]+$',
-                    message: 'Username must be alphanumeric',
-                },
-            };
-
-            const invalidContext: ValidationContext = {
-                operation: 'create',
-                record: { username: 'john@doe!' },
-            };
-
-            const results = await validator.validateField('username', fieldConfig, 'john@doe!', invalidContext);
-            expect(results.length).toBeGreaterThan(0);
-            expect(results[0].valid).toBe(false);
-        });
-    });
-
-    describe('Validation triggers and conditions', () => {
-        it('should apply rule only on specified operations', async () => {
-            const rule: CrossFieldValidationRule = {
-                name: 'budget_check',
-                type: 'cross_field',
-                trigger: ['create', 'update'],
-                rule: {
-                    field: 'budget',
-                    operator: '>=',
-                    value: 0,
-                },
-                message: 'Budget must be positive',
-            };
-
-            const deleteContext: ValidationContext = {
-                operation: 'delete',
-                record: { budget: -100 },
-            };
-
-            // Rule should be skipped on delete operation
-            const result = await validator.validate([rule], deleteContext);
-            expect(result.valid).toBe(true);
-        });
-
-        it('should apply conditional validation', async () => {
-            const rule: CrossFieldValidationRule = {
-                name: 'high_value_approval',
-                type: 'cross_field',
-                apply_when: {
-                    field: 'total_amount',
-                    operator: '>',
-                    value: 10000,
-                },
-                rule: {
-                    field: 'manager_approval_id',
-                    operator: '!=',
-                    value: null,
-                },
-                message: 'Manager approval required for orders over $10,000',
-            };
-
-            // Rule should not apply for low-value orders
-            const lowValueContext: ValidationContext = {
-                operation: 'create',
-                record: {
-                    total_amount: 5000,
-                    manager_approval_id: null,
-                },
-            };
-
-            const result = await validator.validate([rule], lowValueContext);
-            expect(result.valid).toBe(true);
-        });
-    });
-
-    describe('Message formatting with templates', () => {
-        it('should format messages with template variables', async () => {
-            const rule: CrossFieldValidationRule = {
-                name: 'budget_limit',
-                type: 'cross_field',
-                rule: {
-                    field: 'budget',
-                    operator: '<=',
-                    value: 100000,
-                },
-                message: 'Budget {{budget}} exceeds limit',
-            };
-
-            const context: ValidationContext = {
-                operation: 'create',
-                record: { budget: 150000 },
-            };
-
-            const result = await validator.validate([rule], context);
-            expect(result.valid).toBe(false);
-            expect(result.errors[0].message).toContain('150000');
-        });
-    });
-});