create-better-t-stack 2.24.5 → 2.25.0

package/dist/index.js

@@ -3795,6 +3795,7 @@ const DatabaseSetupSchema = enumType([
 	"mongodb-atlas",
 	"supabase",
 	"d1",
+	"docker",
 	"none"
 ]).describe("Database hosting setup");
 const APISchema = enumType([
@@ -4135,21 +4136,43 @@ async function getDBSetupChoice(databaseType, dbSetup, orm, backend, runtime) {
 			label: "Prisma Postgres",
 			hint: "Instant Postgres for Global Applications"
 		}] : [],
+		{
+			value: "docker",
+			label: "Docker",
+			hint: "Run locally with docker compose"
+		},
 		{
 			value: "none",
 			label: "None",
 			hint: "Manual setup"
 		}
 	];
-	else if (databaseType === "mongodb") options = [{
-		value: "mongodb-atlas",
-		label: "MongoDB Atlas",
-		hint: "The most effective way to deploy MongoDB"
+	else if (databaseType === "mysql") options = [{
+		value: "docker",
+		label: "Docker",
+		hint: "Run locally with docker compose"
 	}, {
 		value: "none",
 		label: "None",
 		hint: "Manual setup"
 	}];
+	else if (databaseType === "mongodb") options = [
+		{
+			value: "mongodb-atlas",
+			label: "MongoDB Atlas",
+			hint: "The most effective way to deploy MongoDB"
+		},
+		{
+			value: "docker",
+			label: "Docker",
+			hint: "Run locally with docker compose"
+		},
+		{
+			value: "none",
+			label: "None",
+			hint: "Manual setup"
+		}
+	];
 	else return "none";
 	const response = await select({
 		message: `Select ${databaseType} setup option`,
@@ -5050,6 +5073,14 @@ function processAndValidateFlags(options, providedFlags, projectName) {
 			process.exit(1);
 		}
 	}
+	if (config.dbSetup === "docker" && config.database === "sqlite") {
+		consola$1.fatal("Docker setup is not compatible with SQLite database. SQLite is file-based and doesn't require Docker. Please use '--database postgres', '--database mysql', '--database mongodb', or choose a different setup.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "docker" && config.runtime === "workers") {
+		consola$1.fatal("Docker setup is not compatible with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
+		process.exit(1);
+	}
 	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && config.backend !== "hono") {
 		consola$1.fatal(`Cloudflare Workers runtime (--runtime workers) is only supported with Hono backend (--backend hono). Current backend: ${config.backend}. Please use '--backend hono' or choose a different runtime.`);
 		process.exit(1);
@@ -5070,10 +5101,18 @@ function processAndValidateFlags(options, providedFlags, projectName) {
 		consola$1.fatal("Cloudflare Workers runtime (--runtime workers) is not compatible with MongoDB database. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle ORM. Please use a different database or runtime.");
 		process.exit(1);
 	}
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.dbSetup === "docker") {
+		consola$1.fatal("Cloudflare Workers runtime (--runtime workers) is not compatible with Docker setup. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
+		process.exit(1);
+	}
 	if (providedFlags.has("database") && config.database === "mongodb" && config.runtime === "workers") {
 		consola$1.fatal("MongoDB database is not compatible with Cloudflare Workers runtime. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle ORM. Please use a different database or runtime.");
 		process.exit(1);
 	}
+	if (providedFlags.has("db-setup") && options.dbSetup === "docker" && config.runtime === "workers") {
+		consola$1.fatal("Docker setup (--db-setup docker) is not compatible with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
+		process.exit(1);
+	}
 	const hasWebFrontendFlag = (config.frontend ?? []).some((f) => WEB_FRAMEWORKS.includes(f));
 	if (config.webDeploy && config.webDeploy !== "none" && !hasWebFrontendFlag && providedFlags.has("frontend")) {
 		consola$1.fatal("'--web-deploy' requires a web frontend. Please select a web frontend or set '--web-deploy none'.");
@@ -5864,6 +5903,12 @@ async function handleExtras(projectDir, context) {
 		if (await fs.pathExists(runtimeWorkersDir)) await processAndCopyFiles("**/*", runtimeWorkersDir, projectDir, context, false);
 	}
 }
+async function setupDockerComposeTemplates(projectDir, context) {
+	if (context.dbSetup !== "docker" || context.database === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	const dockerSrcDir = path.join(PKG_ROOT, `templates/db-setup/docker-compose/${context.database}`);
+	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, serverAppDir, context);
+}
 async function setupDeploymentTemplates(projectDir, context) {
 	if (context.webDeploy === "none") return;
 	if (context.webDeploy === "workers") {
@@ -6613,7 +6658,7 @@ async function setupEnvironmentVariables(config) {
 	let corsOrigin = "http://localhost:3001";
 	if (hasReactRouter || hasSvelte) corsOrigin = "http://localhost:5173";
 	let databaseUrl = null;
-	const specializedSetup = dbSetup === "turso" || dbSetup === "prisma-postgres" || dbSetup === "mongodb-atlas" || dbSetup === "neon" || dbSetup === "supabase" || dbSetup === "d1";
+	const specializedSetup = dbSetup === "turso" || dbSetup === "prisma-postgres" || dbSetup === "mongodb-atlas" || dbSetup === "neon" || dbSetup === "supabase" || dbSetup === "d1" || dbSetup === "docker";
 	if (database !== "none" && !specializedSetup) switch (database) {
 		case "postgres":
 			databaseUrl = "postgresql://postgres:password@localhost:5432/postgres";
@@ -6692,6 +6737,35 @@ async function setupCloudflareD1(config) {
 	} catch (_err) {}
 }
 
+//#endregion
+//#region src/helpers/database-providers/docker-compose-setup.ts
+async function setupDockerCompose(config) {
+	const { database, projectDir, projectName } = config;
+	if (database === "none" || database === "sqlite") return;
+	try {
+		await writeEnvFile$4(projectDir, database, projectName);
+	} catch (error) {
+		if (error instanceof Error) console.error(`Error: ${error.message}`);
+	}
+}
+async function writeEnvFile$4(projectDir, database, projectName) {
+	const envPath = path.join(projectDir, "apps/server", ".env");
+	const variables = [{
+		key: "DATABASE_URL",
+		value: getDatabaseUrl(database, projectName),
+		condition: true
+	}];
+	await addEnvVariablesToFile(envPath, variables);
+}
+function getDatabaseUrl(database, projectName) {
+	switch (database) {
+		case "postgres": return `postgresql://postgres:password@localhost:5432/${projectName}`;
+		case "mysql": return `mysql://user:password@localhost:3306/${projectName}`;
+		case "mongodb": return `mongodb://root:password@localhost:27017/${projectName}?authSource=admin`;
+		default: return "";
+	}
+}
+
 //#endregion
 //#region src/utils/command-exists.ts
 async function commandExists(command) {
@@ -7474,7 +7548,8 @@ async function setupDatabase(config) {
 			devDependencies: [],
 			projectDir: serverDir
 		});
-		if (database === "sqlite" && dbSetup === "turso") await setupTurso(config);
+		if (dbSetup === "docker") await setupDockerCompose(config);
+		else if (database === "sqlite" && dbSetup === "turso") await setupTurso(config);
 		else if (database === "sqlite" && dbSetup === "d1") await setupCloudflareD1(config);
 		else if (database === "postgres") {
 			if (orm === "prisma" && dbSetup === "prisma-postgres") await setupPrismaPostgres(config);
@@ -7901,15 +7976,68 @@ async function initializeGit(projectDir, useGit) {
 	await $({ cwd: projectDir })`git commit -m ${"initial commit"}`;
 }
 
+//#endregion
+//#region src/utils/docker-utils.ts
+async function isDockerInstalled() {
+	return commandExists("docker");
+}
+async function isDockerRunning() {
+	try {
+		const { $: $$1 } = await import("execa");
+		await $$1`docker info`;
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getDockerInstallInstructions(platform, database) {
+	const isMac = platform === "darwin";
+	const isWindows = platform === "win32";
+	const isLinux = platform === "linux";
+	let installUrl = "";
+	let platformName = "";
+	if (isMac) {
+		installUrl = "https://docs.docker.com/desktop/setup/install/mac-install/";
+		platformName = "macOS";
+	} else if (isWindows) {
+		installUrl = "https://docs.docker.com/desktop/setup/install/windows-install/";
+		platformName = "Windows";
+	} else if (isLinux) {
+		installUrl = "https://docs.docker.com/desktop/setup/install/linux/";
+		platformName = "Linux";
+	}
+	const databaseName = database === "mongodb" ? "MongoDB" : database === "mysql" ? "MySQL" : "PostgreSQL";
+	return `${pc.yellow("IMPORTANT:")} Docker required for ${databaseName}. Install for ${platformName}:\n${pc.blue(installUrl)}`;
+}
+async function getDockerStatus(database) {
+	const platform = os.platform();
+	const installed = await isDockerInstalled();
+	if (!installed) return {
+		installed: false,
+		running: false,
+		message: getDockerInstallInstructions(platform, database)
+	};
+	const running = await isDockerRunning();
+	if (!running) return {
+		installed: true,
+		running: false,
+		message: `${pc.yellow("IMPORTANT:")} Docker is installed but not running.`
+	};
+	return {
+		installed: true,
+		running: true
+	};
+}
+
 //#endregion
 //#region src/helpers/project-generation/post-installation.ts
-function displayPostInstallInstructions(config) {
+async function displayPostInstallInstructions(config) {
 	const { database, relativePath, packageManager, depsInstalled, orm, addons, runtime, frontend, backend, dbSetup, webDeploy } = config;
 	const isConvex = backend === "convex";
 	const runCmd = packageManager === "npm" ? "npm run" : packageManager;
 	const cdCmd = `cd ${relativePath}`;
 	const hasHuskyOrBiome = addons?.includes("husky") || addons?.includes("biome");
-	const databaseInstructions = !isConvex && database !== "none" ? getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) : "";
+	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) : "";
 	const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(runCmd) : "";
 	const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(runCmd) : "";
 	const nativeInstructions = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles") ? getNativeInstructions(isConvex) : "";
@@ -7978,8 +8106,15 @@ function getNativeInstructions(isConvex) {
 function getLintingInstructions(runCmd) {
 	return `${pc.bold("Linting and formatting:")}\n${pc.cyan("•")} Format and lint fix: ${`${runCmd} check`}\n`;
 }
-function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) {
+async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) {
 	const instructions = [];
+	if (dbSetup === "docker") {
+		const dockerStatus = await getDockerStatus(database);
+		if (dockerStatus.message) {
+			instructions.push(dockerStatus.message);
+			instructions.push("");
+		}
+	}
 	if (runtime === "workers" && dbSetup === "d1") {
 		const packageManager = runCmd === "npm run" ? "npm" : runCmd || "npm";
 		instructions.push(`${pc.cyan("1.")} Login to Cloudflare: ${pc.white(`${packageManager} wrangler login`)}`);
@@ -7993,12 +8128,17 @@ function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) {
 	if (orm === "prisma") {
 		if (database === "sqlite") instructions.push(`${pc.yellow("NOTE:")} Turso support with Prisma is in Early Access and requires additional setup.`, `Learn more at: https://www.prisma.io/docs/orm/overview/databases/turso`);
 		if (runtime === "bun") instructions.push(`${pc.yellow("NOTE:")} Prisma with Bun may require additional configuration. If you encounter errors,\nfollow the guidance provided in the error messages`);
+		if (database === "mongodb" && dbSetup === "docker") instructions.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination may not work.`);
+		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 		instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
 		instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 	} else if (orm === "drizzle") {
+		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 		instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
 		instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 		if (database === "sqlite" && dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Start local DB (if needed): ${`cd apps/server && ${runCmd} db:local`}`);
+	} else if (orm === "mongoose") {
+		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 	} else if (orm === "none") instructions.push(`${pc.yellow("NOTE:")} Manual database schema setup required.`);
 	return instructions.length ? `${pc.bold("Database commands:")}\n${instructions.join("\n")}` : "";
 }
@@ -8065,6 +8205,12 @@ async function updateRootPackageJson(projectDir, options) {
 				scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
 			}
 		}
+		if (options.dbSetup === "docker") {
+			scripts["db:start"] = `turbo -F ${backendPackageName} db:start`;
+			scripts["db:watch"] = `turbo -F ${backendPackageName} db:watch`;
+			scripts["db:stop"] = `turbo -F ${backendPackageName} db:stop`;
+			scripts["db:down"] = `turbo -F ${backendPackageName} db:down`;
+		}
 	} else if (options.packageManager === "pnpm") {
 		scripts.dev = devScript;
 		scripts.build = "pnpm -r build";
@@ -8084,6 +8230,12 @@ async function updateRootPackageJson(projectDir, options) {
 				scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
 			}
 		}
+		if (options.dbSetup === "docker") {
+			scripts["db:start"] = `pnpm --filter ${backendPackageName} db:start`;
+			scripts["db:watch"] = `pnpm --filter ${backendPackageName} db:watch`;
+			scripts["db:stop"] = `pnpm --filter ${backendPackageName} db:stop`;
+			scripts["db:down"] = `pnpm --filter ${backendPackageName} db:down`;
+		}
 	} else if (options.packageManager === "npm") {
 		scripts.dev = devScript;
 		scripts.build = "npm run build --workspaces";
@@ -8103,6 +8255,12 @@ async function updateRootPackageJson(projectDir, options) {
 				scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
 			}
 		}
+		if (options.dbSetup === "docker") {
+			scripts["db:start"] = `npm run db:start --workspace ${backendPackageName}`;
+			scripts["db:watch"] = `npm run db:watch --workspace ${backendPackageName}`;
+			scripts["db:stop"] = `npm run db:stop --workspace ${backendPackageName}`;
+			scripts["db:down"] = `npm run db:down --workspace ${backendPackageName}`;
+		}
 	} else if (options.packageManager === "bun") {
 		scripts.dev = devScript;
 		scripts.build = "bun run --filter '*' build";
@@ -8122,6 +8280,12 @@ async function updateRootPackageJson(projectDir, options) {
 				scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
 			}
 		}
+		if (options.dbSetup === "docker") {
+			scripts["db:start"] = `bun run --filter ${backendPackageName} db:start`;
+			scripts["db:watch"] = `bun run --filter ${backendPackageName} db:watch`;
+			scripts["db:stop"] = `bun run --filter ${backendPackageName} db:stop`;
+			scripts["db:down"] = `bun run --filter ${backendPackageName} db:down`;
+		}
 	}
 	if (options.addons.includes("biome")) scripts.check = "biome check --write .";
 	if (options.addons.includes("husky")) {
@@ -8166,6 +8330,12 @@ async function updateServerPackageJson(projectDir, options) {
 			scripts["db:migrate"] = "drizzle-kit migrate";
 		}
 	}
+	if (options.dbSetup === "docker") {
+		scripts["db:start"] = "docker compose up -d";
+		scripts["db:watch"] = "docker compose up";
+		scripts["db:stop"] = "docker compose stop";
+		scripts["db:down"] = "docker compose down";
+	}
 	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
 }
 async function updateConvexPackageJson(projectDir, options) {
@@ -8189,6 +8359,7 @@ async function createProject(options) {
 		await setupBackendFramework(projectDir, options);
 		if (!isConvex) {
 			await setupDbOrmTemplates(projectDir, options);
+			await setupDockerComposeTemplates(projectDir, options);
 			await setupAuthTemplate(projectDir, options);
 		}
 		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamplesTemplate(projectDir, options);
@@ -8218,7 +8389,7 @@ async function createProject(options) {
 			await generateCloudflareWorkerTypes(options);
 		}
 		await initializeGit(projectDir, options.git);
-		displayPostInstallInstructions({
+		await displayPostInstallInstructions({
 			...options,
 			depsInstalled: options.install
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "2.24.5",
+  "version": "2.25.0",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "type": "module",
   "license": "MIT",

package/templates/addons/turborepo/turbo.json.hbs

@@ -39,5 +39,23 @@
 			"persistent": true
 		}
 		{{/unless}}{{/if}}
+		{{#if (eq dbSetup "docker")}},
+		"db:start": {
+			"cache": false,
+			"persistent": true
+		},
+		"db:stop": {
+			"cache": false,
+			"persistent": true
+		},
+		"db:watch": {
+			"cache": false,
+			"persistent": true
+		},
+		"db:down": {
+			"cache": false,
+			"persistent": true
+		}
+		{{/if}}
 	}
 }

package/templates/db-setup/docker-compose/mongodb/docker-compose.yml.hbs

@@ -0,0 +1,23 @@
+name: {{projectName}}
+
+services:
+  mongodb:
+    image: mongo
+    container_name: {{projectName}}-mongodb
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: password
+      MONGO_INITDB_DATABASE: {{projectName}}
+    ports:
+      - "27017:27017"
+    volumes:
+      - {{projectName}}_mongodb_data:/data/db
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+volumes:
+  {{projectName}}_mongodb_data:

package/templates/db-setup/docker-compose/mysql/docker-compose.yml.hbs

@@ -0,0 +1,24 @@
+name: {{projectName}}
+
+services:
+  mysql:
+    image: mysql
+    container_name: {{projectName}}-mysql
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+      MYSQL_DATABASE: {{projectName}}
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+    ports:
+      - "3306:3306"
+    volumes:
+      - {{projectName}}_mysql_data:/var/lib/mysql
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+volumes:
+  {{projectName}}_mysql_data:

package/templates/db-setup/docker-compose/postgres/docker-compose.yml.hbs

@@ -0,0 +1,23 @@
+name: {{projectName}}
+
+services:
+  postgres:
+    image: postgres
+    container_name: {{projectName}}-postgres
+    environment:
+      POSTGRES_DB: {{projectName}}
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+    ports:
+      - "5432:5432"
+    volumes:
+      - {{projectName}}_postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+
+volumes:
+  {{projectName}}_postgres_data: