create-better-t-stack 2.33.8-canary.98a850ad → 2.33.9-canary.7db03e6d

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createBtsCli } from "./src-D0MPVT22.js";
+import { createBtsCli } from "./src-CEmXO3U_.js";
 
 //#region src/cli.ts
 createBtsCli().run();

package/dist/index.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { builder, createBtsCli, docs, init, router, sponsors } from "./src-D0MPVT22.js";
+import { builder, createBtsCli, docs, init, router, sponsors } from "./src-CEmXO3U_.js";
 
 export { builder, createBtsCli, docs, init, router, sponsors };

package/dist/{src-D0MPVT22.js → src-CEmXO3U_.js}

@@ -5,7 +5,6 @@ import { createCli, trpcServer } from "trpc-cli";
 import z from "zod";
 import path from "node:path";
 import consola, { consola as consola$1 } from "consola";
-import * as fs$1 from "fs-extra";
 import fs from "fs-extra";
 import { fileURLToPath } from "node:url";
 import gradient from "gradient-string";
@@ -137,7 +136,8 @@ const ADDON_COMPATIBILITY = {
 		"react-router",
 		"nuxt",
 		"svelte",
-		"solid"
+		"solid",
+		"next"
 	],
 	biome: [],
 	husky: [],
@@ -565,6 +565,20 @@ function validateWebDeployRequiresWebFrontend(webDeploy, hasWebFrontendFlag) {
 function validateServerDeployRequiresBackend(serverDeploy, backend) {
 	if (serverDeploy && serverDeploy !== "none" && (!backend || backend === "none")) exitWithError("'--server-deploy' requires a backend. Please select a backend or set '--server-deploy none'.");
 }
+function validateAddonsAgainstFrontends(addons = [], frontends = []) {
+	for (const addon of addons) {
+		if (addon === "none") continue;
+		const { isCompatible, reason } = validateAddonCompatibility(addon, frontends);
+		if (!isCompatible) exitWithError(`Incompatible addon/frontend combination: ${reason}`);
+	}
+}
+function validateExamplesCompatibility(examples, backend, database, frontend) {
+	const examplesArr = examples ?? [];
+	if (examplesArr.length === 0 || examplesArr.includes("none")) return;
+	if (examplesArr.includes("todo") && backend !== "convex" && backend !== "none" && database === "none") exitWithError("The 'todo' example requires a database if a backend (other than Convex) is present. Cannot use --examples todo when database is 'none' and a backend is selected.");
+	if (examplesArr.includes("ai") && backend === "elysia") exitWithError("The 'ai' example is not compatible with the Elysia backend.");
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) exitWithError("The 'ai' example is not compatible with the Solid frontend.");
+}
 
 //#endregion
 //#region src/prompts/api.ts
@@ -1298,9 +1312,9 @@ async function getProjectName(initialName) {
 
 //#endregion
 //#region src/utils/get-latest-cli-version.ts
-const getLatestCLIVersion = async () => {
+const getLatestCLIVersion = () => {
 	const packageJsonPath = path.join(PKG_ROOT, "package.json");
-	const packageJsonContent = await fs.readJSON(packageJsonPath);
+	const packageJsonContent = fs.readJSONSync(packageJsonPath);
 	return packageJsonContent.version ?? "1.0.0";
 };
 
@@ -1662,6 +1676,43 @@ function processAndValidateFlags(options, providedFlags, projectName) {
 	validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
 	return config;
 }
+function validateConfigCompatibility(config) {
+	const effectiveDatabase = config.database;
+	const effectiveBackend = config.backend;
+	const effectiveFrontend = config.frontend;
+	const effectiveApi = config.api;
+	validateApiFrontendCompatibility(effectiveApi, effectiveFrontend);
+	if (config.addons && config.addons.length > 0) {
+		validateAddonsAgainstFrontends(config.addons, effectiveFrontend);
+		config.addons = [...new Set(config.addons)];
+	}
+	validateExamplesCompatibility(config.examples ?? [], effectiveBackend, effectiveDatabase, effectiveFrontend ?? []);
+}
+function processProvidedFlagsWithoutValidation(options, projectName) {
+	const config = {};
+	if (options.api) config.api = options.api;
+	if (options.backend) config.backend = options.backend;
+	if (options.database) config.database = options.database;
+	if (options.orm) config.orm = options.orm;
+	if (options.auth !== void 0) config.auth = options.auth;
+	if (options.git !== void 0) config.git = options.git;
+	if (options.install !== void 0) config.install = options.install;
+	if (options.runtime) config.runtime = options.runtime;
+	if (options.dbSetup) config.dbSetup = options.dbSetup;
+	if (options.packageManager) config.packageManager = options.packageManager;
+	if (options.webDeploy) config.webDeploy = options.webDeploy;
+	const derivedName = deriveProjectName(projectName, options.projectDirectory);
+	if (derivedName) {
+		const nameToValidate = projectName ? path.basename(projectName) : derivedName;
+		const result = ProjectNameSchema.safeParse(nameToValidate);
+		if (!result.success) throw new Error(`Invalid project name: ${result.error.issues[0]?.message}`);
+		config.projectName = projectName || derivedName;
+	}
+	if (options.frontend && options.frontend.length > 0) config.frontend = processArrayOption(options.frontend);
+	if (options.addons && options.addons.length > 0) config.addons = processArrayOption(options.addons);
+	if (options.examples && options.examples.length > 0) config.examples = processArrayOption(options.examples);
+	return config;
+}
 function getProvidedFlags(options) {
 	return new Set(Object.keys(options).filter((key) => options[key] !== void 0));
 }
@@ -2216,20 +2267,16 @@ async function setupDeploymentTemplates(projectDir, context) {
 		}
 	} else {
 		if (context.webDeploy === "alchemy") {
+			const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
 			const webAppDir = path.join(projectDir, "apps/web");
-			if (await fs.pathExists(webAppDir)) {
-				const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
-				if (await fs.pathExists(alchemyTemplateSrc)) await processAndCopyFiles("**/*", alchemyTemplateSrc, webAppDir, context);
-			}
+			if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(webAppDir)) await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, webAppDir, context);
 		}
 		if (context.serverDeploy === "alchemy") {
+			const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
 			const serverAppDir = path.join(projectDir, "apps/server");
-			if (await fs.pathExists(serverAppDir)) {
-				const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
-				if (await fs.pathExists(alchemyTemplateSrc)) {
-					await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
-					await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
-				}
+			if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(serverAppDir)) {
+				await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+				await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
 			}
 		}
 	}
@@ -2501,7 +2548,7 @@ async function setupUltracite(config, hasHusky) {
 		];
 		if (editors.length > 0) ultraciteArgs.push("--editors", ...editors);
 		if (rules.length > 0) ultraciteArgs.push("--rules", ...rules);
-		if (hasHusky) ultraciteArgs.push("--features", "husky", "lint-staged");
+		if (hasHusky) ultraciteArgs.push("--integrations", "husky", "lint-staged");
 		const ultraciteArgsString = ultraciteArgs.join(" ");
 		const commandWithArgs = `ultracite@latest ${ultraciteArgsString} --skip-install`;
 		const ultraciteInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
@@ -3342,15 +3389,15 @@ async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 //#region src/helpers/deployment/workers/workers-next-setup.ts
 async function setupNextWorkersDeploy(projectDir, _packageManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs$1.pathExists(webAppDir)) return;
+	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
 		dependencies: ["@opennextjs/cloudflare"],
 		devDependencies: ["wrangler"],
 		projectDir: webAppDir
 	});
 	const packageJsonPath = path.join(webAppDir, "package.json");
-	if (await fs$1.pathExists(packageJsonPath)) {
-		const pkg = await fs$1.readJson(packageJsonPath);
+	if (await fs.pathExists(packageJsonPath)) {
+		const pkg = await fs.readJson(packageJsonPath);
 		pkg.scripts = {
 			...pkg.scripts,
 			preview: "opennextjs-cloudflare build && opennextjs-cloudflare preview",
@@ -3358,7 +3405,7 @@ async function setupNextWorkersDeploy(projectDir, _packageManager) {
 			upload: "opennextjs-cloudflare build && opennextjs-cloudflare upload",
 			"cf-typegen": "wrangler types --env-interface CloudflareEnv cloudflare-env.d.ts"
 		};
-		await fs$1.writeJson(packageJsonPath, pkg, { spaces: 2 });
+		await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
 	}
 }
 
@@ -5471,13 +5518,14 @@ async function displayPostInstallInstructions(config) {
 	const runCmd = packageManager === "npm" ? "npm run" : packageManager;
 	const cdCmd = `cd ${relativePath}`;
 	const hasHuskyOrBiome = addons?.includes("husky") || addons?.includes("biome");
-	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) : "";
+	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy) : "";
 	const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(runCmd) : "";
 	const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(runCmd) : "";
 	const nativeInstructions = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles") ? getNativeInstructions(isConvex) : "";
 	const pwaInstructions = addons?.includes("pwa") && frontend?.includes("react-router") ? getPwaInstructions() : "";
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
-	const workersDeployInstructions = webDeploy === "wrangler" ? getWorkersDeployInstructions(runCmd) : "";
+	const wranglerDeployInstructions = getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy);
+	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy);
 	const hasWeb = frontend?.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -5520,7 +5568,8 @@ async function displayPostInstallInstructions(config) {
 	if (tauriInstructions) output += `\n${tauriInstructions.trim()}\n`;
 	if (lintingInstructions) output += `\n${lintingInstructions.trim()}\n`;
 	if (pwaInstructions) output += `\n${pwaInstructions.trim()}\n`;
-	if (workersDeployInstructions) output += `\n${workersDeployInstructions.trim()}\n`;
+	if (wranglerDeployInstructions) output += `\n${wranglerDeployInstructions.trim()}\n`;
+	if (alchemyDeployInstructions) output += `\n${alchemyDeployInstructions.trim()}\n`;
 	if (starlightInstructions) output += `\n${starlightInstructions.trim()}\n`;
 	if (noOrmWarning) output += `\n${noOrmWarning.trim()}\n`;
 	if (bunWebNativeWarning) output += `\n${bunWebNativeWarning.trim()}\n`;
@@ -5541,7 +5590,7 @@ function getNativeInstructions(isConvex) {
 function getLintingInstructions(runCmd) {
 	return `${pc.bold("Linting and formatting:")}\n${pc.cyan("•")} Format and lint fix: ${`${runCmd} check`}\n`;
 }
-async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) {
+async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup, serverDeploy) {
 	const instructions = [];
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
@@ -5550,7 +5599,7 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup)
 			instructions.push("");
 		}
 	}
-	if (runtime === "workers" && dbSetup === "d1") {
+	if (serverDeploy === "wrangler" && dbSetup === "d1") {
 		const packageManager = runCmd === "npm run" ? "npm" : runCmd || "npm";
 		instructions.push(`${pc.cyan("1.")} Login to Cloudflare: ${pc.white(`${packageManager} wrangler login`)}`);
 		instructions.push(`${pc.cyan("2.")} Create D1 database: ${pc.white(`${packageManager} wrangler d1 create your-database-name`)}`);
@@ -5560,6 +5609,10 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup)
 		instructions.push(`${pc.cyan("6.")} Apply migrations to production: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME`)}`);
 		instructions.push("");
 	}
+	if (dbSetup === "d1" && serverDeploy === "alchemy") {
+		instructions.push(`${pc.cyan("•")} Generate migrations: ${pc.white(`${runCmd} db:generate`)}`);
+		instructions.push("");
+	}
 	if (orm === "prisma") {
 		if (dbSetup === "turso") instructions.push(`${pc.yellow("NOTE:")} Turso support with Prisma is in Early Access and requires\n   additional setup. Learn more at:\n   https://www.prisma.io/docs/orm/overview/databases/turso`);
 		if (database === "mongodb" && dbSetup === "docker") instructions.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination\n   may not work.`);
@@ -5591,8 +5644,18 @@ function getNoOrmWarning() {
 function getBunWebNativeWarning() {
 	return `\n${pc.yellow("WARNING:")} 'bun' might cause issues with web + native apps in a monorepo.\n   Use 'pnpm' if problems arise.`;
 }
-function getWorkersDeployInstructions(runCmd) {
-	return `\n${pc.bold("Deploy frontend to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} run deploy`}`;
+function getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy) {
+	const instructions = [];
+	if (webDeploy === "wrangler") instructions.push(`${pc.bold("Deploy web to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} run deploy`}`);
+	if (serverDeploy === "wrangler") instructions.push(`${pc.bold("Deploy server to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} run deploy`}`);
+	return instructions.length ? `\n${instructions.join("\n")}` : "";
+}
+function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy) {
+	const instructions = [];
+	if (webDeploy === "alchemy" && serverDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy web to Alchemy:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}`);
+	else if (serverDeploy === "alchemy" && webDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy server to Alchemy:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}`);
+	else if (webDeploy === "alchemy" && serverDeploy === "alchemy") instructions.push(`${pc.bold("Deploy to Alchemy:")}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}`);
+	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
 //#endregion
@@ -5902,15 +5965,9 @@ async function createProjectHandler(input) {
 		projectDirectory: input.projectName
 	};
 	const providedFlags = getProvidedFlags(cliInput);
-	const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
-	const { projectName: _projectNameFromFlags,...otherFlags } = flagConfig;
-	if (!input.yes && Object.keys(otherFlags).length > 0) {
-		log.info(pc.yellow("Using these pre-selected options:"));
-		log.message(displayConfig(otherFlags));
-		log.message("");
-	}
 	let config;
 	if (input.yes) {
+		const flagConfig = processProvidedFlagsWithoutValidation(cliInput, finalBaseName);
 		config = {
 			...DEFAULT_CONFIG,
 			...flagConfig,
@@ -5918,12 +5975,22 @@ async function createProjectHandler(input) {
 			projectDir: finalResolvedPath,
 			relativePath: finalPathInput
 		};
+		validateConfigCompatibility(config);
 		if (config.backend === "convex") log.info("Due to '--backend convex' flag, the following options have been automatically set: auth=false, database=none, orm=none, api=none, runtime=none, dbSetup=none, examples=todo");
 		else if (config.backend === "none") log.info("Due to '--backend none', the following options have been automatically set: --auth=false, --database=none, --orm=none, --api=none, --runtime=none, --db-setup=none, --examples=none");
 		log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
 		log.message(displayConfig(config));
 		log.message("");
-	} else config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+	} else {
+		const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
+		const { projectName: _projectNameFromFlags,...otherFlags } = flagConfig;
+		if (Object.keys(otherFlags).length > 0) {
+			log.info(pc.yellow("Using these pre-selected options:"));
+			log.message(displayConfig(otherFlags));
+			log.message("");
+		}
+		config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+	}
 	await createProject(config);
 	const reproducibleCommand = generateReproducibleCommand(config);
 	log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "2.33.8-canary.98a850ad",
+  "version": "2.33.9-canary.7db03e6d",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "type": "module",
   "license": "MIT",