@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/build/__tests__/workspace-build.spec.ts

@@ -1,215 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import type { NormalizedWorkspace } from '../../workspace/types.js';
-import {
-	type AppBuildResult,
-	detectPackageManager,
-	getTurboCommand,
-} from '../index.js';
-
-describe('Workspace Build Command', () => {
-	describe('detectPackageManager', () => {
-		let testDir: string;
-		let originalCwd: string;
-
-		beforeEach(() => {
-			testDir = join(
-				tmpdir(),
-				`gkm-build-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-			);
-			mkdirSync(testDir, { recursive: true });
-			originalCwd = process.cwd();
-			process.chdir(testDir);
-		});
-
-		afterEach(() => {
-			process.chdir(originalCwd);
-			if (testDir) {
-				rmSync(testDir, { recursive: true, force: true });
-			}
-		});
-
-		it('should detect pnpm from lock file', () => {
-			writeFileSync(join(testDir, 'pnpm-lock.yaml'), '');
-			expect(detectPackageManager()).toBe('pnpm');
-		});
-
-		it('should detect yarn from lock file', () => {
-			writeFileSync(join(testDir, 'yarn.lock'), '');
-			expect(detectPackageManager()).toBe('yarn');
-		});
-
-		it('should default to npm when no lock file exists', () => {
-			expect(detectPackageManager()).toBe('npm');
-		});
-
-		it('should prefer pnpm over yarn when both exist', () => {
-			writeFileSync(join(testDir, 'pnpm-lock.yaml'), '');
-			writeFileSync(join(testDir, 'yarn.lock'), '');
-			expect(detectPackageManager()).toBe('pnpm');
-		});
-	});
-
-	describe('getTurboCommand', () => {
-		it('should generate pnpm turbo command', () => {
-			expect(getTurboCommand('pnpm')).toBe('pnpm exec turbo run build');
-		});
-
-		it('should generate yarn turbo command', () => {
-			expect(getTurboCommand('yarn')).toBe('yarn turbo run build');
-		});
-
-		it('should generate npm turbo command', () => {
-			expect(getTurboCommand('npm')).toBe('npx turbo run build');
-		});
-
-		it('should add filter argument when provided', () => {
-			expect(getTurboCommand('pnpm', 'api')).toBe(
-				'pnpm exec turbo run build --filter=api',
-			);
-		});
-
-		it('should add filter for yarn', () => {
-			expect(getTurboCommand('yarn', 'web')).toBe(
-				'yarn turbo run build --filter=web',
-			);
-		});
-
-		it('should add filter for npm', () => {
-			expect(getTurboCommand('npm', '@myapp/api')).toBe(
-				'npx turbo run build --filter=@myapp/api',
-			);
-		});
-	});
-
-	describe('AppBuildResult type', () => {
-		it('should have correct structure for successful build', () => {
-			const result: AppBuildResult = {
-				appName: 'api',
-				type: 'backend',
-				success: true,
-				outputPath: '/path/to/.gkm',
-			};
-
-			expect(result.appName).toBe('api');
-			expect(result.type).toBe('backend');
-			expect(result.success).toBe(true);
-			expect(result.outputPath).toBe('/path/to/.gkm');
-			expect(result.error).toBeUndefined();
-		});
-
-		it('should have correct structure for failed build', () => {
-			const result: AppBuildResult = {
-				appName: 'web',
-				type: 'web',
-				success: false,
-				error: 'Build failed',
-			};
-
-			expect(result.appName).toBe('web');
-			expect(result.type).toBe('web');
-			expect(result.success).toBe(false);
-			expect(result.error).toBe('Build failed');
-			expect(result.outputPath).toBeUndefined();
-		});
-	});
-
-	describe('workspace build integration', () => {
-		it('should correctly categorize apps by type', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test-workspace',
-				root: '/test',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-						routes: './src/**/*.ts',
-					},
-					auth: {
-						type: 'backend',
-						path: 'apps/auth',
-						port: 3001,
-						dependencies: [],
-						routes: './src/**/*.ts',
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3002,
-						dependencies: ['api', 'auth'],
-						framework: 'nextjs',
-					},
-					admin: {
-						type: 'web',
-						path: 'apps/admin',
-						port: 3003,
-						dependencies: ['api'],
-						framework: 'nextjs',
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			const apps = Object.entries(workspace.apps);
-			const backendApps = apps.filter(([, app]) => app.type === 'backend');
-			const frontendApps = apps.filter(([, app]) => app.type === 'web');
-
-			expect(backendApps).toHaveLength(2);
-			expect(frontendApps).toHaveLength(2);
-			expect(backendApps.map(([name]) => name)).toContain('api');
-			expect(backendApps.map(([name]) => name)).toContain('auth');
-			expect(frontendApps.map(([name]) => name)).toContain('web');
-			expect(frontendApps.map(([name]) => name)).toContain('admin');
-		});
-
-		it('should generate correct output paths for different app types', () => {
-			const workspace: NormalizedWorkspace = {
-				name: 'test',
-				root: '/workspace',
-				apps: {
-					api: {
-						type: 'backend',
-						path: 'apps/api',
-						port: 3000,
-						dependencies: [],
-					},
-					web: {
-						type: 'web',
-						path: 'apps/web',
-						port: 3001,
-						dependencies: [],
-					},
-				},
-				services: {},
-				deploy: { default: 'dokploy' },
-				shared: { packages: [] },
-				secrets: {},
-			};
-
-			// Test that backend apps output to .gkm
-			const backendApp = workspace.apps.api!;
-			const backendOutputPath = join(
-				workspace.root,
-				backendApp.path,
-				backendApp.type === 'backend' ? '.gkm' : '.next',
-			);
-			expect(backendOutputPath).toBe('/workspace/apps/api/.gkm');
-
-			// Test that frontend apps output to .next
-			const frontendApp = workspace.apps.web!;
-			const frontendOutputPath = join(
-				workspace.root,
-				frontendApp.path,
-				frontendApp.type === 'web' ? '.next' : '.gkm',
-			);
-			expect(frontendOutputPath).toBe('/workspace/apps/web/.next');
-		});
-	});
-});

package/src/build/bundler.ts

@@ -1,256 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { Construct } from '@geekmidas/constructs';
-
-/**
- * Banner to inject into ESM bundle for CJS compatibility.
- * Creates a `require` function using Node's createRequire for packages
- * that internally use CommonJS require() for Node builtins.
- */
-const ESM_CJS_COMPAT_BANNER =
-	'import { createRequire } from "module"; const require = createRequire(import.meta.url);';
-
-export interface BundleOptions {
-	/** Entry point file (e.g., .gkm/server/server.ts) */
-	entryPoint: string;
-	/** Output directory for bundled files */
-	outputDir: string;
-	/** Minify the output (default: true) */
-	minify: boolean;
-	/** Generate sourcemaps (default: false) */
-	sourcemap: boolean;
-	/** Packages to exclude from bundling */
-	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 {
-	/** Path to the bundled output */
-	outputPath: string;
-	/** Ephemeral master key for deployment (only if stage was provided) */
-	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 esbuild.
- * Creates a fully standalone bundle with all dependencies included.
- *
- * @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,
-		constructs,
-		dockerServices,
-	} = options;
-
-	// Ensure output directory exists
-	await mkdir(outputDir, { recursive: true });
-
-	const mjsOutput = join(outputDir, 'server.mjs');
-
-	// Build command-line arguments for esbuild
-	const args = [
-		'npx',
-		'esbuild',
-		entryPoint,
-		'--bundle',
-		'--platform=node',
-		'--target=node22',
-		'--format=esm',
-		`--outfile=${mjsOutput}`,
-		'--packages=bundle', // Bundle all dependencies for standalone output
-		`--banner:js=${ESM_CJS_COMPAT_BANNER}`, // CJS compatibility for packages like pino
-	];
-
-	if (minify) {
-		args.push('--minify');
-	}
-
-	if (sourcemap) {
-		args.push('--sourcemap');
-	}
-
-	// Add external packages (user-specified)
-	for (const ext of external) {
-		args.push(`--external:${ext}`);
-	}
-
-	// Handle secrets injection if stage is provided
-	let masterKey: string | undefined;
-
-	if (stage) {
-		const {
-			readStageSecrets,
-			toEmbeddableSecrets,
-			validateEnvironmentVariables,
-			initStageSecrets,
-			writeStageSecrets,
-		} = await import('../secrets/storage');
-		const { encryptSecrets, generateDefineOptions } = await import(
-			'../secrets/encryption'
-		);
-
-		let secrets = await readStageSecrets(stage);
-
-		if (!secrets) {
-			// 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
-		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 using esbuild's --define:KEY=VALUE format
-		const defines = generateDefineOptions(encrypted);
-		for (const [key, value] of Object.entries(defines)) {
-			args.push(`--define:${key}=${JSON.stringify(value)}`);
-		}
-
-		console.log(`  Secrets encrypted for stage "${stage}"`);
-	}
-
-	try {
-		// Run esbuild with command-line arguments
-		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(`esbuild exited with code ${result.status}`);
-		}
-
-		// Add shebang to the bundled file
-		const { readFile } = await import('node:fs/promises');
-		const content = await readFile(mjsOutput, 'utf-8');
-		if (!content.startsWith('#!')) {
-			await writeFile(mjsOutput, `#!/usr/bin/env node\n${content}`);
-		}
-	} catch (error) {
-		throw new Error(
-			`Failed to bundle server: ${error instanceof Error ? error.message : 'Unknown error'}`,
-		);
-	}
-
-	return {
-		outputPath: mjsOutput,
-		masterKey,
-	};
-}

package/src/build/endpoint-analyzer.ts

@@ -1,236 +0,0 @@
-/**
- * Endpoint Analyzer for Build-Time Feature Detection
- *
- * Analyzes endpoints at build time to determine their features and assign
- * optimization tiers. This enables generating specialized handler code
- * for maximum performance.
- */
-import type { Endpoint } from '@geekmidas/constructs/endpoints';
-
-/**
- * Features detected from an endpoint configuration
- */
-export interface EndpointFeatures {
-	hasAuth: boolean;
-	hasServices: boolean;
-	hasDatabase: boolean;
-	hasBodyValidation: boolean;
-	hasQueryValidation: boolean;
-	hasParamValidation: boolean;
-	hasAudits: boolean;
-	hasEvents: boolean;
-	hasRateLimit: boolean;
-	hasRls: boolean;
-	hasOutputValidation: boolean;
-}
-
-/**
- * Optimization tiers based on endpoint complexity
- *
- * - minimal: No auth, no services, no audits, no events - near-raw-Hono performance
- * - standard: Some features enabled - uses middleware composition
- * - full: Complex endpoints with many features - full handler chain
- */
-export type EndpointTier = 'minimal' | 'standard' | 'full';
-
-/**
- * Complete analysis of an endpoint for build-time optimization
- */
-export interface EndpointAnalysis {
-	route: string;
-	method: string;
-	exportName: string;
-	features: EndpointFeatures;
-	tier: EndpointTier;
-	serviceNames: string[];
-	databaseServiceName?: string;
-}
-
-/**
- * Analyze an endpoint to extract its features
- */
-export function analyzeEndpointFeatures(
-	endpoint: Endpoint<
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any
-	>,
-): EndpointFeatures {
-	return {
-		hasAuth: !!endpoint.authorizer,
-		hasServices: endpoint.services.length > 0,
-		hasDatabase: !!endpoint.databaseService,
-		hasBodyValidation: !!endpoint.input?.body,
-		hasQueryValidation: !!endpoint.input?.query,
-		hasParamValidation: !!endpoint.input?.params,
-		// Only declarative audits (.audit([...])) require full tier with transaction wrapping
-		// Having auditorStorageService just makes auditor available to handler (like other services)
-		hasAudits: (endpoint.audits?.length ?? 0) > 0,
-		hasEvents: (endpoint.events?.length ?? 0) > 0,
-		hasRateLimit: !!endpoint.rateLimit,
-		hasRls: !!endpoint.rlsConfig && !endpoint.rlsBypass,
-		hasOutputValidation: !!endpoint.outputSchema,
-	};
-}
-
-/**
- * Determine the optimization tier for an endpoint based on its features
- */
-export function determineEndpointTier(
-	features: EndpointFeatures,
-): EndpointTier {
-	const {
-		hasAuth,
-		hasServices,
-		hasDatabase,
-		hasAudits,
-		hasEvents,
-		hasRateLimit,
-		hasRls,
-	} = features;
-
-	// Minimal tier: No complex features
-	// These endpoints can use near-raw-Hono handlers
-	if (
-		!hasAuth &&
-		!hasServices &&
-		!hasDatabase &&
-		!hasAudits &&
-		!hasEvents &&
-		!hasRateLimit &&
-		!hasRls
-	) {
-		return 'minimal';
-	}
-
-	// Full tier: Has audits, RLS, or rate limiting (complex state management)
-	if (hasAudits || hasRls || hasRateLimit) {
-		return 'full';
-	}
-
-	// Standard tier: Auth and/or services, but no complex state
-	return 'standard';
-}
-
-/**
- * Perform complete analysis of an endpoint
- */
-export function analyzeEndpoint(
-	endpoint: Endpoint<
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any,
-		any
-	>,
-	exportName: string,
-): EndpointAnalysis {
-	const features = analyzeEndpointFeatures(endpoint);
-	const tier = determineEndpointTier(features);
-
-	return {
-		route: endpoint.route,
-		method: endpoint.method,
-		exportName,
-		features,
-		tier,
-		serviceNames: endpoint.services.map(
-			(s: { serviceName: string }) => s.serviceName,
-		),
-		databaseServiceName: endpoint.databaseService?.serviceName,
-	};
-}
-
-/**
- * Analyze multiple endpoints and return analysis results
- */
-export function analyzeEndpoints(
-	endpoints: Array<{
-		endpoint: Endpoint<
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any,
-			any
-		>;
-		exportName: string;
-	}>,
-): EndpointAnalysis[] {
-	return endpoints.map(({ endpoint, exportName }) =>
-		analyzeEndpoint(endpoint, exportName),
-	);
-}
-
-/**
- * Generate a summary of endpoint analysis for logging
- */
-export function summarizeAnalysis(analyses: EndpointAnalysis[]): {
-	total: number;
-	byTier: Record<EndpointTier, number>;
-	byFeature: Record<keyof EndpointFeatures, number>;
-} {
-	const byTier: Record<EndpointTier, number> = {
-		minimal: 0,
-		standard: 0,
-		full: 0,
-	};
-
-	const byFeature: Record<keyof EndpointFeatures, number> = {
-		hasAuth: 0,
-		hasServices: 0,
-		hasDatabase: 0,
-		hasBodyValidation: 0,
-		hasQueryValidation: 0,
-		hasParamValidation: 0,
-		hasAudits: 0,
-		hasEvents: 0,
-		hasRateLimit: 0,
-		hasRls: 0,
-		hasOutputValidation: 0,
-	};
-
-	for (const analysis of analyses) {
-		byTier[analysis.tier]++;
-
-		for (const [feature, enabled] of Object.entries(analysis.features)) {
-			if (enabled) {
-				byFeature[feature as keyof EndpointFeatures]++;
-			}
-		}
-	}
-
-	return {
-		total: analyses.length,
-		byTier,
-		byFeature,
-	};
-}