@geekmidas/constructs 9.0.2 → 10.0.0-alpha.0

package/src/endpoints/__tests__/EndpointFactory.database-auditor.spec.ts

@@ -1,509 +0,0 @@
-import type { AuditStorage } from '@geekmidas/audit';
-import type { Logger } from '@geekmidas/logger';
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-import { EndpointFactory } from '../EndpointFactory';
-
-describe('EndpointFactory', () => {
-	const mockLogger: Logger = {
-		debug: vi.fn(),
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		fatal: vi.fn(),
-		trace: vi.fn(),
-		child: vi.fn(() => mockLogger),
-	};
-
-	describe('database', () => {
-		const DatabaseService = {
-			serviceName: 'database' as const,
-			async register() {
-				return {
-					query: vi.fn().mockResolvedValue([]),
-					insertInto: vi.fn(),
-					selectFrom: vi.fn(),
-				};
-			},
-		};
-
-		it('should create a factory with database service', () => {
-			const factory = new EndpointFactory();
-			const factoryWithDb = factory.database(DatabaseService);
-
-			expect(factoryWithDb).toBeInstanceOf(EndpointFactory);
-			expect(factoryWithDb).not.toBe(factory);
-		});
-
-		it('should pass database service to created endpoints', () => {
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.database(DatabaseService);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-		});
-
-		it('should preserve database service through factory chains', () => {
-			const factory = new EndpointFactory()
-				.database(DatabaseService)
-				.logger(mockLogger)
-				.route('/api');
-
-			const endpoint = factory
-				.get('/users')
-				.handle(async () => ({ users: [] }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.route).toBe('/api/users');
-		});
-
-		it('should preserve database service with services()', () => {
-			const OtherService = {
-				serviceName: 'other' as const,
-				async register() {
-					return {};
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.database(DatabaseService)
-				.services([OtherService]);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.services).toContainEqual(OtherService);
-		});
-
-		it('should allow endpoints to override database service', () => {
-			const AlternativeDatabase = {
-				serviceName: 'altDatabase' as const,
-				async register() {
-					return { query: vi.fn() };
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.database(DatabaseService);
-
-			const endpoint = factory
-				.get('/test')
-				.database(AlternativeDatabase)
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(AlternativeDatabase);
-		});
-
-		it('should work with authorization and session', () => {
-			const authFn = async () => true;
-			const sessionFn = async () => ({ userId: '123' });
-
-			const factory = new EndpointFactory()
-				.database(DatabaseService)
-				.authorize(authFn)
-				.session(sessionFn);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.getSession).toBe(sessionFn);
-		});
-	});
-
-	describe('auditor', () => {
-		const mockAuditStorage: AuditStorage = {
-			write: vi.fn().mockResolvedValue(undefined),
-			query: vi.fn().mockResolvedValue([]),
-			count: vi.fn().mockResolvedValue(0),
-		};
-
-		const AuditStorageService = {
-			serviceName: 'auditStorage' as const,
-			async register() {
-				return mockAuditStorage;
-			},
-		};
-
-		it('should create a factory with auditor storage', () => {
-			const factory = new EndpointFactory();
-			const factoryWithAuditor = factory.auditor(AuditStorageService);
-
-			expect(factoryWithAuditor).toBeInstanceOf(EndpointFactory);
-			expect(factoryWithAuditor).not.toBe(factory);
-		});
-
-		it('should pass auditor storage to created endpoints', () => {
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.auditor(AuditStorageService);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-		});
-
-		it('should preserve auditor storage through factory chains', () => {
-			const factory = new EndpointFactory()
-				.auditor(AuditStorageService)
-				.logger(mockLogger)
-				.route('/api');
-
-			const endpoint = factory
-				.get('/users')
-				.handle(async () => ({ users: [] }));
-
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-			expect(endpoint.route).toBe('/api/users');
-		});
-
-		it('should preserve auditor storage with services()', () => {
-			const OtherService = {
-				serviceName: 'other' as const,
-				async register() {
-					return {};
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.auditor(AuditStorageService)
-				.services([OtherService]);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-			expect(endpoint.services).toContainEqual(OtherService);
-		});
-
-		it('should allow endpoints to override auditor storage', () => {
-			const AlternativeAuditStorage = {
-				serviceName: 'altAuditStorage' as const,
-				async register(): Promise<AuditStorage> {
-					return {
-						write: vi.fn(),
-						query: vi.fn().mockResolvedValue([]),
-						count: vi.fn().mockResolvedValue(0),
-					};
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.auditor(AuditStorageService);
-
-			const endpoint = factory
-				.get('/test')
-				.auditor(AlternativeAuditStorage)
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.auditorStorageService).toBe(AlternativeAuditStorage);
-		});
-
-		it('should work with authorization and session', () => {
-			const authFn = async () => true;
-			const sessionFn = async () => ({ userId: '123' });
-
-			const factory = new EndpointFactory()
-				.auditor(AuditStorageService)
-				.authorize(authFn)
-				.session(sessionFn);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.getSession).toBe(sessionFn);
-		});
-	});
-
-	describe('database and auditor together', () => {
-		const DatabaseService = {
-			serviceName: 'database' as const,
-			async register() {
-				return { query: vi.fn() };
-			},
-		};
-
-		const mockAuditStorage: AuditStorage = {
-			write: vi.fn().mockResolvedValue(undefined),
-			query: vi.fn().mockResolvedValue([]),
-			count: vi.fn().mockResolvedValue(0),
-		};
-
-		const AuditStorageService = {
-			serviceName: 'auditStorage' as const,
-			async register() {
-				return mockAuditStorage;
-			},
-		};
-
-		it('should allow both database and auditor to be configured', () => {
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.database(DatabaseService)
-				.auditor(AuditStorageService);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-		});
-
-		it('should preserve both through route chains', () => {
-			const factory = new EndpointFactory()
-				.database(DatabaseService)
-				.auditor(AuditStorageService)
-				.route('/api')
-				.route('/v1');
-
-			const endpoint = factory
-				.post('/users')
-				.body(z.object({ name: z.string() }))
-				.handle(async () => ({ id: '123' }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-			expect(endpoint.route).toBe('/api/v1/users');
-		});
-
-		it('should work with all factory configuration options', () => {
-			const authFn = async () => true;
-			const sessionFn = async () => ({ userId: '123' });
-
-			const OtherService = {
-				serviceName: 'other' as const,
-				async register() {
-					return {};
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.services([OtherService])
-				.database(DatabaseService)
-				.auditor(AuditStorageService)
-				.authorize(authFn)
-				.session(sessionFn)
-				.route('/api');
-
-			const endpoint = factory
-				.post('/users')
-				.body(z.object({ name: z.string() }))
-				.output(z.object({ id: z.string() }))
-				.handle(async () => ({ id: '123' }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.getSession).toBe(sessionFn);
-			expect(endpoint.services).toContainEqual(OtherService);
-			expect(endpoint.route).toBe('/api/users');
-		});
-
-		it('should allow per-endpoint overrides of both', () => {
-			const AltDatabase = {
-				serviceName: 'altDb' as const,
-				async register() {
-					return { query: vi.fn() };
-				},
-			};
-
-			const AltAuditStorage = {
-				serviceName: 'altAudit' as const,
-				async register(): Promise<AuditStorage> {
-					return {
-						write: vi.fn(),
-						query: vi.fn().mockResolvedValue([]),
-						count: vi.fn().mockResolvedValue(0),
-					};
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.database(DatabaseService)
-				.auditor(AuditStorageService);
-
-			const endpoint = factory
-				.get('/test')
-				.database(AltDatabase)
-				.auditor(AltAuditStorage)
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(AltDatabase);
-			expect(endpoint.auditorStorageService).toBe(AltAuditStorage);
-		});
-	});
-
-	describe('actor', () => {
-		it('should create a factory with actor extractor', () => {
-			const actorExtractor = () => ({ id: '123', type: 'user' as const });
-			const factory = new EndpointFactory();
-			const factoryWithActor = factory.actor(actorExtractor);
-
-			expect(factoryWithActor).toBeInstanceOf(EndpointFactory);
-			expect(factoryWithActor).not.toBe(factory);
-		});
-
-		it('should pass actor extractor to created endpoints', () => {
-			const actorExtractor = () => ({ id: '123', type: 'user' as const });
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.actor(actorExtractor);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.actorExtractor).toBe(actorExtractor);
-		});
-
-		it('should preserve actor extractor through factory chains', () => {
-			const actorExtractor = () => ({ id: '123', type: 'user' as const });
-			const factory = new EndpointFactory()
-				.actor(actorExtractor)
-				.logger(mockLogger)
-				.route('/api');
-
-			const endpoint = factory
-				.get('/users')
-				.handle(async () => ({ users: [] }));
-
-			expect(endpoint.actorExtractor).toBe(actorExtractor);
-			expect(endpoint.route).toBe('/api/users');
-		});
-
-		it('should allow endpoints to override actor extractor', () => {
-			const factoryActor = () => ({ id: 'factory', type: 'system' as const });
-			const endpointActor = () => ({ id: 'endpoint', type: 'user' as const });
-
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.actor(factoryActor);
-
-			const endpoint = factory
-				.get('/test')
-				.actor(endpointActor)
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.actorExtractor).toBe(endpointActor);
-		});
-
-		it('should work with auditor and database', () => {
-			const actorExtractor = ({ session }: any) => ({
-				id: session.userId,
-				type: 'user' as const,
-			});
-
-			const mockAuditStorage: AuditStorage = {
-				write: vi.fn().mockResolvedValue(undefined),
-				query: vi.fn().mockResolvedValue([]),
-				count: vi.fn().mockResolvedValue(0),
-			};
-
-			const AuditStorageService = {
-				serviceName: 'auditStorage' as const,
-				async register() {
-					return mockAuditStorage;
-				},
-			};
-
-			const DatabaseService = {
-				serviceName: 'database' as const,
-				async register() {
-					return { query: vi.fn() };
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.logger(mockLogger)
-				.database(DatabaseService)
-				.auditor(AuditStorageService)
-				.actor(actorExtractor);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.actorExtractor).toBe(actorExtractor);
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-		});
-	});
-
-	describe('constructor options with database and auditor', () => {
-		const DatabaseService = {
-			serviceName: 'database' as const,
-			async register() {
-				return { query: vi.fn() };
-			},
-		};
-
-		const mockAuditStorage: AuditStorage = {
-			write: vi.fn().mockResolvedValue(undefined),
-			query: vi.fn().mockResolvedValue([]),
-			count: vi.fn().mockResolvedValue(0),
-		};
-
-		const AuditStorageService = {
-			serviceName: 'auditStorage' as const,
-			async register() {
-				return mockAuditStorage;
-			},
-		};
-
-		it('should accept database and auditor in constructor options', () => {
-			const factory = new EndpointFactory({
-				defaultDatabaseService: DatabaseService,
-				defaultAuditorStorage: AuditStorageService,
-			});
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.auditorStorageService).toBe(AuditStorageService);
-		});
-
-		it('should merge constructor options with method calls', () => {
-			const AltAuditStorage = {
-				serviceName: 'altAudit' as const,
-				async register(): Promise<AuditStorage> {
-					return {
-						write: vi.fn(),
-						query: vi.fn().mockResolvedValue([]),
-						count: vi.fn().mockResolvedValue(0),
-					};
-				},
-			};
-
-			const factory = new EndpointFactory({
-				defaultDatabaseService: DatabaseService,
-			}).auditor(AltAuditStorage);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.databaseService).toBe(DatabaseService);
-			expect(endpoint.auditorStorageService).toBe(AltAuditStorage);
-		});
-	});
-});

package/src/endpoints/__tests__/EndpointFactory.reference-audit.spec.ts

@@ -1,190 +0,0 @@
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import type { Service } from '@geekmidas/services';
-import { describe, expect, it } from 'vitest';
-import { EndpointFactory } from '../EndpointFactory';
-
-const ServiceA = {
-	serviceName: 'a' as const,
-	async register() {
-		return { test: () => 'a' };
-	},
-} satisfies Service<'a', any>;
-
-const ServiceB = {
-	serviceName: 'b' as const,
-	async register() {
-		return { test: () => 'b' };
-	},
-} satisfies Service<'b', any>;
-
-describe('EndpointFactory - Reference Sharing Audit', () => {
-	describe('services array', () => {
-		it('should not share services array references between builders', () => {
-			const factory = new EndpointFactory().services([ServiceA, ServiceB]);
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Should not be the same reference
-			expect((builder1 as any)._services === (builder2 as any)._services).toBe(
-				false,
-			);
-
-			// But should have same content
-			expect((builder1 as any)._services).toEqual([ServiceA, ServiceB]);
-			expect((builder2 as any)._services).toEqual([ServiceA, ServiceB]);
-		});
-
-		it('should not mutate factory services when builder adds services', () => {
-			const factory = new EndpointFactory().services([ServiceA]);
-
-			const builder = factory.post('/test');
-			const originalServices = (factory as any).defaultServices;
-
-			// Builder adds more services
-			builder.services([ServiceB]);
-
-			// Factory's defaultServices should be unchanged
-			expect((factory as any).defaultServices).toEqual(originalServices);
-			expect((factory as any).defaultServices.length).toBe(1);
-		});
-	});
-
-	describe('events array', () => {
-		it('should not share events array references between builders', () => {
-			const factory = new EndpointFactory();
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Each builder should have its own events array
-			expect((builder1 as any)._events === (builder2 as any)._events).toBe(
-				false,
-			);
-			expect((builder1 as any)._events).toEqual([]);
-			expect((builder2 as any)._events).toEqual([]);
-		});
-
-		it('should not share events between builders even after adding events', () => {
-			const factory = new EndpointFactory();
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Add event to builder1
-			const mockEvent: any = { type: 'test', map: () => ({}) };
-			(builder1 as any)._events.push(mockEvent);
-
-			// builder2 should not have the event
-			expect((builder1 as any)._events.length).toBe(1);
-			expect((builder2 as any)._events.length).toBe(0);
-		});
-	});
-
-	describe('schemas object', () => {
-		it('should not share schemas object references between builders', () => {
-			const factory = new EndpointFactory();
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Each builder should have its own schemas object
-			expect((builder1 as any).schemas === (builder2 as any).schemas).toBe(
-				false,
-			);
-		});
-
-		it('should not share schemas between builders after setting schemas', () => {
-			const factory = new EndpointFactory();
-			const bodySchema: any = { '~standard': { validate: () => ({}) } };
-
-			const builder1 = factory.post('/a').body(bodySchema);
-			const builder2 = factory.post('/b');
-
-			// builder1 should have body schema, builder2 should not
-			expect((builder1 as any).schemas.body).toBeDefined();
-			expect((builder2 as any).schemas.body).toBeUndefined();
-		});
-	});
-
-	describe('logger (intentionally shared)', () => {
-		it('should share logger references between builders (by design)', () => {
-			const logger = new ConsoleLogger({ app: 'test' });
-			const factory = new EndpointFactory().logger(logger);
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Logger should be the same reference (it's a singleton service)
-			expect((builder1 as any)._logger === (builder2 as any)._logger).toBe(
-				true,
-			);
-			expect((builder1 as any)._logger).toBe(logger);
-		});
-	});
-
-	describe('authorize and session functions', () => {
-		it('should share authorize function reference (by design)', () => {
-			const authFn = async () => true;
-			const factory = new EndpointFactory().authorize(authFn);
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Function should be the same reference
-			expect(
-				(builder1 as any)._authorize === (builder2 as any)._authorize,
-			).toBe(true);
-			expect((builder1 as any)._authorize).toBe(authFn);
-		});
-
-		it('should share session extractor function reference (by design)', () => {
-			const sessionFn = async () => ({ userId: '123' });
-			const factory = new EndpointFactory().session(sessionFn);
-
-			const builder1 = factory.post('/a');
-			const builder2 = factory.post('/b');
-
-			// Function should be the same reference
-			expect(
-				(builder1 as any)._getSession === (builder2 as any)._getSession,
-			).toBe(true);
-			expect((builder1 as any)._getSession).toBe(sessionFn);
-		});
-	});
-
-	describe('complex nested factory chains', () => {
-		it('should maintain proper isolation through multiple factory layers', () => {
-			// Create base router
-			const base = new EndpointFactory().services([ServiceA]);
-
-			// Create auth router from base
-			const authRouter = base.authorize(async () => true);
-
-			// Create API v1 router from auth router
-			const v1Router = authRouter.route('/v1').services([ServiceB]);
-
-			// Create endpoints from different routers
-			const ep1 = base.get('/test').handle(() => ({}));
-			const ep2 = authRouter.get('/test').handle(() => ({}));
-			const ep3 = v1Router.get('/test').handle(() => ({}));
-
-			// Verify service isolation
-			expect(ep1.services.map((s) => s.serviceName)).toEqual(['a']);
-			expect(ep2.services.map((s) => s.serviceName)).toEqual(['a']);
-			expect(ep3.services.map((s) => s.serviceName)).toEqual(['b', 'a']);
-
-			// Verify they don't share internal arrays
-			const builder1 = base.get('/x');
-			const builder2 = authRouter.get('/x');
-			const builder3 = v1Router.get('/x');
-
-			expect((builder1 as any)._services === (builder2 as any)._services).toBe(
-				false,
-			);
-			expect((builder2 as any)._services === (builder3 as any)._services).toBe(
-				false,
-			);
-		});
-	});
-});