@geekmidas/cli 1.5.0 → 1.6.0

package/src/dev/index.ts

@@ -1,11 +1,12 @@
 import { type ChildProcess, execSync, spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:net';
 import { dirname, join, resolve } from 'node:path';
 import chokidar from 'chokidar';
 import { config as dotenvConfig } from 'dotenv';
 import fg from 'fast-glob';
+import { parse as parseYaml } from 'yaml';
 import { resolveProviders } from '../build/providerResolver';
 import type {
 	BuildContext,
@@ -17,6 +18,7 @@ import type {
 import {
 	getAppNameFromCwd,
 	loadAppConfig,
+	loadWorkspaceAppInfo,
 	loadWorkspaceConfig,
 	parseModuleConfig,
 } from '../config';
@@ -137,6 +139,255 @@ export async function findAvailablePort(
 	);
 }
 
+/**
+ * A port mapping extracted from docker-compose.yml.
+ * Only entries using env var interpolation (e.g., `${VAR:-default}:container`) are captured.
+ */
+export interface ComposePortMapping {
+	service: string;
+	envVar: string;
+	defaultPort: number;
+	containerPort: number;
+}
+
+/** Port state persisted to .gkm/ports.json, keyed by env var name. */
+export type PortState = Record<string, number>;
+
+export interface ResolvedServicePorts {
+	dockerEnv: Record<string, string>;
+	ports: PortState;
+	mappings: ComposePortMapping[];
+}
+
+const PORT_STATE_PATH = '.gkm/ports.json';
+
+/**
+ * Parse docker-compose.yml and extract all port mappings that use env var interpolation.
+ * Entries like `'${POSTGRES_HOST_PORT:-5432}:5432'` are captured.
+ * Fixed port mappings like `'5050:80'` are skipped.
+ * @internal Exported for testing
+ */
+export function parseComposePortMappings(
+	composePath: string,
+): ComposePortMapping[] {
+	if (!existsSync(composePath)) {
+		return [];
+	}
+
+	const content = readFileSync(composePath, 'utf-8');
+	const compose = parseYaml(content) as {
+		services?: Record<string, { ports?: string[] }>;
+	};
+
+	if (!compose?.services) {
+		return [];
+	}
+
+	const results: ComposePortMapping[] = [];
+
+	for (const [serviceName, serviceConfig] of Object.entries(compose.services)) {
+		for (const portMapping of serviceConfig?.ports ?? []) {
+			const match = String(portMapping).match(/\$\{(\w+):-(\d+)\}:(\d+)/);
+			if (match?.[1] && match[2] && match[3]) {
+				results.push({
+					service: serviceName,
+					envVar: match[1],
+					defaultPort: Number(match[2]),
+					containerPort: Number(match[3]),
+				});
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Load saved port state from .gkm/ports.json.
+ * @internal Exported for testing
+ */
+export async function loadPortState(workspaceRoot: string): Promise<PortState> {
+	try {
+		const raw = await readFile(join(workspaceRoot, PORT_STATE_PATH), 'utf-8');
+		return JSON.parse(raw) as PortState;
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Save port state to .gkm/ports.json.
+ * @internal Exported for testing
+ */
+export async function savePortState(
+	workspaceRoot: string,
+	ports: PortState,
+): Promise<void> {
+	const dir = join(workspaceRoot, '.gkm');
+	await mkdir(dir, { recursive: true });
+	await writeFile(
+		join(workspaceRoot, PORT_STATE_PATH),
+		`${JSON.stringify(ports, null, 2)}\n`,
+	);
+}
+
+/**
+ * Check if a project's own Docker container is running and return its host port.
+ * Uses `docker compose port` scoped to the project's compose file.
+ * @internal Exported for testing
+ */
+export function getContainerHostPort(
+	workspaceRoot: string,
+	service: string,
+	containerPort: number,
+): number | null {
+	try {
+		const result = execSync(`docker compose port ${service} ${containerPort}`, {
+			cwd: workspaceRoot,
+			stdio: 'pipe',
+		})
+			.toString()
+			.trim();
+		const match = result.match(/:(\d+)$/);
+		return match ? Number(match[1]) : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Resolve host ports for Docker services by parsing docker-compose.yml.
+ * Priority: running container → saved state → find available port.
+ * Persists resolved ports to .gkm/ports.json.
+ * @internal Exported for testing
+ */
+export async function resolveServicePorts(
+	workspaceRoot: string,
+): Promise<ResolvedServicePorts> {
+	const composePath = join(workspaceRoot, 'docker-compose.yml');
+	const mappings = parseComposePortMappings(composePath);
+
+	if (mappings.length === 0) {
+		return { dockerEnv: {}, ports: {}, mappings: [] };
+	}
+
+	const savedState = await loadPortState(workspaceRoot);
+	const dockerEnv: Record<string, string> = {};
+	const ports: PortState = {};
+
+	logger.log('\n🔌 Resolving service ports...');
+
+	for (const mapping of mappings) {
+		// 1. Check if own container is already running
+		const containerPort = getContainerHostPort(
+			workspaceRoot,
+			mapping.service,
+			mapping.containerPort,
+		);
+		if (containerPort !== null) {
+			ports[mapping.envVar] = containerPort;
+			dockerEnv[mapping.envVar] = String(containerPort);
+			logger.log(
+				`   🔄 ${mapping.service}:${mapping.containerPort}: reusing existing container on port ${containerPort}`,
+			);
+			continue;
+		}
+
+		// 2. Check saved port state
+		const savedPort = savedState[mapping.envVar];
+		if (savedPort && (await isPortAvailable(savedPort))) {
+			ports[mapping.envVar] = savedPort;
+			dockerEnv[mapping.envVar] = String(savedPort);
+			logger.log(
+				`   💾 ${mapping.service}:${mapping.containerPort}: using saved port ${savedPort}`,
+			);
+			continue;
+		}
+
+		// 3. Find available port
+		const resolvedPort = await findAvailablePort(mapping.defaultPort);
+		ports[mapping.envVar] = resolvedPort;
+		dockerEnv[mapping.envVar] = String(resolvedPort);
+
+		if (resolvedPort !== mapping.defaultPort) {
+			logger.log(
+				`   ⚡ ${mapping.service}:${mapping.containerPort}: port ${mapping.defaultPort} occupied, using port ${resolvedPort}`,
+			);
+		} else {
+			logger.log(
+				`   ✅ ${mapping.service}:${mapping.containerPort}: using default port ${resolvedPort}`,
+			);
+		}
+	}
+
+	await savePortState(workspaceRoot, ports);
+
+	return { dockerEnv, ports, mappings };
+}
+
+/**
+ * Replace a port in a URL string.
+ * Handles both `hostname:port` and `localhost:port` patterns.
+ * @internal Exported for testing
+ */
+export function replacePortInUrl(
+	url: string,
+	oldPort: number,
+	newPort: number,
+): string {
+	if (oldPort === newPort) return url;
+	return url.replace(new RegExp(`:${oldPort}(?=/|$)`, 'g'), `:${newPort}`);
+}
+
+/**
+ * Rewrite connection URLs and port vars in secrets with resolved ports.
+ * Uses the parsed compose mappings to determine which default ports to replace.
+ * Pure transform — does not modify secrets on disk.
+ * @internal Exported for testing
+ */
+export function rewriteUrlsWithPorts(
+	secrets: Record<string, string>,
+	resolvedPorts: ResolvedServicePorts,
+): Record<string, string> {
+	const { ports, mappings } = resolvedPorts;
+	const result = { ...secrets };
+
+	// Build a map of defaultPort → resolvedPort for all changed ports
+	const portReplacements: { defaultPort: number; resolvedPort: number }[] = [];
+	for (const mapping of mappings) {
+		const resolved = ports[mapping.envVar];
+		if (resolved !== undefined) {
+			portReplacements.push({
+				defaultPort: mapping.defaultPort,
+				resolvedPort: resolved,
+			});
+		}
+	}
+
+	// Rewrite _PORT env vars whose values match a default port
+	for (const [key, value] of Object.entries(result)) {
+		if (!key.endsWith('_PORT')) continue;
+		for (const { defaultPort, resolvedPort } of portReplacements) {
+			if (value === String(defaultPort)) {
+				result[key] = String(resolvedPort);
+			}
+		}
+	}
+
+	// Rewrite URLs containing default ports
+	for (const [key, value] of Object.entries(result)) {
+		if (!key.endsWith('_URL') && key !== 'DATABASE_URL') continue;
+
+		let rewritten = value;
+		for (const { defaultPort, resolvedPort } of portReplacements) {
+			rewritten = replacePortInUrl(rewritten, defaultPort, resolvedPort);
+		}
+		result[key] = rewritten;
+	}
+
+	return result;
+}
+
 /**
  * Normalize telescope configuration
  * @internal Exported for testing
@@ -578,11 +829,12 @@ export async function devCommand(options: DevOptions): Promise<void> {
 					resolved.providers[0] as LegacyProvider,
 					enableOpenApi,
 					appRoot,
+					true, // bust module cache on rebuild
 				);
 
 				// Regenerate OpenAPI if enabled
 				if (enableOpenApi) {
-					await generateOpenApi(config, { silent: true });
+					await generateOpenApi(config, { silent: true, bustCache: true });
 				}
 
 				logger.log('✅ Rebuild complete, restarting server...');
@@ -848,6 +1100,7 @@ export async function loadSecretsForApp(
  */
 export async function startWorkspaceServices(
 	workspace: NormalizedWorkspace,
+	portEnv?: Record<string, string>,
 ): Promise<void> {
 	const services = workspace.services;
 	if (!services.db && !services.cache && !services.mail) {
@@ -886,6 +1139,7 @@ export async function startWorkspaceServices(
 		execSync(`docker compose up -d ${servicesToStart.join(' ')}`, {
 			cwd: workspace.root,
 			stdio: 'inherit',
+			env: { ...process.env, ...portEnv },
 		});
 
 		logger.log('✅ Services started');
@@ -972,11 +1226,17 @@ async function workspaceDevCommand(
 		}
 	}
 
-	// Start docker-compose services
-	await startWorkspaceServices(workspace);
+	// Resolve dynamic service ports from docker-compose.yml
+	const resolvedPorts = await resolveServicePorts(workspace.root);
+
+	// Start docker-compose services with resolved ports
+	await startWorkspaceServices(workspace, resolvedPorts.dockerEnv);
 
-	// Load secrets if enabled
-	const secretsEnv = await loadDevSecrets(workspace);
+	// Load secrets if enabled, then rewrite URLs with resolved ports
+	const secretsEnv = rewriteUrlsWithPorts(
+		await loadDevSecrets(workspace),
+		resolvedPorts,
+	);
 	if (Object.keys(secretsEnv).length > 0) {
 		logger.log(`   Loaded ${Object.keys(secretsEnv).length} secret(s)`);
 	}
@@ -1196,6 +1456,7 @@ async function buildServer(
 	provider: LegacyProvider,
 	enableOpenApi: boolean,
 	appRoot: string = process.cwd(),
+	bustCache = false,
 ): Promise<void> {
 	// Initialize generators
 	const endpointGenerator = new EndpointGenerator();
@@ -1206,11 +1467,13 @@ async function buildServer(
 	// Load all constructs (resolve paths relative to appRoot)
 	const [allEndpoints, allFunctions, allCrons, allSubscribers] =
 		await Promise.all([
-			endpointGenerator.load(config.routes, appRoot),
-			config.functions ? functionGenerator.load(config.functions, appRoot) : [],
-			config.crons ? cronGenerator.load(config.crons, appRoot) : [],
+			endpointGenerator.load(config.routes, appRoot, bustCache),
+			config.functions
+				? functionGenerator.load(config.functions, appRoot, bustCache)
+				: [],
+			config.crons ? cronGenerator.load(config.crons, appRoot, bustCache) : [],
 			config.subscribers
-				? subscriberGenerator.load(config.subscribers, appRoot)
+				? subscriberGenerator.load(config.subscribers, appRoot, bustCache)
 				: [],
 		]);
 
@@ -1347,10 +1610,10 @@ export async function prepareEntryCredentials(options: {
 	let appName: string | undefined;
 
 	try {
-		const appConfig = await loadAppConfig(cwd);
-		workspaceAppPort = appConfig.app.port;
-		secretsRoot = appConfig.workspaceRoot;
-		appName = appConfig.appName;
+		const appInfo = await loadWorkspaceAppInfo(cwd);
+		workspaceAppPort = appInfo.app.port;
+		secretsRoot = appInfo.workspaceRoot;
+		appName = appInfo.appName;
 	} catch (error) {
 		// Not in a workspace - use defaults
 		logger.log(
@@ -1842,7 +2105,7 @@ export async function execCommand(
 
 	// Prepare credentials (loads workspace config and secrets)
 	// Don't inject PORT for exec since we're not running a server
-	const { credentials, secretsJsonPath, appName } =
+	const { credentials, secretsJsonPath, appName, secretsRoot } =
 		await prepareEntryCredentials({ cwd });
 
 	if (appName) {
@@ -1856,6 +2119,33 @@ export async function execCommand(
 		logger.log(`🔐 Loaded ${secretCount} secret(s)`);
 	}
 
+	// Rewrite URLs with resolved Docker ports (from gkm dev)
+	const composePath = join(secretsRoot, 'docker-compose.yml');
+	const mappings = parseComposePortMappings(composePath);
+	if (mappings.length > 0) {
+		const ports = await loadPortState(secretsRoot);
+		if (Object.keys(ports).length > 0) {
+			const rewritten = rewriteUrlsWithPorts(credentials, {
+				dockerEnv: {},
+				ports,
+				mappings,
+			});
+			Object.assign(credentials, rewritten);
+			logger.log(`🔌 Applied ${Object.keys(ports).length} port mapping(s)`);
+		}
+	}
+
+	// Inject dependency URLs (works for both frontend and backend apps)
+	try {
+		const appInfo = await loadWorkspaceAppInfo(cwd);
+		if (appInfo.appName) {
+			const depEnv = getDependencyEnvVars(appInfo.workspace, appInfo.appName);
+			Object.assign(credentials, depEnv);
+		}
+	} catch {
+		// Not in a workspace — skip dependency URL injection
+	}
+
 	// Create preload script that injects Credentials
 	// Create in cwd so package resolution works (finds node_modules in app directory)
 	const preloadDir = join(cwd, '.gkm');
@@ -1864,13 +2154,18 @@ export async function execCommand(
 	await createCredentialsPreload(preloadPath, secretsJsonPath);
 
 	// Build command
-	const [cmd, ...args] = commandArgs;
+	const [cmd, ...rawArgs] = commandArgs;
 
 	if (!cmd) {
 		throw new Error('No command specified');
 	}
 
-	logger.log(`🚀 Running: ${commandArgs.join(' ')}`);
+	// Replace template variables in command args (e.g. $PORT -> resolved port)
+	const args = rawArgs.map((arg) =>
+		arg.replace(/\$PORT\b/g, credentials.PORT ?? '3000'),
+	);
+
+	logger.log(`🚀 Running: ${[cmd, ...args].join(' ')}`);
 
 	// Merge NODE_OPTIONS with existing value (if any)
 	// Add tsx loader first so our .ts preload can be loaded

package/src/generators/FunctionGenerator.ts

@@ -99,7 +99,7 @@ export class FunctionGenerator extends ConstructGenerator<
 			context.loggerPath,
 		);
 
-		const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
+		const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/aws';
 import { ${exportName} } from '${importPath}';
 import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
 import ${context.loggerImportPattern} from '${relativeLoggerPath}';

package/src/generators/Generator.ts

@@ -34,6 +34,7 @@ export abstract class ConstructGenerator<T extends Construct, R = void> {
 	async load(
 		patterns?: Routes,
 		cwd = process.cwd(),
+		bustCache = false,
 	): Promise<GeneratedConstruct<T>[]> {
 		const logger = console;
 
@@ -56,7 +57,9 @@ export abstract class ConstructGenerator<T extends Construct, R = void> {
 		for await (const f of files) {
 			try {
 				const file = f.toString();
-				const module = await import(file);
+				// Append cache-busting query param to force re-import of changed modules
+				const importPath = bustCache ? `${file}?t=${Date.now()}` : file;
+				const module = await import(importPath);
 
 				// Check all exports for constructs
 				for (const [key, construct] of Object.entries(module)) {

package/src/init/__tests__/generators.spec.ts

@@ -5,7 +5,9 @@ import { generateEnvFiles } from '../generators/env.js';
 import { generateModelsPackage } from '../generators/models.js';
 import { generateMonorepoFiles } from '../generators/monorepo.js';
 import { generatePackageJson } from '../generators/package.js';
+import { generateTestFiles } from '../generators/test.js';
 import { generateUiPackageFiles } from '../generators/ui.js';
+import { apiTemplate } from '../templates/api.js';
 import type { TemplateOptions } from '../templates/index.js';
 import { minimalTemplate } from '../templates/minimal.js';
 import { serverlessTemplate } from '../templates/serverless.js';
@@ -211,31 +213,46 @@ describe('generateDockerFiles', () => {
 		expect(files[0].path).toBe('docker-compose.yml');
 	});
 
-	it('should include postgres when database is enabled', () => {
+	it('should include postgres with dynamic port when database is enabled', () => {
 		const files = generateDockerFiles(baseOptions, minimalTemplate);
 		expect(files[0].content).toContain('postgres');
-		expect(files[0].content).toContain('5432');
+		expect(files[0].content).toContain("'${POSTGRES_HOST_PORT:-5432}:5432'");
 	});
 
-	it('should include redis', () => {
+	it('should include redis with dynamic port', () => {
 		const files = generateDockerFiles(baseOptions, minimalTemplate);
 		expect(files[0].content).toContain('redis');
-		expect(files[0].content).toContain('6379');
+		expect(files[0].content).toContain("'${REDIS_HOST_PORT:-6379}:6379'");
 	});
 
-	it('should include serverless-redis-http for serverless template', () => {
+	it('should include serverless-redis-http with dynamic port for serverless template', () => {
 		const options = { ...baseOptions, template: 'serverless' as const };
 		const files = generateDockerFiles(options, serverlessTemplate);
 		expect(files[0].content).toContain('hiett/serverless-redis-http');
-		expect(files[0].content).toContain('8079');
+		expect(files[0].content).toContain("'${SRH_HOST_PORT:-8079}:80'");
 	});
 
-	it('should include rabbitmq for worker template', () => {
+	it('should include rabbitmq with dynamic ports for worker template', () => {
 		const options = { ...baseOptions, template: 'worker' as const };
 		const files = generateDockerFiles(options, workerTemplate);
 		expect(files[0].content).toContain('rabbitmq');
-		expect(files[0].content).toContain('5672');
-		expect(files[0].content).toContain('15672');
+		expect(files[0].content).toContain("'${RABBITMQ_HOST_PORT:-5672}:5672'");
+		expect(files[0].content).toContain(
+			"'${RABBITMQ_MGMT_HOST_PORT:-15672}:15672'",
+		);
+	});
+
+	it('should include mailpit with dynamic ports when mail is enabled', () => {
+		const options = {
+			...baseOptions,
+			services: { db: true, cache: true, mail: true },
+		};
+		const files = generateDockerFiles(options, minimalTemplate);
+		expect(files[0].content).toContain('mailpit');
+		expect(files[0].content).toContain(
+			"'${MAILPIT_SMTP_HOST_PORT:-1025}:1025'",
+		);
+		expect(files[0].content).toContain("'${MAILPIT_UI_HOST_PORT:-8025}:8025'");
 	});
 });
 
@@ -557,15 +574,15 @@ describe('generateUiPackageFiles', () => {
 			(f) => f.path === 'packages/ui/src/components/ui/index.ts',
 		);
 		expect(indexFile).toBeDefined();
-		expect(indexFile!.content).toContain("from './button'");
-		expect(indexFile!.content).toContain("from './input'");
-		expect(indexFile!.content).toContain("from './card'");
-		expect(indexFile!.content).toContain("from './label'");
-		expect(indexFile!.content).toContain("from './badge'");
-		expect(indexFile!.content).toContain("from './separator'");
-		expect(indexFile!.content).toContain("from './tabs'");
-		expect(indexFile!.content).toContain("from './tooltip'");
-		expect(indexFile!.content).toContain("from './dialog'");
+		expect(indexFile!.content).toContain("from './button.tsx'");
+		expect(indexFile!.content).toContain("from './input.tsx'");
+		expect(indexFile!.content).toContain("from './card.tsx'");
+		expect(indexFile!.content).toContain("from './label.tsx'");
+		expect(indexFile!.content).toContain("from './badge.tsx'");
+		expect(indexFile!.content).toContain("from './separator.tsx'");
+		expect(indexFile!.content).toContain("from './tabs.tsx'");
+		expect(indexFile!.content).toContain("from './tooltip.tsx'");
+		expect(indexFile!.content).toContain("from './dialog.tsx'");
 	});
 
 	it('should include cn utility function', () => {
@@ -645,3 +662,135 @@ describe('generateUiPackageFiles', () => {
 		expect(config.compilerOptions.paths['~/*']).toEqual(['./src/*']);
 	});
 });
+
+describe('generateTestFiles', () => {
+	it('should return empty array when database is disabled', () => {
+		const options = { ...baseOptions, database: false };
+		const files = generateTestFiles(options, minimalTemplate);
+		expect(files).toHaveLength(0);
+	});
+
+	it('should generate all test infrastructure files when database is enabled', () => {
+		const files = generateTestFiles(baseOptions, minimalTemplate);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('test/config.ts');
+		expect(paths).toContain('test/globalSetup.ts');
+		expect(paths).toContain('test/factory/index.ts');
+		expect(paths).toContain('test/factory/users.ts');
+		expect(paths).toContain('test/example.spec.ts');
+	});
+
+	it('should use wrapVitestKyselyTransaction in config', () => {
+		const files = generateTestFiles(baseOptions, minimalTemplate);
+		const configFile = files.find((f) => f.path === 'test/config.ts');
+		expect(configFile).toBeDefined();
+		expect(configFile!.content).toContain('wrapVitestKyselyTransaction');
+		expect(configFile!.content).toContain('@geekmidas/testkit/kysely');
+		expect(configFile!.content).toContain('~/services/database.ts');
+	});
+
+	it('should use PostgresKyselyMigrator in globalSetup', () => {
+		const files = generateTestFiles(baseOptions, minimalTemplate);
+		const setupFile = files.find((f) => f.path === 'test/globalSetup.ts');
+		expect(setupFile).toBeDefined();
+		expect(setupFile!.content).toContain('PostgresKyselyMigrator');
+		expect(setupFile!.content).toContain('_test');
+		expect(setupFile!.content).toContain('migrateToLatest');
+	});
+
+	it('should use KyselyFactory in factory files', () => {
+		const files = generateTestFiles(baseOptions, minimalTemplate);
+		const factoryIndex = files.find((f) => f.path === 'test/factory/index.ts');
+		expect(factoryIndex).toBeDefined();
+		expect(factoryIndex!.content).toContain('KyselyFactory');
+		expect(factoryIndex!.content).toContain('createFactory');
+
+		const usersBuilder = files.find((f) => f.path === 'test/factory/users.ts');
+		expect(usersBuilder).toBeDefined();
+		expect(usersBuilder!.content).toContain('KyselyFactory.createBuilder');
+		expect(usersBuilder!.content).toContain("'users'");
+	});
+
+	it('should generate example spec with transaction-wrapped it', () => {
+		const files = generateTestFiles(baseOptions, minimalTemplate);
+		const exampleSpec = files.find((f) => f.path === 'test/example.spec.ts');
+		expect(exampleSpec).toBeDefined();
+		expect(exampleSpec!.content).toContain("from './config.ts'");
+		expect(exampleSpec!.content).toContain('{ db }');
+	});
+
+	it('should work with fullstack template options', () => {
+		const options: TemplateOptions = {
+			...baseOptions,
+			template: 'fullstack',
+			monorepo: true,
+			apiPath: 'apps/api',
+		};
+		const files = generateTestFiles(options, apiTemplate);
+		expect(files.length).toBeGreaterThan(0);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('test/config.ts');
+		expect(paths).toContain('test/globalSetup.ts');
+	});
+});
+
+describe('generateConfigFiles - vitest.config.ts', () => {
+	it('should generate vitest.config.ts when database is enabled (standalone)', () => {
+		const files = generateConfigFiles(baseOptions, minimalTemplate);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('vitest.config.ts');
+
+		const vitestConfig = files.find((f) => f.path === 'vitest.config.ts');
+		expect(vitestConfig!.content).toContain('globalSetup');
+		expect(vitestConfig!.content).toContain('./test/globalSetup.ts');
+		expect(vitestConfig!.content).toContain('vite-tsconfig-paths');
+		expect(vitestConfig!.content).not.toContain('globals: true');
+	});
+
+	it('should not generate vitest.config.ts when database is disabled', () => {
+		const options = { ...baseOptions, database: false };
+		const files = generateConfigFiles(options, minimalTemplate);
+		const paths = files.map((f) => f.path);
+		expect(paths).not.toContain('vitest.config.ts');
+	});
+
+	it('should generate vitest.config.ts for monorepo app with database', () => {
+		const options: TemplateOptions = {
+			...baseOptions,
+			monorepo: true,
+			apiPath: 'apps/api',
+		};
+		const files = generateConfigFiles(options, minimalTemplate);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('vitest.config.ts');
+	});
+
+	it('should generate vitest.config.ts for fullstack template with database', () => {
+		const options: TemplateOptions = {
+			...baseOptions,
+			template: 'fullstack',
+			monorepo: true,
+			apiPath: 'apps/api',
+		};
+		const files = generateConfigFiles(options, apiTemplate);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('vitest.config.ts');
+	});
+});
+
+describe('generatePackageJson - testkit dependencies', () => {
+	it('should include testkit and faker when database is enabled', () => {
+		const files = generatePackageJson(baseOptions, minimalTemplate);
+		const pkg = JSON.parse(files[0].content);
+		expect(pkg.devDependencies['@geekmidas/testkit']).toMatch(/^~/);
+		expect(pkg.devDependencies['@faker-js/faker']).toMatch(/^~/);
+	});
+
+	it('should not include testkit when database is disabled', () => {
+		const options = { ...baseOptions, database: false };
+		const files = generatePackageJson(options, minimalTemplate);
+		const pkg = JSON.parse(files[0].content);
+		expect(pkg.devDependencies['@geekmidas/testkit']).toBeUndefined();
+		expect(pkg.devDependencies['@faker-js/faker']).toBeUndefined();
+	});
+});