@geekmidas/cli 1.10.4 → 1.10.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.10.4",
+  "version": "1.10.5",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -57,10 +57,10 @@
     "tsx": "~4.20.3",
     "yaml": "~2.8.2",
     "@geekmidas/constructs": "~3.0.2",
-    "@geekmidas/envkit": "~1.0.3",
-    "@geekmidas/schema": "~1.0.0",
+    "@geekmidas/errors": "~1.0.0",
     "@geekmidas/logger": "~1.0.0",
-    "@geekmidas/errors": "~1.0.0"
+    "@geekmidas/schema": "~1.0.0",
+    "@geekmidas/envkit": "~1.0.3"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

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

@@ -1257,10 +1257,11 @@ describe('rewriteUrlsWithPorts', () => {
 		containerPort: 5672,
 	};
 
-	it('should rewrite DATABASE_URL with resolved postgres port', () => {
+	it('should rewrite DATABASE_URL with resolved postgres port and hostname', () => {
 		const secrets = {
 			DATABASE_URL: 'postgresql://app:pass@postgres:5432/mydb',
 			POSTGRES_PORT: '5432',
+			POSTGRES_HOST: 'postgres',
 			SOME_OTHER: 'value',
 		};
 		const result = rewriteUrlsWithPorts(secrets, {
@@ -1269,9 +1270,10 @@ describe('rewriteUrlsWithPorts', () => {
 			mappings: [pgMapping],
 		});
 		expect(result.DATABASE_URL).toBe(
-			'postgresql://app:pass@postgres:5433/mydb',
+			'postgresql://app:pass@localhost:5433/mydb',
 		);
 		expect(result.POSTGRES_PORT).toBe('5433');
+		expect(result.POSTGRES_HOST).toBe('localhost');
 		expect(result.SOME_OTHER).toBe('value');
 	});
 
@@ -1293,18 +1295,20 @@ describe('rewriteUrlsWithPorts', () => {
 		);
 	});
 
-	it('should rewrite REDIS_URL and REDIS_PORT', () => {
+	it('should rewrite REDIS_URL, REDIS_PORT, and REDIS_HOST', () => {
 		const secrets = {
 			REDIS_URL: 'redis://:pass@redis:6379',
 			REDIS_PORT: '6379',
+			REDIS_HOST: 'redis',
 		};
 		const result = rewriteUrlsWithPorts(secrets, {
 			dockerEnv: { REDIS_HOST_PORT: '6380' },
 			ports: { REDIS_HOST_PORT: 6380 },
 			mappings: [redisMapping],
 		});
-		expect(result.REDIS_URL).toBe('redis://:pass@redis:6380');
+		expect(result.REDIS_URL).toBe('redis://:pass@localhost:6380');
 		expect(result.REDIS_PORT).toBe('6380');
+		expect(result.REDIS_HOST).toBe('localhost');
 	});
 
 	it('should rewrite RABBITMQ_URL and RABBITMQ_PORT', () => {
@@ -1317,7 +1321,7 @@ describe('rewriteUrlsWithPorts', () => {
 			ports: { RABBITMQ_HOST_PORT: 5673 },
 			mappings: [rmqMapping],
 		});
-		expect(result.RABBITMQ_URL).toBe('amqp://app:pass@rabbitmq:5673/%2F');
+		expect(result.RABBITMQ_URL).toBe('amqp://app:pass@localhost:5673/%2F');
 		expect(result.RABBITMQ_PORT).toBe('5673');
 	});
 
@@ -1336,26 +1340,48 @@ describe('rewriteUrlsWithPorts', () => {
 			ports: { POSTGRES_HOST_PORT: 5433, REDIS_HOST_PORT: 6380 },
 			mappings: [pgMapping, redisMapping],
 		});
-		expect(result.DATABASE_URL).toContain(':5433/');
+		expect(result.DATABASE_URL).toBe(
+			'postgresql://app:pass@localhost:5433/mydb',
+		);
 		expect(result.POSTGRES_PORT).toBe('5433');
-		expect(result.REDIS_URL).toContain(':6380');
+		expect(result.REDIS_URL).toBe('redis://:pass@localhost:6380');
 		expect(result.REDIS_PORT).toBe('6380');
 	});
 
-	it('should not modify secrets when ports are defaults', () => {
+	it('should rewrite hostnames even when ports are defaults', () => {
 		const secrets = {
 			DATABASE_URL: 'postgresql://app:pass@postgres:5432/mydb',
 			POSTGRES_PORT: '5432',
+			POSTGRES_HOST: 'postgres',
 		};
 		const result = rewriteUrlsWithPorts(secrets, {
 			dockerEnv: { POSTGRES_HOST_PORT: '5432' },
 			ports: { POSTGRES_HOST_PORT: 5432 },
 			mappings: [pgMapping],
 		});
-		expect(result.DATABASE_URL).toBe(secrets.DATABASE_URL);
+		expect(result.DATABASE_URL).toBe(
+			'postgresql://app:pass@localhost:5432/mydb',
+		);
+		expect(result.POSTGRES_HOST).toBe('localhost');
 		expect(result.POSTGRES_PORT).toBe('5432');
 	});
 
+	it('should not rewrite _HOST vars that are already localhost', () => {
+		const secrets = {
+			DATABASE_URL: 'postgresql://app:pass@localhost:5432/mydb',
+			POSTGRES_HOST: 'localhost',
+		};
+		const result = rewriteUrlsWithPorts(secrets, {
+			dockerEnv: { POSTGRES_HOST_PORT: '5432' },
+			ports: { POSTGRES_HOST_PORT: 5432 },
+			mappings: [pgMapping],
+		});
+		expect(result.DATABASE_URL).toBe(
+			'postgresql://app:pass@localhost:5432/mydb',
+		);
+		expect(result.POSTGRES_HOST).toBe('localhost');
+	});
+
 	it('should return empty for no mappings', () => {
 		const result = rewriteUrlsWithPorts(
 			{},

package/src/dev/index.ts

@@ -354,7 +354,10 @@ export function rewriteUrlsWithPorts(
 
 	// Build a map of defaultPort → resolvedPort for all changed ports
 	const portReplacements: { defaultPort: number; resolvedPort: number }[] = [];
+	// Collect Docker service names for hostname rewriting
+	const serviceNames = new Set<string>();
 	for (const mapping of mappings) {
+		serviceNames.add(mapping.service);
 		const resolved = ports[mapping.envVar];
 		if (resolved !== undefined) {
 			portReplacements.push({
@@ -364,6 +367,14 @@ export function rewriteUrlsWithPorts(
 		}
 	}
 
+	// Rewrite _HOST env vars that use Docker service names
+	for (const [key, value] of Object.entries(result)) {
+		if (!key.endsWith('_HOST')) continue;
+		if (serviceNames.has(value)) {
+			result[key] = 'localhost';
+		}
+	}
+
 	// Rewrite _PORT env vars whose values match a default port
 	for (const [key, value] of Object.entries(result)) {
 		if (!key.endsWith('_PORT')) continue;
@@ -374,11 +385,17 @@ export function rewriteUrlsWithPorts(
 		}
 	}
 
-	// Rewrite URLs containing default ports
+	// Rewrite URLs: replace Docker service hostnames with localhost and fix ports
 	for (const [key, value] of Object.entries(result)) {
 		if (!key.endsWith('_URL') && key !== 'DATABASE_URL') continue;
 
 		let rewritten = value;
+		for (const name of serviceNames) {
+			rewritten = rewritten.replace(
+				new RegExp(`@${name}:`, 'g'),
+				'@localhost:',
+			);
+		}
 		for (const { defaultPort, resolvedPort } of portReplacements) {
 			rewritten = replacePortInUrl(rewritten, defaultPort, resolvedPort);
 		}

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

@@ -122,14 +122,14 @@ describe('generateDockerCompose', () => {
 	});
 
 	describe('postgres service', () => {
-		it('should add DATABASE_URL environment variable', () => {
+		it('should add DATABASE_URL environment variable with credential interpolation', () => {
 			const yaml = generateDockerCompose({
 				...baseOptions,
 				services: { postgres: true },
 			});
 
 			expect(yaml).toContain(
-				'- DATABASE_URL=${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}',
+				'- DATABASE_URL=${DATABASE_URL:-postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@postgres:5432/${POSTGRES_DB:-app}}',
 			);
 		});
 
@@ -185,13 +185,15 @@ describe('generateDockerCompose', () => {
 			expect(yaml).toContain('postgres_data:');
 		});
 
-		it('should include postgres healthcheck', () => {
+		it('should include postgres healthcheck using POSTGRES_USER', () => {
 			const yaml = generateDockerCompose({
 				...baseOptions,
 				services: { postgres: true },
 			});
 
-			expect(yaml).toContain('test: ["CMD-SHELL", "pg_isready -U postgres"]');
+			expect(yaml).toContain(
+				'test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]',
+			);
 		});
 
 		it('should add depends_on for postgres', () => {
@@ -801,7 +803,7 @@ describe('generateWorkspaceCompose', () => {
 			const yaml = generateWorkspaceCompose(workspace);
 
 			expect(yaml).toContain(
-				'DATABASE_URL=${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}',
+				'DATABASE_URL=${DATABASE_URL:-postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@postgres:5432/${POSTGRES_DB:-app}}',
 			);
 		});
 

package/src/docker/compose.ts

@@ -105,7 +105,7 @@ services:
 
 	// Add environment variables based on services
 	if (serviceMap.has('postgres')) {
-		yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}
+		yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://\${POSTGRES_USER:-postgres}:\${POSTGRES_PASSWORD:-postgres}@postgres:5432/\${POSTGRES_DB:-app}}
 `;
 	}
 
@@ -156,7 +156,7 @@ services:
     volumes:
       - postgres_data:/var/lib/postgresql/data
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]
       interval: 5s
       timeout: 5s
       retries: 5
@@ -335,7 +335,7 @@ services:
     volumes:
       - postgres_data:/var/lib/postgresql/data
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]
       interval: 5s
       timeout: 5s
       retries: 5
@@ -480,7 +480,7 @@ function generateAppService(
 	// Add infrastructure service URLs for backend apps
 	if (app.type === 'backend') {
 		if (hasPostgres) {
-			yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}
+			yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://\${POSTGRES_USER:-postgres}:\${POSTGRES_PASSWORD:-postgres}@postgres:5432/\${POSTGRES_DB:-app}}
 `;
 		}
 		if (hasRedis) {

package/src/init/generators/docker.ts

@@ -46,15 +46,15 @@ export function generateDockerFiles(
     container_name: ${options.name}-postgres
     restart: unless-stopped${envFile}
     environment:
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-      POSTGRES_DB: ${options.name.replace(/-/g, '_')}_dev
+      POSTGRES_USER: \${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: \${POSTGRES_DB:-${options.name.replace(/-/g, '_')}_dev}
     ports:
       - '\${POSTGRES_HOST_PORT:-5432}:5432'
     volumes:
       - postgres_data:/var/lib/postgresql/data${initVolume}
     healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U postgres']
+      test: ['CMD-SHELL', 'pg_isready -U $$POSTGRES_USER']
       interval: 5s
       timeout: 5s
       retries: 5`);

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

@@ -24,7 +24,7 @@ import {
 	rewriteUrlsWithPorts,
 	savePortState,
 } from '../../dev/index';
-import { ensureTestDatabase, rewriteDatabaseUrlForTests } from '../index';
+import { rewriteDatabaseUrlForTests } from '../index';
 
 describe('rewriteDatabaseUrlForTests', () => {
 	beforeAll(() => {
@@ -128,39 +128,6 @@ describe('rewriteDatabaseUrlForTests', () => {
 	});
 });
 
-describe('ensureTestDatabase', () => {
-	beforeAll(() => {
-		vi.spyOn(console, 'log').mockImplementation(() => {});
-	});
-
-	afterAll(() => {
-		vi.restoreAllMocks();
-	});
-
-	it('should do nothing when DATABASE_URL is missing', async () => {
-		// Should resolve without error
-		await ensureTestDatabase({});
-		await ensureTestDatabase({ REDIS_URL: 'redis://localhost:6379' });
-	});
-
-	it('should do nothing when database name is empty', async () => {
-		await ensureTestDatabase({
-			DATABASE_URL: 'postgresql://app:secret@localhost:5432/',
-		});
-	});
-
-	it('should not throw when postgres is unreachable', async () => {
-		// Use a port that's almost certainly not running postgres
-		await ensureTestDatabase({
-			DATABASE_URL: 'postgresql://app:secret@localhost:59999/test_db',
-		});
-		// Should log a warning but not throw
-		expect(console.log).toHaveBeenCalledWith(
-			expect.stringContaining('Could not ensure test database'),
-		);
-	});
-});
-
 describe('port rewriting + test database pipeline', () => {
 	let testDir: string;
 
@@ -359,4 +326,65 @@ services:
 		// RabbitMQ port rewritten
 		expect(secrets.RABBITMQ_URL).toBe('amqp://app:secret@localhost:5673');
 	});
+
+	it('should preserve root postgres credentials through the pipeline', async () => {
+		writeFileSync(
+			join(testDir, 'docker-compose.yml'),
+			`
+services:
+  postgres:
+    image: postgres:17
+    ports:
+      - '\${POSTGRES_HOST_PORT:-5432}:5432'
+`,
+		);
+
+		await savePortState(testDir, {
+			POSTGRES_HOST_PORT: 5434,
+		});
+
+		// Simulate toEmbeddableSecrets output for a workspace with app-specific users
+		let secrets: Record<string, string> = {
+			DATABASE_URL: 'postgresql://app:rootpass@postgres:5432/app',
+			API_DATABASE_URL: 'postgresql://api:apipass@localhost:5432/myproject_dev',
+			AUTH_DATABASE_URL:
+				'postgresql://auth:authpass@localhost:5432/myproject_dev',
+			POSTGRES_USER: 'app',
+			POSTGRES_PASSWORD: 'rootpass',
+			POSTGRES_DB: 'app',
+			POSTGRES_HOST: 'postgres',
+			POSTGRES_PORT: '5432',
+		};
+
+		// Apply port + host rewriting
+		const mappings = parseComposePortMappings(
+			join(testDir, 'docker-compose.yml'),
+		);
+		const ports = await loadPortState(testDir);
+		secrets = rewriteUrlsWithPorts(secrets, {
+			dockerEnv: {},
+			ports,
+			mappings,
+		});
+
+		// Apply test database suffix
+		secrets = rewriteDatabaseUrlForTests(secrets);
+
+		// Root credentials should be present and rewritten to localhost
+		expect(secrets.POSTGRES_USER).toBe('app');
+		expect(secrets.POSTGRES_PASSWORD).toBe('rootpass');
+		expect(secrets.POSTGRES_HOST).toBe('localhost');
+		expect(secrets.POSTGRES_PORT).toBe('5434');
+
+		// All DATABASE_URLs should have localhost, resolved port, and _test suffix
+		expect(secrets.DATABASE_URL).toBe(
+			'postgresql://app:rootpass@localhost:5434/app_test',
+		);
+		expect(secrets.API_DATABASE_URL).toBe(
+			'postgresql://api:apipass@localhost:5434/myproject_dev_test',
+		);
+		expect(secrets.AUTH_DATABASE_URL).toBe(
+			'postgresql://auth:authpass@localhost:5434/myproject_dev_test',
+		);
+	});
 });

package/src/test/index.ts

@@ -81,7 +81,6 @@ export async function testCommand(options: TestOptions = {}): Promise<void> {
 
 	// 4. Use a separate test database (append _test suffix)
 	secretsEnv = rewriteDatabaseUrlForTests(secretsEnv);
-	await ensureTestDatabase(secretsEnv);
 
 	// 5. Load workspace config + dependency URLs + sniff env vars
 	let dependencyEnv: Record<string, string> = {};
@@ -225,43 +224,3 @@ export function rewriteDatabaseUrlForTests(
 
 	return result;
 }
-
-/**
- * Ensure the test database exists by connecting to the default database
- * and running CREATE DATABASE IF NOT EXISTS.
- * @internal Exported for testing
- */
-export async function ensureTestDatabase(
-	env: Record<string, string>,
-): Promise<void> {
-	const databaseUrl = env.DATABASE_URL;
-	if (!databaseUrl) return;
-
-	try {
-		const url = new URL(databaseUrl);
-		const testDbName = url.pathname.slice(1);
-		if (!testDbName) return;
-
-		// Connect to the default 'postgres' database to create the test database
-		url.pathname = '/postgres';
-		const { default: pg } = await import('pg');
-		const client = new pg.Client({ connectionString: url.toString() });
-		await client.connect();
-
-		try {
-			await client.query(`CREATE DATABASE "${testDbName}"`);
-			console.log(`  📦 Created test database "${testDbName}"`);
-		} catch (err: unknown) {
-			// 42P04 = database already exists — that's fine
-			if ((err as { code?: string }).code !== '42P04') throw err;
-		} finally {
-			await client.end();
-		}
-	} catch (err) {
-		// Don't fail test startup if we can't create the database
-		// (e.g., postgres not running yet, will fail later with a clear error)
-		console.log(
-			`  ⚠️  Could not ensure test database: ${(err as Error).message}`,
-		);
-	}
-}