@geekmidas/constructs 9.0.2 → 10.0.0-alpha.0

package/src/endpoints/__tests__/EndpointFactory.spec.ts

@@ -1,479 +0,0 @@
-import type { Logger } from '@geekmidas/logger';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-import { EndpointFactory } from '../EndpointFactory';
-
-describe('EndpointFactory', () => {
-	describe('joinPaths', () => {
-		it('should join simple paths', () => {
-			expect(EndpointFactory.joinPaths('/users', '/api')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('users', '/api')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('/users', 'api')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('users', 'api')).toBe('/api/users');
-		});
-
-		it('should handle empty base path', () => {
-			expect(EndpointFactory.joinPaths('/users', '')).toBe('/users');
-			expect(EndpointFactory.joinPaths('users', '')).toBe('/users');
-		});
-
-		it('should handle empty segment path', () => {
-			expect(EndpointFactory.joinPaths('', '/api')).toBe('/api');
-			expect(EndpointFactory.joinPaths('', 'api')).toBe('/api');
-		});
-
-		it('should handle both paths empty', () => {
-			expect(EndpointFactory.joinPaths('', '')).toBe('/');
-		});
-
-		it('should handle trailing slashes in base path', () => {
-			expect(EndpointFactory.joinPaths('/users', '/api/')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('users', '/api/')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('/users', 'api/')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('users', 'api/')).toBe('/api/users');
-		});
-
-		it('should handle root paths', () => {
-			expect(EndpointFactory.joinPaths('/users', '/')).toBe('/users');
-			expect(EndpointFactory.joinPaths('users', '/')).toBe('/users');
-			expect(EndpointFactory.joinPaths('/', '/')).toBe('/');
-		});
-
-		it('should handle multiple slashes', () => {
-			expect(EndpointFactory.joinPaths('//users', '/api')).toBe('/api//users');
-			expect(EndpointFactory.joinPaths('/users', '//api')).toBe('/api/users');
-		});
-
-		it('should handle complex paths', () => {
-			expect(EndpointFactory.joinPaths('/users/:id', '/api/v1')).toBe(
-				'/api/v1/users/:id',
-			);
-			expect(
-				EndpointFactory.joinPaths(
-					'/posts/:postId/comments/:commentId',
-					'/blog',
-				),
-			).toBe('/blog/posts/:postId/comments/:commentId');
-		});
-
-		it('should handle paths with query parameters notation', () => {
-			expect(EndpointFactory.joinPaths('/users?page=1', '/api')).toBe(
-				'/api/users?page=1',
-			);
-			expect(EndpointFactory.joinPaths('/search', '/api')).toBe('/api/search');
-		});
-
-		it('should handle nested segments', () => {
-			expect(EndpointFactory.joinPaths('/admin/users', '/api')).toBe(
-				'/api/admin/users',
-			);
-			expect(EndpointFactory.joinPaths('/v2/resources/items', '/api/v1')).toBe(
-				'/api/v1/v2/resources/items',
-			);
-		});
-
-		it('should not add extra slashes when paths already have them', () => {
-			expect(EndpointFactory.joinPaths('/users', '/api')).toBe('/api/users');
-			expect(EndpointFactory.joinPaths('/', '/api')).toBe('/api');
-		});
-
-		it('should preserve path parameters', () => {
-			expect(EndpointFactory.joinPaths('/:id', '/users')).toBe('/users/:id');
-			expect(
-				EndpointFactory.joinPaths('/:userId/posts/:postId', '/api/users'),
-			).toBe('/api/users/:userId/posts/:postId');
-		});
-
-		it('should work with undefined base path (default parameter)', () => {
-			expect(EndpointFactory.joinPaths('/users')).toBe('/users');
-			expect(EndpointFactory.joinPaths('users')).toBe('/users');
-			expect(EndpointFactory.joinPaths('')).toBe('/');
-		});
-	});
-
-	describe('authorize', () => {
-		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),
-		};
-
-		it('should create a factory with authorization function', () => {
-			const factory = new EndpointFactory();
-			const authFn = async () => true;
-
-			const authorizedFactory = factory.authorize(authFn);
-
-			expect(authorizedFactory).toBeInstanceOf(EndpointFactory);
-			expect(authorizedFactory).not.toBe(factory);
-		});
-
-		it('should apply authorization to created endpoints', async () => {
-			const authFn = vi.fn().mockResolvedValue(true);
-			const factory = new EndpointFactory()
-				.services([])
-				.logger(mockLogger)
-				.authorize(authFn);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.authorize).toBe(authFn);
-		});
-
-		it('should handle authorization with different service types', async () => {
-			const AuthService = {
-				serviceName: 'AuthService' as const,
-
-				async register() {
-					return { validateToken: (token: string) => token === 'valid' };
-				},
-			};
-
-			const authFn = async ({ header, services }: any) => {
-				const token = header('authorization')?.replace('Bearer ', '');
-				return services.AuthService.validateToken(token);
-			};
-
-			const factory = new EndpointFactory()
-				.services([AuthService])
-				.logger(mockLogger)
-				.authorize(authFn);
-
-			const endpoint = factory
-				.post('/protected')
-				.body(z.object({ data: z.string() }))
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.authorize).toBe(authFn);
-		});
-
-		it('should chain with other factory methods', () => {
-			const authFn = async () => true;
-			const sessionFn = async () => ({ userId: 'user1' });
-
-			const factory = new EndpointFactory()
-				.route('/api')
-				.services([])
-				.logger(mockLogger)
-				.authorize(authFn)
-				.session(sessionFn);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.getSession).toBe(sessionFn);
-		});
-
-		it('should preserve authorization in factory chains', () => {
-			const authFn = async () => true;
-			const newLogger = new ConsoleLogger();
-
-			const factory = new EndpointFactory()
-				.services([])
-				.authorize(authFn)
-				.logger(newLogger); // Chain after authorize
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.logger).toBe(newLogger);
-		});
-
-		it('should handle authorization function returning boolean', async () => {
-			const authFn = ({ header }: any) => {
-				return header('authorization') === 'Bearer valid-token';
-			};
-
-			const factory = new EndpointFactory()
-				.services([])
-				.logger(mockLogger)
-				.authorize(authFn);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.authorize).toBe(authFn);
-		});
-
-		it('should handle authorization function returning Promise<boolean>', async () => {
-			const authFn = async ({ header }: any) => {
-				await new Promise((resolve) => setTimeout(resolve, 1));
-				return header('authorization') === 'Bearer valid-token';
-			};
-
-			const factory = new EndpointFactory()
-				.services([])
-				.logger(mockLogger)
-				.authorize(authFn);
-
-			const endpoint = factory
-				.get('/test')
-				.handle(async () => ({ success: true }));
-
-			expect(endpoint.authorize).toBe(authFn);
-		});
-	});
-
-	describe('route', () => {
-		it('should create a sub-factory with path prefix', () => {
-			const factory = new EndpointFactory();
-			const apiFactory = factory.route('/api');
-			const v1Factory = apiFactory.route('/v1');
-
-			const endpoint = v1Factory.get('/users').handle(async () => []);
-
-			expect(endpoint.route).toBe('/api/v1/users');
-		});
-
-		it('should preserve services, auth, and logger in sub-routes', () => {
-			const authFn = async () => true;
-			const sessionFn = async () => ({ userId: 'user1' });
-
-			const TestService = {
-				serviceName: 'TestService' as const,
-				async register() {
-					return {};
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.services([TestService])
-				.authorize(authFn)
-				.session(sessionFn)
-				.route('/api');
-
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.route).toBe('/api/test');
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.getSession).toBe(sessionFn);
-		});
-	});
-
-	describe('services', () => {
-		const Service1 = {
-			serviceName: 'Service1' as const,
-			async register() {
-				return { method1: () => 'service1' };
-			},
-		};
-
-		const Service2 = {
-			serviceName: 'Service2' as const,
-			async register() {
-				return { method2: () => 'service2' };
-			},
-		};
-
-		it('should add services to factory', () => {
-			const factory = new EndpointFactory().services([Service1, Service2]);
-			const endpoint = factory.get('/test').handle(async ({ services }) => ({
-				result1: (await services[Service1.serviceName]).method1(),
-				result2: (await services[Service2.serviceName]).method2(),
-			}));
-
-			expect(endpoint.services).toEqual([Service1, Service2]);
-		});
-
-		it('should handle duplicate services', () => {
-			const factory = new EndpointFactory()
-				.services([Service1])
-				.services([Service1, Service2]);
-
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			// Should contain unique services
-			const serviceNames = endpoint.services.map((s) => s.serviceName);
-			expect(serviceNames).toContain('Service1');
-			expect(serviceNames).toContain('Service2');
-		});
-
-		it('should merge services in options', () => {
-			const factory = new EndpointFactory({
-				defaultServices: [Service1],
-			}).services([Service2]);
-
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.services).toEqual([Service2, Service1]);
-		});
-	});
-
-	describe('logger', () => {
-		it('should set custom logger', () => {
-			const customLogger: Logger = {
-				debug: vi.fn(),
-				info: vi.fn(),
-				warn: vi.fn(),
-				error: vi.fn(),
-				fatal: vi.fn(),
-				trace: vi.fn(),
-				child: vi.fn(),
-			};
-
-			const factory = new EndpointFactory().logger(customLogger);
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.logger).toBe(customLogger);
-		});
-
-		it('should use default logger when not specified', () => {
-			const factory = new EndpointFactory();
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.logger).toBeDefined();
-			expect(endpoint.logger).toBeInstanceOf(ConsoleLogger);
-		});
-	});
-
-	describe('session', () => {
-		it('should set session extractor', () => {
-			const sessionFn = async () => ({ userId: '123', role: 'admin' });
-			const factory = new EndpointFactory().session(sessionFn);
-
-			const endpoint = factory.get('/test').handle(async ({ session }) => ({
-				session,
-			}));
-
-			expect(endpoint.getSession).toBe(sessionFn);
-		});
-
-		it('should handle session with services', () => {
-			const SessionService = {
-				serviceName: 'SessionService' as const,
-				async register() {
-					return {
-						getSession: (token: string) => ({ userId: token }),
-					};
-				},
-			};
-
-			const sessionFn = async ({ header, services }: any) => {
-				const token = header('authorization');
-				return services.SessionService.getSession(token);
-			};
-
-			const factory = new EndpointFactory()
-				.services([SessionService])
-				.session(sessionFn);
-
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.getSession).toBe(sessionFn);
-		});
-	});
-
-	describe('HTTP method builders', () => {
-		const testMethods = [
-			{ method: 'get', httpMethod: 'GET' },
-			{ method: 'post', httpMethod: 'POST' },
-			{ method: 'put', httpMethod: 'PUT' },
-			{ method: 'delete', httpMethod: 'DELETE' },
-			{ method: 'patch', httpMethod: 'PATCH' },
-			{ method: 'options', httpMethod: 'OPTIONS' },
-		] as const;
-
-		testMethods.forEach(({ method, httpMethod }) => {
-			it(`should create ${httpMethod} endpoint`, () => {
-				const factory = new EndpointFactory();
-				const builder = (factory as any)[method]('/test');
-				const endpoint = builder.handle(async () => ({}));
-
-				expect(endpoint.method).toBe(httpMethod);
-				expect(endpoint.route).toBe('/test');
-			});
-		});
-
-		it('should apply basePath to all HTTP methods', () => {
-			const factory = new EndpointFactory().route('/api/v1');
-
-			testMethods.forEach(({ method, httpMethod }) => {
-				const builder = (factory as any)[method]('/test');
-				const endpoint = builder.handle(async () => ({}));
-
-				expect(endpoint.method).toBe(httpMethod);
-				expect(endpoint.route).toBe('/api/v1/test');
-			});
-		});
-	});
-
-	describe('constructor options', () => {
-		it('should initialize with all options', () => {
-			const authFn = async () => true;
-			const sessionFn = async () => ({ userId: '123' });
-			const logger: Logger = new ConsoleLogger();
-
-			const TestService = {
-				serviceName: 'TestService' as const,
-				async register() {
-					return {};
-				},
-			};
-
-			const factory = new EndpointFactory({
-				basePath: '/api',
-				defaultServices: [TestService],
-				defaultAuthorizeFn: authFn,
-				defaultLogger: logger,
-				defaultSessionExtractor: sessionFn,
-			});
-
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.route).toBe('/api/test');
-			expect(endpoint.authorize).toBe(authFn);
-			expect(endpoint.getSession).toBe(sessionFn);
-			expect(endpoint.logger).toBe(logger);
-			expect(endpoint.services).toEqual([TestService]);
-		});
-
-		it('should handle empty options', () => {
-			const factory = new EndpointFactory({});
-			const endpoint = factory.get('/test').handle(async () => ({}));
-
-			expect(endpoint.route).toBe('/test');
-			expect(endpoint.services).toEqual([]);
-		});
-	});
-
-	describe('type safety', () => {
-		it('should maintain type information through chains', () => {
-			const TypedService = {
-				serviceName: 'TypedService' as const,
-				async register() {
-					return { getData: () => ({ value: 42 }) };
-				},
-			};
-
-			const factory = new EndpointFactory()
-				.services([TypedService])
-				.session(async () => ({ userId: '123' }));
-
-			const endpoint = factory
-				.post('/data')
-				.body(z.object({ input: z.number() }))
-				.output(z.object({ result: z.number() }))
-				.handle(async ({ body, services }) => ({
-					result:
-						body.input +
-						(await services[TypedService.serviceName]).getData().value,
-				}));
-
-			// Type assertions to ensure type safety
-			expect(endpoint.route).toBe('/data');
-			expect(endpoint.method).toBe('POST');
-		});
-	});
-});

package/src/endpoints/__tests__/EndpointFactory.state-isolation.spec.ts

@@ -1,155 +0,0 @@
-import type { Service } from '@geekmidas/services';
-import { describe, expect, it } from 'vitest';
-import { EndpointFactory } from '../EndpointFactory';
-
-const CacheService = {
-	serviceName: 'cache' as const,
-	async register() {
-		return { get: () => 'cached' };
-	},
-} satisfies Service<'cache', any>;
-
-const DatabaseService = {
-	serviceName: 'database' as const,
-	async register() {
-		return { query: () => 'result' };
-	},
-} satisfies Service<'database', any>;
-
-describe('EndpointFactory - State Isolation', () => {
-	it('should create independent endpoints with sequential factory.services() calls', () => {
-		const factory = new EndpointFactory();
-
-		const endpoint1 = factory
-			.services([CacheService, DatabaseService])
-			.post('/user')
-			.handle(() => ({}));
-
-		const endpoint2 = factory
-			.services([CacheService])
-			.get('/user')
-			.handle(() => ({}));
-
-		expect(endpoint1.services.map((s) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-		expect(endpoint2.services.map((s) => s.serviceName)).toEqual(['cache']);
-	});
-
-	it('should create independent builders from reused factory instance', () => {
-		const factory = new EndpointFactory().services([
-			CacheService,
-			DatabaseService,
-		]);
-
-		const builder1 = factory.post('/users');
-		const builder2 = factory.get('/users');
-
-		// Both should have the factory's default services
-		expect((builder1 as any)._services.map((s: any) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-		expect((builder2 as any)._services.map((s: any) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-
-		// But they should not share the same array reference
-		expect((builder1 as any)._services === (builder2 as any)._services).toBe(
-			false,
-		);
-	});
-
-	it('should not leak services between independent builder chains', () => {
-		const factory = new EndpointFactory();
-
-		const builder1 = factory.post('/api1').services([CacheService]);
-		const builder2 = factory.post('/api2').services([DatabaseService]);
-
-		expect((builder1 as any)._services.map((s: any) => s.serviceName)).toEqual([
-			'cache',
-		]);
-		expect((builder2 as any)._services.map((s: any) => s.serviceName)).toEqual([
-			'database',
-		]);
-	});
-
-	it('should allow builder to add services without affecting other builders', () => {
-		const factory = new EndpointFactory().services([CacheService]);
-
-		const endpoint1 = factory
-			.post('/test')
-			.services([DatabaseService])
-			.handle(() => ({}));
-
-		const endpoint2 = factory.get('/test').handle(() => ({}));
-
-		expect(endpoint1.services.map((s) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-		expect(endpoint2.services.map((s) => s.serviceName)).toEqual(['cache']);
-	});
-
-	it('should support base router pattern with extended services', () => {
-		// Create a base router with default services
-		const r = new EndpointFactory().services([CacheService, DatabaseService]);
-
-		// Create endpoint with additional service
-		const getUsers = r
-			.services([CacheService])
-			.get('/users')
-			.handle(() => ({}));
-
-		// Create endpoint with just base services
-		const createUser = r.post('/users').handle(() => ({}));
-
-		// getUsers should have additional service (but deduplicated)
-		expect(getUsers.services.map((s) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-
-		// createUser should only have base services
-		expect(createUser.services.map((s) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-	});
-
-	it('should support base router pattern with truly additional services', () => {
-		const AdditionalService = {
-			serviceName: 'additional' as const,
-			async register() {
-				return { process: () => 'processed' };
-			},
-		} satisfies Service<'additional', any>;
-
-		// Create a base router with default services
-		const r = new EndpointFactory().services([CacheService, DatabaseService]);
-
-		// Create endpoint with additional service
-		const getUsers = r
-			.services([AdditionalService])
-			.get('/users')
-			.handle(() => ({}));
-
-		// Create endpoint with just base services
-		const createUser = r.post('/users').handle(() => ({}));
-
-		// getUsers should have all three services
-		expect(getUsers.services.map((s) => s.serviceName)).toEqual([
-			'additional',
-			'cache',
-			'database',
-		]);
-
-		// createUser should only have base services
-		expect(createUser.services.map((s) => s.serviceName)).toEqual([
-			'cache',
-			'database',
-		]);
-	});
-});