@objectql/core 4.2.0 → 4.2.2

package/test/filter-syntax.test.ts

@@ -1,233 +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.
- */
-
-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/gateway.test.ts

@@ -1,88 +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.
- */
-
-import { ObjectGateway } from '../src/gateway';
-import { ApiRequest, ApiResponse, GatewayProtocol } from '@objectql/types';
-
-describe('ObjectGateway', () => {
-    let gateway: ObjectGateway;
-    let mockProtocol: GatewayProtocol;
-
-    beforeEach(() => {
-        gateway = new ObjectGateway();
-        mockProtocol = {
-            name: 'mock',
-            route: jest.fn().mockReturnValue(true),
-            handle: jest.fn().mockResolvedValue({ status: 200, body: 'ok' })
-        };
-        gateway.registerProtocol(mockProtocol);
-    });
-
-    it('should route request to registered protocol', async () => {
-        const req: ApiRequest = {
-            path: '/test',
-            method: 'GET',
-            headers: {},
-            query: {}
-        };
-        
-        const response = await gateway.handle(req);
-        
-        expect(mockProtocol.route).toHaveBeenCalledWith(req);
-        expect(mockProtocol.handle).toHaveBeenCalledWith(req);
-        expect(response.status).toBe(200);
-    });
-
-    it('should return 404 if no protocol matches', async () => {
-        const specializedGateway = new ObjectGateway();
-        const response = await specializedGateway.handle({
-            path: '/unknown',
-            method: 'GET',
-            headers: {},
-            query: {}
-        });
-        
-        expect(response.status).toBe(404);
-        expect(response.body.error.code).toBe('PROTOCOL_NOT_FOUND');
-    });
-
-    it('should apply request transformers', async () => {
-        const req: ApiRequest = {
-            path: '/original',
-            method: 'GET',
-            headers: {},
-            query: {}
-        };
-
-        gateway.addRequestTransform(async (r) => {
-            return { ...r, path: '/transformed' };
-        });
-
-        await gateway.handle(req);
-        
-        // Protocol should see the transformed request
-        expect(mockProtocol.route).toHaveBeenCalledWith(expect.objectContaining({ path: '/transformed' }));
-    });
-
-    it('should apply response transformers', async () => {
-        const req: ApiRequest = {
-            path: '/test',
-            method: 'GET',
-            headers: {},
-            query: {}
-        };
-
-        gateway.addResponseTransform(async (res) => {
-            return { ...res, headers: { ...res.headers, 'X-Custom': 'Added' } };
-        });
-
-        const response = await gateway.handle(req);
-        
-        expect(response.headers?.['X-Custom']).toBe('Added');
-    });
-});

package/test/protocol.test.ts

@@ -1,143 +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.
- */
-
-import { ObjectStackProtocolImplementation } from '../src/protocol';
-import { IObjectQL } from '@objectql/types';
-
-describe('ObjectStackProtocolImplementation', () => {
-    let mockEngine: Partial<IObjectQL>;
-    let protocol: ObjectStackProtocolImplementation;
-
-    beforeEach(() => {
-        mockEngine = {
-            metadata: {
-                getTypes: jest.fn().mockReturnValue(['object']),
-                list: jest.fn().mockReturnValue([{ name: 'testObject', label: 'Test Object' }]),
-                get: jest.fn().mockReturnValue({ name: 'testObject', fields: {} }),
-            } as any,
-            // Mock kernel-like direct methods
-            find: jest.fn(),
-            get: jest.fn(),
-            create: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn(),
-        };
-        protocol = new ObjectStackProtocolImplementation(mockEngine as IObjectQL);
-    });
-
-    describe('Meta Operations', () => {
-        it('getMetaTypes should return types from engine metadata', async () => {
-            const result = await protocol.getMetaTypes({});
-            expect(result).toEqual({ types: ['object'] });
-            expect(mockEngine.metadata?.getTypes).toHaveBeenCalled();
-        });
-
-        it('getMetaItems should return items for a type', async () => {
-            const result = await protocol.getMetaItems({ type: 'object' });
-            expect(result).toEqual({ 
-                type: 'object', 
-                items: [{ name: 'testObject', label: 'Test Object' }] 
-            });
-            expect(mockEngine.metadata?.list).toHaveBeenCalledWith('object');
-        });
-
-        it('getMetaItem should return specific item definition', async () => {
-            const result = await protocol.getMetaItem({ type: 'object', name: 'testObject' });
-            expect(result).toEqual({ name: 'testObject', fields: {} });
-            expect(mockEngine.metadata?.get).toHaveBeenCalledWith('object', 'testObject');
-        });
-    });
-
-    describe('Data Operations (Direct Kernel Mode)', () => {
-        it('findData should delegate to engine.find', async () => {
-            const mockData = [{ id: '1', name: 'Test' }];
-            (mockEngine as any).find.mockResolvedValue(mockData);
-
-            const result = await protocol.findData({ object: 'testObject', query: {} });
-            expect(result).toBe(mockData);
-            expect((mockEngine as any).find).toHaveBeenCalledWith('testObject', {});
-        });
-
-        it('getData should delegate to engine.get', async () => {
-            const mockRecord = { id: '1', name: 'Test' };
-            (mockEngine as any).get.mockResolvedValue(mockRecord);
-
-            const result = await protocol.getData({ object: 'testObject', id: '1' });
-            expect(result).toBe(mockRecord);
-            expect((mockEngine as any).get).toHaveBeenCalledWith('testObject', '1');
-        });
-
-        it('createData should delegate to engine.create', async () => {
-            const newData = { name: 'New' };
-            const createdRecord = { id: '2', ...newData };
-            (mockEngine as any).create.mockResolvedValue(createdRecord);
-
-            const result = await protocol.createData({ object: 'testObject', data: newData });
-            expect(result).toBe(createdRecord);
-            expect((mockEngine as any).create).toHaveBeenCalledWith('testObject', newData);
-        });
-
-        it('updateData should delegate to engine.update', async () => {
-            const updateData = { name: 'Updated' };
-            const updatedRecord = { id: '1', ...updateData };
-            (mockEngine as any).update.mockResolvedValue(updatedRecord);
-
-            const result = await protocol.updateData({ object: 'testObject', id: '1', data: updateData });
-            expect(result).toBe(updatedRecord);
-            expect((mockEngine as any).update).toHaveBeenCalledWith('testObject', '1', updateData);
-        });
-
-        it('deleteData should delegate to engine.delete', async () => {
-            (mockEngine as any).delete.mockResolvedValue(true);
-
-            const result = await protocol.deleteData({ object: 'testObject', id: '1' });
-            expect(result).toEqual({ object: 'testObject', id: '1', success: true });
-            expect((mockEngine as any).delete).toHaveBeenCalledWith('testObject', '1');
-        });
-    });
-
-    describe('Legacy Mode (IObjectQL Context)', () => {
-        let mockRepo: any;
-        
-        beforeEach(() => {
-            // Remove direct methods to force legacy path
-            delete (mockEngine as any).find;
-            delete (mockEngine as any).get;
-            delete (mockEngine as any).create;
-            delete (mockEngine as any).update;
-            delete (mockEngine as any).delete;
-
-            mockRepo = {
-                find: jest.fn(),
-                findOne: jest.fn(),
-                create: jest.fn(),
-                update: jest.fn(),
-                delete: jest.fn(),
-            };
-
-            (mockEngine as any).createContext = jest.fn().mockReturnValue({
-                object: jest.fn().mockReturnValue(mockRepo)
-            });
-        });
-
-        it('findData should use repo.find in legacy mode', async () => {
-            const mockData = [{ id: '1' }];
-            mockRepo.find.mockResolvedValue(mockData);
-
-            await protocol.findData({ object: 'testObject' });
-            expect(mockRepo.find).toHaveBeenCalled();
-        });
-
-        it('deleteData should use repo.delete in legacy mode', async () => {
-            mockRepo.delete.mockResolvedValue(true);
-            const result = await protocol.deleteData({ object: 'testObject', id: '1' });
-            expect(result.success).toBe(true);
-            expect(mockRepo.delete).toHaveBeenCalledWith('1');
-        });
-    });
-});