@geekmidas/cli 0.12.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,7 +1,8 @@
-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';
+import type { Construct } from '@geekmidas/constructs';
 
 export interface BundleOptions {
 	/** Entry point file (e.g., .gkm/server/server.ts) */
@@ -16,6 +17,14 @@ export interface BundleOptions {
 	external: string[];
 	/** Stage for secrets injection (optional) */
 	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 {
@@ -25,16 +34,58 @@ export interface BundleResult {
 	masterKey?: string;
 }
 
+/**
+ * Collect all required environment variables from constructs.
+ * Uses the SnifferEnvironmentParser to detect which env vars each service needs.
+ *
+ * @param constructs - Array of constructs to analyze
+ * @returns Deduplicated array of required environment variable names
+ */
+async function collectRequiredEnvVars(
+	constructs: Construct[],
+): Promise<string[]> {
+	const allEnvVars = new Set<string>();
+
+	for (const construct of constructs) {
+		const envVars = await construct.getEnvironment();
+		envVars.forEach((v) => allEnvVars.add(v));
+	}
+
+	return Array.from(allEnvVars).sort();
+}
+
 /**
  * Bundle the server application using tsdown
  *
  * @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> {
-	const { entryPoint, outputDir, minify, sourcemap, external, stage } = options;
+	const {
+		entryPoint,
+		outputDir,
+		minify,
+		sourcemap,
+		external,
+		stage,
+		constructs,
+		dockerServices,
+	} = options;
 
 	// Ensure output directory exists
 	await mkdir(outputDir, { recursive: true });
@@ -76,9 +127,11 @@ export async function bundleServer(
 	let masterKey: string | undefined;
 
 	if (stage) {
-		const { readStageSecrets, toEmbeddableSecrets } = await import(
-			'../secrets/storage'
-		);
+		const {
+			readStageSecrets,
+			toEmbeddableSecrets,
+			validateEnvironmentVariables,
+		} = await import('../secrets/storage');
 		const { encryptSecrets, generateDefineOptions } = await import(
 			'../secrets/encryption'
 		);
@@ -91,15 +144,69 @@ 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...');
+			const requiredVars = await collectRequiredEnvVars(constructs);
+
+			if (requiredVars.length > 0) {
+				const validation = validateEnvironmentVariables(requiredVars, secrets);
+
+				if (!validation.valid) {
+					const errorMessage = [
+						`Missing environment variables for stage "${stage}":`,
+						'',
+						...validation.missing.map((v) => `  ❌ ${v}`),
+						'',
+						'To fix this, either:',
+						`  1. Add the missing variables to .gkm/secrets/${stage}.json using:`,
+						`     gkm secrets:set <KEY> <VALUE> --stage ${stage}`,
+						'',
+						`  2. Or import from a JSON file:`,
+						`     gkm secrets:import secrets.json --stage ${stage}`,
+						'',
+						'Required variables:',
+						...validation.required.map((v) =>
+							validation.missing.includes(v) ? `  ❌ ${v}` : `  ✓ ${v}`,
+						),
+					].join('\n');
+
+					throw new Error(errorMessage);
+				}
+
+				console.log(
+					`  ✓ All ${requiredVars.length} required environment variables found`,
+				);
+			}
+		}
+
 		// Convert to embeddable format and encrypt
 		const embeddable = toEmbeddableSecrets(secrets);
 		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}"`);
@@ -109,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
@@ -236,6 +253,18 @@ async function buildForProvider(
 		if (context.production?.bundle && !skipBundle) {
 			logger.log(`\n📦 Bundling production server...`);
 			const { bundleServer } = await import('./bundler');
+
+			// Collect all constructs for environment variable validation
+			const allConstructs = [
+				...endpoints.map((e) => e.construct),
+				...functions.map((f) => f.construct),
+				...crons.map((c) => c.construct),
+				...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'),
@@ -243,6 +272,8 @@ async function buildForProvider(
 				sourcemap: false,
 				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 {