@objectql/core 3.0.0 → 4.0.0

package/test/filter-syntax.test.ts

@@ -0,0 +1,233 @@
+/**
+ * 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.
+ */
+
+import { ObjectQL } from '../src/index';
+import { MockDriver } from './mock-driver';
+import { ObjectConfig } from '@objectql/types';
+
+/**
+ * Modern Filter Syntax Tests
+ * 
+ * Tests the new object-based filter syntax from @objectstack/spec FilterCondition.
+ * This replaces the old array-based FilterExpression syntax.
+ * 
+ * Note: These tests verify filter translation logic. Full filter functionality
+ * is tested in driver integration tests.
+ */
+
+const productObject: ObjectConfig = {
+    name: 'product',
+    fields: {
+        name: { type: 'text' },
+        price: { type: 'number' },
+        category: { type: 'text' },
+        status: { type: 'text' }
+    }
+};
+
+describe('Modern Filter Syntax - Translation', () => {
+    let app: ObjectQL;
+    let driver: MockDriver;
+
+    beforeEach(async () => {
+        driver = new MockDriver();
+        app = new ObjectQL({
+            datasources: {
+                default: driver
+            },
+            objects: {
+                product: productObject
+            }
+        });
+        await app.init();
+    });
+
+    describe('Filter Translation to Kernel', () => {
+        it('should accept object-based filter syntax', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            // This should not throw - it accepts the new syntax
+            await expect(repo.find({
+                filters: { category: 'Electronics' }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept $eq operator', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: { status: { $eq: 'active' } }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept $ne operator', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: { status: { $ne: 'inactive' } }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept comparison operators', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: { price: { $gt: 100 } }
+            })).resolves.toBeDefined();
+
+            await expect(repo.find({
+                filters: { price: { $gte: 100 } }
+            })).resolves.toBeDefined();
+
+            await expect(repo.find({
+                filters: { price: { $lt: 500 } }
+            })).resolves.toBeDefined();
+
+            await expect(repo.find({
+                filters: { price: { $lte: 500 } }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept $in operator', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: { status: { $in: ['active', 'pending'] } }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept $nin operator', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: { status: { $nin: ['inactive', 'deleted'] } }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept $and operator', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: {
+                    $and: [
+                        { category: 'Electronics' },
+                        { status: 'active' }
+                    ]
+                }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept $or operator', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: {
+                    $or: [
+                        { category: 'Electronics' },
+                        { category: 'Furniture' }
+                    ]
+                }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept nested logical operators', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: {
+                    $and: [
+                        {
+                            $or: [
+                                { category: 'Electronics' },
+                                { category: 'Furniture' }
+                            ]
+                        },
+                        { status: 'active' }
+                    ]
+                }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept multiple operators on same field', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: {
+                    price: {
+                        $gte: 100,
+                        $lte: 500
+                    }
+                }
+            })).resolves.toBeDefined();
+        });
+
+        it('should accept mixed implicit and explicit syntax', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: {
+                    category: 'Electronics',
+                    price: { $gte: 100 }
+                }
+            })).resolves.toBeDefined();
+        });
+    });
+
+    describe('Backward Compatibility', () => {
+        it('should still support legacy array-based filter syntax', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            // Old syntax should still work
+            await expect(repo.find({
+                filters: [['category', '=', 'Electronics']] as any
+            })).resolves.toBeDefined();
+        });
+
+        it('should support legacy complex filters with logical operators', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: [
+                    ['category', '=', 'Electronics'],
+                    'and',
+                    ['status', '=', 'active']
+                ] as any
+            })).resolves.toBeDefined();
+        });
+
+        it('should support legacy nested filter groups', async () => {
+            const ctx = app.createContext({ userId: 'test', isSystem: true });
+            const repo = ctx.object('product');
+
+            await expect(repo.find({
+                filters: [
+                    [
+                        ['category', '=', 'Electronics'],
+                        'or',
+                        ['category', '=', 'Furniture']
+                    ],
+                    'and',
+                    ['status', '=', 'active']
+                ] as any
+            })).resolves.toBeDefined();
+        });
+    });
+});

package/test/formula-engine.test.ts

@@ -1,3 +1,11 @@
+/**
+ * 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 Engine Tests
  * 

package/test/formula-integration.test.ts

@@ -1,3 +1,11 @@
+/**
+ * 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
  * 

package/test/formula-plugin.test.ts

@@ -0,0 +1,197 @@
+/**
+ * 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 '@objectstack/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/introspection.test.ts

@@ -1,3 +1,11 @@
+/**
+ * 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.
+ */
+
 import { convertIntrospectedSchemaToObjects } from '../src/util';
 import { IntrospectedSchema, ObjectConfig } from '@objectql/types';
 

package/test/mock-driver.ts

@@ -1,3 +1,11 @@
+/**
+ * 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.
+ */
+
 import { Driver } from '@objectql/types';
 
 export class MockDriver implements Driver {

package/test/plugin-integration.test.ts

@@ -0,0 +1,213 @@
+/**
+ * ObjectQL Plugin Integration 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 { ObjectQLPlugin } from '../src/plugin';
+import { ValidatorPlugin } from '../src/validator-plugin';
+import { FormulaPlugin } from '../src/formula-plugin';
+
+// Mock the sub-plugins
+jest.mock('../src/validator-plugin');
+jest.mock('../src/formula-plugin');
+
+describe('ObjectQLPlugin Integration', () => {
+    let plugin: ObjectQLPlugin;
+    let mockKernel: any;
+    let mockContext: any;
+
+    beforeEach(() => {
+        // Clear all mocks
+        jest.clearAllMocks();
+        
+        // Create a mock kernel
+        mockKernel = {
+            use: jest.fn(),
+            registerFormulaProvider: jest.fn(),
+        };
+        
+        mockContext = { engine: mockKernel };
+        
+        // Setup mock implementations
+        (ValidatorPlugin as jest.Mock).mockImplementation(() => ({
+            install: jest.fn().mockResolvedValue(undefined),
+        }));
+        
+        (FormulaPlugin as jest.Mock).mockImplementation(() => ({
+            install: jest.fn().mockResolvedValue(undefined),
+        }));
+    });
+
+    describe('Plugin Metadata', () => {
+        it('should have correct name and version', () => {
+            plugin = new ObjectQLPlugin();
+            expect(plugin.name).toBe('@objectql/core');
+            expect(plugin.version).toBe('4.0.0');
+        });
+    });
+
+    describe('Constructor', () => {
+        it('should create plugin with default config', () => {
+            plugin = new ObjectQLPlugin();
+            expect(plugin).toBeDefined();
+        });
+
+        it('should create plugin with custom config', () => {
+            plugin = new ObjectQLPlugin({
+                enableRepository: false,
+                enableValidator: false,
+                enableFormulas: true,
+                enableAI: false,
+            });
+            expect(plugin).toBeDefined();
+        });
+
+        it('should accept validator config', () => {
+            plugin = new ObjectQLPlugin({
+                validatorConfig: {
+                    language: 'zh-CN',
+                    enableQueryValidation: false,
+                },
+            });
+            expect(plugin).toBeDefined();
+        });
+
+        it('should accept formula config', () => {
+            plugin = new ObjectQLPlugin({
+                formulaConfig: {
+                    enable_cache: true,
+                    cache_ttl: 600,
+                },
+            });
+            expect(plugin).toBeDefined();
+        });
+    });
+
+    describe('Installation - Conditional Plugin Loading', () => {
+        it('should install validator plugin when enabled', async () => {
+            plugin = new ObjectQLPlugin({ enableValidator: true });
+            await plugin.install(mockContext);
+            
+            expect(ValidatorPlugin).toHaveBeenCalled();
+            const validatorInstance = (ValidatorPlugin as jest.Mock).mock.results[0].value;
+            expect(validatorInstance.install).toHaveBeenCalledWith(mockContext);
+        });
+
+        it('should not install validator plugin when disabled', async () => {
+            plugin = new ObjectQLPlugin({ enableValidator: false });
+            await plugin.install(mockContext);
+            
+            expect(ValidatorPlugin).not.toHaveBeenCalled();
+        });
+
+        it('should install formula plugin when enabled', async () => {
+            plugin = new ObjectQLPlugin({ enableFormulas: true });
+            await plugin.install(mockContext);
+            
+            expect(FormulaPlugin).toHaveBeenCalled();
+            const formulaInstance = (FormulaPlugin as jest.Mock).mock.results[0].value;
+            expect(formulaInstance.install).toHaveBeenCalledWith(mockContext);
+        });
+
+        it('should not install formula plugin when disabled', async () => {
+            plugin = new ObjectQLPlugin({ enableFormulas: false });
+            await plugin.install(mockContext);
+            
+            expect(FormulaPlugin).not.toHaveBeenCalled();
+        });
+
+        it('should pass validator config to validator plugin', async () => {
+            const validatorConfig = {
+                language: 'zh-CN',
+                enableQueryValidation: false,
+            };
+            
+            plugin = new ObjectQLPlugin({
+                enableValidator: true,
+                validatorConfig,
+            });
+            
+            await plugin.install(mockContext);
+            
+            expect(ValidatorPlugin).toHaveBeenCalledWith(validatorConfig);
+        });
+
+        it('should pass formula config to formula plugin', async () => {
+            const formulaConfig = {
+                enable_cache: true,
+                cache_ttl: 600,
+            };
+            
+            plugin = new ObjectQLPlugin({
+                enableFormulas: true,
+                formulaConfig,
+            });
+            
+            await plugin.install(mockContext);
+            
+            expect(FormulaPlugin).toHaveBeenCalledWith(formulaConfig);
+        });
+
+        it('should install multiple plugins when all enabled', async () => {
+            plugin = new ObjectQLPlugin({
+                enableValidator: true,
+                enableFormulas: true,
+            });
+            
+            await plugin.install(mockContext);
+            
+            expect(ValidatorPlugin).toHaveBeenCalled();
+            expect(FormulaPlugin).toHaveBeenCalled();
+        });
+
+        it('should not install any plugins when all disabled', async () => {
+            plugin = new ObjectQLPlugin({
+                enableRepository: false,
+                enableValidator: false,
+                enableFormulas: false,
+                enableAI: false,
+            });
+            
+            await plugin.install(mockContext);
+            
+            expect(ValidatorPlugin).not.toHaveBeenCalled();
+            expect(FormulaPlugin).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('Lifecycle Hooks', () => {
+        it('should have onStart method', async () => {
+            plugin = new ObjectQLPlugin();
+            expect(typeof plugin.onStart).toBe('function');
+            
+            // Should not throw when called
+            await expect(plugin.onStart(mockContext)).resolves.not.toThrow();
+        });
+    });
+
+    describe('Default Configuration', () => {
+        it('should enable all features by default', async () => {
+            plugin = new ObjectQLPlugin();
+            await plugin.install(mockContext);
+            
+            // Validator and Formula should be installed by default
+            expect(ValidatorPlugin).toHaveBeenCalled();
+            expect(FormulaPlugin).toHaveBeenCalled();
+        });
+
+        it('should treat undefined config as enabled', async () => {
+            plugin = new ObjectQLPlugin({
+                // Explicitly not setting enableValidator or enableFormulas
+            });
+            
+            await plugin.install(mockContext);
+            
+            // Both should still be installed
+            expect(ValidatorPlugin).toHaveBeenCalled();
+            expect(FormulaPlugin).toHaveBeenCalled();
+        });
+    });
+});