@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

package/src/config.ts

@@ -1,330 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join, parse } from 'node:path';
-import type { GkmConfig } from './types.js';
-import {
-	getAppGkmConfig,
-	isWorkspaceConfig,
-	type LoadedConfig,
-	type NormalizedAppConfig,
-	type NormalizedWorkspace,
-	processConfig,
-	type WorkspaceConfig,
-} from './workspace/index.js';
-
-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.
- *
- * @example
- * ```ts
- * // gkm.config.ts
- * import { defineConfig } from '@geekmidas/cli/config';
- *
- * export default defineConfig({
- *   routes: './src/endpoints/**\/*.ts',
- *   envParser: './src/config/env',
- *   logger: './src/config/logger',
- *   telescope: true,
- * });
- * ```
- */
-export function defineConfig(config: GkmConfig): GkmConfig {
-	return config;
-}
-
-export interface ParsedModuleConfig {
-	path: string;
-	importPattern: string;
-}
-
-/**
- * Parse a module config string into path and import pattern.
- *
- * @param configString - Config string in format "./path/to/module" or "./path/to/module#exportName"
- * @param defaultAlias - The default alias name to use if no export name specified
- * @returns Object with path and import pattern
- *
- * @example
- * parseModuleConfig('./src/config/env', 'envParser')
- * // { path: './src/config/env', importPattern: 'envParser' }
- *
- * parseModuleConfig('./src/config/env#envParser', 'envParser')
- * // { path: './src/config/env', importPattern: '{ envParser }' }
- *
- * parseModuleConfig('./src/config/env#myEnv', 'envParser')
- * // { path: './src/config/env', importPattern: '{ myEnv as envParser }' }
- */
-export function parseModuleConfig(
-	configString: string,
-	defaultAlias: string,
-): ParsedModuleConfig {
-	const parts = configString.split('#');
-	const path = parts[0] ?? configString;
-	const exportName = parts[1];
-	const importPattern = !exportName
-		? defaultAlias
-		: exportName === defaultAlias
-			? `{ ${defaultAlias} }`
-			: `{ ${exportName} as ${defaultAlias} }`;
-
-	return { path, importPattern };
-}
-
-export interface ConfigDiscoveryResult {
-	configPath: string;
-	workspaceRoot: string;
-}
-
-/**
- * Find and return the path to the config file.
- *
- * Resolution order:
- * 1. GKM_CONFIG_PATH env var (set by workspace dev command)
- * 2. Walk up directory tree from cwd
- */
-function findConfigPath(cwd: string): ConfigDiscoveryResult {
-	const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
-
-	// Check GKM_CONFIG_PATH env var first (set by workspace dev command)
-	const envConfigPath = process.env.GKM_CONFIG_PATH;
-	if (envConfigPath && existsSync(envConfigPath)) {
-		return {
-			configPath: envConfigPath,
-			workspaceRoot: dirname(envConfigPath),
-		};
-	}
-
-	// Walk up directory tree to find config
-	let currentDir = cwd;
-	const { root } = parse(currentDir);
-
-	while (currentDir !== root) {
-		for (const file of files) {
-			const configPath = join(currentDir, file);
-			if (existsSync(configPath)) {
-				return {
-					configPath,
-					workspaceRoot: currentDir,
-				};
-			}
-		}
-		currentDir = dirname(currentDir);
-	}
-
-	throw new Error(
-		'Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.',
-	);
-}
-
-/**
- * Get app name from package.json in the given directory.
- * Handles scoped packages by extracting the name after the scope.
- *
- * @example
- * getAppNameFromCwd('/path/to/apps/api')
- * // package.json: { "name": "@myorg/api" }
- * // Returns: 'api'
- */
-export function getAppNameFromCwd(cwd: string = process.cwd()): string | null {
-	const packageJsonPath = join(cwd, 'package.json');
-
-	if (!existsSync(packageJsonPath)) {
-		return null;
-	}
-
-	try {
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-		const name = packageJson.name as string | undefined;
-
-		if (!name) {
-			return null;
-		}
-
-		// Handle scoped packages: @scope/name -> name
-		if (name.startsWith('@') && name.includes('/')) {
-			return name.split('/')[1] ?? null;
-		}
-
-		return name;
-	} catch {
-		return null;
-	}
-}
-
-interface RawConfigResult {
-	config: GkmConfig | WorkspaceConfig;
-	workspaceRoot: string;
-}
-
-/**
- * Load raw configuration from file.
- */
-async function loadRawConfig(cwd: string): Promise<RawConfigResult> {
-	const { configPath, workspaceRoot } = findConfigPath(cwd);
-
-	try {
-		const config = await import(configPath);
-		return {
-			config: config.default,
-			workspaceRoot,
-		};
-	} 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(
-			'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, workspaceRoot } = await loadRawConfig(cwd);
-	return processConfig(config, workspaceRoot);
-}
-
-export interface AppConfigResult {
-	appName: string;
-	app: NormalizedAppConfig;
-	gkmConfig: GkmConfig;
-	workspace: NormalizedWorkspace;
-	workspaceRoot: string;
-	appRoot: string;
-}
-
-/**
- * Load app-specific configuration from workspace.
- * Uses the app name from package.json to find the correct app config.
- *
- * @example
- * ```ts
- * // From apps/api directory with package.json: { "name": "@myorg/api" }
- * const { app, workspace, workspaceRoot } = await loadAppConfig();
- * console.log(app.routes); // './src/endpoints/**\/*.ts'
- * ```
- */
-export async function loadAppConfig(
-	cwd: string = process.cwd(),
-): Promise<AppConfigResult> {
-	const appName = getAppNameFromCwd(cwd);
-
-	if (!appName) {
-		throw new Error(
-			'Could not determine app name. Ensure package.json exists with a "name" field.',
-		);
-	}
-
-	const { config, workspaceRoot } = await loadRawConfig(cwd);
-	const loadedConfig = processConfig(config, workspaceRoot);
-
-	// Find the app in workspace (apps is a Record<string, NormalizedAppConfig>)
-	const app = loadedConfig.workspace.apps[appName];
-
-	if (!app) {
-		const availableApps = Object.keys(loadedConfig.workspace.apps).join(', ');
-		throw new Error(
-			`App "${appName}" not found in workspace config. Available apps: ${availableApps}. ` +
-				`Ensure the package.json name matches the app key in gkm.config.ts.`,
-		);
-	}
-
-	// Get the app's GKM config using the helper
-	const gkmConfig = getAppGkmConfig(loadedConfig.workspace, appName);
-
-	if (!gkmConfig) {
-		throw new Error(
-			`App "${appName}" is not a backend app and cannot be run with gkm dev.`,
-		);
-	}
-
-	return {
-		appName,
-		app,
-		gkmConfig,
-		workspace: loadedConfig.workspace,
-		workspaceRoot,
-		appRoot: join(workspaceRoot, app.path),
-	};
-}
-
-export interface WorkspaceAppInfo {
-	appName: string;
-	app: NormalizedAppConfig;
-	workspace: NormalizedWorkspace;
-	workspaceRoot: string;
-}
-
-/**
- * Load workspace info for any app (frontend or backend).
- * Unlike loadAppConfig, this does NOT require the app to have a gkm config
- * (routes, entry, etc.), making it suitable for gkm exec/test from frontend apps.
- */
-export async function loadWorkspaceAppInfo(
-	cwd: string = process.cwd(),
-): Promise<WorkspaceAppInfo> {
-	const appName = getAppNameFromCwd(cwd);
-
-	if (!appName) {
-		throw new Error(
-			'Could not determine app name. Ensure package.json exists with a "name" field.',
-		);
-	}
-
-	const { config, workspaceRoot } = await loadRawConfig(cwd);
-	const loadedConfig = processConfig(config, workspaceRoot);
-
-	const app = loadedConfig.workspace.apps[appName];
-
-	if (!app) {
-		const availableApps = Object.keys(loadedConfig.workspace.apps).join(', ');
-		throw new Error(
-			`App "${appName}" not found in workspace config. Available apps: ${availableApps}. ` +
-				`Ensure the package.json name matches the app key in gkm.config.ts.`,
-		);
-	}
-
-	return {
-		appName,
-		app,
-		workspace: loadedConfig.workspace,
-		workspaceRoot,
-	};
-}

package/src/credentials/__tests__/fullDockerPorts.spec.ts

@@ -1,144 +0,0 @@
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
-import type { AddressInfo } from 'node:net';
-import { createServer } from 'node:net';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-	afterEach,
-	describe as baseDescribe,
-	beforeEach,
-	expect,
-	it,
-} from 'vitest';
-import { prepareEntryCredentials } from '../index';
-import {
-	createDockerCompose,
-	createPackageJson,
-	createSecretsFile,
-} from './helpers';
-
-// Skip port-probing tests in CI due to flaky port binding issues
-const describe = process.env.CI ? baseDescribe.skip : baseDescribe;
-
-// Track servers to clean up after each test
-const activeServers: ReturnType<typeof createServer>[] = [];
-
-function occupyPort(
-	port: number,
-): Promise<{ server: ReturnType<typeof createServer>; port: number }> {
-	return new Promise((resolve, reject) => {
-		const server = createServer();
-		server.once('error', (err) => reject(err));
-		server.once('listening', () => {
-			activeServers.push(server);
-			const actualPort = (server.address() as AddressInfo).port;
-			resolve({ server, port: actualPort });
-		});
-		server.listen(port);
-	});
-}
-
-describe('full mode Docker port resolution', () => {
-	let testDir: string;
-
-	beforeEach(() => {
-		testDir = join(
-			tmpdir(),
-			`gkm-ports-full-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-		);
-		mkdirSync(testDir, { recursive: true });
-		createPackageJson('my-app', testDir);
-		createDockerCompose(
-			[
-				{
-					name: 'postgres',
-					envVar: 'POSTGRES_HOST_PORT',
-					defaultPort: 5432,
-					containerPort: 5432,
-				},
-			],
-			testDir,
-		);
-		createSecretsFile(
-			'development',
-			{
-				DATABASE_URL: 'postgresql://user:pass@postgres:5432/mydb',
-				POSTGRES_HOST: 'postgres',
-				POSTGRES_PORT: '5432',
-			},
-			testDir,
-		);
-	});
-
-	afterEach(async () => {
-		await Promise.all(
-			activeServers.map(
-				(server) =>
-					new Promise<void>((resolve) => {
-						server.close(() => resolve());
-					}),
-			),
-		);
-		activeServers.length = 0;
-		await new Promise((resolve) => setTimeout(resolve, 50));
-
-		if (existsSync(testDir)) {
-			const { rm } = await import('node:fs/promises');
-			await rm(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should resolve ports and rewrite URLs', async () => {
-		const result = await prepareEntryCredentials({
-			cwd: testDir,
-			resolveDockerPorts: 'full',
-		});
-
-		expect(result.credentials.POSTGRES_HOST).toBe('localhost');
-		expect(result.credentials.DATABASE_URL).toContain('@localhost:');
-		expect(result.credentials.PORT).toBe('3000');
-	});
-
-	it('should write ports.json after full resolution', async () => {
-		await prepareEntryCredentials({
-			cwd: testDir,
-			resolveDockerPorts: 'full',
-		});
-
-		const portsPath = join(testDir, '.gkm', 'ports.json');
-		expect(existsSync(portsPath)).toBe(true);
-
-		const ports = JSON.parse(readFileSync(portsPath, 'utf-8'));
-		expect(ports.POSTGRES_HOST_PORT).toBeDefined();
-		expect(typeof ports.POSTGRES_HOST_PORT).toBe('number');
-	});
-
-	it('should pick a different port when default is occupied', async () => {
-		// Occupy port 5432 (may already be in use by a real postgres)
-		let occupiedPort: number;
-		try {
-			const result = await occupyPort(5432);
-			occupiedPort = result.port;
-		} catch {
-			// Port 5432 already occupied (e.g., by a running postgres)
-			occupiedPort = 5432;
-		}
-		expect(occupiedPort).toBe(5432);
-
-		const result = await prepareEntryCredentials({
-			cwd: testDir,
-			resolveDockerPorts: 'full',
-		});
-
-		const portsPath = join(testDir, '.gkm', 'ports.json');
-		const ports = JSON.parse(readFileSync(portsPath, 'utf-8'));
-		expect(ports.POSTGRES_HOST_PORT).not.toBe(5432);
-
-		expect(result.credentials.DATABASE_URL).toContain(
-			`:${ports.POSTGRES_HOST_PORT}`,
-		);
-		expect(result.credentials.POSTGRES_PORT).toBe(
-			String(ports.POSTGRES_HOST_PORT),
-		);
-	});
-});

package/src/credentials/__tests__/helpers.ts

@@ -1,112 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-export function createSecretsFile(
-	stage: string,
-	secrets: Record<string, string>,
-	root: string,
-) {
-	const secretsDir = join(root, '.gkm', 'secrets');
-	mkdirSync(secretsDir, { recursive: true });
-	const stageSecrets = {
-		stage,
-		createdAt: new Date().toISOString(),
-		updatedAt: new Date().toISOString(),
-		services: {},
-		urls: {},
-		custom: secrets,
-	};
-	writeFileSync(
-		join(secretsDir, `${stage}.json`),
-		JSON.stringify(stageSecrets, null, 2),
-	);
-}
-
-export function createDockerCompose(
-	services: {
-		name: string;
-		envVar: string;
-		defaultPort: number;
-		containerPort: number;
-	}[],
-	root: string,
-) {
-	const svcEntries = services
-		.map(
-			(s) => `  ${s.name}:
-    image: ${s.name}:latest
-    ports:
-      - '\${${s.envVar}:-${s.defaultPort}}:${s.containerPort}'`,
-		)
-		.join('\n');
-
-	const content = `services:\n${svcEntries}\n`;
-	writeFileSync(join(root, 'docker-compose.yml'), content);
-}
-
-export function createPortState(ports: Record<string, number>, root: string) {
-	const dir = join(root, '.gkm');
-	mkdirSync(dir, { recursive: true });
-	writeFileSync(join(dir, 'ports.json'), JSON.stringify(ports, null, 2));
-}
-
-export function createPackageJson(name: string, dir: string) {
-	mkdirSync(dir, { recursive: true });
-	writeFileSync(
-		join(dir, 'package.json'),
-		JSON.stringify({ name, version: '0.0.1' }, null, 2),
-	);
-}
-
-export function createWorkspaceConfig(
-	apps: Record<
-		string,
-		{
-			type: string;
-			path: string;
-			port: number;
-			dependencies?: string[];
-			framework?: string;
-		}
-	>,
-	root: string,
-) {
-	const appEntries = Object.entries(apps)
-		.map(([name, app]) => {
-			const deps = app.dependencies
-				? `dependencies: [${app.dependencies.map((d) => `'${d}'`).join(', ')}],`
-				: '';
-			if (app.type === 'web') {
-				const framework = app.framework ?? 'nextjs';
-				return `    ${name}: {
-      type: '${app.type}',
-      path: '${app.path}',
-      port: ${app.port},
-      framework: '${framework}',
-      ${deps}
-    },`;
-			}
-			return `    ${name}: {
-      type: '${app.type}',
-      path: '${app.path}',
-      port: ${app.port},
-      routes: './src/endpoints/**/*.ts',
-      envParser: './src/config/env#envParser',
-      logger: './src/config/logger#logger',
-      ${deps}
-    },`;
-		})
-		.join('\n');
-
-	const content = `import { defineWorkspace } from '@geekmidas/cli/config';
-
-export default defineWorkspace({
-  name: 'test-workspace',
-  apps: {
-${appEntries}
-  },
-  services: {},
-});
-`;
-	writeFileSync(join(root, 'gkm.config.ts'), content);
-}

package/src/credentials/__tests__/prepareEntryCredentials.spec.ts

@@ -1,125 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { prepareEntryCredentials } from '../index';
-import { createPackageJson, createSecretsFile } from './helpers';
-
-describe('prepareEntryCredentials', () => {
-	let testDir: string;
-
-	beforeEach(() => {
-		testDir = join(
-			tmpdir(),
-			`gkm-creds-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-		);
-		mkdirSync(testDir, { recursive: true });
-		createPackageJson('my-app', testDir);
-	});
-
-	afterEach(async () => {
-		if (existsSync(testDir)) {
-			const { rm } = await import('node:fs/promises');
-			await rm(testDir, { recursive: true, force: true });
-		}
-	});
-
-	it('should return default port 3000', async () => {
-		const result = await prepareEntryCredentials({ cwd: testDir });
-
-		expect(result.resolvedPort).toBe(3000);
-		expect(result.credentials.PORT).toBe('3000');
-	});
-
-	it('should respect explicitPort', async () => {
-		const result = await prepareEntryCredentials({
-			cwd: testDir,
-			explicitPort: 8080,
-		});
-
-		expect(result.resolvedPort).toBe(8080);
-		expect(result.credentials.PORT).toBe('8080');
-	});
-
-	it('should load secrets from development stage by default', async () => {
-		createSecretsFile(
-			'development',
-			{ DATABASE_URL: 'postgresql://localhost/mydb', API_KEY: 'secret' },
-			testDir,
-		);
-
-		const result = await prepareEntryCredentials({ cwd: testDir });
-
-		expect(result.credentials.DATABASE_URL).toBe('postgresql://localhost/mydb');
-		expect(result.credentials.API_KEY).toBe('secret');
-	});
-
-	it('should load secrets from custom stage', async () => {
-		createSecretsFile('staging', { API_KEY: 'staging-key' }, testDir);
-
-		const result = await prepareEntryCredentials({
-			cwd: testDir,
-			stages: ['staging'],
-		});
-
-		expect(result.credentials.API_KEY).toBe('staging-key');
-	});
-
-	it('should not load secrets when stage does not exist', async () => {
-		createSecretsFile('development', { API_KEY: 'dev-key' }, testDir);
-
-		const result = await prepareEntryCredentials({
-			cwd: testDir,
-			stages: ['production'],
-		});
-
-		expect(result.credentials.API_KEY).toBeUndefined();
-		expect(result.credentials.PORT).toBe('3000');
-	});
-
-	it('should use custom secretsFileName', async () => {
-		const result = await prepareEntryCredentials({
-			cwd: testDir,
-			secretsFileName: 'test-secrets.json',
-		});
-
-		expect(result.secretsJsonPath).toBe(
-			join(testDir, '.gkm', 'test-secrets.json'),
-		);
-		const content = JSON.parse(readFileSync(result.secretsJsonPath, 'utf-8'));
-		expect(content.PORT).toBe('3000');
-	});
-
-	it('should have undefined appInfo outside workspace', async () => {
-		const result = await prepareEntryCredentials({ cwd: testDir });
-
-		expect(result.appInfo).toBeUndefined();
-	});
-
-	it('should extract appName from package.json', async () => {
-		const result = await prepareEntryCredentials({ cwd: testDir });
-
-		expect(result.appName).toBe('my-app');
-	});
-
-	it('should extract appName from scoped package', async () => {
-		writeFileSync(
-			join(testDir, 'package.json'),
-			JSON.stringify({ name: '@scope/my-app', version: '0.0.1' }),
-		);
-
-		const result = await prepareEntryCredentials({ cwd: testDir });
-
-		expect(result.appName).toBe('my-app');
-	});
-
-	it('should write credentials JSON with all secrets and PORT', async () => {
-		createSecretsFile('development', { JWT_SECRET: 'abc123' }, testDir);
-
-		const result = await prepareEntryCredentials({ cwd: testDir });
-
-		const content = JSON.parse(readFileSync(result.secretsJsonPath, 'utf-8'));
-		expect(content.PORT).toBe('3000');
-		expect(content.JWT_SECRET).toBe('abc123');
-	});
-});