@geekmidas/cli 0.13.0 → 0.15.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
@@ -111,17 +131,39 @@ export async function bundleServer(
 			readStageSecrets,
 			toEmbeddableSecrets,
 			validateEnvironmentVariables,
+			initStageSecrets,
+			writeStageSecrets,
 		} = await import('../secrets/storage');
 		const { encryptSecrets, generateDefineOptions } = await import(
 			'../secrets/encryption'
 		);
 
-		const secrets = await readStageSecrets(stage);
+		let secrets = await readStageSecrets(stage);
 
 		if (!secrets) {
-			throw new Error(
-				`No secrets found for stage "${stage}". Run "gkm secrets:init --stage ${stage}" first.`,
-			);
+			// Auto-initialize secrets for the stage
+			console.log(`  Initializing secrets for stage "${stage}"...`);
+			secrets = initStageSecrets(stage);
+			await writeStageSecrets(secrets);
+			console.log(`  ✓ Created .gkm/secrets/${stage}.json`);
+		}
+
+		// 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
@@ -165,10 +207,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 +220,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 {

package/src/deploy/__tests__/docker.spec.ts

@@ -1,6 +1,11 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import type { GkmConfig } from '../../types';
-import { getImageRef, resolveDockerConfig } from '../docker';
+import {
+	getAppNameFromCwd,
+	getAppNameFromPackageJson,
+	getImageRef,
+	resolveDockerConfig,
+} from '../docker';
 
 describe('getImageRef', () => {
 	it('should return image with registry prefix', () => {
@@ -36,8 +41,26 @@ describe('getImageRef', () => {
 	});
 });
 
+describe('getAppNameFromCwd', () => {
+	it('should return app name from package.json in current directory', () => {
+		// Tests run from the monorepo root, so cwd is the root directory
+		const appName = getAppNameFromCwd();
+		// The root package.json has name "@geekmidas/toolbox", so it should strip the scope
+		expect(appName).toBe('toolbox');
+	});
+});
+
+describe('getAppNameFromPackageJson', () => {
+	it('should return app name from package.json adjacent to lockfile', () => {
+		// This test runs in the toolbox monorepo, so it should find the root package.json
+		const appName = getAppNameFromPackageJson();
+		// The root package.json has name "@geekmidas/toolbox", so it should strip the scope
+		expect(appName).toBe('toolbox');
+	});
+});
+
 describe('resolveDockerConfig', () => {
-	it('should return empty config when docker not configured', () => {
+	it('should fallback to package.json name when docker not configured', () => {
 		const config: GkmConfig = {
 			routes: './src/endpoints',
 			envParser: './src/env',
@@ -47,7 +70,8 @@ describe('resolveDockerConfig', () => {
 		const dockerConfig = resolveDockerConfig(config);
 
 		expect(dockerConfig.registry).toBeUndefined();
-		expect(dockerConfig.imageName).toBeUndefined();
+		// Should fallback to package.json name or 'app'
+		expect(dockerConfig.imageName).toBeDefined();
 	});
 
 	it('should return registry from docker config', () => {
@@ -97,7 +121,7 @@ describe('resolveDockerConfig', () => {
 		expect(dockerConfig.imageName).toBe('backend-api');
 	});
 
-	it('should handle empty docker object', () => {
+	it('should fallback to package.json name when docker object is empty', () => {
 		const config: GkmConfig = {
 			routes: './src/endpoints',
 			docker: {},
@@ -106,6 +130,20 @@ describe('resolveDockerConfig', () => {
 		const dockerConfig = resolveDockerConfig(config);
 
 		expect(dockerConfig.registry).toBeUndefined();
-		expect(dockerConfig.imageName).toBeUndefined();
+		// Should fallback to package.json name or 'app'
+		expect(dockerConfig.imageName).toBeDefined();
+	});
+
+	it('should prefer explicit imageName over package.json', () => {
+		const config: GkmConfig = {
+			routes: './src/endpoints',
+			docker: {
+				imageName: 'explicit-name',
+			},
+		};
+
+		const dockerConfig = resolveDockerConfig(config);
+
+		expect(dockerConfig.imageName).toBe('explicit-name');
 	});
 });