bunsane 0.1.4 → 0.2.0

package/tests/graphql/builders/ResolverBuilder.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Tests for ResolverBuilder
+ * Tests GraphQL resolver building
+ */
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { ResolverBuilder } from '../../../gql/builders/ResolverBuilder';
+
+describe('ResolverBuilder', () => {
+    let builder: ResolverBuilder;
+
+    beforeEach(() => {
+        builder = new ResolverBuilder();
+    });
+
+    describe('addResolver()', () => {
+        test('adds resolver to collection', () => {
+            const mockService = { myMethod: () => 'result' };
+            builder.addResolver({
+                name: 'myMethod',
+                propertyKey: 'myMethod',
+                type: 'Query',
+                service: mockService,
+                hasInput: false
+            });
+
+            const stats = builder.getStats();
+            expect(stats.queries).toBe(1);
+        });
+
+        test('categorizes Query resolvers', () => {
+            const mockService = { getUser: () => {} };
+            builder.addResolver({
+                name: 'getUser',
+                propertyKey: 'getUser',
+                type: 'Query',
+                service: mockService,
+                hasInput: false
+            });
+
+            const stats = builder.getStats();
+            expect(stats.queries).toBe(1);
+        });
+
+        test('categorizes Mutation resolvers', () => {
+            const mockService = { createUser: () => {} };
+            builder.addResolver({
+                name: 'createUser',
+                propertyKey: 'createUser',
+                type: 'Mutation',
+                service: mockService,
+                hasInput: true
+            });
+
+            const stats = builder.getStats();
+            expect(stats.mutations).toBe(1);
+        });
+
+        test('categorizes Subscription resolvers', () => {
+            const mockService = { userCreated: () => {} };
+            builder.addResolver({
+                name: 'userCreated',
+                propertyKey: 'userCreated',
+                type: 'Subscription',
+                service: mockService,
+                hasInput: false
+            });
+
+            const stats = builder.getStats();
+            expect(stats.subscriptions).toBe(1);
+        });
+    });
+
+    describe('getResolvers()', () => {
+        test('returns empty object when no resolvers', () => {
+            const resolvers = builder.getResolvers();
+            expect(resolvers.Query).toEqual({});
+            expect(resolvers.Mutation).toEqual({});
+        });
+
+        test('returns Query resolvers', () => {
+            const mockService = { getUser: () => 'user' };
+            builder.addResolver({
+                name: 'getUser',
+                propertyKey: 'getUser',
+                type: 'Query',
+                service: mockService,
+                hasInput: false
+            });
+
+            const resolvers = builder.getResolvers();
+            expect(resolvers.Query!.getUser).toBeDefined();
+        });
+
+        test('returns Mutation resolvers', () => {
+            const mockService = { createUser: () => 'user' };
+            builder.addResolver({
+                name: 'createUser',
+                propertyKey: 'createUser',
+                type: 'Mutation',
+                service: mockService,
+                hasInput: true
+            });
+
+            const resolvers = builder.getResolvers();
+            expect(resolvers.Mutation!.createUser).toBeDefined();
+        });
+    });
+
+    describe('getResolversForType()', () => {
+        test('returns resolvers for specific type', () => {
+            const mockService = { getUser: () => {}, getUsers: () => {} };
+            builder.addResolver({
+                name: 'getUser',
+                propertyKey: 'getUser',
+                type: 'Query',
+                service: mockService,
+                hasInput: false
+            });
+            builder.addResolver({
+                name: 'getUsers',
+                propertyKey: 'getUsers',
+                type: 'Query',
+                service: mockService,
+                hasInput: false
+            });
+
+            const queryResolvers = builder.getResolversForType('Query');
+            expect(Object.keys(queryResolvers).length).toBe(2);
+        });
+
+        test('returns empty object for type with no resolvers', () => {
+            const resolvers = builder.getResolversForType('Subscription');
+            expect(resolvers).toEqual({});
+        });
+    });
+
+    describe('createResolverWithoutInput()', () => {
+        test('creates resolver function', () => {
+            const mockService = {
+                getUser: async () => ({ id: '1', name: 'Test' })
+            };
+
+            const resolver = (builder as any).createResolverWithoutInput(mockService, 'getUser');
+            expect(typeof resolver).toBe('function');
+        });
+
+        test('resolver calls service method', async () => {
+            let called = false;
+            const mockService = {
+                getUser: async () => {
+                    called = true;
+                    return { id: '1' };
+                }
+            };
+
+            const resolver = (builder as any).createResolverWithoutInput(mockService, 'getUser');
+            await resolver({}, {}, {}, {} as any);
+            expect(called).toBe(true);
+        });
+    });
+
+    describe('createResolverWithInput()', () => {
+        test('creates resolver function with input handling', () => {
+            const mockService = {
+                createUser: async (input: any) => ({ id: '1', ...input })
+            };
+
+            const resolver = (builder as any).createResolverWithInput(mockService, 'createUser');
+            expect(typeof resolver).toBe('function');
+        });
+
+        test('resolver passes input to service', async () => {
+            let receivedInput: any = null;
+            const mockService = {
+                createUser: async (input: any) => {
+                    receivedInput = input;
+                    return { id: '1', ...input };
+                }
+            };
+
+            const resolver = (builder as any).createResolverWithInput(mockService, 'createUser');
+            await resolver({}, { input: { name: 'Test' } }, {}, {} as any);
+            expect(receivedInput).toEqual({ name: 'Test' });
+        });
+    });
+
+    describe('clear()', () => {
+        test('clears all resolvers', () => {
+            const mockService = { getUser: () => {} };
+            builder.addResolver({
+                name: 'getUser',
+                propertyKey: 'getUser',
+                type: 'Query',
+                service: mockService,
+                hasInput: false
+            });
+
+            builder.clear();
+
+            const stats = builder.getStats();
+            expect(stats.queries).toBe(0);
+            expect(stats.mutations).toBe(0);
+            expect(stats.subscriptions).toBe(0);
+        });
+    });
+
+    describe('getStats()', () => {
+        test('returns accurate statistics', () => {
+            const mockService = { m1: () => {}, m2: () => {}, m3: () => {} };
+
+            builder.addResolver({ name: 'q1', propertyKey: 'q1', type: 'Query', service: mockService, hasInput: false });
+            builder.addResolver({ name: 'q2', propertyKey: 'q2', type: 'Query', service: mockService, hasInput: false });
+            builder.addResolver({ name: 'm1', propertyKey: 'm1', type: 'Mutation', service: mockService, hasInput: true });
+            builder.addResolver({ name: 's1', propertyKey: 's1', type: 'Subscription', service: mockService, hasInput: false });
+
+            const stats = builder.getStats();
+
+            expect(stats.queries).toBe(2);
+            expect(stats.mutations).toBe(1);
+            expect(stats.subscriptions).toBe(1);
+        });
+    });
+});

package/tests/graphql/builders/TypeDefBuilder.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for TypeDefBuilder
+ * Tests GraphQL type definition building
+ */
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { TypeDefBuilder } from '../../../gql/builders/TypeDefBuilder';
+
+describe('TypeDefBuilder', () => {
+    let builder: TypeDefBuilder;
+
+    beforeEach(() => {
+        builder = new TypeDefBuilder();
+    });
+
+    describe('addQueryField()', () => {
+        test('adds query field', () => {
+            builder.addQueryField({ name: 'getUser', fieldDef: 'getUser(id: ID!): User' });
+            const stats = builder.getStats();
+            expect(stats.queries).toBe(1);
+        });
+
+        test('adds multiple query fields', () => {
+            builder.addQueryField({ name: 'getUser', fieldDef: 'getUser(id: ID!): User' });
+            builder.addQueryField({ name: 'getUsers', fieldDef: 'getUsers: [User!]!' });
+            const stats = builder.getStats();
+            expect(stats.queries).toBe(2);
+        });
+    });
+
+    describe('addMutationField()', () => {
+        test('adds mutation field', () => {
+            builder.addMutationField({ name: 'createUser', fieldDef: 'createUser(input: CreateUserInput!): User!' });
+            const stats = builder.getStats();
+            expect(stats.mutations).toBe(1);
+        });
+    });
+
+    describe('addSubscriptionField()', () => {
+        test('adds subscription field', () => {
+            builder.addSubscriptionField({ name: 'userCreated', fieldDef: 'userCreated: User!' });
+            const stats = builder.getStats();
+            expect(stats.subscriptions).toBe(1);
+        });
+    });
+
+    describe('buildQueryType()', () => {
+        test('returns empty string when no queries', () => {
+            const result = builder.buildQueryType();
+            expect(result).toBe('');
+        });
+
+        test('builds Query type with fields', () => {
+            builder.addQueryField({ name: 'getUser', fieldDef: 'getUser(id: ID!): User' });
+            const result = builder.buildQueryType();
+
+            expect(result).toContain('type Query');
+            expect(result).toContain('getUser(id: ID!): User');
+        });
+
+        test('sorts fields alphabetically', () => {
+            builder.addQueryField({ name: 'zebra', fieldDef: 'zebra: String' });
+            builder.addQueryField({ name: 'alpha', fieldDef: 'alpha: String' });
+            const result = builder.buildQueryType();
+
+            const alphaIndex = result.indexOf('alpha');
+            const zebraIndex = result.indexOf('zebra');
+            expect(alphaIndex).toBeLessThan(zebraIndex);
+        });
+    });
+
+    describe('buildMutationType()', () => {
+        test('returns empty string when no mutations', () => {
+            const result = builder.buildMutationType();
+            expect(result).toBe('');
+        });
+
+        test('builds Mutation type with fields', () => {
+            builder.addMutationField({ name: 'createUser', fieldDef: 'createUser(input: CreateUserInput!): User!' });
+            const result = builder.buildMutationType();
+
+            expect(result).toContain('type Mutation');
+            expect(result).toContain('createUser');
+        });
+    });
+
+    describe('buildSubscriptionType()', () => {
+        test('returns empty string when no subscriptions', () => {
+            const result = builder.buildSubscriptionType();
+            expect(result).toBe('');
+        });
+
+        test('builds Subscription type with fields', () => {
+            builder.addSubscriptionField({ name: 'userCreated', fieldDef: 'userCreated: User!' });
+            const result = builder.buildSubscriptionType();
+
+            expect(result).toContain('type Subscription');
+            expect(result).toContain('userCreated');
+        });
+    });
+
+    describe('buildAllOperationTypes()', () => {
+        test('builds all operation types', () => {
+            builder.addQueryField({ name: 'getUser', fieldDef: 'getUser(id: ID!): User' });
+            builder.addMutationField({ name: 'createUser', fieldDef: 'createUser(input: CreateUserInput!): User!' });
+            builder.addSubscriptionField({ name: 'userCreated', fieldDef: 'userCreated: User!' });
+
+            const result = builder.buildAllOperationTypes();
+
+            expect(result).toContain('type Query');
+            expect(result).toContain('type Mutation');
+            expect(result).toContain('type Subscription');
+        });
+
+        test('returns only defined types', () => {
+            builder.addQueryField({ name: 'getUser', fieldDef: 'getUser(id: ID!): User' });
+
+            const result = builder.buildAllOperationTypes();
+
+            expect(result).toContain('type Query');
+            expect(result).not.toContain('type Mutation');
+            expect(result).not.toContain('type Subscription');
+        });
+    });
+
+    describe('clear()', () => {
+        test('clears all fields', () => {
+            builder.addQueryField({ name: 'getUser', fieldDef: 'getUser: User' });
+            builder.addMutationField({ name: 'createUser', fieldDef: 'createUser: User' });
+            builder.addSubscriptionField({ name: 'userCreated', fieldDef: 'userCreated: User' });
+
+            builder.clear();
+
+            const stats = builder.getStats();
+            expect(stats.queries).toBe(0);
+            expect(stats.mutations).toBe(0);
+            expect(stats.subscriptions).toBe(0);
+        });
+    });
+
+    describe('getStats()', () => {
+        test('returns correct counts', () => {
+            builder.addQueryField({ name: 'q1', fieldDef: 'q1: String' });
+            builder.addQueryField({ name: 'q2', fieldDef: 'q2: String' });
+            builder.addMutationField({ name: 'm1', fieldDef: 'm1: String' });
+
+            const stats = builder.getStats();
+
+            expect(stats.queries).toBe(2);
+            expect(stats.mutations).toBe(1);
+            expect(stats.subscriptions).toBe(0);
+        });
+    });
+});

package/tests/integration/archetype/ArcheType.persistence.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Integration tests for ArcheType persistence
+ * Tests archetype creation and loading with the database
+ */
+import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
+import { Entity } from '../../../core/Entity';
+import { Query, FilterOp } from '../../../query/Query';
+import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
+import { TestUserArchetype, TestUserWithOrdersArchetype } from '../../fixtures/archetypes/TestUserArchetype';
+import { createTestContext, ensureComponentsRegistered } from '../../utils';
+
+describe('ArcheType Persistence', () => {
+    const ctx = createTestContext();
+
+    beforeAll(async () => {
+        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
+    });
+
+    describe('createAndSaveEntity()', () => {
+        test('creates and persists entity with archetype components', async () => {
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'ArchetypeSave', email: 'archsave@example.com', age: 30 } });
+            const entity = await archetype.createAndSaveEntity();
+            ctx.tracker.track(entity);
+
+            expect(entity._persisted).toBe(true);
+
+            const loaded = await Entity.FindById(entity.id);
+            expect(loaded).not.toBeNull();
+
+            // Use async get() since component may not be in memory after FindById
+            const userData = await loaded?.get(TestUser);
+            expect(userData?.name).toBe('ArchetypeSave');
+        });
+
+        test('creates entity with multiple components', async () => {
+            const archetype = new TestUserWithOrdersArchetype();
+            archetype.fill({
+                user: { name: 'MultiArch', email: 'multiarch@example.com', age: 28 },
+                order: {
+                    orderNumber: 'ORD-ARCH-001',
+                    total: 199.99,
+                    status: 'completed',
+                    createdAt: new Date()
+                }
+            });
+            const entity = await archetype.createAndSaveEntity();
+            ctx.tracker.track(entity);
+
+            const loaded = await Entity.FindById(entity.id);
+            expect(loaded).not.toBeNull();
+
+            // Load components and verify
+            const userData = await loaded?.get(TestUser);
+            const orderData = await loaded?.get(TestOrder);
+            expect(userData).toBeDefined();
+            expect(orderData).toBeDefined();
+        });
+    });
+
+    describe('createEntity() with fill()', () => {
+        test('creates entity from archetype with data', async () => {
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'FillCreate', email: 'fillcreate@example.com', age: 25 } });
+            const entity = archetype.createEntity();
+            ctx.tracker.track(entity);
+
+            expect(entity).toBeInstanceOf(Entity);
+            expect(entity.id).toBeDefined();
+            expect((entity as any)._dirty).toBe(true);
+            expect(entity._persisted).toBe(false);
+
+            // Component should be in memory after createEntity
+            const userData = entity.getInMemory(TestUser);
+            expect(userData?.name).toBe('FillCreate');
+        });
+
+        test('entity can be saved after creation', async () => {
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'SaveAfter', email: 'saveafter@example.com', age: 30 } });
+            const entity = archetype.createEntity();
+            ctx.tracker.track(entity);
+
+            await entity.save();
+
+            expect(entity._persisted).toBe(true);
+            expect((entity as any)._dirty).toBe(false);
+        });
+    });
+
+    describe('getEntityWithID()', () => {
+        test('loads entity by ID with archetype components', async () => {
+            // Create and save an entity
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'GetWithId', email: 'getwithid@example.com', age: 25 } });
+            const entity = await archetype.createAndSaveEntity();
+            ctx.tracker.track(entity);
+
+            // Load using archetype's getEntityWithID
+            const loadArchetype = new TestUserArchetype();
+            const loaded = await loadArchetype.getEntityWithID(entity.id);
+
+            expect(loaded).not.toBeNull();
+            expect(loaded?.id).toBe(entity.id);
+
+            // Component should be loaded
+            const userData = await loaded?.get(TestUser);
+            expect(userData?.name).toBe('GetWithId');
+        });
+
+        test('returns null for non-existent ID', async () => {
+            const archetype = new TestUserArchetype();
+            const loaded = await archetype.getEntityWithID('00000000-0000-0000-0000-000000000000');
+            expect(loaded).toBeNull();
+        });
+
+        test('returns null for invalid ID', async () => {
+            const archetype = new TestUserArchetype();
+            const loaded = await archetype.getEntityWithID('');
+            expect(loaded).toBeNull();
+        });
+    });
+
+    describe('updateEntity()', () => {
+        test('updates entity with new data', async () => {
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'ToUpdate', email: 'toupdate@example.com', age: 30 } });
+            const entity = await archetype.createAndSaveEntity();
+            ctx.tracker.track(entity);
+
+            // Update the entity
+            await archetype.updateEntity(entity, {
+                user: { name: 'Updated', age: 31 }
+            });
+            await entity.save();
+
+            const loaded = await Entity.FindById(entity.id);
+            const userData = await loaded?.get(TestUser);
+            expect(userData?.name).toBe('Updated');
+            expect(userData?.age).toBe(31);
+        });
+
+        test('preserves unchanged fields', async () => {
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'Preserve', email: 'preserve@example.com', age: 25 } });
+            const entity = await archetype.createAndSaveEntity();
+            ctx.tracker.track(entity);
+
+            // Update only name
+            await archetype.updateEntity(entity, {
+                user: { name: 'PreserveUpdated' }
+            });
+            await entity.save();
+
+            const loaded = await Entity.FindById(entity.id);
+            const userData = await loaded?.get(TestUser);
+            expect(userData?.name).toBe('PreserveUpdated');
+            expect(userData?.email).toBe('preserve@example.com'); // Email unchanged
+        });
+    });
+
+    describe('querying entities with archetype components', () => {
+        beforeEach(async () => {
+            // Create test data
+            for (let i = 0; i < 3; i++) {
+                const archetype = new TestUserArchetype();
+                archetype.fill({
+                    user: {
+                        name: `QueryArchUser${i}`,
+                        email: `queryarch${i}@example.com`,
+                        age: 20 + i * 10
+                    }
+                });
+                const entity = await archetype.createAndSaveEntity();
+                ctx.tracker.track(entity);
+            }
+        });
+
+        test('finds entities via Query with archetype components', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('email', FilterOp.LIKE, 'queryarch%@example.com')]
+                })
+                .populate()
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(3);
+        });
+
+        test('filters by component field values', async () => {
+            const results = await new Query()
+                .with(TestUser, {
+                    filters: [Query.filter('name', FilterOp.EQ, 'QueryArchUser0')]
+                })
+                .populate()
+                .exec();
+
+            expect(results.length).toBeGreaterThanOrEqual(1);
+            const userData = await results[0]?.get(TestUser);
+            expect(userData?.name).toBe('QueryArchUser0');
+        });
+    });
+
+    describe('Unwrap()', () => {
+        test('unwraps entity to plain object', async () => {
+            const archetype = new TestUserArchetype();
+            archetype.fill({ user: { name: 'Unwrap', email: 'unwrap@example.com', age: 30 } });
+            const entity = await archetype.createAndSaveEntity();
+            ctx.tracker.track(entity);
+
+            const unwrapped = await archetype.Unwrap(entity);
+
+            expect(unwrapped.id).toBe(entity.id);
+            // The unwrapped format may vary - check that user data is present
+            expect(unwrapped.user || unwrapped).toBeDefined();
+        });
+    });
+
+    describe('validation', () => {
+        test('withValidation validates input data', () => {
+            const archetype = new TestUserArchetype();
+
+            // Valid data should pass
+            const validResult = archetype.withValidation({
+                user: { name: 'Valid', email: 'valid@example.com', age: 25 }
+            });
+
+            expect(validResult).toBeDefined();
+        });
+    });
+
+    describe('component properties', () => {
+        test('getComponentsToLoad returns component constructors', () => {
+            const archetype = new TestUserArchetype();
+            const components = (archetype as any).getComponentsToLoad();
+
+            expect(Array.isArray(components)).toBe(true);
+            expect(components.length).toBeGreaterThan(0);
+        });
+    });
+});