bunsane 0.3.2 → 0.4.0

package/tests/graphql/SchemaGeneration.test.ts

@@ -1,90 +0,0 @@
-/**
- * Tests for GraphQL Schema Generation
- * Tests the overall schema generation process
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { TestUser, TestProduct, TestOrder } from '../fixtures/components';
-import { TestUserArchetype } from '../fixtures/archetypes/TestUserArchetype';
-import { ensureComponentsRegistered } from '../utils';
-
-describe('GraphQL Schema Generation', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-    });
-
-    describe('archetype schema generation', () => {
-        test('archetype has zodObjectSchema method', () => {
-            const archetype = new TestUserArchetype();
-            expect(typeof archetype.getZodObjectSchema).toBe('function');
-        });
-
-        test('archetype has inputSchema method', () => {
-            const archetype = new TestUserArchetype();
-            expect(typeof archetype.getInputSchema).toBe('function');
-        });
-    });
-
-    describe('component to GraphQL type mapping', () => {
-        test('archetype schema is defined', () => {
-            const archetype = new TestUserArchetype();
-            const schema = archetype.getZodObjectSchema();
-
-            expect(schema).toBeDefined();
-        });
-
-        test('input schema is defined', () => {
-            const archetype = new TestUserArchetype();
-            const inputSchema = archetype.getInputSchema();
-
-            expect(inputSchema).toBeDefined();
-        });
-    });
-
-    describe('input type generation', () => {
-        test('generates input schema for archetype', () => {
-            const archetype = new TestUserArchetype();
-            const inputSchema = archetype.getInputSchema();
-
-            expect(inputSchema).toBeDefined();
-            expect(typeof inputSchema).toBe('object');
-        });
-
-        test('input schema validates valid data', () => {
-            const archetype = new TestUserArchetype();
-            const schema = archetype.withValidation({
-                user: { name: 'Valid', email: 'valid@example.com', age: 25 }
-            });
-
-            expect(schema).toBeDefined();
-            expect(schema.shape).toBeDefined();
-            expect(typeof schema.safeParse).toBe('function');
-        });
-    });
-
-    describe('schema consistency', () => {
-        test('multiple calls return structurally equivalent schemas', () => {
-            const archetype = new TestUserArchetype();
-
-            const schema1 = archetype.getZodObjectSchema();
-            const schema2 = archetype.getZodObjectSchema();
-
-            // Both should have the same shape keys
-            const keys1 = Object.keys(schema1.shape);
-            const keys2 = Object.keys(schema2.shape);
-            expect(keys1).toEqual(keys2);
-            expect(keys1.length).toBeGreaterThan(0);
-        });
-    });
-
-    describe('archetype with components', () => {
-        test('archetype has componentMap', () => {
-            const archetype = new TestUserArchetype();
-            expect(archetype.componentMap).toBeDefined();
-        });
-
-        test('componentMap includes user component', () => {
-            const archetype = new TestUserArchetype();
-            expect(archetype.componentMap.user).toBeDefined();
-        });
-    });
-});

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

@@ -1,223 +0,0 @@
-/**
- * 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

@@ -1,153 +0,0 @@
-/**
- * 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/helpers/MockRedisClient.ts

@@ -1,113 +0,0 @@
-/**
- * ioredis-shaped client backed by a MockRedisStreamServer.
- *
- * Cast the returned instance to `Redis` (from "ioredis") when passing into
- * the remote subsystem via `redisFactory`. Only methods the remote layer
- * touches are implemented; others throw on use.
- */
-
-import type { MockRedisStreamServer } from "./MockRedisStreamServer";
-
-export class MockRedisClient {
-    private server: MockRedisStreamServer;
-    private connected = true;
-    private listeners = new Map<string, Array<(...args: any[]) => void>>();
-
-    constructor(server: MockRedisStreamServer) {
-        this.server = server;
-    }
-
-    on(event: string, listener: (...args: any[]) => void): this {
-        const arr = this.listeners.get(event) ?? [];
-        arr.push(listener);
-        this.listeners.set(event, arr);
-        return this;
-    }
-
-    async xadd(key: string, ...args: any[]): Promise<string | null> {
-        this.ensureConnected();
-        try {
-            return this.server.xadd(key, ...args);
-        } catch (err: any) {
-            throw err;
-        }
-    }
-
-    async xgroup(...args: any[]): Promise<string> {
-        this.ensureConnected();
-        const [op, key, group, id, mk] = args;
-        return this.server.xgroup(op, key, group, id, mk);
-    }
-
-    async xreadgroup(...args: any[]): Promise<any> {
-        this.ensureConnected();
-        return this.server.xreadgroup(...args);
-    }
-
-    async xread(...args: any[]): Promise<any> {
-        this.ensureConnected();
-        return this.server.xread(...args);
-    }
-
-    async xack(key: string, group: string, msgId: string): Promise<number> {
-        this.ensureConnected();
-        return this.server.xack(key, group, msgId);
-    }
-
-    async xpending(...args: any[]): Promise<any> {
-        this.ensureConnected();
-        const [key, group, ...rest] = args;
-        return this.server.xpending(key, group, ...rest);
-    }
-
-    async xautoclaim(...args: any[]): Promise<any> {
-        this.ensureConnected();
-        return this.server.xautoclaim(
-            args[0],
-            args[1],
-            args[2],
-            Number(args[3]),
-            args[4],
-            ...args.slice(5)
-        );
-    }
-
-    async xlen(key: string): Promise<number> {
-        this.ensureConnected();
-        return this.server.xlen(key);
-    }
-
-    async xrange(...args: any[]): Promise<any> {
-        this.ensureConnected();
-        return this.server.xrange(
-            args[0],
-            args[1],
-            args[2],
-            ...args.slice(3)
-        );
-    }
-
-    async ping(): Promise<string> {
-        this.ensureConnected();
-        return this.server.ping();
-    }
-
-    disconnect(): void {
-        this.connected = false;
-    }
-
-    async quit(): Promise<string> {
-        this.connected = false;
-        return "OK";
-    }
-
-    private ensureConnected(): void {
-        if (!this.connected) {
-            throw new Error("Connection is closed");
-        }
-    }
-}
-
-export function createMockRedisFactory(server: MockRedisStreamServer) {
-    return (_blocking: boolean) => new MockRedisClient(server);
-}