@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/src/__tests__/Construct.environment.spec.ts

@@ -1,704 +0,0 @@
-import type { EventPublisher, PublishableMessage } from '@geekmidas/events';
-import type { Service, ServiceRegisterOptions } from '@geekmidas/services';
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import { sniffService } from '../Construct';
-import { c } from '../crons';
-import { e } from '../endpoints';
-import { f } from '../functions';
-import { s } from '../subscribers';
-
-describe('Construct environment getter', () => {
-	describe('Function', () => {
-		it('should return empty array when no services are provided', async () => {
-			const fn = f.handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment()).toEqual([]);
-		});
-
-		it('should detect environment variables from a single service', async () => {
-			const databaseService = {
-				serviceName: 'database' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						url: get('DATABASE_URL').string(),
-						port: get('DATABASE_PORT').string().transform(Number).default(5432),
-					}));
-				},
-			} satisfies Service<'database', any>;
-
-			const fn = f
-				.services([databaseService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			expect(envVars).toEqual(['DATABASE_PORT', 'DATABASE_URL']);
-		});
-
-		it('should detect environment variables from multiple services', async () => {
-			const databaseService = {
-				serviceName: 'database' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						url: get('DATABASE_URL').string(),
-					}));
-				},
-			} satisfies Service<'database', any>;
-
-			const redisService = {
-				serviceName: 'redis' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						url: get('REDIS_URL').string(),
-						ttl: get('REDIS_TTL').string().transform(Number).default(3600),
-					}));
-				},
-			} satisfies Service<'redis', any>;
-
-			const fn = f
-				.services([databaseService, redisService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			expect(envVars).toEqual(['DATABASE_URL', 'REDIS_TTL', 'REDIS_URL']);
-		});
-
-		it('should deduplicate environment variables across services', async () => {
-			const service1 = {
-				serviceName: 'service1' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						apiKey: get('SHARED_API_KEY').string(),
-					}));
-				},
-			} satisfies Service<'service1', any>;
-
-			const service2 = {
-				serviceName: 'service2' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						apiKey: get('SHARED_API_KEY').string(),
-					}));
-				},
-			} satisfies Service<'service2', any>;
-
-			const fn = f
-				.services([service1, service2])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			// Should only appear once despite being used in both services
-			expect(envVars).toEqual(['SHARED_API_KEY']);
-		});
-
-		it('should handle services with nested configuration', async () => {
-			const configService = {
-				serviceName: 'config' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						database: {
-							host: get('DB_HOST').string(),
-							port: get('DB_PORT').string().transform(Number),
-						},
-						api: {
-							key: get('API_KEY').string(),
-							url: get('API_URL').string().url(),
-						},
-					}));
-				},
-			} satisfies Service<'config', any>;
-
-			const fn = f
-				.services([configService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			expect(envVars).toEqual(['API_KEY', 'API_URL', 'DB_HOST', 'DB_PORT']);
-		});
-
-		it('should handle services that return non-ConfigParser values', async () => {
-			const simpleService = {
-				serviceName: 'simple' as const,
-				register(_options: ServiceRegisterOptions) {
-					// This service doesn't use envParser - just returns a plain object
-					return { value: 'test' };
-				},
-			} satisfies Service<'simple', any>;
-
-			const databaseService = {
-				serviceName: 'database' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						url: get('DATABASE_URL').string(),
-					}));
-				},
-			} satisfies Service<'database', any>;
-
-			const fn = f
-				.services([simpleService, databaseService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			// Should only include env vars from databaseService
-			expect(envVars).toEqual(['DATABASE_URL']);
-		});
-	});
-
-	describe('Endpoint', () => {
-		it('should detect environment variables from endpoint services', async () => {
-			const authService = {
-				serviceName: 'auth' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						secret: get('JWT_SECRET').string(),
-						expiresIn: get('JWT_EXPIRES_IN').string().default('15m'),
-					}));
-				},
-			} satisfies Service<'auth', any>;
-
-			const endpoint = e
-				.services([authService])
-				.get('/users')
-				.handle(async () => []);
-
-			const envVars = await endpoint.getEnvironment();
-
-			expect(envVars).toEqual(['JWT_EXPIRES_IN', 'JWT_SECRET']);
-		});
-
-		it('should work with different HTTP methods', async () => {
-			const storageService = {
-				serviceName: 'storage' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						bucket: get('S3_BUCKET').string(),
-						region: get('AWS_REGION').string().default('us-east-1'),
-					}));
-				},
-			} satisfies Service<'storage', any>;
-
-			const postEndpoint = e
-				.services([storageService])
-				.post('/upload')
-				.handle(async () => ({ success: true }));
-
-			const getEndpoint = e
-				.services([storageService])
-				.get('/files')
-				.handle(async () => []);
-
-			expect(await postEndpoint.getEnvironment()).toEqual([
-				'AWS_REGION',
-				'S3_BUCKET',
-			]);
-			expect(await getEndpoint.getEnvironment()).toEqual([
-				'AWS_REGION',
-				'S3_BUCKET',
-			]);
-		});
-	});
-
-	describe('Cron', () => {
-		it('should detect environment variables from cron services', async () => {
-			const emailService = {
-				serviceName: 'email' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						smtpHost: get('SMTP_HOST').string(),
-						smtpPort: get('SMTP_PORT').string().transform(Number).default(587),
-						smtpUser: get('SMTP_USER').string(),
-						smtpPass: get('SMTP_PASS').string(),
-					}));
-				},
-			} satisfies Service<'email', any>;
-
-			const cronJob = c
-				.services([emailService])
-				.schedule('rate(1 hour)')
-				.handle(async () => {
-					// Send daily report email
-				});
-
-			const envVars = await cronJob.getEnvironment();
-
-			expect(envVars).toEqual([
-				'SMTP_HOST',
-				'SMTP_PASS',
-				'SMTP_PORT',
-				'SMTP_USER',
-			]);
-		});
-	});
-
-	describe('Subscriber', () => {
-		it('should detect environment variables from subscriber services', async () => {
-			type UserEvents =
-				| PublishableMessage<'user.created', { userId: string }>
-				| PublishableMessage<'user.updated', { userId: string }>;
-
-			class UserEventPublisher implements EventPublisher<UserEvents> {
-				async publish(_events: UserEvents[]): Promise<void> {}
-			}
-
-			const eventPublisherService: Service<'events', UserEventPublisher> = {
-				serviceName: 'events' as const,
-				register() {
-					return new UserEventPublisher();
-				},
-			};
-
-			const notificationService = {
-				serviceName: 'notification' as const,
-				register({ envParser }) {
-					return envParser
-						.create((get) => ({
-							apiKey: get('NOTIFICATION_API_KEY').string(),
-							endpoint: get('NOTIFICATION_ENDPOINT')
-								.string()
-								.url()
-								.default('https://api.example.com/notify'),
-						}))
-						.parse();
-				},
-			} satisfies Service<'notification', any>;
-
-			const subscriber = s
-				.publisher(eventPublisherService)
-				.services([notificationService])
-				.subscribe('user.created')
-				.handle(async () => {
-					// Handle user created events
-				});
-
-			const envVars = await subscriber.getEnvironment();
-
-			expect(envVars).toEqual([
-				'NOTIFICATION_API_KEY',
-				'NOTIFICATION_ENDPOINT',
-			]);
-		});
-	});
-
-	describe('Edge cases', () => {
-		it('should return empty array when services array is empty', async () => {
-			const fn = f.services([]).handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment()).toEqual([]);
-		});
-
-		it('should handle service with optional environment variables', async () => {
-			const optionalConfigService = {
-				serviceName: 'optionalConfig' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						required: get('REQUIRED_VAR').string(),
-						optional1: get('OPTIONAL_VAR_1').string().optional(),
-						optional2: get('OPTIONAL_VAR_2').string().optional(),
-					}));
-				},
-			} satisfies Service<'optionalConfig', any>;
-
-			const fn = f
-				.services([optionalConfigService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			// Should include both required and optional variables
-			expect(envVars).toEqual([
-				'OPTIONAL_VAR_1',
-				'OPTIONAL_VAR_2',
-				'REQUIRED_VAR',
-			]);
-		});
-
-		it('should be callable multiple times with consistent results', async () => {
-			const service = {
-				serviceName: 'testService' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						var1: get('VAR_1').string(),
-						var2: get('VAR_2').string(),
-					}));
-				},
-			} satisfies Service<'testService', any>;
-
-			const fn = f.services([service]).handle(async () => ({ success: true }));
-
-			const firstCall = await fn.getEnvironment();
-			const secondCall = await fn.getEnvironment();
-			const thirdCall = await fn.getEnvironment();
-
-			expect(firstCall).toEqual(['VAR_1', 'VAR_2']);
-			expect(secondCall).toEqual(['VAR_1', 'VAR_2']);
-			expect(thirdCall).toEqual(['VAR_1', 'VAR_2']);
-		});
-
-		it('should handle services with complex transformations', async () => {
-			const complexService = {
-				serviceName: 'complex' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						origins: get('ALLOWED_ORIGINS')
-							.string()
-							.transform((v) => v.split(',')),
-						flags: get('FEATURE_FLAGS')
-							.string()
-							.transform((v) => v.split(',').map((f) => f.trim())),
-						config: get('JSON_CONFIG')
-							.string()
-							.transform((v) => JSON.parse(v))
-							.pipe(z.record(z.string(), z.boolean())),
-					}));
-				},
-			} satisfies Service<'complex', any>;
-
-			const fn = f
-				.services([complexService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-
-			expect(envVars).toEqual([
-				'ALLOWED_ORIGINS',
-				'FEATURE_FLAGS',
-				'JSON_CONFIG',
-			]);
-		});
-
-		it('should handle services that throw synchronous errors during registration', async () => {
-			const throwingService = {
-				serviceName: 'throwing' as const,
-				register({ envParser }) {
-					const config = envParser
-						.create((get) => ({
-							url: get('SERVICE_URL').string(),
-						}))
-						.parse();
-
-					// Simulate a library that validates config immediately
-					// Sniffer returns '' for strings, so this will throw
-					if (!config.url || config.url === '') {
-						throw new Error('Invalid URL provided');
-					}
-
-					return { url: config.url };
-				},
-			} satisfies Service<'throwing', any>;
-
-			// Verify env vars are captured even when service throws
-			const result = await sniffService(throwingService);
-			expect(result.envVars).toEqual(['SERVICE_URL']);
-			expect(result.error).toBeDefined();
-			expect(result.error?.message).toBe('Invalid URL provided');
-
-			// Also verify it works in a construct context with multiple services
-			const workingService = {
-				serviceName: 'working' as const,
-				register({ envParser }) {
-					return envParser
-						.create((get) => ({
-							key: get('API_KEY').string(),
-						}))
-						.parse();
-				},
-			} satisfies Service<'working', any>;
-
-			const fn = f
-				.services([throwingService, workingService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-			expect(envVars).toEqual(['API_KEY', 'SERVICE_URL']);
-		});
-
-		it('should handle services that return rejecting promises', async () => {
-			const asyncThrowingService = {
-				serviceName: 'asyncThrowing' as const,
-				async register({ envParser }) {
-					const config = envParser
-						.create((get) => ({
-							secret: get('AUTH_SECRET').string(),
-							frontendUrl: get('FRONTEND_URL').string(),
-						}))
-						.parse();
-
-					// Simulate an async library that validates config
-					await Promise.resolve();
-					if (!config.frontendUrl) {
-						throw new Error('Frontend URL is required');
-					}
-
-					return { config };
-				},
-			} satisfies Service<'asyncThrowing', any>;
-
-			// Verify env vars are captured even when service rejects
-			const result = await sniffService(asyncThrowingService);
-			expect(result.envVars).toEqual(['AUTH_SECRET', 'FRONTEND_URL']);
-			expect(result.error).toBeDefined();
-			expect(result.error?.message).toBe('Frontend URL is required');
-
-			// Also verify via construct
-			const fn = f
-				.services([asyncThrowingService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-			expect(envVars).toEqual(['AUTH_SECRET', 'FRONTEND_URL']);
-		});
-
-		it('should handle services that create fire-and-forget rejecting promises (BetterAuth scenario)', async () => {
-			// This test uses the REAL better-auth library to verify that
-			// the sniffer gracefully handles libraries that create internal
-			// fire-and-forget promises which reject on invalid config
-			const { betterAuth } = await import('better-auth');
-
-			const betterAuthService = {
-				serviceName: 'auth' as const,
-				register({ envParser }) {
-					const config = envParser
-						.create((get) => ({
-							secret: get('BETTER_AUTH_SECRET').string(),
-							baseURL: get('BETTER_AUTH_URL').string(),
-							trustedOrigins: get('BETTER_AUTH_TRUSTED_ORIGINS').string(),
-						}))
-						.parse();
-
-					// When sniffer runs, config values are empty strings
-					// BetterAuth will create fire-and-forget promises that reject
-					// when it tries to validate trustedOrigins with new URL('')
-					const auth = betterAuth({
-						secret: config.secret,
-						baseURL: config.baseURL,
-						trustedOrigins: config.trustedOrigins
-							? config.trustedOrigins.split(',')
-							: [],
-						database: {
-							// Use memory adapter to avoid DB setup
-							type: 'sqlite',
-							url: ':memory:',
-						},
-					});
-
-					return auth;
-				},
-			} satisfies Service<'auth', any>;
-
-			// Verify env vars are captured even though BetterAuth's internal
-			// fire-and-forget promise will reject on invalid trustedOrigins
-			const result = await sniffService(betterAuthService);
-			expect(result.envVars).toEqual([
-				'BETTER_AUTH_SECRET',
-				'BETTER_AUTH_TRUSTED_ORIGINS',
-				'BETTER_AUTH_URL',
-			]);
-			// Synchronous registration succeeds
-			expect(result.error).toBeUndefined();
-			// But fire-and-forget rejections are captured from better-auth
-			expect(result.unhandledRejections.length).toBeGreaterThan(0);
-			// Log the actual errors for debugging visibility
-			console.log(
-				'Captured better-auth unhandled rejections:',
-				result.unhandledRejections.map((e) => e.message),
-			);
-
-			// Most importantly: the process should NOT crash from unhandled rejection
-			const fn = f
-				.services([betterAuthService])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-			expect(envVars).toEqual([
-				'BETTER_AUTH_SECRET',
-				'BETTER_AUTH_TRUSTED_ORIGINS',
-				'BETTER_AUTH_URL',
-			]);
-		});
-
-		it('should handle multiple problematic services without crashing', async () => {
-			const service1 = {
-				serviceName: 'service1' as const,
-				register({ envParser }) {
-					envParser.create((get) => ({
-						var1: get('VAR_1').string(),
-					}));
-					throw new Error('Service 1 failed');
-				},
-			} satisfies Service<'service1', any>;
-
-			const service2 = {
-				serviceName: 'service2' as const,
-				register({ envParser }) {
-					const config = envParser.create((get) => ({
-						var2: get('VAR_2').string(),
-					}));
-
-					// Fire-and-forget rejection
-					Promise.reject(new Error('Service 2 async error'));
-
-					return config;
-				},
-			} satisfies Service<'service2', any>;
-
-			const service3 = {
-				serviceName: 'service3' as const,
-				register({ envParser }) {
-					return envParser.create((get) => ({
-						var3: get('VAR_3').string(),
-					}));
-				},
-			} satisfies Service<'service3', any>;
-
-			// Verify individual services
-			const result1 = await sniffService(service1);
-			expect(result1.envVars).toEqual(['VAR_1']);
-			expect(result1.error?.message).toBe('Service 1 failed');
-
-			const result2 = await sniffService(service2);
-			expect(result2.envVars).toEqual(['VAR_2']);
-			// Fire-and-forget - no error captured
-			expect(result2.error).toBeUndefined();
-
-			const result3 = await sniffService(service3);
-			expect(result3.envVars).toEqual(['VAR_3']);
-			expect(result3.error).toBeUndefined();
-
-			// Verify all work together in construct
-			const fn = f
-				.services([service1, service2, service3])
-				.handle(async () => ({ success: true }));
-
-			const envVars = await fn.getEnvironment();
-			expect(envVars).toEqual(['VAR_1', 'VAR_2', 'VAR_3']);
-		});
-	});
-
-	describe('markOptional option', () => {
-		const dbService = {
-			serviceName: 'db' as const,
-			register({ envParser }) {
-				return envParser
-					.create((get) => ({
-						url: get('DATABASE_URL').string(),
-						pool: get('DB_POOL_SIZE').string().transform(Number).default(10),
-					}))
-					.parse();
-			},
-		} satisfies Service<'db', any>;
-
-		const authService = {
-			serviceName: 'auth' as const,
-			register({ envParser }) {
-				return envParser
-					.create((get) => ({
-						secret: get('JWT_SECRET').string(),
-						ttl: get('JWT_TTL').string().optional(),
-					}))
-					.parse();
-			},
-		} satisfies Service<'auth', any>;
-
-		it('returns plain var names when markOptional is false (default)', async () => {
-			const fn = f
-				.services([dbService])
-				.handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment()).toEqual([
-				'DATABASE_URL',
-				'DB_POOL_SIZE',
-			]);
-			expect(await fn.getEnvironment({ markOptional: false })).toEqual([
-				'DATABASE_URL',
-				'DB_POOL_SIZE',
-			]);
-		});
-
-		it('suffixes optional vars with ? when markOptional is true', async () => {
-			const fn = f
-				.services([dbService])
-				.handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment({ markOptional: true })).toEqual([
-				'DATABASE_URL',
-				'DB_POOL_SIZE?',
-			]);
-		});
-
-		it('marks vars with .optional() as optional', async () => {
-			const fn = f
-				.services([authService])
-				.handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment({ markOptional: true })).toEqual([
-				'JWT_SECRET',
-				'JWT_TTL?',
-			]);
-		});
-
-		it('marks optional vars across multiple services', async () => {
-			const fn = f
-				.services([dbService, authService])
-				.handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment({ markOptional: true })).toEqual([
-				'DATABASE_URL',
-				'DB_POOL_SIZE?',
-				'JWT_SECRET',
-				'JWT_TTL?',
-			]);
-		});
-
-		it('works on Endpoint constructs', async () => {
-			const endpoint = e
-				.services([dbService])
-				.get('/users')
-				.handle(async () => []);
-
-			expect(await endpoint.getEnvironment({ markOptional: true })).toEqual([
-				'DATABASE_URL',
-				'DB_POOL_SIZE?',
-			]);
-		});
-
-		it('works on Cron constructs', async () => {
-			const cron = c
-				.schedule('rate(1 hour)')
-				.services([authService])
-				.handle(async () => {});
-
-			expect(await cron.getEnvironment({ markOptional: true })).toEqual([
-				'JWT_SECRET',
-				'JWT_TTL?',
-			]);
-		});
-
-		it('required-only vars have no ? suffix', async () => {
-			const requiredOnly = {
-				serviceName: 'required' as const,
-				register({ envParser }) {
-					return envParser
-						.create((get) => ({
-							a: get('VAR_A').string(),
-							b: get('VAR_B').string(),
-						}))
-						.parse();
-				},
-			} satisfies Service<'required', any>;
-
-			const fn = f
-				.services([requiredOnly])
-				.handle(async () => ({ success: true }));
-
-			expect(await fn.getEnvironment({ markOptional: true })).toEqual([
-				'VAR_A',
-				'VAR_B',
-			]);
-		});
-	});
-});