@geekmidas/cli 0.18.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -15,6 +15,11 @@
       "import": "./dist/config.mjs",
       "require": "./dist/config.cjs"
     },
+    "./workspace": {
+      "types": "./dist/workspace/index.d.ts",
+      "import": "./dist/workspace/index.mjs",
+      "require": "./dist/workspace/index.cjs"
+    },
     "./openapi": {
       "types": "./dist/openapi.d.ts",
       "import": "./dist/openapi.mjs",
@@ -53,11 +58,11 @@
     "@geekmidas/testkit": "0.6.0"
   },
   "peerDependencies": {
-    "@geekmidas/constructs": "~0.6.0",
     "@geekmidas/envkit": "~0.4.0",
+    "@geekmidas/logger": "~0.4.0",
+    "@geekmidas/constructs": "~0.6.0",
     "@geekmidas/schema": "~0.1.0",
-    "@geekmidas/telescope": "~0.4.0",
-    "@geekmidas/logger": "~0.4.0"
+    "@geekmidas/telescope": "~0.4.0"
   },
   "peerDependenciesMeta": {
     "@geekmidas/telescope": {

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

@@ -0,0 +1,215 @@
+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: 'frontend',
+				success: false,
+				error: 'Build failed',
+			};
+
+			expect(result.appName).toBe('web');
+			expect(result.type).toBe('frontend');
+			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: 'frontend',
+						path: 'apps/web',
+						port: 3002,
+						dependencies: ['api', 'auth'],
+						framework: 'nextjs',
+					},
+					admin: {
+						type: 'frontend',
+						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 === 'frontend');
+
+			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: 'frontend',
+						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 === 'frontend' ? '.next' : '.gkm',
+			);
+			expect(frontendOutputPath).toBe('/workspace/apps/web/.next');
+		});
+	});
+});

package/src/build/index.ts

@@ -1,10 +1,12 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import type { Cron } from '@geekmidas/constructs/crons';
 import type { Endpoint } from '@geekmidas/constructs/endpoints';
 import type { Function } from '@geekmidas/constructs/functions';
 import type { Subscriber } from '@geekmidas/constructs/subscribers';
-import { loadConfig, parseModuleConfig } from '../config';
+import { loadConfig, loadWorkspaceConfig, parseModuleConfig } from '../config';
 import {
 	getProductionConfigFromGkm,
 	normalizeHooksConfig,
@@ -25,6 +27,11 @@ import type {
 	LegacyProvider,
 	RouteInfo,
 } from '../types';
+import {
+	getAppBuildOrder,
+	type NormalizedAppConfig,
+	type NormalizedWorkspace,
+} from '../workspace/index.js';
 import {
 	generateAwsManifest,
 	generateServerManifest,
@@ -38,6 +45,16 @@ const logger = console;
 export async function buildCommand(
 	options: BuildOptions,
 ): Promise<BuildResult> {
+	// Load config with workspace detection
+	const loadedConfig = await loadWorkspaceConfig();
+
+	// Route to workspace build mode for multi-app workspaces
+	if (loadedConfig.type === 'workspace') {
+		logger.log('📦 Detected workspace configuration');
+		return workspaceBuildCommand(loadedConfig.workspace, options);
+	}
+
+	// Single-app build - use existing logic
 	const config = await loadConfig();
 
 	// Resolve providers from new config format
@@ -299,3 +316,174 @@ async function buildForProvider(
 
 	return {};
 }
+
+/**
+ * Result of building a single app in a workspace.
+ */
+export interface AppBuildResult {
+	appName: string;
+	type: 'backend' | 'frontend';
+	success: boolean;
+	outputPath?: string;
+	error?: string;
+}
+
+/**
+ * Result of workspace build command.
+ */
+export interface WorkspaceBuildResult extends BuildResult {
+	apps: AppBuildResult[];
+}
+
+/**
+ * Detect available package manager.
+ * @internal Exported for testing
+ */
+export function detectPackageManager(): 'pnpm' | 'npm' | 'yarn' {
+	if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+	if (existsSync('yarn.lock')) return 'yarn';
+	return 'npm';
+}
+
+/**
+ * Get the turbo command for running builds.
+ * @internal Exported for testing
+ */
+export function getTurboCommand(
+	pm: 'pnpm' | 'npm' | 'yarn',
+	filter?: string,
+): string {
+	const filterArg = filter ? ` --filter=${filter}` : '';
+	switch (pm) {
+		case 'pnpm':
+			return `pnpm exec turbo run build${filterArg}`;
+		case 'yarn':
+			return `yarn turbo run build${filterArg}`;
+		case 'npm':
+			return `npx turbo run build${filterArg}`;
+	}
+}
+
+/**
+ * Build all apps in a workspace using Turbo for dependency-ordered parallel builds.
+ * @internal Exported for testing
+ */
+export async function workspaceBuildCommand(
+	workspace: NormalizedWorkspace,
+	options: BuildOptions,
+): Promise<WorkspaceBuildResult> {
+	const results: AppBuildResult[] = [];
+	const apps = Object.entries(workspace.apps);
+	const backendApps = apps.filter(([, app]) => app.type === 'backend');
+	const frontendApps = apps.filter(([, app]) => app.type === 'frontend');
+
+	logger.log(`\n🏗️  Building workspace: ${workspace.name}`);
+	logger.log(
+		`   Backend apps: ${backendApps.map(([name]) => name).join(', ') || 'none'}`,
+	);
+	logger.log(
+		`   Frontend apps: ${frontendApps.map(([name]) => name).join(', ') || 'none'}`,
+	);
+
+	if (options.production) {
+		logger.log(`   🏭 Production mode enabled`);
+	}
+
+	// Get build order (topologically sorted by dependencies)
+	const buildOrder = getAppBuildOrder(workspace);
+	logger.log(`   Build order: ${buildOrder.join(' → ')}`);
+
+	// Use Turbo for parallel builds with dependency awareness
+	const pm = detectPackageManager();
+	logger.log(`\n📦 Using ${pm} with Turbo for parallel builds...\n`);
+
+	try {
+		// Run turbo build which handles dependency ordering and parallelization
+		const turboCommand = getTurboCommand(pm);
+		logger.log(`Running: ${turboCommand}`);
+
+		await new Promise<void>((resolve, reject) => {
+			const child = spawn(turboCommand, {
+				shell: true,
+				cwd: workspace.root,
+				stdio: 'inherit',
+				env: {
+					...process.env,
+					// Pass production flag to builds
+					NODE_ENV: options.production ? 'production' : 'development',
+				},
+			});
+
+			child.on('close', (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(new Error(`Turbo build failed with exit code ${code}`));
+				}
+			});
+
+			child.on('error', (err) => {
+				reject(err);
+			});
+		});
+
+		// Mark all apps as successful
+		for (const [appName, app] of apps) {
+			const outputPath = getAppOutputPath(workspace, appName, app);
+			results.push({
+				appName,
+				type: app.type,
+				success: true,
+				outputPath,
+			});
+		}
+
+		logger.log(`\n✅ Workspace build complete!`);
+
+		// Summary
+		logger.log(`\n📋 Build Summary:`);
+		for (const result of results) {
+			const icon = result.type === 'backend' ? '⚙️' : '🌐';
+			logger.log(
+				`   ${icon} ${result.appName}: ${result.outputPath || 'built'}`,
+			);
+		}
+	} catch (error) {
+		const errorMessage =
+			error instanceof Error ? error.message : 'Build failed';
+		logger.log(`\n❌ Build failed: ${errorMessage}`);
+
+		// Mark all apps as failed
+		for (const [appName, app] of apps) {
+			results.push({
+				appName,
+				type: app.type,
+				success: false,
+				error: errorMessage,
+			});
+		}
+
+		throw error;
+	}
+
+	return { apps: results };
+}
+
+/**
+ * Get the output path for a built app.
+ */
+function getAppOutputPath(
+	workspace: NormalizedWorkspace,
+	_appName: string,
+	app: NormalizedAppConfig,
+): string {
+	const appPath = join(workspace.root, app.path);
+
+	if (app.type === 'frontend') {
+		// Next.js standalone output
+		return join(appPath, '.next');
+	} else {
+		// Backend .gkm output
+		return join(appPath, '.gkm');
+	}
+}

package/src/config.ts

@@ -1,8 +1,16 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import type { GkmConfig } from './types.ts';
+import type { GkmConfig } from './types.js';
+import {
+	isWorkspaceConfig,
+	type LoadedConfig,
+	processConfig,
+	type WorkspaceConfig,
+} from './workspace/index.js';
 
-export type { GkmConfig } from './types.ts';
+export type { GkmConfig } from './types.js';
+export type { LoadedConfig, WorkspaceConfig } from './workspace/index.js';
+export { defineWorkspace } from './workspace/index.js';
 /**
  * Define GKM configuration with full TypeScript support.
  * This is an identity function that provides type safety and autocomplete.
@@ -62,32 +70,81 @@ export function parseModuleConfig(
 	return { path, importPattern };
 }
 
-export async function loadConfig(
-	cwd: string = process.cwd(),
-): Promise<GkmConfig> {
+/**
+ * Find and return the path to the config file.
+ */
+function findConfigPath(cwd: string): string {
 	const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
-	let configPath = '';
 
 	for (const file of files) {
 		const path = join(cwd, file);
 		if (existsSync(path)) {
-			configPath = path;
-			break;
+			return path;
 		}
 	}
 
-	if (!configPath) {
-		throw new Error(
-			'Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.',
-		);
-	}
+	throw new Error(
+		'Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.',
+	);
+}
+
+/**
+ * Load raw configuration from file.
+ */
+async function loadRawConfig(
+	cwd: string,
+): Promise<GkmConfig | WorkspaceConfig> {
+	const configPath = findConfigPath(cwd);
 
 	try {
 		const config = await import(configPath);
 		return config.default;
 	} catch (error) {
+		throw new Error(`Failed to load config: ${(error as Error).message}`);
+	}
+}
+
+/**
+ * Load configuration file (single-app format).
+ * For backwards compatibility with existing code.
+ *
+ * @deprecated Use loadWorkspaceConfig for new code
+ */
+export async function loadConfig(
+	cwd: string = process.cwd(),
+): Promise<GkmConfig> {
+	const config = await loadRawConfig(cwd);
+
+	// If it's a workspace config, throw an error
+	if (isWorkspaceConfig(config)) {
 		throw new Error(
-			`Failed to load gkm.config.json: ${(error as Error).message}`,
+			'Workspace configuration detected. Use loadWorkspaceConfig() instead.',
 		);
 	}
+
+	return config;
+}
+
+/**
+ * Load configuration file and process it as a workspace.
+ * Works with both single-app and workspace configurations.
+ *
+ * Single-app configs are automatically wrapped as a workspace with one app.
+ *
+ * @example
+ * ```ts
+ * const { type, workspace } = await loadWorkspaceConfig();
+ *
+ * if (type === 'workspace') {
+ *   console.log('Multi-app workspace:', workspace.apps);
+ * } else {
+ *   console.log('Single app wrapped as workspace');
+ * }
+ * ```
+ */
+export async function loadWorkspaceConfig(
+	cwd: string = process.cwd(),
+): Promise<LoadedConfig> {
+	const config = await loadRawConfig(cwd);
+	return processConfig(config, cwd);
 }

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

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import type { GkmConfig } from '../../types';
 import {
 	getAppNameFromCwd,