@geekmidas/cli 0.13.0 → 0.14.0

package/src/build/__tests__/handler-templates.spec.ts

@@ -0,0 +1,272 @@
+import { describe, expect, it } from 'vitest';
+import type { EndpointAnalysis, EndpointFeatures } from '../endpoint-analyzer';
+import {
+	generateOptimizedImports,
+	generateValidatorFactories,
+} from '../handler-templates';
+
+// Helper to create endpoint features
+function createFeatures(
+	overrides: Partial<EndpointFeatures> = {},
+): EndpointFeatures {
+	return {
+		hasAuth: false,
+		hasServices: false,
+		hasDatabase: false,
+		hasBodyValidation: false,
+		hasQueryValidation: false,
+		hasParamValidation: false,
+		hasAudits: false,
+		hasEvents: false,
+		hasRateLimit: false,
+		hasRls: false,
+		hasOutputValidation: false,
+		...overrides,
+	};
+}
+
+// Helper to create analysis
+function createAnalysis(
+	overrides: Partial<EndpointAnalysis> = {},
+): EndpointAnalysis {
+	return {
+		route: '/test',
+		method: 'GET',
+		exportName: 'testEndpoint',
+		tier: 'minimal',
+		serviceNames: [],
+		features: createFeatures(),
+		...overrides,
+	};
+}
+
+describe('handler-templates', () => {
+	describe('generateOptimizedImports', () => {
+		it('should always include base imports', () => {
+			const result = generateOptimizedImports([]);
+
+			expect(result).toContain('import type { EnvironmentParser }');
+			expect(result).toContain('import type { Logger }');
+			expect(result).toContain('import type { Hono }');
+			expect(result).toContain('import { Endpoint }');
+		});
+
+		it('should include validator import when body validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasBodyValidation: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { validator }');
+		});
+
+		it('should include validator import when query validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasQueryValidation: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { validator }');
+		});
+
+		it('should include validator import when param validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasParamValidation: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { validator }');
+		});
+
+		it('should include ResponseBuilder for standard tier', () => {
+			const analyses = [
+				createAnalysis({
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { ResponseBuilder }');
+		});
+
+		it('should include ResponseBuilder for full tier', () => {
+			const analyses = [
+				createAnalysis({
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { ResponseBuilder }');
+		});
+
+		it('should include ServiceDiscovery when services are used', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasServices: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { ServiceDiscovery }');
+		});
+
+		it('should include ServiceDiscovery when database is used', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasDatabase: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { ServiceDiscovery }');
+		});
+
+		it('should include events import when events are used', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasEvents: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { publishConstructEvents }');
+		});
+
+		it('should include audit imports when audits are used', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('createAuditContext');
+			expect(result).toContain('withAuditableEndpointTransaction');
+		});
+
+		it('should include createError when rate limiting is used', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasRateLimit: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('import { createError }');
+		});
+
+		it('should include RLS imports when RLS is used', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasRls: true }),
+				}),
+			];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).toContain('withRlsContext');
+			expect(result).toContain('extractRlsContext');
+		});
+
+		it('should not include optional imports when not needed', () => {
+			const analyses = [createAnalysis()];
+
+			const result = generateOptimizedImports(analyses);
+			expect(result).not.toContain('import { validator }');
+			expect(result).not.toContain('ServiceDiscovery');
+			expect(result).not.toContain('publishConstructEvents');
+			expect(result).not.toContain('createAuditContext');
+			expect(result).not.toContain('createError');
+			expect(result).not.toContain('withRlsContext');
+		});
+	});
+
+	describe('generateValidatorFactories', () => {
+		it('should return empty string when no validation needed', () => {
+			const result = generateValidatorFactories([createAnalysis()]);
+			expect(result).toBe('');
+		});
+
+		it('should generate body validator when body validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasBodyValidation: true }),
+				}),
+			];
+
+			const result = generateValidatorFactories(analyses);
+			expect(result).toContain('validateBody');
+			expect(result).toContain("validator('json'");
+			expect(result).toContain('endpoint.input?.body');
+		});
+
+		it('should generate query validator when query validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasQueryValidation: true }),
+				}),
+			];
+
+			const result = generateValidatorFactories(analyses);
+			expect(result).toContain('validateQuery');
+			expect(result).toContain("validator('query'");
+			expect(result).toContain('endpoint.input?.query');
+		});
+
+		it('should generate params validator when param validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({ hasParamValidation: true }),
+				}),
+			];
+
+			const result = generateValidatorFactories(analyses);
+			expect(result).toContain('validateParams');
+			expect(result).toContain("validator('param'");
+			expect(result).toContain('endpoint.input?.params');
+		});
+
+		it('should generate all validators when all validation types needed', () => {
+			const analyses = [
+				createAnalysis({
+					features: createFeatures({
+						hasBodyValidation: true,
+						hasQueryValidation: true,
+						hasParamValidation: true,
+					}),
+				}),
+			];
+
+			const result = generateValidatorFactories(analyses);
+			expect(result).toContain('validateBody');
+			expect(result).toContain('validateQuery');
+			expect(result).toContain('validateParams');
+		});
+
+		it('should handle multiple endpoints with different validation', () => {
+			const analyses = [
+				createAnalysis({
+					exportName: 'endpoint1',
+					features: createFeatures({ hasBodyValidation: true }),
+				}),
+				createAnalysis({
+					exportName: 'endpoint2',
+					features: createFeatures({ hasQueryValidation: true }),
+				}),
+			];
+
+			const result = generateValidatorFactories(analyses);
+			expect(result).toContain('validateBody');
+			expect(result).toContain('validateQuery');
+			expect(result).not.toContain('validateParams');
+		});
+	});
+});

package/src/build/bundler.ts

@@ -1,4 +1,4 @@
-import { execSync } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { mkdir, rename, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -19,6 +19,12 @@ export interface BundleOptions {
 	stage?: string;
 	/** Constructs to validate environment variables for */
 	constructs?: Construct[];
+	/** Docker compose services configured (for auto-populating env vars) */
+	dockerServices?: {
+		postgres?: boolean;
+		redis?: boolean;
+		rabbitmq?: boolean;
+	};
 }
 
 export interface BundleResult {
@@ -54,6 +60,19 @@ async function collectRequiredEnvVars(
  * @param options - Bundle configuration options
  * @returns Bundle result with output path and optional master key
  */
+/** Default env var values for docker compose services */
+const DOCKER_SERVICE_ENV_VARS: Record<string, Record<string, string>> = {
+	postgres: {
+		DATABASE_URL: 'postgresql://postgres:postgres@postgres:5432/app',
+	},
+	redis: {
+		REDIS_URL: 'redis://redis:6379',
+	},
+	rabbitmq: {
+		RABBITMQ_URL: 'amqp://rabbitmq:5672',
+	},
+};
+
 export async function bundleServer(
 	options: BundleOptions,
 ): Promise<BundleResult> {
@@ -65,6 +84,7 @@ export async function bundleServer(
 		external,
 		stage,
 		constructs,
+		dockerServices,
 	} = options;
 
 	// Ensure output directory exists
@@ -124,6 +144,24 @@ export async function bundleServer(
 			);
 		}
 
+		// Auto-populate env vars from docker compose services
+		if (dockerServices) {
+			for (const [service, enabled] of Object.entries(dockerServices)) {
+				if (enabled && DOCKER_SERVICE_ENV_VARS[service]) {
+					for (const [envVar, defaultValue] of Object.entries(
+						DOCKER_SERVICE_ENV_VARS[service],
+					)) {
+						// Check if not already in urls or custom
+						const urlKey = envVar as keyof typeof secrets.urls;
+						if (!secrets.urls[urlKey] && !secrets.custom[envVar]) {
+							secrets.urls[urlKey] = defaultValue;
+							console.log(`  Auto-populated ${envVar} from docker compose`);
+						}
+					}
+				}
+			}
+		}
+
 		// Validate environment variables if constructs are provided
 		if (constructs && constructs.length > 0) {
 			console.log('  Analyzing environment variable requirements...');
@@ -165,10 +203,10 @@ export async function bundleServer(
 		const encrypted = encryptSecrets(embeddable);
 		masterKey = encrypted.masterKey;
 
-		// Add define options for build-time injection
+		// Add define options for build-time injection using tsdown's --env.* format
 		const defines = generateDefineOptions(encrypted);
 		for (const [key, value] of Object.entries(defines)) {
-			args.push('--define', `${key}=${value}`);
+			args.push(`--env.${key}`, value);
 		}
 
 		console.log(`  Secrets encrypted for stage "${stage}"`);
@@ -178,11 +216,22 @@ export async function bundleServer(
 
 	try {
 		// Run tsdown with command-line arguments
-		execSync(args.join(' '), {
+		// Use spawnSync with args array to avoid shell escaping issues with --define values
+		// args is always populated with ['npx', 'tsdown', ...] so cmd is never undefined
+		const [cmd, ...cmdArgs] = args as [string, ...string[]];
+		const result = spawnSync(cmd, cmdArgs, {
 			cwd: process.cwd(),
 			stdio: 'inherit',
+			shell: process.platform === 'win32', // Only use shell on Windows for npx resolution
 		});
 
+		if (result.error) {
+			throw result.error;
+		}
+		if (result.status !== 0) {
+			throw new Error(`tsdown exited with code ${result.status}`);
+		}
+
 		// Rename output to .mjs for explicit ESM
 		// tsdown outputs as server.js for ESM format
 		const jsOutput = join(outputDir, 'server.js');

package/src/build/index.ts

@@ -93,6 +93,22 @@ export async function buildCommand(
 		logger.log(`🪝 Server hooks enabled`);
 	}
 
+	// Extract docker compose services for env var auto-population
+	const services = config.docker?.compose?.services;
+	const dockerServices = services
+		? Array.isArray(services)
+			? {
+					postgres: services.includes('postgres'),
+					redis: services.includes('redis'),
+					rabbitmq: services.includes('rabbitmq'),
+				}
+			: {
+					postgres: Boolean(services.postgres),
+					redis: Boolean(services.redis),
+					rabbitmq: Boolean(services.rabbitmq),
+				}
+		: undefined;
+
 	const buildContext: BuildContext = {
 		envParserPath,
 		envParserImportPattern,
@@ -102,6 +118,7 @@ export async function buildCommand(
 		studio,
 		hooks,
 		production,
+		dockerServices,
 	};
 
 	// Initialize generators
@@ -245,6 +262,9 @@ async function buildForProvider(
 				...subscribers.map((s) => s.construct),
 			];
 
+			// Get docker compose services for auto-populating env vars
+			const dockerServices = context.dockerServices;
+
 			const bundleResult = await bundleServer({
 				entryPoint: join(outputDir, 'server.ts'),
 				outputDir: join(outputDir, 'dist'),
@@ -253,6 +273,7 @@ async function buildForProvider(
 				external: context.production.external,
 				stage,
 				constructs: allConstructs,
+				dockerServices,
 			});
 			masterKey = bundleResult.masterKey;
 			logger.log(`✅ Bundle complete: .gkm/server/dist/server.mjs`);

package/src/build/types.ts

@@ -84,6 +84,12 @@ export interface BuildContext {
 	hooks?: NormalizedHooksConfig;
 	/** Production build configuration */
 	production?: NormalizedProductionConfig;
+	/** Docker compose services for auto-populating env vars */
+	dockerServices?: {
+		postgres?: boolean;
+		redis?: boolean;
+		rabbitmq?: boolean;
+	};
 }
 
 export interface ProviderBuildResult {