@objectql/core 4.0.1 → 4.0.3

package/test/formula-integration.test.ts

@@ -1,286 +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 Integration Tests
- * 
- * Tests formula evaluation within repository queries
- */
-
-import { ObjectQL } from '../src/app';
-import { MockDriver } from './mock-driver';
-
-describe('Formula Integration', () => {
-  let app: ObjectQL;
-  let mockDriver: MockDriver;
-
-  beforeEach(async () => {
-    mockDriver = new MockDriver();
-    
-    app = new ObjectQL({
-      datasources: {
-        default: mockDriver
-      }
-    });
-
-    // Register an object with formula fields
-    app.registerObject({
-      name: 'contact',
-      fields: {
-        first_name: {
-          type: 'text',
-          required: true,
-        },
-        last_name: {
-          type: 'text',
-          required: true,
-        },
-        full_name: {
-          type: 'formula',
-          formula: 'first_name + " " + last_name',
-          data_type: 'text',
-          label: 'Full Name',
-        },
-        quantity: {
-          type: 'number',
-        },
-        unit_price: {
-          type: 'currency',
-        },
-        total: {
-          type: 'formula',
-          formula: 'quantity * unit_price',
-          data_type: 'currency',
-          label: 'Total',
-        },
-        is_active: {
-          type: 'boolean',
-        },
-        status_label: {
-          type: 'formula',
-          formula: 'is_active ? "Active" : "Inactive"',
-          data_type: 'text',
-          label: 'Status',
-        },
-      },
-    });
-
-    await app.init();
-  });
-
-  describe('Formula Evaluation in Queries', () => {
-    it('should evaluate formula fields in find results', async () => {
-      // Setup mock data
-      mockDriver.setMockData('contact', [
-        {
-          _id: '1',
-          first_name: 'John',
-          last_name: 'Doe',
-          quantity: 10,
-          unit_price: 25.5,
-          is_active: true,
-        },
-        {
-          _id: '2',
-          first_name: 'Jane',
-          last_name: 'Smith',
-          quantity: 5,
-          unit_price: 30,
-          is_active: false,
-        },
-      ]);
-
-      const ctx = app.createContext({ isSystem: true });
-      const results = await ctx.object('contact').find({});
-
-      expect(results).toHaveLength(2);
-      
-      // Check first record
-      expect(results[0].full_name).toBe('John Doe');
-      expect(results[0].total).toBe(255); // 10 * 25.5
-      expect(results[0].status_label).toBe('Active');
-
-      // Check second record
-      expect(results[1].full_name).toBe('Jane Smith');
-      expect(results[1].total).toBe(150); // 5 * 30
-      expect(results[1].status_label).toBe('Inactive');
-    });
-
-    it('should evaluate formula fields in findOne result', async () => {
-      mockDriver.setMockData('contact', [
-        {
-          _id: '1',
-          first_name: 'John',
-          last_name: 'Doe',
-          quantity: 10,
-          unit_price: 25.5,
-          is_active: true,
-        },
-      ]);
-
-      const ctx = app.createContext({ isSystem: true });
-      const result = await ctx.object('contact').findOne('1');
-
-      expect(result).toBeDefined();
-      expect(result.full_name).toBe('John Doe');
-      expect(result.total).toBe(255);
-      expect(result.status_label).toBe('Active');
-    });
-
-    it('should handle null values in formulas', async () => {
-      mockDriver.setMockData('contact', [
-        {
-          _id: '1',
-          first_name: 'John',
-          last_name: 'Doe',
-          quantity: null,
-          unit_price: 25.5,
-          is_active: true,
-        },
-      ]);
-
-      const ctx = app.createContext({ isSystem: true });
-      const result = await ctx.object('contact').findOne('1');
-
-      expect(result).toBeDefined();
-      expect(result.full_name).toBe('John Doe');
-      // In JavaScript, null * number = 0 (null is coerced to 0)
-      expect(result.total).toBe(0);
-    });
-  });
-
-  describe('Complex Formula Examples', () => {
-    beforeEach(async () => {
-      // Register an object with more complex formulas
-      app.registerObject({
-        name: 'order',
-        fields: {
-          subtotal: { type: 'currency' },
-          discount_rate: { type: 'percent' },
-          tax_rate: { type: 'percent' },
-          final_price: {
-            type: 'formula',
-            formula: 'subtotal * (1 - discount_rate / 100) * (1 + tax_rate / 100)',
-            data_type: 'currency',
-            label: 'Final Price',
-          },
-          created_at: { type: 'date' },
-          status: { type: 'select', options: ['draft', 'confirmed', 'shipped'] },
-          risk_level: {
-            type: 'formula',
-            formula: `
-              if (subtotal > 10000) {
-                return 'High';
-              } else if (subtotal > 1000) {
-                return 'Medium';
-              } else {
-                return 'Low';
-              }
-            `,
-            data_type: 'text',
-          },
-        },
-      });
-
-      await app.init();
-    });
-
-    it('should calculate complex financial formulas', async () => {
-      mockDriver.setMockData('order', [
-        {
-          _id: '1',
-          subtotal: 5000,
-          discount_rate: 10,
-          tax_rate: 8,
-          status: 'confirmed',
-          created_at: new Date('2026-01-01'),
-        },
-      ]);
-
-      const ctx = app.createContext({ isSystem: true });
-      const result = await ctx.object('order').findOne('1');
-
-      expect(result).toBeDefined();
-      expect(result.final_price).toBeCloseTo(4860, 1);
-      expect(result.risk_level).toBe('Medium');
-    });
-
-    it('should handle conditional logic in formulas', async () => {
-      mockDriver.setMockData('order', [
-        {
-          _id: '1',
-          subtotal: 500,
-          discount_rate: 0,
-          tax_rate: 0,
-          status: 'draft',
-          created_at: new Date('2026-01-01'),
-        },
-        {
-          _id: '2',
-          subtotal: 5000,
-          discount_rate: 0,
-          tax_rate: 0,
-          status: 'confirmed',
-          created_at: new Date('2026-01-01'),
-        },
-        {
-          _id: '3',
-          subtotal: 15000,
-          discount_rate: 0,
-          tax_rate: 0,
-          status: 'shipped',
-          created_at: new Date('2026-01-01'),
-        },
-      ]);
-
-      const ctx = app.createContext({ isSystem: true });
-      const results = await ctx.object('order').find({});
-
-      expect(results[0].risk_level).toBe('Low');
-      expect(results[1].risk_level).toBe('Medium');
-      expect(results[2].risk_level).toBe('High');
-    });
-  });
-
-  describe('Formula Error Handling', () => {
-    beforeEach(async () => {
-      app.registerObject({
-        name: 'product',
-        fields: {
-          name: { type: 'text' },
-          price: { type: 'currency' },
-          invalid_formula: {
-            type: 'formula',
-            formula: 'nonexistent_field * 2',
-            data_type: 'number',
-          },
-        },
-      });
-
-      await app.init();
-    });
-
-    it('should handle formula evaluation errors gracefully', async () => {
-      mockDriver.setMockData('product', [
-        {
-          _id: '1',
-          name: 'Widget',
-          price: 100,
-        },
-      ]);
-
-      const ctx = app.createContext({ isSystem: true });
-      const result = await ctx.object('product').findOne('1');
-
-      expect(result).toBeDefined();
-      expect(result.name).toBe('Widget');
-      // Formula failed, should be null
-      expect(result.invalid_formula).toBeNull();
-    });
-  });
-});

package/test/formula-plugin.test.ts

@@ -1,197 +0,0 @@
-/**
- * ObjectQL Formula Plugin Tests
- * 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.
- */
-
-import { FormulaPlugin } from '../src/formula-plugin';
-import { ObjectStackKernel } from '@objectql/runtime';
-
-describe('FormulaPlugin', () => {
-    let plugin: FormulaPlugin;
-    let mockKernel: any;
-
-    beforeEach(() => {
-        // Create a mock kernel with middleware and formula provider support
-        mockKernel = {
-            use: jest.fn(),
-            registerFormulaProvider: jest.fn(),
-        };
-        plugin = new FormulaPlugin();
-    });
-
-    describe('Plugin Metadata', () => {
-        it('should have correct name and version', () => {
-            expect(plugin.name).toBe('@objectql/formulas');
-            expect(plugin.version).toBe('4.0.0');
-        });
-    });
-
-    describe('Constructor', () => {
-        it('should create plugin with default config', () => {
-            const defaultPlugin = new FormulaPlugin();
-            expect(defaultPlugin).toBeDefined();
-        });
-
-        it('should create plugin with custom config', () => {
-            const customPlugin = new FormulaPlugin({
-                enable_cache: true,
-                cache_ttl: 600,
-                autoEvaluateOnQuery: false,
-            });
-            expect(customPlugin).toBeDefined();
-        });
-
-        it('should accept formula engine config', () => {
-            const customPlugin = new FormulaPlugin({
-                enable_monitoring: true,
-                max_execution_time: 5000,
-            });
-            expect(customPlugin).toBeDefined();
-        });
-    });
-
-    describe('Installation', () => {
-        it('should install successfully with mock kernel', async () => {
-            const ctx = { engine: mockKernel };
-            await plugin.install(ctx);
-            
-            // Verify that formula provider was registered
-            expect(mockKernel.registerFormulaProvider).toHaveBeenCalled();
-        });
-
-        it('should register formula provider with evaluate function', async () => {
-            const ctx = { engine: mockKernel };
-            await plugin.install(ctx);
-            
-            expect(mockKernel.registerFormulaProvider).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    evaluate: expect.any(Function),
-                    validate: expect.any(Function),
-                    extractMetadata: expect.any(Function),
-                })
-            );
-        });
-
-        it('should register formula middleware when auto-evaluation is enabled', async () => {
-            const pluginWithAuto = new FormulaPlugin({ autoEvaluateOnQuery: true });
-            const ctx = { engine: mockKernel };
-            
-            await pluginWithAuto.install(ctx);
-            
-            // Check that middleware was registered
-            expect(mockKernel.use).toHaveBeenCalledWith('afterQuery', expect.any(Function));
-        });
-
-        it('should not register formula middleware when auto-evaluation is disabled', async () => {
-            const pluginNoAuto = new FormulaPlugin({ autoEvaluateOnQuery: false });
-            const ctx = { engine: mockKernel };
-            
-            await pluginNoAuto.install(ctx);
-            
-            // Should not have registered afterQuery hook
-            const afterQueryCalls = mockKernel.use.mock.calls.filter(
-                (call: any[]) => call[0] === 'afterQuery'
-            );
-            expect(afterQueryCalls.length).toBe(0);
-        });
-
-        it('should handle kernel without registerFormulaProvider', async () => {
-            const kernelNoProvider = {
-                use: jest.fn(),
-            };
-            const ctx = { engine: kernelNoProvider };
-            
-            // Should not throw error and should set formulaEngine property
-            await expect(plugin.install(ctx)).resolves.not.toThrow();
-            expect((kernelNoProvider as any).formulaEngine).toBeDefined();
-        });
-
-        it('should handle kernel without middleware support', async () => {
-            const kernelNoMiddleware = {
-                registerFormulaProvider: jest.fn(),
-            };
-            const ctx = { engine: kernelNoMiddleware };
-            
-            // Should not throw error
-            await expect(plugin.install(ctx)).resolves.not.toThrow();
-        });
-    });
-
-    describe('Formula Provider', () => {
-        it('should provide evaluate function that works', async () => {
-            const ctx = { engine: mockKernel };
-            await plugin.install(ctx);
-            
-            // Get the registered provider
-            const provider = mockKernel.registerFormulaProvider.mock.calls[0][0];
-            
-            // Test the evaluate function
-            const result = provider.evaluate('1 + 1', {
-                record: {},
-                system: {
-                    today: new Date(),
-                    now: new Date(),
-                    year: 2026,
-                    month: 1,
-                    day: 22,
-                    hour: 12,
-                    minute: 0,
-                    second: 0,
-                },
-                current_user: {},
-                is_new: false,
-            });
-            
-            expect(result).toBeDefined();
-            expect(result.success).toBe(true);
-            // The result is coerced to 'text' by default, so it's a string "2"
-            expect(result.value).toBe('2');
-        });
-
-        it('should provide validate function that works', async () => {
-            const ctx = { engine: mockKernel };
-            await plugin.install(ctx);
-            
-            // Get the registered provider
-            const provider = mockKernel.registerFormulaProvider.mock.calls[0][0];
-            
-            // Test the validate function
-            const result = provider.validate('quantity * price');
-            
-            expect(result).toBeDefined();
-            expect(result.valid).toBe(true);
-            expect(result.errors.length).toBe(0);
-        });
-
-        it('should provide extractMetadata function that works', async () => {
-            const ctx = { engine: mockKernel };
-            await plugin.install(ctx);
-            
-            // Get the registered provider
-            const provider = mockKernel.registerFormulaProvider.mock.calls[0][0];
-            
-            // Test the extractMetadata function
-            const metadata = provider.extractMetadata('total', 'quantity * price', 'number');
-            
-            expect(metadata).toBeDefined();
-            expect(metadata.field_name).toBe('total');
-            expect(metadata.expression).toBe('quantity * price');
-            expect(metadata.data_type).toBe('number');
-            expect(metadata.dependencies).toContain('quantity');
-            expect(metadata.dependencies).toContain('price');
-        });
-    });
-
-    describe('Engine Access', () => {
-        it('should expose formula engine instance', () => {
-            const engine = plugin.getEngine();
-            expect(engine).toBeDefined();
-            expect(typeof engine.evaluate).toBe('function');
-            expect(typeof engine.validate).toBe('function');
-            expect(typeof engine.extractMetadata).toBe('function');
-        });
-    });
-});

package/test/validator-plugin.test.ts

@@ -1,126 +0,0 @@
-/**
- * ObjectQL Validator Plugin Tests
- * 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.
- */
-
-import { ValidatorPlugin } from '../src/validator-plugin';
-import { ObjectStackKernel } from '@objectql/runtime';
-
-describe('ValidatorPlugin', () => {
-    let plugin: ValidatorPlugin;
-    let mockKernel: any;
-
-    beforeEach(() => {
-        // Create a mock kernel with middleware support
-        mockKernel = {
-            use: jest.fn(),
-        };
-        plugin = new ValidatorPlugin();
-    });
-
-    describe('Plugin Metadata', () => {
-        it('should have correct name and version', () => {
-            expect(plugin.name).toBe('@objectql/validator');
-            expect(plugin.version).toBe('4.0.0');
-        });
-    });
-
-    describe('Constructor', () => {
-        it('should create plugin with default config', () => {
-            const defaultPlugin = new ValidatorPlugin();
-            expect(defaultPlugin).toBeDefined();
-        });
-
-        it('should create plugin with custom config', () => {
-            const customPlugin = new ValidatorPlugin({
-                language: 'zh-CN',
-                enableQueryValidation: false,
-                enableMutationValidation: true,
-            });
-            expect(customPlugin).toBeDefined();
-        });
-
-        it('should accept language options', () => {
-            const customPlugin = new ValidatorPlugin({
-                language: 'fr',
-                languageFallback: ['en', 'zh-CN'],
-            });
-            expect(customPlugin).toBeDefined();
-        });
-    });
-
-    describe('Installation', () => {
-        it('should install successfully with mock kernel', async () => {
-            const ctx = { engine: mockKernel };
-            await plugin.install(ctx);
-            
-            // Verify that middleware hooks were registered
-            expect(mockKernel.use).toHaveBeenCalled();
-        });
-
-        it('should register query validation when enabled', async () => {
-            const pluginWithQuery = new ValidatorPlugin({ enableQueryValidation: true });
-            const ctx = { engine: mockKernel };
-            
-            await pluginWithQuery.install(ctx);
-            
-            // Check that use was called (for query validation)
-            expect(mockKernel.use).toHaveBeenCalledWith('beforeQuery', expect.any(Function));
-        });
-
-        it('should register mutation validation when enabled', async () => {
-            const pluginWithMutation = new ValidatorPlugin({ enableMutationValidation: true });
-            const ctx = { engine: mockKernel };
-            
-            await pluginWithMutation.install(ctx);
-            
-            // Check that use was called (for mutation validation)
-            expect(mockKernel.use).toHaveBeenCalledWith('beforeMutation', expect.any(Function));
-        });
-
-        it('should not register query validation when disabled', async () => {
-            const pluginNoQuery = new ValidatorPlugin({ enableQueryValidation: false });
-            const ctx = { engine: mockKernel };
-            
-            await pluginNoQuery.install(ctx);
-            
-            // Should not have registered beforeQuery hook
-            const beforeQueryCalls = mockKernel.use.mock.calls.filter(
-                (call: any[]) => call[0] === 'beforeQuery'
-            );
-            expect(beforeQueryCalls.length).toBe(0);
-        });
-
-        it('should not register mutation validation when disabled', async () => {
-            const pluginNoMutation = new ValidatorPlugin({ enableMutationValidation: false });
-            const ctx = { engine: mockKernel };
-            
-            await pluginNoMutation.install(ctx);
-            
-            // Should not have registered beforeMutation hook
-            const beforeMutationCalls = mockKernel.use.mock.calls.filter(
-                (call: any[]) => call[0] === 'beforeMutation'
-            );
-            expect(beforeMutationCalls.length).toBe(0);
-        });
-
-        it('should handle kernel without middleware support', async () => {
-            const kernelNoMiddleware = {};
-            const ctx = { engine: kernelNoMiddleware };
-            
-            // Should not throw error
-            await expect(plugin.install(ctx)).resolves.not.toThrow();
-        });
-    });
-
-    describe('Validator Access', () => {
-        it('should expose validator instance', () => {
-            const validator = plugin.getValidator();
-            expect(validator).toBeDefined();
-            expect(typeof validator.validate).toBe('function');
-        });
-    });
-});