@geekmidas/cli 0.18.0 → 0.20.0

package/src/dev/__tests__/index.spec.ts

@@ -1,13 +1,24 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import type { AddressInfo } from 'node:net';
 import { createServer } from 'node:net';
-import { afterEach, describe, expect, it } from 'vitest';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type {
+	NormalizedAppConfig,
+	NormalizedWorkspace,
+} from '../../workspace/index.js';
 import {
+	checkPortConflicts,
 	findAvailablePort,
+	generateAllDependencyEnvVars,
 	isPortAvailable,
 	normalizeHooksConfig,
 	normalizeProductionConfig,
 	normalizeStudioConfig,
 	normalizeTelescopeConfig,
+	validateFrontendApp,
+	validateFrontendApps,
 } from '../index';
 
 // Skip port-related tests in CI due to flaky port binding issues
@@ -396,3 +407,563 @@ describe('normalizeProductionConfig', () => {
 		expect(result?.bundle).toBe(false);
 	});
 });
+
+describe('Workspace Dev Server', () => {
+	/**
+	 * Helper to create a test workspace configuration.
+	 * Automatically adds resolvedDeployTarget to each app.
+	 */
+	function createTestWorkspace(
+		apps: Record<string, Omit<NormalizedAppConfig, 'resolvedDeployTarget'>>,
+		overrides: Partial<NormalizedWorkspace> = {},
+	): NormalizedWorkspace {
+		const appsWithDeployTarget: NormalizedWorkspace['apps'] = {};
+		for (const [name, app] of Object.entries(apps)) {
+			appsWithDeployTarget[name] = {
+				...app,
+				resolvedDeployTarget: 'dokploy',
+			};
+		}
+		return {
+			name: 'test-workspace',
+			root: '/test/workspace',
+			apps: appsWithDeployTarget,
+			services: {},
+			deploy: { default: 'dokploy' },
+			shared: { packages: ['packages/*'] },
+			secrets: {},
+			...overrides,
+		};
+	}
+
+	describe('checkPortConflicts', () => {
+		it('should return empty array when no conflicts', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3001,
+					dependencies: [],
+				},
+				admin: {
+					type: 'frontend',
+					path: 'apps/admin',
+					port: 3002,
+					dependencies: [],
+				},
+			});
+
+			const conflicts = checkPortConflicts(workspace);
+			expect(conflicts).toEqual([]);
+		});
+
+		it('should detect port conflicts between two apps', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3000, // Same port as api!
+					dependencies: [],
+				},
+			});
+
+			const conflicts = checkPortConflicts(workspace);
+			expect(conflicts).toHaveLength(1);
+			expect(conflicts[0]).toEqual({
+				app1: 'api',
+				app2: 'web',
+				port: 3000,
+			});
+		});
+
+		it('should detect multiple port conflicts', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				auth: {
+					type: 'backend',
+					path: 'apps/auth',
+					port: 3000, // Conflicts with api
+					dependencies: [],
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3001,
+					dependencies: [],
+				},
+				admin: {
+					type: 'frontend',
+					path: 'apps/admin',
+					port: 3001, // Conflicts with web
+					dependencies: [],
+				},
+			});
+
+			const conflicts = checkPortConflicts(workspace);
+			expect(conflicts).toHaveLength(2);
+		});
+
+		it('should handle single app workspace', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+			});
+
+			const conflicts = checkPortConflicts(workspace);
+			expect(conflicts).toEqual([]);
+		});
+	});
+
+	describe('generateAllDependencyEnvVars', () => {
+		it('should generate empty object for apps with no dependencies', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3001,
+					dependencies: [],
+				},
+			});
+
+			const env = generateAllDependencyEnvVars(workspace);
+			expect(env).toEqual({});
+		});
+
+		it('should generate URL env vars for dependencies', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				auth: {
+					type: 'backend',
+					path: 'apps/auth',
+					port: 3001,
+					dependencies: [],
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3002,
+					dependencies: ['api', 'auth'],
+				},
+			});
+
+			const env = generateAllDependencyEnvVars(workspace);
+			expect(env).toEqual({
+				API_URL: 'http://localhost:3000',
+				AUTH_URL: 'http://localhost:3001',
+			});
+		});
+
+		it('should handle cross-dependencies between backend apps', () => {
+			const workspace = createTestWorkspace({
+				'api-gateway': {
+					type: 'backend',
+					path: 'apps/api-gateway',
+					port: 3000,
+					dependencies: [],
+				},
+				'user-service': {
+					type: 'backend',
+					path: 'apps/user-service',
+					port: 3001,
+					dependencies: [],
+				},
+				'order-service': {
+					type: 'backend',
+					path: 'apps/order-service',
+					port: 3002,
+					dependencies: ['user-service'],
+				},
+			});
+
+			const env = generateAllDependencyEnvVars(workspace);
+			expect(env).toEqual({
+				'USER-SERVICE_URL': 'http://localhost:3001',
+			});
+		});
+
+		it('should use custom URL prefix', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3001,
+					dependencies: ['api'],
+				},
+			});
+
+			const env = generateAllDependencyEnvVars(workspace, 'http://127.0.0.1');
+			expect(env).toEqual({
+				API_URL: 'http://127.0.0.1:3000',
+			});
+		});
+
+		it('should handle complex dependency graph', () => {
+			const workspace = createTestWorkspace({
+				api: {
+					type: 'backend',
+					path: 'apps/api',
+					port: 3000,
+					dependencies: [],
+				},
+				auth: {
+					type: 'backend',
+					path: 'apps/auth',
+					port: 3001,
+					dependencies: [],
+				},
+				payments: {
+					type: 'backend',
+					path: 'apps/payments',
+					port: 3002,
+					dependencies: ['auth'], // Payments depends on auth
+				},
+				web: {
+					type: 'frontend',
+					path: 'apps/web',
+					port: 3003,
+					dependencies: ['api', 'auth'], // Web depends on api and auth
+				},
+				admin: {
+					type: 'frontend',
+					path: 'apps/admin',
+					port: 3004,
+					dependencies: ['api', 'payments'], // Admin depends on api and payments
+				},
+			});
+
+			const env = generateAllDependencyEnvVars(workspace);
+			expect(env).toEqual({
+				AUTH_URL: 'http://localhost:3001',
+				API_URL: 'http://localhost:3000',
+				PAYMENTS_URL: 'http://localhost:3002',
+			});
+		});
+	});
+
+	describe('validateFrontendApp', () => {
+		let testDir: string;
+
+		beforeEach(() => {
+			// Create a unique temp directory for each test
+			testDir = join(
+				tmpdir(),
+				`gkm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+			);
+			mkdirSync(testDir, { recursive: true });
+		});
+
+		afterEach(() => {
+			// Clean up temp directory
+			if (existsSync(testDir)) {
+				rmSync(testDir, { recursive: true, force: true });
+			}
+		});
+
+		it('should validate a properly configured Next.js app', async () => {
+			// Create a valid Next.js app structure
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Create next.config.js
+			writeFileSync(join(appDir, 'next.config.js'), 'module.exports = {}');
+
+			// Create package.json with next dependency
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0', react: '^18.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+			expect(result.errors).toHaveLength(0);
+			expect(result.warnings).toHaveLength(0);
+		});
+
+		it('should detect missing Next.js config file', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Create package.json without next.config.js
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(false);
+			expect(result.errors).toContainEqual(
+				expect.stringContaining('Next.js config file not found'),
+			);
+		});
+
+		it('should detect missing Next.js dependency', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Create next.config.js
+			writeFileSync(join(appDir, 'next.config.js'), 'module.exports = {}');
+
+			// Create package.json WITHOUT next dependency
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { react: '^18.0.0' },
+					scripts: { dev: 'echo no next' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(false);
+			expect(result.errors).toContainEqual(
+				expect.stringContaining('Next.js not found in dependencies'),
+			);
+		});
+
+		it('should detect missing package.json', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Create next.config.js but no package.json
+			writeFileSync(join(appDir, 'next.config.js'), 'module.exports = {}');
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(false);
+			expect(result.errors).toContainEqual(
+				expect.stringContaining('package.json not found'),
+			);
+		});
+
+		it('should warn about missing dev script', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			writeFileSync(join(appDir, 'next.config.js'), 'module.exports = {}');
+
+			// Create package.json WITHOUT dev script
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0' },
+					// No scripts
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true); // Still valid, just a warning
+			expect(result.warnings).toContainEqual(
+				expect.stringContaining('No "dev" script found'),
+			);
+		});
+
+		it('should accept next.config.ts', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Create next.config.ts (TypeScript config)
+			writeFileSync(
+				join(appDir, 'next.config.ts'),
+				'export default { reactStrictMode: true }',
+			);
+
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+		});
+
+		it('should accept next.config.mjs', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			// Create next.config.mjs (ESM config)
+			writeFileSync(
+				join(appDir, 'next.config.mjs'),
+				'export default { reactStrictMode: true }',
+			);
+
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+		});
+
+		it('should detect next in devDependencies', async () => {
+			const appDir = join(testDir, 'apps/web');
+			mkdirSync(appDir, { recursive: true });
+
+			writeFileSync(join(appDir, 'next.config.js'), 'module.exports = {}');
+
+			// Next in devDependencies (valid)
+			writeFileSync(
+				join(appDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					devDependencies: { next: '^14.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			const result = await validateFrontendApp('web', 'apps/web', testDir);
+
+			expect(result.valid).toBe(true);
+		});
+	});
+
+	describe('validateFrontendApps', () => {
+		let testDir: string;
+
+		beforeEach(() => {
+			testDir = join(
+				tmpdir(),
+				`gkm-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+			);
+			mkdirSync(testDir, { recursive: true });
+		});
+
+		afterEach(() => {
+			if (existsSync(testDir)) {
+				rmSync(testDir, { recursive: true, force: true });
+			}
+		});
+
+		it('should validate only frontend apps', async () => {
+			// Create valid frontend app
+			const webDir = join(testDir, 'apps/web');
+			mkdirSync(webDir, { recursive: true });
+			writeFileSync(join(webDir, 'next.config.js'), 'module.exports = {}');
+			writeFileSync(
+				join(webDir, 'package.json'),
+				JSON.stringify({
+					name: 'web',
+					dependencies: { next: '^14.0.0' },
+					scripts: { dev: 'next dev' },
+				}),
+			);
+
+			const workspace: NormalizedWorkspace = {
+				name: 'test-workspace',
+				root: testDir,
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
+					},
+					web: {
+						type: 'frontend',
+						path: 'apps/web',
+						port: 3001,
+						dependencies: ['api'],
+						resolvedDeployTarget: 'dokploy',
+					},
+				},
+				services: {},
+				deploy: { default: 'dokploy' },
+				shared: { packages: [] },
+				secrets: {},
+			};
+
+			const results = await validateFrontendApps(workspace);
+
+			// Should only validate the frontend app
+			expect(results).toHaveLength(1);
+			expect(results[0]?.appName).toBe('web');
+			expect(results[0]?.valid).toBe(true);
+		});
+
+		it('should return empty array for backend-only workspace', async () => {
+			const workspace: NormalizedWorkspace = {
+				name: 'test-workspace',
+				root: testDir,
+				apps: {
+					api: {
+						type: 'backend',
+						path: 'apps/api',
+						port: 3000,
+						dependencies: [],
+						resolvedDeployTarget: 'dokploy',
+					},
+				},
+				services: {},
+				deploy: { default: 'dokploy' },
+				shared: { packages: [] },
+				secrets: {},
+			};
+
+			const results = await validateFrontendApps(workspace);
+
+			expect(results).toHaveLength(0);
+		});
+	});
+});