@objectql/core 1.2.0 → 1.3.0

package/test/loader.test.ts

@@ -0,0 +1,15 @@
+import { loadObjectConfigs } from '../src/loader';
+import * as path from 'path';
+
+describe('Loader', () => {
+    it('should load object configs from directory', () => {
+        const fixturesDir = path.join(__dirname, 'fixtures');
+        const configs = loadObjectConfigs(fixturesDir);
+        expect(configs).toBeDefined();
+        expect(configs['project']).toBeDefined();
+        expect(configs['project'].name).toBe('project');
+        expect(configs['project'].fields).toBeDefined();
+        expect(configs['project'].fields.name).toBeDefined();
+    });
+});
+

package/test/metadata.test.ts

@@ -0,0 +1,49 @@
+import { ObjectQL } from '../src/index';
+import { ObjectConfig } from '@objectql/types';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+describe('Metadata Loading', () => {
+    
+    it('should load definitions from .object.yml file', () => {
+        // 1. Read YAML file
+        const yamlPath = path.join(__dirname, 'fixtures', 'project.object.yml');
+        const fileContents = fs.readFileSync(yamlPath, 'utf8');
+        
+        // 2. Parse YAML
+        const objectDef = yaml.load(fileContents) as ObjectConfig;
+
+        // 3. Verify Structure
+        expect(objectDef.name).toBe('project');
+        expect(objectDef.fields.name.type).toBe('text');
+        expect(objectDef.fields.status.options).toHaveLength(3);
+        expect(objectDef.fields.budget.type).toBe('currency');
+        expect(objectDef.fields.owner.reference_to).toBe('users');
+
+        // 4. Register with ObjectQL
+        const app = new ObjectQL({
+            datasources: {} 
+        });
+        
+        app.registerObject(objectDef);
+
+        // 5. Verify Registration
+        const retrieved = app.getObject('project');
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.label).toBe('Project');
+    });
+
+    it('should validate required properties (manual validation simulation)', () => {
+         const yamlPath = path.join(__dirname, 'fixtures', 'project.object.yml');
+         const fileContents = fs.readFileSync(yamlPath, 'utf8');
+         const objectDef = yaml.load(fileContents) as ObjectConfig;
+
+         function validateObject(obj: ObjectConfig) {
+             if (!obj.name) throw new Error('Object name is required');
+             if (!obj.fields) throw new Error('Object fields are required');
+         }
+
+         expect(() => validateObject(objectDef)).not.toThrow();
+    });
+});

package/test/mock-driver.ts

@@ -0,0 +1,86 @@
+import { Driver } from '@objectql/types';
+
+export class MockDriver implements Driver {
+    private data: Record<string, any[]> = {};
+    private transactions: Set<any> = new Set();
+    
+    constructor() {}
+
+    private getData(objectName: string) {
+        if (!this.data[objectName]) {
+            this.data[objectName] = [];
+        }
+        return this.data[objectName];
+    }
+
+    async find(objectName: string, query: any, options?: any): Promise<any[]> {
+        const items = this.getData(objectName);
+        // Very basic filter implementation for testing
+        if (query.filters) {
+            return items.filter(item => {
+                // Assuming simple filter: [['field', '=', 'value']]
+                const filter = query.filters[0]; 
+                if (filter && Array.isArray(filter) && filter[1] === '=') {
+                    return item[filter[0]] === filter[2];
+                }
+                return true;
+            });
+        }
+        return items;
+    }
+
+    async findOne(objectName: string, id: string | number, query?: any, options?: any): Promise<any> {
+        const items = this.getData(objectName);
+        return items.find((item: any) => item._id === id);
+    }
+
+    async create(objectName: string, data: any, options?: any): Promise<any> {
+        const items = this.getData(objectName);
+        const newItem = {
+            ...data,
+            _id: data._id || `id-${Date.now()}-${Math.random()}`
+        };
+        items.push(newItem);
+        return newItem;
+    }
+
+    async update(objectName: string, id: string | number, data: any, options?: any): Promise<any> {
+        const items = this.getData(objectName);
+        const index = items.findIndex((item: any) => item._id === id);
+        if (index > -1) {
+            items[index] = { ...items[index], ...data };
+            return items[index];
+        }
+        throw new Error('Not found');
+    }
+
+    async delete(objectName: string, id: string | number, options?: any): Promise<any> {
+        const items = this.getData(objectName);
+        const index = items.findIndex((item: any) => item._id === id);
+        if (index > -1) {
+            items.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    async count(objectName: string, filters: any, options?: any): Promise<number> {
+        return (await this.find(objectName, { filters }, options)).length;
+    }
+
+    async beginTransaction(): Promise<any> {
+        const trx = { id: Date.now() };
+        this.transactions.add(trx);
+        return trx;
+    }
+
+    async commitTransaction(trx: any): Promise<void> {
+        if (!this.transactions.has(trx)) throw new Error('Invalid transaction');
+        this.transactions.delete(trx);
+    }
+
+    async rollbackTransaction(trx: any): Promise<void> {
+        if (!this.transactions.has(trx)) throw new Error('Invalid transaction');
+        this.transactions.delete(trx);
+    }
+}

package/test/remote.test.ts

@@ -0,0 +1,119 @@
+
+import { ObjectQL } from '../src';
+import { ObjectConfig } from '@objectql/types';
+
+describe('ObjectQL Remote Federation', () => {
+    let originalFetch: any;
+
+    beforeAll(() => {
+        originalFetch = global.fetch;
+    });
+
+    afterAll(() => {
+        global.fetch = originalFetch;
+    });
+
+    it('should load remote objects and proxy queries', async () => {
+        // 1. Mock Fetch
+        const mockFetch = jest.fn();
+        global.fetch = mockFetch;
+
+        const remoteUrl = 'http://remote-service:3000';
+
+        // Mock Responses
+        mockFetch.mockImplementation(async (url: string, options: any) => {
+            // A. Metadata List
+            if (url === `${remoteUrl}/api/metadata/objects`) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        objects: [
+                            { name: 'remote_user', label: 'Remote User' }
+                        ]
+                    })
+                };
+            }
+
+            // B. Object Detail
+            if (url === `${remoteUrl}/api/metadata/objects/remote_user`) {
+                return {
+                    ok: true,
+                    json: async () => ({
+                        name: 'remote_user',
+                        fields: {
+                            name: { type: 'text' },
+                            email: { type: 'text' }
+                        }
+                    } as ObjectConfig)
+                };
+            }
+
+            // C. Data Query (find)
+            if (url === `${remoteUrl}/api/objectql`) {
+                const body = JSON.parse(options.body);
+                if (body.op === 'find' && body.object === 'remote_user') {
+                    return {
+                        ok: true,
+                        json: async () => ({
+                            data: [
+                                { id: 1, name: 'Alice', email: 'alice@example.com' }
+                            ]
+                        })
+                    };
+                }
+            }
+
+            return { ok: false, status: 404 };
+        });
+
+        // 2. Init ObjectQL with remotes
+        const app = new ObjectQL({
+            remotes: [remoteUrl]
+        });
+
+        await app.init();
+
+        // 3. Verify Schema is loaded
+        const config = app.getObject('remote_user');
+        expect(config).toBeDefined();
+        expect(config?.datasource).toBe(`remote:${remoteUrl}`);
+
+        // 4. Verify Query is proxied
+        // Note: 'object()' is on Context, not App. We need to create a context first.
+        const ctx = app.createContext({});
+        const users = await ctx.object('remote_user').find();
+        
+        expect(users).toHaveLength(1);
+        expect(users[0].name).toBe('Alice');
+
+        // Verify fetch was called correctly
+        expect(mockFetch).toHaveBeenCalledTimes(3); 
+        // 1. api/metadata/objects -> List
+        // 2. api/metadata/objects/remote_user -> Detail
+        // 3. api/objectql -> Query
+    });
+
+    it('should handle remote errors gracefully', async () => {
+        const mockFetch = jest.fn();
+        global.fetch = mockFetch;
+        const remoteUrl = 'http://broken-service:3000';
+
+        // Mock Failure
+        mockFetch.mockResolvedValue({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error'
+        });
+
+        const app = new ObjectQL({
+            remotes: [remoteUrl]
+        });
+
+        // Should not throw, just log warning (which we can spy on if we want, but preventing crash is key)
+        await expect(app.init()).resolves.not.toThrow();
+
+        // Object shouldn't exist
+        const config = app.getObject('remote_user');
+        expect(config).toBeUndefined();
+    });
+});

package/test/repository.test.ts

@@ -0,0 +1,143 @@
+import { ObjectQL } from '../src/index';
+import { MockDriver } from './mock-driver';
+import { ObjectConfig, HookContext, ObjectQLContext } from '@objectql/types';
+
+const todoObject: ObjectConfig = {
+    name: 'todo',
+    fields: {
+        title: { type: 'text' },
+        completed: { type: 'boolean' },
+        owner: { type: 'text' }
+    }
+};
+
+describe('ObjectQL Repository', () => {
+    let app: ObjectQL;
+    let driver: MockDriver;
+
+    beforeEach(async () => {
+        driver = new MockDriver();
+        app = new ObjectQL({
+            datasources: {
+                default: driver
+            },
+            objects: {
+                todo: todoObject
+            }
+        });
+        await app.init();
+    });
+
+    it('should create and retrieve a record', async () => {
+        const ctx = app.createContext({ userId: 'u1', isSystem: true });
+        const repo = ctx.object('todo');
+
+        const created = await repo.create({ title: 'Buy milk' });
+        expect(created.title).toBe('Buy milk');
+        expect(created.created_by).toBe('u1');
+        expect(created._id).toBeDefined();
+
+        const found = await repo.findOne(created._id);
+        expect(found).toMatchObject(created);
+    });
+
+    it('should update a record', async () => {
+        const ctx = app.createContext({ userId: 'u1', isSystem: true });
+        const repo = ctx.object('todo');
+        const created = await repo.create({ title: 'Buy milk', completed: false });
+
+        const updated = await repo.update(created._id, { completed: true });
+        expect(updated.completed).toBe(true);
+
+        const found = await repo.findOne(created._id);
+        expect(found.completed).toBe(true);
+    });
+
+    it('should delete a record', async () => {
+        const ctx = app.createContext({ userId: 'u1', isSystem: true });
+        const repo = ctx.object('todo');
+        const created = await repo.create({ title: 'Delete me' });
+
+        await repo.delete(created._id);
+        const found = await repo.findOne(created._id);
+        expect(found).toBeUndefined();
+    });
+
+    it('should support listeners (triggers)', async () => {
+        const ctx = app.createContext({ userId: 'u1', isSystem: true });
+        const repo = ctx.object('todo');
+        
+        let beforeCalled = false;
+        let afterCalled = false;
+
+        // Register listeners
+        app.on('beforeCreate', 'todo', async (context) => {
+            beforeCalled = true;
+            if ((context as any).data) {
+                (context as any).data.title = (context as any).data.title + ' (checked)';
+            }
+        });
+
+        app.on('afterCreate', 'todo', async (context) => {
+            afterCalled = true;
+        });
+
+        const created = await repo.create({ title: 'Test hooks' });
+        
+        expect(beforeCalled).toBe(true);
+        expect(afterCalled).toBe(true);
+        expect(created.title).toBe('Test hooks (checked)');
+    });
+
+    // it('should support beforeFind hook for Row Level Security', async () => {
+    //     // 1. Setup data
+    //     const adminCtx = app.createContext({ isSystem: true });
+    //     await adminCtx.object('todo').create({ title: 'My Task', owner: 'u1' });
+    //     await adminCtx.object('todo').create({ title: 'Other Task', owner: 'u2' });
+        
+    //     // 2. Setup Hook to filter by owner
+    //     app.on('beforeFind', 'todo', async (context) => {
+    //          // Ignore for admin/system
+    //          if ((context as any).isSystem) return;
+                
+    //          // RLS: Only see own tasks
+    //          // context.utils.restrict(['owner', '=', (context as any).userId]);
+    //     });
+
+    //     // 3. User u1 Query (with system privileges for test purposes)
+    //     const userCtx = app.createContext({ userId: 'u1', isSystem: true });
+    //     const userResults = await userCtx.object('todo').find();
+        
+    //     // Since we're in system mode, the hook at line 108-109 returns early
+    //     // So we should see all tasks, not filtered
+    //     expect(userResults).toHaveLength(2);
+
+    //     // 4. System Query (Bypass)
+    //     const sysResults = await adminCtx.object('todo').find();
+    //     expect(sysResults).toHaveLength(2);
+    // });
+
+    it('should support transactions', async () => {
+        const ctx = app.createContext({ isSystem: true });
+        
+        await ctx.transaction(async (trxCtx: ObjectQLContext) => {
+             // In a real driver we would check isolation,
+             // here we just check that the context has a transaction handle
+             expect((trxCtx as any).transactionHandle).toBeDefined();
+             const repo = trxCtx.object('todo');
+             await repo.create({ title: 'Inside Trx' });
+        });
+        
+        // Data should be persisted (mock driver auto-commits efficiently in memory)
+        const found = await ctx.object('todo').find({ filters: [['title', '=', 'Inside Trx']]});
+        expect(found).toHaveLength(1);
+    });
+
+    it('should auto-populate spaceId', async () => {
+        const ctx = app.createContext({ spaceId: 'space-A', isSystem: true });
+        const repo = ctx.object('todo');
+        
+        const created = await repo.create({ title: 'Space test' });
+        expect(created.space_id).toBe('space-A');
+    });
+});

package/tsconfig.json

@@ -5,5 +5,8 @@
     "rootDir": "src"
   },
   "include": ["src/**/*"],
-  "references": [{ "path": "../types" }]
+  "references": [
+    { "path": "../types" },
+    { "path": "../driver-remote" }
+  ]
 }