@geekmidas/cli 1.10.17 → 1.10.19

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

@@ -0,0 +1,125 @@
+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');
+	});
+});

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

@@ -0,0 +1,190 @@
+import { existsSync, mkdirSync, readFileSync } 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 {
+	createDockerCompose,
+	createPackageJson,
+	createPortState,
+	createSecretsFile,
+} from './helpers';
+
+describe('readonly Docker port resolution', () => {
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = join(
+			tmpdir(),
+			`gkm-ports-ro-${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,
+				},
+				{
+					name: 'redis',
+					envVar: 'REDIS_HOST_PORT',
+					defaultPort: 6379,
+					containerPort: 6379,
+				},
+			],
+			testDir,
+		);
+		createSecretsFile(
+			'development',
+			{
+				DATABASE_URL: 'postgresql://user:pass@postgres:5432/mydb',
+				REDIS_URL: 'redis://default:pass@redis:6379',
+				POSTGRES_HOST: 'postgres',
+				POSTGRES_PORT: '5432',
+				CACHE_ENDPOINT: 'redis://default:pass@redis:6379/0',
+				EVENT_SUBSCRIBER_CONNECTION_STRING:
+					'sqs://key:secret@localstack:4566?region=us-east-1',
+			},
+			testDir,
+		);
+	});
+
+	afterEach(async () => {
+		if (existsSync(testDir)) {
+			const { rm } = await import('node:fs/promises');
+			await rm(testDir, { recursive: true, force: true });
+		}
+	});
+
+	it('should rewrite URLs with saved port state', async () => {
+		createPortState(
+			{ POSTGRES_HOST_PORT: 15432, REDIS_HOST_PORT: 16379 },
+			testDir,
+		);
+
+		const result = await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		expect(result.credentials.DATABASE_URL).toBe(
+			'postgresql://user:pass@localhost:15432/mydb',
+		);
+		expect(result.credentials.REDIS_URL).toBe(
+			'redis://default:pass@localhost:16379',
+		);
+	});
+
+	it('should rewrite _HOST vars to localhost', async () => {
+		createPortState({ POSTGRES_HOST_PORT: 15432 }, testDir);
+
+		const result = await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		expect(result.credentials.POSTGRES_HOST).toBe('localhost');
+	});
+
+	it('should rewrite _PORT vars to resolved port', async () => {
+		createPortState({ POSTGRES_HOST_PORT: 15432 }, testDir);
+
+		const result = await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		expect(result.credentials.POSTGRES_PORT).toBe('15432');
+	});
+
+	it('should rewrite _ENDPOINT keys', async () => {
+		createPortState({ REDIS_HOST_PORT: 16379 }, testDir);
+
+		const result = await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		expect(result.credentials.CACHE_ENDPOINT).toBe(
+			'redis://default:pass@localhost:16379/0',
+		);
+	});
+
+	it('should rewrite _CONNECTION_STRING keys', async () => {
+		createDockerCompose(
+			[
+				{
+					name: 'postgres',
+					envVar: 'POSTGRES_HOST_PORT',
+					defaultPort: 5432,
+					containerPort: 5432,
+				},
+				{
+					name: 'redis',
+					envVar: 'REDIS_HOST_PORT',
+					defaultPort: 6379,
+					containerPort: 6379,
+				},
+				{
+					name: 'localstack',
+					envVar: 'LOCALSTACK_HOST_PORT',
+					defaultPort: 4566,
+					containerPort: 4566,
+				},
+			],
+			testDir,
+		);
+		createPortState(
+			{
+				POSTGRES_HOST_PORT: 15432,
+				REDIS_HOST_PORT: 16379,
+				LOCALSTACK_HOST_PORT: 14566,
+			},
+			testDir,
+		);
+
+		const result = await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		expect(result.credentials.EVENT_SUBSCRIBER_CONNECTION_STRING).toContain(
+			'@localhost:',
+		);
+		expect(result.credentials.EVENT_SUBSCRIBER_CONNECTION_STRING).toContain(
+			':14566',
+		);
+	});
+
+	it('should not rewrite URLs when no saved state exists', async () => {
+		const result = await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		expect(result.credentials.DATABASE_URL).toBe(
+			'postgresql://user:pass@postgres:5432/mydb',
+		);
+		expect(result.credentials.REDIS_URL).toBe(
+			'redis://default:pass@redis:6379',
+		);
+	});
+
+	it('should not overwrite existing ports.json', async () => {
+		const originalPorts = { POSTGRES_HOST_PORT: 15432 };
+		createPortState(originalPorts, testDir);
+
+		await prepareEntryCredentials({
+			cwd: testDir,
+			resolveDockerPorts: 'readonly',
+		});
+
+		const portsAfter = JSON.parse(
+			readFileSync(join(testDir, '.gkm', 'ports.json'), 'utf-8'),
+		);
+		expect(portsAfter).toEqual(originalPorts);
+	});
+});

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

@@ -0,0 +1,209 @@
+import { existsSync, mkdirSync } 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 {
+	createDockerCompose,
+	createPackageJson,
+	createPortState,
+	createSecretsFile,
+	createWorkspaceConfig,
+} from './helpers';
+
+describe('workspace credentials', () => {
+	let testDir: string;
+	const originalGkmConfigPath = process.env.GKM_CONFIG_PATH;
+
+	beforeEach(() => {
+		testDir = join(
+			tmpdir(),
+			`gkm-ws-creds-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+		);
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(async () => {
+		if (originalGkmConfigPath === undefined) {
+			delete process.env.GKM_CONFIG_PATH;
+		} else {
+			process.env.GKM_CONFIG_PATH = originalGkmConfigPath;
+		}
+
+		if (existsSync(testDir)) {
+			const { rm } = await import('node:fs/promises');
+			await rm(testDir, { recursive: true, force: true });
+		}
+	});
+
+	describe('workspace mode', () => {
+		let apiDir: string;
+		let webDir: string;
+
+		beforeEach(() => {
+			createWorkspaceConfig(
+				{
+					api: { type: 'backend', path: 'apps/api', port: 3001 },
+					web: {
+						type: 'frontend',
+						path: 'apps/web',
+						port: 3002,
+						dependencies: ['api'],
+					},
+				},
+				testDir,
+			);
+
+			apiDir = join(testDir, 'apps', 'api');
+			webDir = join(testDir, 'apps', 'web');
+
+			createPackageJson('@test/api', apiDir);
+			createPackageJson('@test/web', webDir);
+
+			process.env.GKM_CONFIG_PATH = join(testDir, 'gkm.config.ts');
+		});
+
+		it('should populate appInfo in workspace mode', async () => {
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.appInfo).toBeDefined();
+			expect(result.appInfo?.appName).toBe('api');
+			expect(result.appInfo?.workspaceRoot).toBe(testDir);
+		});
+
+		it('should resolve port from workspace config', async () => {
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.resolvedPort).toBe(3001);
+			expect(result.credentials.PORT).toBe('3001');
+		});
+
+		it('should inject dependency URLs for frontend app', async () => {
+			const result = await prepareEntryCredentials({ cwd: webDir });
+
+			expect(result.credentials.API_URL).toBe('http://localhost:3001');
+		});
+
+		it('should map APP_DATABASE_URL to DATABASE_URL', async () => {
+			createSecretsFile(
+				'development',
+				{
+					API_DATABASE_URL: 'postgresql://localhost/apidb',
+					WEB_DATABASE_URL: 'postgresql://localhost/webdb',
+				},
+				testDir,
+			);
+
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.credentials.DATABASE_URL).toBe(
+				'postgresql://localhost/apidb',
+			);
+		});
+
+		it('should use app-specific secrets filename by default', async () => {
+			const result = await prepareEntryCredentials({ cwd: apiDir });
+
+			expect(result.secretsJsonPath).toBe(
+				join(testDir, '.gkm', 'dev-secrets-api.json'),
+			);
+		});
+
+		it('should use custom secretsFileName in workspace mode', async () => {
+			const result = await prepareEntryCredentials({
+				cwd: apiDir,
+				secretsFileName: 'test-secrets.json',
+			});
+
+			expect(result.secretsJsonPath).toBe(
+				join(testDir, '.gkm', 'test-secrets.json'),
+			);
+		});
+	});
+
+	describe('exec-style readonly in workspace', () => {
+		let apiDir: string;
+
+		beforeEach(() => {
+			createWorkspaceConfig(
+				{
+					api: { type: 'backend', path: 'apps/api', port: 3001 },
+				},
+				testDir,
+			);
+
+			apiDir = join(testDir, 'apps', 'api');
+			createPackageJson('@test/api', apiDir);
+
+			process.env.GKM_CONFIG_PATH = join(testDir, 'gkm.config.ts');
+
+			createDockerCompose(
+				[
+					{
+						name: 'postgres',
+						envVar: 'POSTGRES_HOST_PORT',
+						defaultPort: 5432,
+						containerPort: 5432,
+					},
+					{
+						name: 'redis',
+						envVar: 'REDIS_HOST_PORT',
+						defaultPort: 6379,
+						containerPort: 6379,
+					},
+				],
+				testDir,
+			);
+
+			createSecretsFile(
+				'development',
+				{
+					DATABASE_URL: 'postgresql://user:pass@postgres:5432/mydb',
+					REDIS_URL: 'redis://default:pass@redis:6379',
+					API_DATABASE_URL: 'postgresql://api:pass@postgres:5432/apidb',
+				},
+				testDir,
+			);
+
+			createPortState(
+				{ POSTGRES_HOST_PORT: 25432, REDIS_HOST_PORT: 26379 },
+				testDir,
+			);
+		});
+
+		it('should resolve ports from saved state and rewrite URLs', async () => {
+			const result = await prepareEntryCredentials({
+				cwd: apiDir,
+				resolveDockerPorts: 'readonly',
+			});
+
+			expect(result.credentials.DATABASE_URL).toBe(
+				'postgresql://api:pass@localhost:25432/apidb',
+			);
+			expect(result.credentials.REDIS_URL).toBe(
+				'redis://default:pass@localhost:26379',
+			);
+		});
+
+		it('should use workspace port, not Docker port, for PORT', async () => {
+			const result = await prepareEntryCredentials({
+				cwd: apiDir,
+				resolveDockerPorts: 'readonly',
+			});
+
+			expect(result.credentials.PORT).toBe('3001');
+			expect(result.resolvedPort).toBe(3001);
+		});
+
+		it('should have appInfo set alongside readonly ports', async () => {
+			const result = await prepareEntryCredentials({
+				cwd: apiDir,
+				resolveDockerPorts: 'readonly',
+			});
+
+			expect(result.appInfo).toBeDefined();
+			expect(result.appInfo?.appName).toBe('api');
+			expect(result.appName).toBe('api');
+		});
+	});
+});