@objectql/core 1.1.0 → 1.3.0

package/src/repository.ts

@@ -1,7 +1,4 @@
-import { ObjectQLContext, IObjectQL, HookContext, HookFunction } from './types';
-import { ObjectConfig, FieldConfig } from './metadata';
-import { Driver } from './driver';
-import { UnifiedQuery, FilterCriterion } from './query';
+import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, HookContext, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext } from '@objectql/types';
 
 export class ObjectRepository {
     constructor(
@@ -31,97 +28,52 @@ export class ObjectRepository {
         return obj;
     }
 
-    // === Hook Execution Logic ===
-    private async executeHook(
-        hookName: keyof import('./metadata').ObjectListeners, 
-        op: HookContext['op'], 
-        dataOrQuery: any
-    ) {
-        if (this.context.ignoreTriggers) return;
-        
-        const obj = this.getSchema();
-        if (!obj.listeners || !obj.listeners[hookName]) return;
-
-        const hookFn = obj.listeners[hookName] as HookFunction;
-
-        // Construct HookContext
-        const hookContext: HookContext = {
-            ctx: this.context,
-            entity: this.objectName,
-            op: op,
-            utils: {
-                restrict: (criterion: FilterCriterion) => {
-                    if (op !== 'find' && op !== 'count') {
-                        throw new Error('utils.restrict is only available in query operations');
-                    }
-                    const query = dataOrQuery as UnifiedQuery;
-                    if (!query.filters) {
-                        query.filters = [criterion];
-                    } else {
-                        // Enclose existing filters in implicit AND group by array structure logic or explicit 'and'
-                        // Implementation depends on how driver parses.
-                        // Safe approach: filters = [ [criterion], 'and', [existing] ] or similar.
-                        // For simplicity assuming array of terms means AND:
-                        query.filters.push(criterion);
-                    }
-                }
-            },
-            getPreviousDoc: async () => {
-                 // For update/delete, we might need the ID to find the doc.
-                 // If doc has ID, use it.
-                 // This is simplistic; usually 'update' takes 'id', we need to capture it from arguments.
-                 if (op === 'create') return undefined;
-                 if (dataOrQuery._id || dataOrQuery.id) {
-                     return this.findOne(dataOrQuery._id || dataOrQuery.id);
-                 }
-                 return undefined;
-            }
+    private getHookAPI(): HookAPI {
+        return {
+            find: (obj, q) => this.context.object(obj).find(q),
+            findOne: (obj, id) => this.context.object(obj).findOne(id),
+            count: (obj, q) => this.context.object(obj).count(q),
+            create: (obj, data) => this.context.object(obj).create(data),
+            update: (obj, id, data) => this.context.object(obj).update(id, data),
+            delete: (obj, id) => this.context.object(obj).delete(id)
         };
-
-        if (op === 'find' || op === 'count' || op === 'aggregate') {
-            hookContext.query = dataOrQuery;
-        } else {
-            hookContext.doc = dataOrQuery;
-        }
-        
-        // Pass ID manually if needed or attach to doc? 
-        // For strictness, getPreviousDoc needs the ID passed to the operation.
-        // We'll rely on "doc" having the data being processed.
-        
-        await hookFn(hookContext);
     }
 
     async find(query: UnifiedQuery = {}): Promise<any[]> {
-        // Hooks: beforeFind
-        await this.executeHook('beforeFind', 'find', query);
+        const hookCtx: RetrievalHookContext = {
+            ...this.context,
+            objectName: this.objectName,
+            operation: 'find',
+            api: this.getHookAPI(),
+            state: {},
+            query
+        };
+        await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
 
-        // TODO: Apply basic filters like spaceId (could be done via a default generic hook too)
-        const results = await this.getDriver().find(this.objectName, query, this.getOptions());
+        // TODO: Apply basic filters like spaceId
+        const results = await this.getDriver().find(this.objectName, hookCtx.query || {}, this.getOptions());
         
-        // Hooks: afterFind
-        // Not implemented in spec fully iterate results? usually for single doc or metadata
-        // For performance, afterFind on list is rare or costly. 
-        if (this.getSchema().listeners?.afterFind && !this.context.ignoreTriggers) {
-             const hookFn = this.getSchema().listeners!.afterFind!;
-             // Executing per result or once? Spec says "HookContext" has "doc". 
-             // If finding list, might not match signature.
-             // Implemented per-item for now (caution: performance).
-             /*
-             for (const item of results) {
-                 await this.executeHookForDoc('afterFind', 'find', item);
-             }
-             */
-        }
-        return results;
+        hookCtx.result = results;
+        await this.app.triggerHook('afterFind', this.objectName, hookCtx);
+
+        return hookCtx.result as any[];
     }
 
     async findOne(idOrQuery: string | number | UnifiedQuery): Promise<any> {
         if (typeof idOrQuery === 'string' || typeof idOrQuery === 'number') {
-            // Convert ID lookup to standard query to reuse 'find' hooks?
-            // Or treat as specific op. 
-            // Let's rely on simple driver call but maybe wrap in object for hook consistency if needed.
-            // For now, simple implementation:
-            return this.getDriver().findOne(this.objectName, idOrQuery, undefined, this.getOptions());
+            const hookCtx: RetrievalHookContext = {
+                ...this.context,
+                objectName: this.objectName,
+                operation: 'find',
+                api: this.getHookAPI(),                state: {},                query: { _id: idOrQuery }
+            };
+            await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
+            
+            const result = await this.getDriver().findOne(this.objectName, idOrQuery, hookCtx.query, this.getOptions());
+
+            hookCtx.result = result;
+            await this.app.triggerHook('afterFind', this.objectName, hookCtx);
+            return hookCtx.result;
         } else {
             const results = await this.find(idOrQuery);
             return results[0] || null;
@@ -129,60 +81,95 @@ export class ObjectRepository {
     }
 
     async count(filters: any): Promise<number> {
-        // Can wrap filters in a query object for hook
-        const query: UnifiedQuery = { filters };
-        await this.executeHook('beforeFind', 'count', query); // Reusing beforeFind logic often?
-        return this.getDriver().count(this.objectName, query.filters, this.getOptions());
-    }
+        const hookCtx: RetrievalHookContext = {
+            ...this.context,
+            objectName: this.objectName,
+            operation: 'count',
+            api: this.getHookAPI(),
+            state: {},
+            query: filters
+        };
+        await this.app.triggerHook('beforeCount', this.objectName, hookCtx);
 
-    async create(doc: any): Promise<any> {
-        const obj = this.getSchema();
-        if (this.context.userId) doc.created_by = this.context.userId;
-        if (this.context.spaceId) doc.space_id = this.context.spaceId;
+        const result = await this.getDriver().count(this.objectName, hookCtx.query, this.getOptions());
 
-        await this.executeHook('beforeCreate', 'create', doc);
+        hookCtx.result = result;
+        await this.app.triggerHook('afterCount', this.objectName, hookCtx);
+        return hookCtx.result as number;
+    }
 
-        const result = await this.getDriver().create(this.objectName, doc, this.getOptions());
+    async create(doc: any): Promise<any> {
+        const hookCtx: MutationHookContext = {
+            ...this.context,
+            objectName: this.objectName,
+            operation: 'create',
+            state: {},
+            api: this.getHookAPI(),
+            data: doc
+        };
+        await this.app.triggerHook('beforeCreate', this.objectName, hookCtx);
+        const finalDoc = hookCtx.data || doc;
 
-        await this.executeHook('afterCreate', 'create', result);
-        return result;
+        const obj = this.getSchema();
+        if (this.context.userId) finalDoc.created_by = this.context.userId;
+        if (this.context.spaceId) finalDoc.space_id = this.context.spaceId;
+        
+        const result = await this.getDriver().create(this.objectName, finalDoc, this.getOptions());
+        
+        hookCtx.result = result;
+        await this.app.triggerHook('afterCreate', this.objectName, hookCtx);
+        return hookCtx.result;
     }
 
     async update(id: string | number, doc: any, options?: any): Promise<any> {
-        // Attach ID to doc for hook context to know which record
-        const docWithId = { ...doc, _id: id, id: id };
-        
-        await this.executeHook('beforeUpdate', 'update', docWithId);
-        
-        // Remove ID before sending to driver if driver doesn't like it in $set
-        const { _id, id: _id2, ...cleanDoc } = docWithId;
+        const hookCtx: UpdateHookContext = {
+            ...this.context,
+            objectName: this.objectName,
+            operation: 'update',
+            state: {},
+            api: this.getHookAPI(),
+            id,
+            data: doc,
+            isModified: (field) => hookCtx.data ? Object.prototype.hasOwnProperty.call(hookCtx.data, field) : false
+        };
+        await this.app.triggerHook('beforeUpdate', this.objectName, hookCtx);
 
-        const result = await this.getDriver().update(this.objectName, id, cleanDoc, this.getOptions(options));
+        const result = await this.getDriver().update(this.objectName, id, hookCtx.data, this.getOptions(options));
 
-        // Result might be count or doc depending on driver.
-        // If we want the updated doc for afterUpdate, we might need to fetch it if driver defaults to count.
-        // Assuming result is the doc or we just pass the patch.
-        await this.executeHook('afterUpdate', 'update', docWithId); 
-        return result;
+        hookCtx.result = result;
+        await this.app.triggerHook('afterUpdate', this.objectName, hookCtx);
+        return hookCtx.result;
     }
 
     async delete(id: string | number): Promise<any> {
-        const docWithId = { _id: id, id: id };
-        await this.executeHook('beforeDelete', 'delete', docWithId);
+        const hookCtx: MutationHookContext = {
+            ...this.context,
+            objectName: this.objectName,
+            operation: 'delete',
+            state: {},
+            api: this.getHookAPI(),
+            id
+        };
+        await this.app.triggerHook('beforeDelete', this.objectName, hookCtx);
 
         const result = await this.getDriver().delete(this.objectName, id, this.getOptions());
 
-        await this.executeHook('afterDelete', 'delete', docWithId);
-        return result;
-    }    async aggregate(query: any): Promise<any> {
+        hookCtx.result = result;
+        await this.app.triggerHook('afterDelete', this.objectName, hookCtx);
+        return hookCtx.result;
+    }
+
+    async aggregate(query: any): Promise<any> {
         const driver = this.getDriver();
         if (!driver.aggregate) throw new Error("Driver does not support aggregate");
+        
         return driver.aggregate(this.objectName, query, this.getOptions());
     }
 
     async distinct(field: string, filters?: any): Promise<any[]> {
         const driver = this.getDriver();
         if (!driver.distinct) throw new Error("Driver does not support distinct");
+        
         return driver.distinct(this.objectName, field, filters, this.getOptions());
     }
 
@@ -193,8 +180,8 @@ export class ObjectRepository {
     }
 
     async createMany(data: any[]): Promise<any> {
-        // TODO: Triggers per record?
         const driver = this.getDriver();
+        
         if (!driver.createMany) {
             // Fallback
             const results = [];
@@ -218,15 +205,24 @@ export class ObjectRepository {
         return driver.deleteMany(this.objectName, filters, this.getOptions());
     }
 
-    async call(actionName: string, params: any): Promise<any> {
-        const obj = this.getSchema();
-        const action = obj.actions?.[actionName];
-        if (!action) {
-            throw new Error(`Action '${actionName}' not found on object '${this.objectName}'`);
-        }
-        if (action.handler) {
-            return action.handler(this.context, params);
-        }
-        throw new Error(`Action '${actionName}' has no handler`);
+    async execute(actionName: string, id: string | number | undefined, params: any): Promise<any> {
+        const api: HookAPI = {
+            find: (obj, q) => this.context.object(obj).find(q),
+            findOne: (obj, id) => this.context.object(obj).findOne(id),
+            count: (obj, q) => this.context.object(obj).count(q),
+            create: (obj, data) => this.context.object(obj).create(data),
+            update: (obj, id, data) => this.context.object(obj).update(id, data),
+            delete: (obj, id) => this.context.object(obj).delete(id)
+        };
+
+        const ctx: ActionContext = {
+            ...this.context,
+            objectName: this.objectName,
+            actionName,
+            id,
+            input: params,
+            api
+        };
+        return await this.app.executeAction(this.objectName, actionName, ctx);
     }
 }

package/test/action.test.ts

@@ -0,0 +1,58 @@
+import { ObjectQL } from '../src';
+import { MockDriver } from './utils';
+
+describe('ObjectQL Actions', () => {
+    let app: ObjectQL;
+    let driver: MockDriver;
+
+    beforeEach(async () => {
+        driver = new MockDriver();
+        app = new ObjectQL({
+            datasources: {
+                default: driver
+            },
+            objects: {
+                'invoice': {
+                    name: 'invoice',
+                    fields: {
+                        amount: { type: 'number' },
+                        status: { type: 'text' }
+                    },
+                    actions: {
+                        'pay': {
+                            label: 'Pay Invoice',
+                            params: {
+                                method: { type: 'text' }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        await app.init();
+    });
+
+    it('should register and execute an action', async () => {
+        const repo = app.createContext({}).object('invoice');
+        
+        let actionCalled = false;
+        app.registerAction('invoice', 'pay', async (ctx) => {
+            actionCalled = true;
+            expect(ctx.objectName).toBe('invoice');
+            expect(ctx.actionName).toBe('pay');
+            expect(ctx.id).toBe('inv-123');
+            expect(ctx.input.method).toBe('credit_card');
+            return { success: true, paid: true };
+        });
+
+        const result = await repo.execute('pay', 'inv-123', { method: 'credit_card' });
+        
+        expect(actionCalled).toBe(true);
+        expect(result.success).toBe(true);
+    });
+
+    it('should throw error if action not registered', async () => {
+        const repo = app.createContext({}).object('invoice');
+        await expect(repo.execute('refund', '1', {})).rejects.toThrow("Action 'refund' not found for object 'invoice'");
+    });
+});

package/test/fixtures/project.action.js

@@ -0,0 +1,8 @@
+module.exports = {
+    listenTo: 'project',
+    closeProject: {
+        handler: async function(ctx) {
+            return { success: true };
+        }
+    }
+};

package/test/hook.test.ts

@@ -0,0 +1,60 @@
+import { ObjectQL } from '../src';
+import { MockDriver } from './utils';
+
+describe('ObjectQL Hooks', () => {
+    let app: ObjectQL;
+    let driver: MockDriver;
+
+    beforeEach(async () => {
+        driver = new MockDriver();
+        app = new ObjectQL({
+            datasources: {
+                default: driver
+            },
+            objects: {
+                'post': {
+                    name: 'post',
+                    fields: {
+                        title: { type: 'text' },
+                        status: { type: 'text' }
+                    }
+                }
+            }
+        });
+        await app.init();
+    });
+
+    it('should trigger beforeFind and modify query', async () => {
+        const repo = app.createContext({}).object('post');
+        
+        let hookTriggered = false;
+        app.on('beforeFind', 'post', async (ctx) => {
+            hookTriggered = true;
+            (ctx as any).query = { ...(ctx as any).query, filters: [['status', '=', 'published']] };
+        });
+
+        // Mock driver find to check query
+        const spyFind = jest.spyOn(driver, 'find');
+
+        await repo.find({});
+        
+        expect(hookTriggered).toBe(true);
+        expect(spyFind).toHaveBeenCalledWith('post', { filters: [['status', '=', 'published']] }, expect.any(Object));
+    });
+
+    it('should trigger afterCreate and return result', async () => {
+        const repo = app.createContext({ userId: 'u1' }).object('post');
+        
+        app.on('afterCreate', 'post', async (ctx) => {
+            if (ctx.result) {
+                ctx.result.augmented = true;
+            }
+        });
+
+        const created = await repo.create({ title: 'New Post' });
+        
+        expect(created.id).toBeDefined();
+        expect(created.created_by).toBe('u1');
+        expect(created.augmented).toBe(true);
+    });
+});

package/test/loader.test.ts

@@ -11,12 +11,5 @@ describe('Loader', () => {
         expect(configs['project'].fields).toBeDefined();
         expect(configs['project'].fields.name).toBeDefined();
     });
-
-    it('should load actions from .action.ts files', () => {
-        const fixturesDir = path.join(__dirname, 'fixtures');
-        const configs = loadObjectConfigs(fixturesDir);
-        expect(configs['project'].actions).toBeDefined();
-        expect(configs['project'].actions!.closeProject).toBeDefined();
-        expect(typeof configs['project'].actions!.closeProject.handler).toBe('function');
-    });
 });
+

package/test/metadata.test.ts

@@ -1,5 +1,5 @@
 import { ObjectQL } from '../src/index';
-import { ObjectConfig } from '../src/metadata';
+import { ObjectConfig } from '@objectql/types';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'js-yaml';

package/test/mock-driver.ts

@@ -1,4 +1,4 @@
-import { Driver } from '../src/driver';
+import { Driver } from '@objectql/types';
 
 export class MockDriver implements Driver {
     private data: Record<string, any[]> = {};

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();
+    });
+});