@geekmidas/cli 1.10.4 → 1.10.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.10.4",
+  "version": "1.10.6",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -56,11 +56,11 @@
     "prompts": "~2.4.2",
     "tsx": "~4.20.3",
     "yaml": "~2.8.2",
-    "@geekmidas/constructs": "~3.0.2",
     "@geekmidas/envkit": "~1.0.3",
-    "@geekmidas/schema": "~1.0.0",
+    "@geekmidas/constructs": "~3.0.2",
     "@geekmidas/logger": "~1.0.0",
-    "@geekmidas/errors": "~1.0.0"
+    "@geekmidas/errors": "~1.0.0",
+    "@geekmidas/schema": "~1.0.0"
   },
   "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}}',
 			);
 		});
 
@@ -181,17 +181,19 @@ describe('generateDockerCompose', () => {
 				services: { postgres: true },
 			});
 
-			expect(yaml).toContain('- postgres_data:/var/lib/postgresql/data');
-			expect(yaml).toContain('postgres_data:');
+			expect(yaml).toContain('- dbdata:/var/lib/postgresql/18/data');
+			expect(yaml).toContain('dbdata:');
 		});
 
-		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', () => {
@@ -371,7 +373,7 @@ describe('generateDockerCompose', () => {
 				services: { postgres: true, redis: true, rabbitmq: true },
 			});
 
-			expect(yaml).toContain('postgres_data:');
+			expect(yaml).toContain('dbdata:');
 			expect(yaml).toContain('redis_data:');
 			expect(yaml).toContain('rabbitmq_data:');
 		});
@@ -790,7 +792,7 @@ describe('generateWorkspaceCompose', () => {
 			const yaml = generateWorkspaceCompose(workspace);
 
 			expect(yaml).toContain('postgres:');
-			expect(yaml).toContain('image: postgres:16-alpine');
+			expect(yaml).toContain('image: postgres:18-alpine');
 			expect(yaml).toContain('container_name: test-workspace-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}}',
 			);
 		});
 
@@ -843,8 +845,8 @@ describe('generateWorkspaceCompose', () => {
 			});
 			const yaml = generateWorkspaceCompose(workspace);
 
-			expect(yaml).toContain('postgres_data:');
-			expect(yaml).toContain('postgres_data:/var/lib/postgresql/data');
+			expect(yaml).toContain('dbdata:');
+			expect(yaml).toContain('dbdata:/var/lib/postgresql/18/data');
 		});
 
 		it('should add redis_data volume when redis is enabled', () => {

package/src/docker/compose.ts

@@ -17,7 +17,7 @@ export const DEFAULT_SERVICE_IMAGES: Record<ComposeServiceName, string> = {
 
 /** Default Docker image versions for services */
 export const DEFAULT_SERVICE_VERSIONS: Record<ComposeServiceName, string> = {
-	postgres: '16-alpine',
+	postgres: '18-alpine',
 	redis: '7-alpine',
 	rabbitmq: '3-management-alpine',
 };
@@ -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}}
 `;
 	}
 
@@ -154,9 +154,9 @@ services:
       POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
       POSTGRES_DB: \${POSTGRES_DB:-app}
     volumes:
-      - postgres_data:/var/lib/postgresql/data
+      - dbdata:/var/lib/postgresql/18/data
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]
       interval: 5s
       timeout: 5s
       retries: 5
@@ -214,7 +214,7 @@ volumes:
 `;
 
 	if (serviceMap.has('postgres')) {
-		yaml += `  postgres_data:
+		yaml += `  dbdata:
 `;
 	}
 
@@ -333,9 +333,9 @@ services:
       POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
       POSTGRES_DB: \${POSTGRES_DB:-app}
     volumes:
-      - postgres_data:/var/lib/postgresql/data
+      - dbdata:/var/lib/postgresql/18/data
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]
       interval: 5s
       timeout: 5s
       retries: 5
@@ -382,7 +382,7 @@ volumes:
 `;
 
 	if (hasPostgres) {
-		yaml += `  postgres_data:
+		yaml += `  dbdata:
 `;
 	}
 
@@ -409,7 +409,7 @@ function getInfraServiceImage(
 	config: boolean | { version?: string; image?: string } | undefined,
 ): string {
 	const defaults: Record<'postgres' | 'redis', string> = {
-		postgres: 'postgres:16-alpine',
+		postgres: 'postgres:18-alpine',
 		redis: 'redis:7-alpine',
 	};
 
@@ -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/__tests__/init.spec.ts

@@ -545,7 +545,7 @@ describe('initCommand', () => {
 
 			const dockerPath = join(tempDir, 'my-api', 'docker-compose.yml');
 			const content = await readFile(dockerPath, 'utf-8');
-			expect(content).toContain('postgres:16-alpine');
+			expect(content).toContain('postgres:18-alpine');
 			expect(content).toContain("'${POSTGRES_HOST_PORT:-5432}:5432'");
 		});
 

package/src/init/generators/docker.ts

@@ -42,23 +42,23 @@ export function generateDockerFiles(
 				: '';
 
 		services.push(`  postgres:
-    image: postgres:16-alpine
+    image: postgres:18-alpine
     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}
+      - dbdata:/var/lib/postgresql/18/data${initVolume}
     healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U postgres']
+      test: ['CMD-SHELL', 'pg_isready -U $$POSTGRES_USER']
       interval: 5s
       timeout: 5s
       retries: 5`);
-		volumes.push('  postgres_data:');
+		volumes.push('  dbdata:');
 
 		// Generate PostgreSQL init script and .env for fullstack template
 		if (isFullstack && dbApps?.length) {

package/src/init/index.ts

@@ -331,7 +331,9 @@ export async function initCommand(
 	if (services.db) secretServices.push('postgres');
 	if (services.cache) secretServices.push('redis');
 
-	const devSecrets = createStageSecrets('development', secretServices);
+	const devSecrets = createStageSecrets('development', secretServices, {
+		projectName: name,
+	});
 
 	// Add common custom secrets
 	const customSecrets: Record<string, string> = {

package/src/secrets/generator.ts

@@ -114,13 +114,24 @@ export function generateConnectionUrls(
 
 /**
  * Create a new StageSecrets object with generated credentials.
+ * @param stage - The deployment stage (e.g., 'development', 'production')
+ * @param services - List of services to generate credentials for
+ * @param options - Optional configuration
+ * @param options.projectName - Project name used to derive the database name (e.g., 'myapp' → 'myapp_dev')
  */
 export function createStageSecrets(
 	stage: string,
 	services: ComposeServiceName[],
+	options?: { projectName?: string },
 ): StageSecrets {
 	const now = new Date().toISOString();
 	const serviceCredentials = generateServicesCredentials(services);
+
+	// Override postgres database name with project-derived name if provided
+	if (options?.projectName && serviceCredentials.postgres) {
+		serviceCredentials.postgres.database = `${options.projectName.replace(/-/g, '_')}_dev`;
+	}
+
 	const urls = generateConnectionUrls(serviceCredentials);
 
 	return {

package/src/secrets/index.ts

@@ -86,23 +86,29 @@ export async function secretsInitCommand(
 		);
 	}
 
-	// Generate secrets
-	const secrets = createStageSecrets(stage, services);
-
-	// Detect workspace mode and generate fullstack-aware custom secrets
+	// Detect workspace mode for project name and fullstack secrets
+	let projectName: string | undefined;
+	let workspaceSecrets: Record<string, string> | undefined;
 	try {
 		const loaded = await loadWorkspaceConfig();
+		projectName = loaded.workspace.name;
 		const isMultiApp = Object.keys(loaded.workspace.apps).length > 1;
 
 		if (isMultiApp) {
-			const customSecrets = generateFullstackCustomSecrets(loaded.workspace);
-			secrets.custom = customSecrets;
+			workspaceSecrets = generateFullstackCustomSecrets(loaded.workspace);
 			logger.log('  Detected workspace mode — generating per-app secrets');
 		}
 	} catch {
 		// Not a workspace — single-app mode, skip custom secrets
 	}
 
+	// Generate secrets (with project name so DATABASE_URL matches app-specific URLs)
+	const secrets = createStageSecrets(stage, services, { projectName });
+
+	if (workspaceSecrets) {
+		secrets.custom = workspaceSecrets;
+	}
+
 	// Write to file
 	await writeStageSecrets(secrets);
 

package/src/setup/index.ts

@@ -196,7 +196,9 @@ async function generateFreshSecrets(
 	if (workspace.services.cache) serviceNames.push('redis');
 
 	// Create base secrets with service credentials
-	const secrets = createStageSecrets(stage, serviceNames);
+	const secrets = createStageSecrets(stage, serviceNames, {
+		projectName: workspace.name,
+	});
 
 	// Generate fullstack-aware custom secrets
 	const isMultiApp = Object.keys(workspace.apps).length > 1;

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}`,
-		);
-	}
-}

package/src/workspace/types.ts

@@ -85,7 +85,7 @@ export type FrontendFramework = 'nextjs' | 'remix' | 'vite';
  * @example
  * ```ts
  * // Use specific version
- * db: { version: '16-alpine' }
+ * db: { version: '18-alpine' }
  *
  * // Use custom image
  * db: { image: 'timescale/timescaledb:latest-pg16' }
@@ -144,7 +144,7 @@ export interface MailServiceConfig extends ServiceImageConfig {
  *
  * // Custom versions
  * services: {
- *   db: { version: '16-alpine' },
+ *   db: { version: '18-alpine' },
  *   cache: { version: '7-alpine' },
  * }
  *