@objectql/core 3.0.1 → 4.0.1

package/test/hook.test.ts

@@ -1,343 +0,0 @@
-import { ObjectQL } from '../src';
-import { MockDriver } from './mock-driver';
-
-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' },
-                        views: { type: 'number' }
-                    }
-                }
-            }
-        });
-        await app.init();
-    });
-
-    describe('Find Hooks', () => {
-        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']] };
-            });
-
-            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 afterFind and transform results', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            app.on('afterFind', 'post', async (ctx) => {
-                if (Array.isArray(ctx.result)) {
-                    ctx.result = ctx.result.map(item => ({
-                        ...item,
-                        transformed: true
-                    }));
-                }
-            });
-
-            const results = await repo.find({});
-            
-            expect(results).toBeDefined();
-            // Results should be transformed even if empty
-            expect(Array.isArray(results)).toBe(true);
-        });
-
-        it('should provide user context in beforeFind', async () => {
-            const repo = app.createContext({ userId: 'user123' }).object('post');
-            
-            let capturedUser: any;
-            app.on('beforeFind', 'post', async (ctx) => {
-                capturedUser = ctx.user;
-            });
-
-            await repo.find({});
-            
-            expect(capturedUser).toBeDefined();
-            expect(capturedUser.id).toBe('user123');
-        });
-    });
-
-    describe('Count Hooks', () => {
-        it('should trigger beforeCount and modify query', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            let hookTriggered = false;
-            app.on('beforeCount', 'post', async (ctx) => {
-                hookTriggered = true;
-                ctx.query = { filters: [['status', '=', 'published']] };
-            });
-
-            await repo.count({});
-            
-            expect(hookTriggered).toBe(true);
-        });
-
-        it('should trigger afterCount and access result', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            let capturedResult: any;
-            app.on('afterCount', 'post', async (ctx) => {
-                capturedResult = ctx.result;
-            });
-
-            const count = await repo.count({});
-            
-            expect(capturedResult).toBeDefined();
-            expect(typeof capturedResult).toBe('number');
-            expect(count).toBe(capturedResult);
-        });
-    });
-
-    describe('Create Hooks', () => {
-        it('should trigger beforeCreate and modify data', async () => {
-            const repo = app.createContext({ userId: 'u1' }).object('post');
-            
-            app.on('beforeCreate', 'post', async (ctx) => {
-                if (ctx.data) {
-                    ctx.data.status = ctx.data.status || 'draft';
-                    ctx.data.views = 0;
-                }
-            });
-
-            const created = await repo.create({ title: 'New Post' });
-            
-            expect(created.status).toBe('draft');
-            expect(created.views).toBe(0);
-        });
-
-        it('should trigger afterCreate and access result', async () => {
-            const repo = app.createContext({ userId: 'u1' }).object('post');
-            
-            let capturedResult: any;
-            app.on('afterCreate', 'post', async (ctx) => {
-                capturedResult = ctx.result;
-                if (ctx.result) {
-                    ctx.result.augmented = true;
-                }
-            });
-
-            const created = await repo.create({ title: 'New Post' });
-            
-            expect(capturedResult).toBeDefined();
-            expect(created._id).toBeDefined();
-            expect(created.created_by).toBe('u1');
-            expect(created.augmented).toBe(true);
-        });
-
-        it('should provide api access in beforeCreate', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            app.on('beforeCreate', 'post', async (ctx) => {
-                // Check for duplicate titles
-                const existing = await ctx.api.count('post', { filters: [['title', '=', ctx.data?.title]] });
-                if (existing > 0) {
-                    throw new Error('Title already exists');
-                }
-            });
-
-            await repo.create({ title: 'Unique Title' });
-            
-            // This should work fine on first create
-            expect(true).toBe(true);
-        });
-    });
-
-    describe('Update Hooks', () => {
-        it('should trigger beforeUpdate with previousData', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'Original', status: 'draft' });
-            
-            let capturedPrevious: any;
-            app.on('beforeUpdate', 'post', async (ctx) => {
-                capturedPrevious = ctx.previousData;
-            });
-
-            await repo.update(created._id, { title: 'Updated' });
-            
-            expect(capturedPrevious).toBeDefined();
-            expect(capturedPrevious.title).toBe('Original');
-            expect(capturedPrevious.status).toBe('draft');
-        });
-
-        it('should use isModified helper correctly', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'Test', status: 'draft', views: 0 });
-            
-            let titleModified = false;
-            let statusModified = false;
-            app.on('beforeUpdate', 'post', async (ctx) => {
-                if ('isModified' in ctx) {
-                    titleModified = ctx.isModified('title' as any);
-                    statusModified = ctx.isModified('status' as any);
-                }
-            });
-
-            await repo.update(created._id, { title: 'New Title' });
-            
-            expect(titleModified).toBe(true);
-            expect(statusModified).toBe(false);
-        });
-
-        it('should trigger afterUpdate with result', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'Test', status: 'draft' });
-            
-            let capturedResult: any;
-            app.on('afterUpdate', 'post', async (ctx) => {
-                capturedResult = ctx.result;
-            });
-
-            await repo.update(created._id, { status: 'published' });
-            
-            expect(capturedResult).toBeDefined();
-            expect(capturedResult.status).toBe('published');
-        });
-
-        it('should validate state transitions in beforeUpdate', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'Test', status: 'published' });
-            
-            app.on('beforeUpdate', 'post', async (ctx) => {
-                if ('isModified' in ctx && ctx.isModified('status' as any)) {
-                    if (ctx.previousData?.status === 'published' && ctx.data?.status === 'draft') {
-                        throw new Error('Cannot revert published post to draft');
-                    }
-                }
-            });
-
-            await expect(repo.update(created._id, { status: 'draft' }))
-                .rejects
-                .toThrow('Cannot revert published post to draft');
-        });
-    });
-
-    describe('Delete Hooks', () => {
-        it('should trigger beforeDelete with id and previousData', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'To Delete', status: 'draft' });
-            
-            let capturedId: any;
-            let capturedPrevious: any;
-            app.on('beforeDelete', 'post', async (ctx) => {
-                capturedId = ctx.id;
-                capturedPrevious = ctx.previousData;
-            });
-
-            await repo.delete(created._id);
-            
-            expect(capturedId).toBe(created._id);
-            expect(capturedPrevious).toBeDefined();
-            expect(capturedPrevious.title).toBe('To Delete');
-        });
-
-        it('should trigger afterDelete with result', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'To Delete' });
-            
-            let capturedResult: any;
-            app.on('afterDelete', 'post', async (ctx) => {
-                capturedResult = ctx.result;
-            });
-
-            await repo.delete(created._id);
-            
-            expect(capturedResult).toBeDefined();
-        });
-
-        it('should check dependencies in beforeDelete', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'Protected Post', status: 'published' });
-            
-            app.on('beforeDelete', 'post', async (ctx) => {
-                if (ctx.previousData?.status === 'published') {
-                    throw new Error('Cannot delete published posts');
-                }
-            });
-
-            await expect(repo.delete(created._id))
-                .rejects
-                .toThrow('Cannot delete published posts');
-        });
-    });
-
-    describe('State Sharing', () => {
-        it('should share state between before and after hooks', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            app.on('beforeCreate', 'post', async (ctx) => {
-                ctx.state.timestamp = Date.now();
-                ctx.state.customData = 'test';
-            });
-
-            let capturedState: any;
-            app.on('afterCreate', 'post', async (ctx) => {
-                capturedState = ctx.state;
-            });
-
-            await repo.create({ title: 'Test' });
-            
-            expect(capturedState).toBeDefined();
-            expect(capturedState.timestamp).toBeDefined();
-            expect(capturedState.customData).toBe('test');
-        });
-    });
-
-    describe('Error Handling', () => {
-        it('should prevent operation when beforeCreate throws error', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            app.on('beforeCreate', 'post', async (ctx) => {
-                if (!ctx.data?.title || ctx.data.title.length < 5) {
-                    throw new Error('Title must be at least 5 characters');
-                }
-            });
-
-            await expect(repo.create({ title: 'Hi' }))
-                .rejects
-                .toThrow('Title must be at least 5 characters');
-        });
-
-        it('should prevent update when beforeUpdate throws error', async () => {
-            const repo = app.createContext({}).object('post');
-            
-            const created = await repo.create({ title: 'Test Post', status: 'draft' });
-            
-            app.on('beforeUpdate', 'post', async (ctx) => {
-                if (ctx.data?.status === 'archived') {
-                    throw new Error('Archiving is not allowed');
-                }
-            });
-
-            await expect(repo.update(created._id, { status: 'archived' }))
-                .rejects
-                .toThrow('Archiving is not allowed');
-        });
-    });
-});

package/test/object.test.ts

@@ -1,183 +0,0 @@
-import { registerObjectHelper, getConfigsHelper } from '../src/object';
-import { ObjectConfig, MetadataRegistry } from '@objectql/types';
-
-describe('Object Helper Functions', () => {
-    let metadata: MetadataRegistry;
-
-    beforeEach(() => {
-        metadata = new MetadataRegistry();
-    });
-
-    describe('registerObjectHelper', () => {
-        it('should register object with normalized fields', () => {
-            const object: ObjectConfig = {
-                name: 'todo',
-                fields: {
-                    title: { type: 'text' },
-                    completed: { type: 'boolean' }
-                }
-            };
-
-            registerObjectHelper(metadata, object);
-
-            const registered = metadata.get<ObjectConfig>('object', 'todo');
-            expect(registered).toBeDefined();
-            expect(registered?.name).toBe('todo');
-        });
-
-        it('should add name property to fields', () => {
-            const object: ObjectConfig = {
-                name: 'todo',
-                fields: {
-                    title: { type: 'text' },
-                    status: { type: 'select', options: ['active', 'done'] }
-                }
-            };
-
-            registerObjectHelper(metadata, object);
-
-            const registered = metadata.get<ObjectConfig>('object', 'todo');
-            expect(registered?.fields?.title.name).toBe('title');
-            expect(registered?.fields?.status.name).toBe('status');
-        });
-
-        it('should not override existing name property', () => {
-            const object: ObjectConfig = {
-                name: 'todo',
-                fields: {
-                    title: { type: 'text', name: 'customTitle' }
-                }
-            };
-
-            registerObjectHelper(metadata, object);
-
-            const registered = metadata.get<ObjectConfig>('object', 'todo');
-            expect(registered?.fields?.title.name).toBe('customTitle');
-        });
-
-        it('should handle object without fields', () => {
-            const object: ObjectConfig = {
-                name: 'empty'
-            };
-
-            registerObjectHelper(metadata, object);
-
-            const registered = metadata.get<ObjectConfig>('object', 'empty');
-            expect(registered).toBeDefined();
-            expect(registered?.name).toBe('empty');
-        });
-
-        it('should register object with complex field configurations', () => {
-            const object: ObjectConfig = {
-                name: 'project',
-                fields: {
-                    name: { 
-                        type: 'text', 
-                        required: true, 
-                        unique: true,
-                        max_length: 100 
-                    },
-                    owner: { 
-                        type: 'lookup', 
-                        reference_to: 'users' 
-                    },
-                    tags: { 
-                        type: 'select', 
-                        multiple: true, 
-                        options: ['urgent', 'important'] 
-                    }
-                }
-            };
-
-            registerObjectHelper(metadata, object);
-
-            const registered = metadata.get<ObjectConfig>('object', 'project');
-            expect(registered?.fields?.name.required).toBe(true);
-            expect(registered?.fields?.name.unique).toBe(true);
-            expect(registered?.fields?.owner.reference_to).toBe('users');
-            expect(registered?.fields?.tags.multiple).toBe(true);
-        });
-    });
-
-    describe('getConfigsHelper', () => {
-        it('should return empty object when no objects registered', () => {
-            const configs = getConfigsHelper(metadata);
-            expect(configs).toEqual({});
-        });
-
-        it('should return all registered objects', () => {
-            const todo: ObjectConfig = {
-                name: 'todo',
-                fields: { title: { type: 'text' } }
-            };
-            const project: ObjectConfig = {
-                name: 'project',
-                fields: { name: { type: 'text' } }
-            };
-
-            registerObjectHelper(metadata, todo);
-            registerObjectHelper(metadata, project);
-
-            const configs = getConfigsHelper(metadata);
-            expect(Object.keys(configs)).toHaveLength(2);
-            expect(configs.todo).toBeDefined();
-            expect(configs.project).toBeDefined();
-            expect(configs.todo.name).toBe('todo');
-            expect(configs.project.name).toBe('project');
-        });
-
-        it('should return configs as key-value pairs by object name', () => {
-            const objects: ObjectConfig[] = [
-                { name: 'users', fields: { name: { type: 'text' } } },
-                { name: 'tasks', fields: { title: { type: 'text' } } },
-                { name: 'projects', fields: { name: { type: 'text' } } }
-            ];
-
-            objects.forEach(obj => registerObjectHelper(metadata, obj));
-
-            const configs = getConfigsHelper(metadata);
-            expect(configs.users.name).toBe('users');
-            expect(configs.tasks.name).toBe('tasks');
-            expect(configs.projects.name).toBe('projects');
-        });
-
-        it('should reflect latest state after registration', () => {
-            let configs = getConfigsHelper(metadata);
-            expect(Object.keys(configs)).toHaveLength(0);
-
-            registerObjectHelper(metadata, {
-                name: 'todo',
-                fields: { title: { type: 'text' } }
-            });
-
-            configs = getConfigsHelper(metadata);
-            expect(Object.keys(configs)).toHaveLength(1);
-
-            registerObjectHelper(metadata, {
-                name: 'project',
-                fields: { name: { type: 'text' } }
-            });
-
-            configs = getConfigsHelper(metadata);
-            expect(Object.keys(configs)).toHaveLength(2);
-        });
-
-        it('should return configs after unregistration', () => {
-            registerObjectHelper(metadata, {
-                name: 'todo',
-                fields: { title: { type: 'text' } }
-            });
-            registerObjectHelper(metadata, {
-                name: 'project',
-                fields: { name: { type: 'text' } }
-            });
-
-            metadata.unregister('object', 'todo');
-
-            const configs = getConfigsHelper(metadata);
-            expect(Object.keys(configs)).toHaveLength(1);
-            expect(configs.todo).toBeUndefined();
-            expect(configs.project).toBeDefined();
-        });
-    });
-});