create-better-t-stack 3.7.4 → 3.8.1

package/dist/{src-B6YuFjPr.js → src-BDXa8gsB.mjs}

@@ -3,11 +3,12 @@ import { autocompleteMultiselect, cancel, confirm, group, groupMultiselect, intr
 import { createRouterClient, os } from "@orpc/server";
 import pc from "picocolors";
 import { createCli } from "trpc-cli";
-import z$1, { z } from "zod";
+import z from "zod";
 import path from "node:path";
 import consola, { consola as consola$1 } from "consola";
 import fs from "fs-extra";
 import { fileURLToPath } from "node:url";
+import { APISchema, AddonsSchema, AuthSchema, BackendSchema, DatabaseSchema, DatabaseSetupSchema, DirectoryConflictSchema, ExamplesSchema, FrontendSchema, ORMSchema, PackageManagerSchema, PaymentsSchema, ProjectNameSchema, RuntimeSchema, ServerDeploySchema, TemplateSchema, WebDeploySchema } from "@better-t-stack/types";
 import gradient from "gradient-string";
 import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
@@ -62,43 +63,44 @@ function getDefaultConfig() {
 }
 const DEFAULT_CONFIG = getDefaultConfig();
 const dependencyVersionMap = {
-	"better-auth": "^1.4.5",
-	"@better-auth/expo": "^1.4.5",
+	typescript: "^5",
+	"better-auth": "1.4.5",
+	"@better-auth/expo": "1.4.5",
 	"@clerk/nextjs": "^6.31.5",
 	"@clerk/clerk-react": "^5.45.0",
 	"@clerk/tanstack-react-start": "^0.26.3",
 	"@clerk/clerk-expo": "^2.14.25",
-	"drizzle-orm": "^0.45.0",
+	"drizzle-orm": "^0.45.1",
 	"drizzle-kit": "^0.31.8",
 	"@planetscale/database": "^1.19.0",
-	"@libsql/client": "^0.14.0",
-	libsql: "^0.5.22",
+	"@libsql/client": "0.15.15",
+	libsql: "0.5.22",
 	"@neondatabase/serverless": "^1.0.2",
 	pg: "^8.16.3",
 	"@types/pg": "^8.15.6",
 	"@types/ws": "^8.18.1",
 	ws: "^8.18.3",
 	mysql2: "^3.14.0",
-	"@prisma/client": "^7.0.1",
-	prisma: "^7.0.1",
-	"@prisma/adapter-d1": "^7.0.1",
-	"@prisma/adapter-neon": "^7.0.1",
-	"@prisma/adapter-mariadb": "^7.0.1",
-	"@prisma/adapter-libsql": "^7.0.1",
-	"@prisma/adapter-better-sqlite3": "^7.0.1",
-	"@prisma/adapter-pg": "^7.0.1",
-	"@prisma/adapter-planetscale": "^7.0.1",
+	"@prisma/client": "^7.1.0",
+	prisma: "^7.1.0",
+	"@prisma/adapter-d1": "^7.1.0",
+	"@prisma/adapter-neon": "^7.1.0",
+	"@prisma/adapter-mariadb": "^7.1.0",
+	"@prisma/adapter-libsql": "^7.1.0",
+	"@prisma/adapter-better-sqlite3": "^7.1.0",
+	"@prisma/adapter-pg": "^7.1.0",
+	"@prisma/adapter-planetscale": "^7.1.0",
 	mongoose: "^8.14.0",
 	"vite-plugin-pwa": "^1.0.1",
 	"@vite-pwa/assets-generator": "^1.0.0",
 	"@tauri-apps/cli": "^2.4.0",
 	"@biomejs/biome": "^2.2.0",
-	oxlint: "^1.12.0",
+	oxlint: "^1.32.0",
 	husky: "^9.1.7",
 	"lint-staged": "^16.1.2",
 	tsx: "^4.19.2",
 	"@types/node": "^22.13.11",
-	"@types/bun": "^1.2.6",
+	"@types/bun": "^1.3.4",
 	"@elysiajs/node": "^1.3.1",
 	"@elysiajs/cors": "^1.3.3",
 	"@elysiajs/trpc": "^1.1.0",
@@ -150,7 +152,7 @@ const dependencyVersionMap = {
 	"nitro-cloudflare-dev": "^0.2.2",
 	"@sveltejs/adapter-cloudflare": "^7.2.1",
 	"@cloudflare/workers-types": "^4.20250822.0",
-	alchemy: "^0.77.0",
+	alchemy: "^0.81.1",
 	dotenv: "^17.2.2",
 	tsdown: "^0.16.5",
 	zod: "^4.1.13",
@@ -184,121 +186,6 @@ const ADDON_COMPATIBILITY = {
 	none: []
 };
 
-//#endregion
-//#region src/types.ts
-const DatabaseSchema = z.enum([
-	"none",
-	"sqlite",
-	"postgres",
-	"mysql",
-	"mongodb"
-]).describe("Database type");
-const ORMSchema = z.enum([
-	"drizzle",
-	"prisma",
-	"mongoose",
-	"none"
-]).describe("ORM type");
-const BackendSchema = z.enum([
-	"hono",
-	"express",
-	"fastify",
-	"elysia",
-	"convex",
-	"self",
-	"none"
-]).describe("Backend framework");
-const RuntimeSchema = z.enum([
-	"bun",
-	"node",
-	"workers",
-	"none"
-]).describe("Runtime environment");
-const FrontendSchema = z.enum([
-	"tanstack-router",
-	"react-router",
-	"tanstack-start",
-	"next",
-	"nuxt",
-	"native-bare",
-	"native-uniwind",
-	"native-unistyles",
-	"svelte",
-	"solid",
-	"none"
-]).describe("Frontend framework");
-const AddonsSchema = z.enum([
-	"pwa",
-	"tauri",
-	"starlight",
-	"biome",
-	"husky",
-	"ruler",
-	"turborepo",
-	"fumadocs",
-	"ultracite",
-	"oxlint",
-	"none"
-]).describe("Additional addons");
-const ExamplesSchema = z.enum([
-	"todo",
-	"ai",
-	"none"
-]).describe("Example templates to include");
-const PackageManagerSchema = z.enum([
-	"npm",
-	"pnpm",
-	"bun"
-]).describe("Package manager");
-const DatabaseSetupSchema = z.enum([
-	"turso",
-	"neon",
-	"prisma-postgres",
-	"planetscale",
-	"mongodb-atlas",
-	"supabase",
-	"d1",
-	"docker",
-	"none"
-]).describe("Database hosting setup");
-const APISchema = z.enum([
-	"trpc",
-	"orpc",
-	"none"
-]).describe("API type");
-const AuthSchema = z.enum([
-	"better-auth",
-	"clerk",
-	"none"
-]).describe("Authentication provider");
-const PaymentsSchema = z.enum(["polar", "none"]).describe("Payments provider");
-const ProjectNameSchema = z.string().min(1, "Project name cannot be empty").max(255, "Project name must be less than 255 characters").refine((name) => name === "." || !name.startsWith("."), "Project name cannot start with a dot (except for '.')").refine((name) => name === "." || !name.startsWith("-"), "Project name cannot start with a dash").refine((name) => {
-	return ![
-		"<",
-		">",
-		":",
-		"\"",
-		"|",
-		"?",
-		"*"
-	].some((char) => name.includes(char));
-}, "Project name contains invalid characters").refine((name) => name.toLowerCase() !== "node_modules", "Project name is reserved").describe("Project name or path");
-const WebDeploySchema = z.enum(["alchemy", "none"]).describe("Web deployment");
-const ServerDeploySchema = z.enum(["alchemy", "none"]).describe("Server deployment");
-const DirectoryConflictSchema = z.enum([
-	"merge",
-	"overwrite",
-	"increment",
-	"error"
-]).describe("How to handle existing directory conflicts");
-const TemplateSchema = z.enum([
-	"mern",
-	"pern",
-	"t3",
-	"uniwind",
-	"none"
-]).describe("Predefined project template");
-
 //#endregion
 //#region src/utils/compatibility.ts
 const WEB_FRAMEWORKS = [
@@ -400,7 +287,8 @@ function allowedApisForFrontends(frontends = []) {
 function isExampleTodoAllowed(backend, database) {
 	return !(backend !== "convex" && backend !== "none" && database === "none");
 }
-function isExampleAIAllowed(_backend, frontends = []) {
+function isExampleAIAllowed(backend, frontends = []) {
+	if (backend === "convex") return false;
 	if (frontends.includes("solid")) return false;
 	return true;
 }
@@ -447,6 +335,7 @@ 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 === "convex") exitWithError("The 'ai' example is not yet available with Convex backend.");
 	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) exitWithError("The 'ai' example is not compatible with the Solid frontend.");
 }
 
@@ -873,13 +762,11 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 //#region src/prompts/examples.ts
 async function getExamplesChoice(examples, database, frontends, backend, api) {
 	if (examples !== void 0) return examples;
-	if (api === "none") {
-		if (backend === "convex") return ["todo"];
-		return [];
-	}
-	if (backend === "convex") return ["todo"];
 	if (backend === "none") return [];
-	if (database === "none") return [];
+	if (backend !== "convex") {
+		if (api === "none") return [];
+		if (database === "none") return [];
+	}
 	let response = [];
 	const options = [];
 	if (isExampleTodoAllowed(backend, database)) options.push({
@@ -1366,7 +1253,7 @@ async function sendConvexEvent(payload) {
 }
 async function trackProjectCreation(config, disableAnalytics = false) {
 	if (!isTelemetryEnabled() || disableAnalytics) return;
-	const { projectName: _projectName, projectDir: _projectDir, relativePath: _relativePath,...safeConfig } = config;
+	const { projectName: _projectName, projectDir: _projectDir, relativePath: _relativePath, ...safeConfig } = config;
 	try {
 		await sendConvexEvent({
 			...safeConfig,
@@ -2925,6 +2812,8 @@ async function setupDbPackage(projectDir, context) {
 	await fs.ensureDir(dbPackageDir);
 	const dbBaseDir = path.join(PKG_ROOT, "templates/db/base");
 	if (await fs.pathExists(dbBaseDir)) await processAndCopyFiles("**/*", dbBaseDir, dbPackageDir, context);
+	const dbOrmBaseDir = path.join(PKG_ROOT, `templates/db/${context.orm}/base`);
+	if (await fs.pathExists(dbOrmBaseDir)) await processAndCopyFiles("**/*", dbOrmBaseDir, dbPackageDir, context);
 	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
 	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, dbPackageDir, context);
 }
@@ -3195,7 +3084,11 @@ async function setupExamplesTemplate(projectDir, context) {
 	for (const example of context.examples) {
 		if (example === "none") continue;
 		const exampleBaseDir = path.join(PKG_ROOT, `templates/examples/${example}`);
-		if ((serverAppDirExists || context.backend === "self") && context.backend !== "convex" && context.backend !== "none") {
+		if (context.backend === "convex") {
+			const convexBackendDestDir = path.join(projectDir, "packages/backend");
+			const convexExampleSrc = path.join(exampleBaseDir, "convex/packages/backend");
+			if (await fs.pathExists(convexExampleSrc)) await processAndCopyFiles("**/*", convexExampleSrc, convexBackendDestDir, context, false);
+		} else if ((serverAppDirExists || context.backend === "self") && context.backend !== "none") {
 			const exampleServerSrc = path.join(exampleBaseDir, "server");
 			if (context.api !== "none") {
 				const apiPackageDir = path.join(projectDir, "packages/api");
@@ -3863,6 +3756,7 @@ async function addDeploymentToProject(input) {
 async function setupCatalogs(projectDir, options) {
 	if (options.packageManager === "npm") return;
 	const packagePaths = [
+		".",
 		"apps/server",
 		"apps/web",
 		"apps/native",
@@ -3871,7 +3765,8 @@ async function setupCatalogs(projectDir, options) {
 		"packages/api",
 		"packages/db",
 		"packages/auth",
-		"packages/backend"
+		"packages/backend",
+		"packages/config"
 	];
 	const packagesInfo = [];
 	for (const pkgPath of packagePaths) {
@@ -3970,15 +3865,18 @@ async function updatePackageJsonsWithCatalogs(packagesInfo, catalog) {
 //#endregion
 //#region src/helpers/addons/examples-setup.ts
 async function setupExamples(config) {
-	const { examples, frontend, backend, projectDir, orm } = config;
+	const { examples, frontend, backend, projectDir, orm, database } = config;
 	if (backend === "convex" || !examples || examples.length === 0 || examples[0] === "none") return;
 	const apiDir = path.join(projectDir, "packages/api");
 	if (await fs.pathExists(apiDir) && backend !== "none") {
-		if (orm === "drizzle") await addPackageDependency({
-			dependencies: ["drizzle-orm", "@types/pg"],
-			projectDir: apiDir
-		});
-		else if (orm === "prisma") await addPackageDependency({
+		if (orm === "drizzle") {
+			const dependencies = ["drizzle-orm"];
+			if (database === "postgres") dependencies.push("@types/pg");
+			await addPackageDependency({
+				dependencies,
+				projectDir: apiDir
+			});
+		} else if (orm === "prisma") await addPackageDependency({
 			dependencies: ["@prisma/client"],
 			projectDir: apiDir
 		});
@@ -4027,15 +3925,6 @@ async function setupExamples(config) {
 
 //#endregion
 //#region src/helpers/core/api-setup.ts
-async function addBackendWorkspaceDependency(projectDir, backendPackageName, workspaceVersion) {
-	const pkgJsonPath = path.join(projectDir, "package.json");
-	try {
-		const pkgJson = await fs.readJson(pkgJsonPath);
-		if (!pkgJson.dependencies) pkgJson.dependencies = {};
-		pkgJson.dependencies[backendPackageName] = workspaceVersion;
-		await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
-	} catch {}
-}
 function getFrontendType(frontend) {
 	const reactBasedFrontends = [
 		"tanstack-router",
@@ -4153,7 +4042,7 @@ function getConvexDependencies(frontend) {
 	return deps;
 }
 async function setupApi(config) {
-	const { api, projectName, frontend, backend, packageManager, projectDir } = config;
+	const { api, frontend, backend, projectDir } = config;
 	const isConvex = backend === "convex";
 	const webDir = path.join(projectDir, "apps/web");
 	const nativeDir = path.join(projectDir, "apps/native");
@@ -4223,10 +4112,6 @@ async function setupApi(config) {
 			dependencies: convexDeps.native.dependencies,
 			projectDir: nativeDir
 		});
-		const backendPackageName = `@${projectName}/backend`;
-		const backendWorkspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
-		if (webDirExists) await addBackendWorkspaceDependency(webDir, backendPackageName, backendWorkspaceVersion);
-		if (nativeDirExists) await addBackendWorkspaceDependency(nativeDir, backendPackageName, backendWorkspaceVersion);
 	}
 }
 
@@ -6431,93 +6316,113 @@ function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend)
 //#endregion
 //#region src/helpers/core/workspace-setup.ts
 async function setupWorkspaceDependencies(projectDir, options) {
-	const projectName = options.projectName;
-	const workspaceVersion = options.packageManager === "npm" ? "*" : "workspace:*";
+	const { projectName, packageManager, database, auth, api, runtime, backend } = options;
+	const workspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
 	const commonDeps = ["dotenv", "zod"];
-	const commonDevDeps = [];
-	const configPackageDir = path.join(projectDir, "packages/config");
-	const configDep = {};
-	if (await fs.pathExists(configPackageDir)) configDep[`@${projectName}/config`] = workspaceVersion;
-	const dbPackageDir = path.join(projectDir, "packages/db");
-	if (await fs.pathExists(dbPackageDir)) await addPackageDependency({
+	const commonDevDeps = ["typescript"];
+	const configDir = path.join(projectDir, "packages/config");
+	const dbDir = path.join(projectDir, "packages/db");
+	const authDir = path.join(projectDir, "packages/auth");
+	const apiDir = path.join(projectDir, "packages/api");
+	const backendDir = path.join(projectDir, "packages/backend");
+	const serverDir = path.join(projectDir, "apps/server");
+	const webDir = path.join(projectDir, "apps/web");
+	const nativeDir = path.join(projectDir, "apps/native");
+	const [configExists, dbExists, authExists, apiExists, backendExists, serverExists, webExists, nativeExists] = await Promise.all([
+		fs.pathExists(configDir),
+		fs.pathExists(dbDir),
+		fs.pathExists(authDir),
+		fs.pathExists(apiDir),
+		fs.pathExists(backendDir),
+		fs.pathExists(serverDir),
+		fs.pathExists(webDir),
+		fs.pathExists(nativeDir)
+	]);
+	const configDep = configExists ? { [`@${projectName}/config`]: workspaceVersion } : {};
+	if (dbExists) await addPackageDependency({
 		dependencies: commonDeps,
 		devDependencies: commonDevDeps,
 		customDevDependencies: configDep,
-		projectDir: dbPackageDir
+		projectDir: dbDir
 	});
-	const authPackageDir = path.join(projectDir, "packages/auth");
-	if (await fs.pathExists(authPackageDir)) {
+	if (authExists) {
 		const authDeps = {};
-		if (options.database !== "none" && await fs.pathExists(dbPackageDir)) authDeps[`@${projectName}/db`] = workspaceVersion;
+		if (database !== "none" && dbExists) authDeps[`@${projectName}/db`] = workspaceVersion;
 		await addPackageDependency({
 			dependencies: commonDeps,
 			devDependencies: commonDevDeps,
 			customDependencies: authDeps,
 			customDevDependencies: configDep,
-			projectDir: authPackageDir
+			projectDir: authDir
 		});
 	}
-	const apiPackageDir = path.join(projectDir, "packages/api");
-	if (await fs.pathExists(apiPackageDir)) {
+	if (apiExists) {
 		const apiDeps = {};
-		if (options.auth !== "none" && await fs.pathExists(authPackageDir)) apiDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (options.database !== "none" && await fs.pathExists(dbPackageDir)) apiDeps[`@${projectName}/db`] = workspaceVersion;
+		if (auth !== "none" && authExists) apiDeps[`@${projectName}/auth`] = workspaceVersion;
+		if (database !== "none" && dbExists) apiDeps[`@${projectName}/db`] = workspaceVersion;
 		await addPackageDependency({
 			dependencies: commonDeps,
 			devDependencies: commonDevDeps,
 			customDependencies: apiDeps,
 			customDevDependencies: configDep,
-			projectDir: apiPackageDir
+			projectDir: apiDir
 		});
 	}
-	const serverPackageDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverPackageDir)) {
+	if (backendExists) await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: commonDevDeps,
+		customDevDependencies: configDep,
+		projectDir: backendDir
+	});
+	if (serverExists) {
 		const serverDeps = {};
-		if (options.api !== "none" && await fs.pathExists(apiPackageDir)) serverDeps[`@${projectName}/api`] = workspaceVersion;
-		if (options.auth !== "none" && await fs.pathExists(authPackageDir)) serverDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (options.database !== "none" && await fs.pathExists(dbPackageDir)) serverDeps[`@${projectName}/db`] = workspaceVersion;
+		if (api !== "none" && apiExists) serverDeps[`@${projectName}/api`] = workspaceVersion;
+		if (auth !== "none" && authExists) serverDeps[`@${projectName}/auth`] = workspaceVersion;
+		if (database !== "none" && dbExists) serverDeps[`@${projectName}/db`] = workspaceVersion;
 		await addPackageDependency({
 			dependencies: commonDeps,
 			devDependencies: [...commonDevDeps, "tsdown"],
 			customDependencies: serverDeps,
 			customDevDependencies: configDep,
-			projectDir: serverPackageDir
+			projectDir: serverDir
 		});
 	}
-	const webPackageDir = path.join(projectDir, "apps/web");
-	if (await fs.pathExists(webPackageDir)) {
+	if (webExists) {
 		const webDeps = {};
-		if (options.api !== "none" && await fs.pathExists(apiPackageDir)) webDeps[`@${projectName}/api`] = workspaceVersion;
-		if (options.auth !== "none" && await fs.pathExists(authPackageDir)) webDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (Object.keys(webDeps).length > 0) await addPackageDependency({
+		if (api !== "none" && apiExists) webDeps[`@${projectName}/api`] = workspaceVersion;
+		if (auth !== "none" && authExists) webDeps[`@${projectName}/auth`] = workspaceVersion;
+		if (backend === "convex" && backendExists) webDeps[`@${projectName}/backend`] = workspaceVersion;
+		await addPackageDependency({
+			dependencies: commonDeps,
+			devDependencies: commonDevDeps,
 			customDependencies: webDeps,
 			customDevDependencies: configDep,
-			projectDir: webPackageDir
+			projectDir: webDir
 		});
 	}
-	const nativePackageDir = path.join(projectDir, "apps/native");
-	if (await fs.pathExists(nativePackageDir)) {
+	if (nativeExists) {
 		const nativeDeps = {};
-		if (options.api !== "none" && await fs.pathExists(apiPackageDir)) nativeDeps[`@${projectName}/api`] = workspaceVersion;
-		if (Object.keys(nativeDeps).length > 0) await addPackageDependency({
+		if (api !== "none" && apiExists) nativeDeps[`@${projectName}/api`] = workspaceVersion;
+		if (backend === "convex" && backendExists) nativeDeps[`@${projectName}/backend`] = workspaceVersion;
+		await addPackageDependency({
+			dependencies: commonDeps,
+			devDependencies: commonDevDeps,
 			customDependencies: nativeDeps,
 			customDevDependencies: configDep,
-			projectDir: nativePackageDir
+			projectDir: nativeDir
 		});
 	}
-	const runtimeDevDeps = getRuntimeDevDeps(options);
+	const runtimeDevDeps = getRuntimeDevDeps(runtime, backend);
 	await addPackageDependency({
 		dependencies: commonDeps,
 		devDependencies: [...commonDevDeps, ...runtimeDevDeps],
 		projectDir
 	});
 }
-function getRuntimeDevDeps(options) {
-	const { runtime, backend } = options;
+function getRuntimeDevDeps(runtime, backend) {
 	if (runtime === "none" && backend === "self") return ["@types/node"];
-	if (runtime === "node") return ["@types/node"];
+	if (runtime === "node" || runtime === "workers") return ["@types/node"];
 	if (runtime === "bun") return ["@types/bun"];
-	if (runtime === "workers") return ["@types/node"];
 	return [];
 }
 
@@ -6526,185 +6431,130 @@ function getRuntimeDevDeps(options) {
 async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(projectDir, options);
 	if (options.backend === "convex") await updateConvexPackageJson(projectDir, options);
-	else if (options.backend === "self") {
+	else if (options.backend !== "none") {
 		await updateDbPackageJson(projectDir, options);
 		await updateAuthPackageJson(projectDir, options);
 		await updateApiPackageJson(projectDir, options);
-		await setupWorkspaceDependencies(projectDir, options);
-	} else if (options.backend !== "none") {
-		await updateServerPackageJson(projectDir, options);
-		await updateAuthPackageJson(projectDir, options);
-		await updateApiPackageJson(projectDir, options);
-		await setupWorkspaceDependencies(projectDir, options);
+		if (options.backend !== "self") await updateServerPackageJson(projectDir, options);
 	}
+	await setupWorkspaceDependencies(projectDir, options);
 }
 async function updateRootPackageJson(projectDir, options) {
 	const rootPackageJsonPath = path.join(projectDir, "package.json");
 	if (!await fs.pathExists(rootPackageJsonPath)) return;
 	const packageJson = await fs.readJson(rootPackageJsonPath);
 	packageJson.name = options.projectName;
-	if (!packageJson.scripts) packageJson.scripts = {};
+	packageJson.scripts = packageJson.scripts || {};
+	packageJson.workspaces = packageJson.workspaces || [];
 	const scripts = packageJson.scripts;
-	const backendPackageName = options.backend === "convex" ? `@${options.projectName}/backend` : "server";
-	const dbPackageName = `@${options.projectName}/db`;
-	let serverDevScript = "";
-	if (options.addons.includes("turborepo")) serverDevScript = `turbo -F ${backendPackageName} dev`;
-	else if (options.packageManager === "bun") serverDevScript = `bun run --filter ${backendPackageName} dev`;
-	else if (options.packageManager === "pnpm") serverDevScript = `pnpm --filter ${backendPackageName} dev`;
-	else if (options.packageManager === "npm") serverDevScript = `npm run dev --workspace ${backendPackageName}`;
-	let devScript = "";
-	if (options.packageManager === "pnpm") devScript = "pnpm -r dev";
-	else if (options.packageManager === "npm") devScript = "npm run dev --workspaces";
-	else if (options.packageManager === "bun") devScript = "bun run --filter '*' dev";
-	const needsDbScripts = options.backend !== "convex" && options.database !== "none" && options.orm !== "none" && options.orm !== "mongoose";
-	if (options.addons.includes("turborepo")) {
-		scripts.dev = "turbo dev";
-		scripts.build = "turbo build";
-		scripts["check-types"] = "turbo check-types";
-		scripts["dev:native"] = "turbo -F native dev";
-		scripts["dev:web"] = "turbo -F web dev";
-		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
-		if (options.backend === "convex") scripts["dev:setup"] = `turbo -F ${backendPackageName} dev:setup`;
-		if (needsDbScripts) {
-			scripts["db:push"] = `turbo -F ${dbPackageName} db:push`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `turbo -F ${dbPackageName} db:studio`;
-			if (options.orm === "prisma") {
-				scripts["db:generate"] = `turbo -F ${dbPackageName} db:generate`;
-				scripts["db:migrate"] = `turbo -F ${dbPackageName} db:migrate`;
-			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `turbo -F ${dbPackageName} db:generate`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `turbo -F ${dbPackageName} db:migrate`;
-			}
-		}
-		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `turbo -F ${dbPackageName} db:start`;
-			scripts["db:watch"] = `turbo -F ${dbPackageName} db:watch`;
-			scripts["db:stop"] = `turbo -F ${dbPackageName} db:stop`;
-			scripts["db:down"] = `turbo -F ${dbPackageName} db:down`;
-		}
-	} else if (options.packageManager === "pnpm") {
-		scripts.dev = devScript;
-		scripts.build = "pnpm -r build";
-		scripts["check-types"] = "pnpm -r check-types";
-		scripts["dev:native"] = "pnpm --filter native dev";
-		scripts["dev:web"] = "pnpm --filter web dev";
-		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
-		if (options.backend === "convex") scripts["dev:setup"] = `pnpm --filter ${backendPackageName} dev:setup`;
-		if (needsDbScripts) {
-			scripts["db:push"] = `pnpm --filter ${dbPackageName} db:push`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `pnpm --filter ${dbPackageName} db:studio`;
-			if (options.orm === "prisma") {
-				scripts["db:generate"] = `pnpm --filter ${dbPackageName} db:generate`;
-				scripts["db:migrate"] = `pnpm --filter ${dbPackageName} db:migrate`;
-			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `pnpm --filter ${dbPackageName} db:generate`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `pnpm --filter ${dbPackageName} db:migrate`;
-			}
-		}
-		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `pnpm --filter ${dbPackageName} db:start`;
-			scripts["db:watch"] = `pnpm --filter ${dbPackageName} db:watch`;
-			scripts["db:stop"] = `pnpm --filter ${dbPackageName} db:stop`;
-			scripts["db:down"] = `pnpm --filter ${dbPackageName} db:down`;
-		}
-	} else if (options.packageManager === "npm") {
-		scripts.dev = devScript;
-		scripts.build = "npm run build --workspaces";
-		scripts["check-types"] = "npm run check-types --workspaces";
-		scripts["dev:native"] = "npm run dev --workspace native";
-		scripts["dev:web"] = "npm run dev --workspace web";
-		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
-		if (options.backend === "convex") scripts["dev:setup"] = `npm run dev:setup --workspace ${backendPackageName}`;
-		if (needsDbScripts) {
-			scripts["db:push"] = `npm run db:push --workspace ${dbPackageName}`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `npm run db:studio --workspace ${dbPackageName}`;
-			if (options.orm === "prisma") {
-				scripts["db:generate"] = `npm run db:generate --workspace ${dbPackageName}`;
-				scripts["db:migrate"] = `npm run db:migrate --workspace ${dbPackageName}`;
-			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `npm run db:generate --workspace ${dbPackageName}`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `npm run db:migrate --workspace ${dbPackageName}`;
-			}
-		}
-		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `npm run db:start --workspace ${dbPackageName}`;
-			scripts["db:watch"] = `npm run db:watch --workspace ${dbPackageName}`;
-			scripts["db:stop"] = `npm run db:stop --workspace ${dbPackageName}`;
-			scripts["db:down"] = `npm run db:down --workspace ${dbPackageName}`;
-		}
-	} else if (options.packageManager === "bun") {
-		scripts.dev = devScript;
-		scripts.build = "bun run --filter '*' build";
-		scripts["check-types"] = "bun run --filter '*' check-types";
-		scripts["dev:native"] = "bun run --filter native dev";
-		scripts["dev:web"] = "bun run --filter web dev";
-		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
-		if (options.backend === "convex") scripts["dev:setup"] = `bun run --filter ${backendPackageName} dev:setup`;
-		if (needsDbScripts) {
-			scripts["db:push"] = `bun run --filter ${dbPackageName} db:push`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `bun run --filter ${dbPackageName} db:studio`;
-			if (options.orm === "prisma") {
-				scripts["db:generate"] = `bun run --filter ${dbPackageName} db:generate`;
-				scripts["db:migrate"] = `bun run --filter ${dbPackageName} db:migrate`;
-			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `bun run --filter ${dbPackageName} db:generate`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `bun run --filter ${dbPackageName} db:migrate`;
-			}
-		}
-		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `bun run --filter ${dbPackageName} db:start`;
-			scripts["db:watch"] = `bun run --filter ${dbPackageName} db:watch`;
-			scripts["db:stop"] = `bun run --filter ${dbPackageName} db:stop`;
-			scripts["db:down"] = `bun run --filter ${dbPackageName} db:down`;
+	const workspaces = packageJson.workspaces;
+	const { projectName, packageManager, backend, database, orm, dbSetup, serverDeploy, addons } = options;
+	const backendPackageName = backend === "convex" ? `@${projectName}/backend` : "server";
+	const dbPackageName = `@${projectName}/db`;
+	const hasTurborepo = addons.includes("turborepo");
+	const needsDbScripts = backend !== "convex" && database !== "none" && orm !== "none" && orm !== "mongoose";
+	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "alchemy";
+	const pmConfig = getPackageManagerConfig(packageManager, hasTurborepo);
+	scripts.dev = pmConfig.dev;
+	scripts.build = pmConfig.build;
+	scripts["check-types"] = pmConfig.checkTypes;
+	scripts["dev:native"] = pmConfig.filter("native", "dev");
+	scripts["dev:web"] = pmConfig.filter("web", "dev");
+	if (backend !== "self" && backend !== "none") scripts["dev:server"] = pmConfig.filter(backendPackageName, "dev");
+	if (backend === "convex") scripts["dev:setup"] = pmConfig.filter(backendPackageName, "dev:setup");
+	if (needsDbScripts) {
+		scripts["db:push"] = pmConfig.filter(dbPackageName, "db:push");
+		if (!isD1Alchemy) scripts["db:studio"] = pmConfig.filter(dbPackageName, "db:studio");
+		if (orm === "prisma") {
+			scripts["db:generate"] = pmConfig.filter(dbPackageName, "db:generate");
+			scripts["db:migrate"] = pmConfig.filter(dbPackageName, "db:migrate");
+		} else if (orm === "drizzle") {
+			scripts["db:generate"] = pmConfig.filter(dbPackageName, "db:generate");
+			if (!isD1Alchemy) scripts["db:migrate"] = pmConfig.filter(dbPackageName, "db:migrate");
 		}
 	}
+	if (dbSetup === "docker") {
+		scripts["db:start"] = pmConfig.filter(dbPackageName, "db:start");
+		scripts["db:watch"] = pmConfig.filter(dbPackageName, "db:watch");
+		scripts["db:stop"] = pmConfig.filter(dbPackageName, "db:stop");
+		scripts["db:down"] = pmConfig.filter(dbPackageName, "db:down");
+	}
 	try {
-		const { stdout } = await execa(options.packageManager, ["-v"], { cwd: projectDir });
-		packageJson.packageManager = `${options.packageManager}@${stdout.trim()}`;
+		const { stdout } = await execa(packageManager, ["-v"], { cwd: projectDir });
+		packageJson.packageManager = `${packageManager}@${stdout.trim()}`;
 	} catch {
-		log.warn(`Could not determine ${options.packageManager} version.`);
+		log.warn(`Could not determine ${packageManager} version.`);
 	}
-	if (!packageJson.workspaces) packageJson.workspaces = [];
-	const workspaces = packageJson.workspaces;
-	if (options.backend === "convex") {
+	if (backend === "convex") {
 		if (!workspaces.includes("packages/*")) workspaces.push("packages/*");
-		if ((options.frontend.length > 0 || options.addons.includes("starlight")) && !workspaces.includes("apps/*")) workspaces.push("apps/*");
+		if ((options.frontend.length > 0 || addons.includes("starlight")) && !workspaces.includes("apps/*")) workspaces.push("apps/*");
 	} else {
 		if (!workspaces.includes("apps/*")) workspaces.push("apps/*");
 		if (!workspaces.includes("packages/*")) workspaces.push("packages/*");
 	}
 	await fs.writeJson(rootPackageJsonPath, packageJson, { spaces: 2 });
 }
-async function updateServerPackageJson(projectDir, options) {
+function getPackageManagerConfig(packageManager, hasTurborepo) {
+	if (hasTurborepo) return {
+		dev: "turbo dev",
+		build: "turbo build",
+		checkTypes: "turbo check-types",
+		filter: (workspace, script) => `turbo -F ${workspace} ${script}`
+	};
+	switch (packageManager) {
+		case "pnpm": return {
+			dev: "pnpm -r dev",
+			build: "pnpm -r build",
+			checkTypes: "pnpm -r check-types",
+			filter: (workspace, script) => `pnpm --filter ${workspace} ${script}`
+		};
+		case "npm": return {
+			dev: "npm run dev --workspaces",
+			build: "npm run build --workspaces",
+			checkTypes: "npm run check-types --workspaces",
+			filter: (workspace, script) => `npm run ${script} --workspace ${workspace}`
+		};
+		case "bun": return {
+			dev: "bun run --filter '*' dev",
+			build: "bun run --filter '*' build",
+			checkTypes: "bun run --filter '*' check-types",
+			filter: (workspace, script) => `bun run --filter ${workspace} ${script}`
+		};
+	}
+}
+async function updateServerPackageJson(projectDir, _options) {
 	const serverPackageJsonPath = path.join(projectDir, "apps/server/package.json");
 	if (!await fs.pathExists(serverPackageJsonPath)) return;
 	const serverPackageJson = await fs.readJson(serverPackageJsonPath);
-	if (!serverPackageJson.scripts) serverPackageJson.scripts = {};
+	serverPackageJson.scripts = serverPackageJson.scripts || {};
 	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
-	await updateDbPackageJson(projectDir, options);
 }
 async function updateDbPackageJson(projectDir, options) {
 	const dbPackageJsonPath = path.join(projectDir, "packages/db/package.json");
 	if (!await fs.pathExists(dbPackageJsonPath)) return;
 	const dbPackageJson = await fs.readJson(dbPackageJsonPath);
 	dbPackageJson.name = `@${options.projectName}/db`;
-	if (!dbPackageJson.scripts) dbPackageJson.scripts = {};
+	dbPackageJson.scripts = dbPackageJson.scripts || {};
 	const scripts = dbPackageJson.scripts;
-	if (options.database !== "none") {
-		if (options.database === "sqlite" && options.orm === "drizzle" && options.dbSetup !== "d1") scripts["db:local"] = "turso dev --db-file local.db";
-		if (options.orm === "prisma") {
+	const { database, orm, dbSetup, serverDeploy } = options;
+	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "alchemy";
+	if (database !== "none") {
+		if (database === "sqlite" && orm === "drizzle" && dbSetup !== "d1") scripts["db:local"] = "turso dev --db-file local.db";
+		if (orm === "prisma") {
 			scripts["db:push"] = "prisma db push";
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = "prisma studio";
 			scripts["db:generate"] = "prisma generate";
 			scripts["db:migrate"] = "prisma migrate dev";
-		} else if (options.orm === "drizzle") {
+			if (!isD1Alchemy) scripts["db:studio"] = "prisma studio";
+		} else if (orm === "drizzle") {
 			scripts["db:push"] = "drizzle-kit push";
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = "drizzle-kit studio";
 			scripts["db:generate"] = "drizzle-kit generate";
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = "drizzle-kit migrate";
+			if (!isD1Alchemy) {
+				scripts["db:studio"] = "drizzle-kit studio";
+				scripts["db:migrate"] = "drizzle-kit migrate";
+			}
 		}
 	}
-	if (options.dbSetup === "docker") {
+	if (dbSetup === "docker") {
 		scripts["db:start"] = "docker compose up -d";
 		scripts["db:watch"] = "docker compose up";
 		scripts["db:stop"] = "docker compose stop";
@@ -6731,7 +6581,7 @@ async function updateConvexPackageJson(projectDir, options) {
 	if (!await fs.pathExists(convexPackageJsonPath)) return;
 	const convexPackageJson = await fs.readJson(convexPackageJsonPath);
 	convexPackageJson.name = `@${options.projectName}/backend`;
-	if (!convexPackageJson.scripts) convexPackageJson.scripts = {};
+	convexPackageJson.scripts = convexPackageJson.scripts || {};
 	await fs.writeJson(convexPackageJsonPath, convexPackageJson, { spaces: 2 });
 }
 
@@ -6896,7 +6746,7 @@ async function createProjectHandler(input) {
 		log.message(displayConfig(config));
 	} else {
 		const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
-		const { projectName: _projectNameFromFlags,...otherFlags } = flagConfig;
+		const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
 		if (Object.keys(otherFlags).length > 0) {
 			log.info(pc.yellow("Using these pre-selected options:"));
 			log.message(displayConfig(otherFlags));
@@ -7094,21 +6944,21 @@ const router = os.router({
 		description: "Create a new Better-T-Stack project",
 		default: true,
 		negateBooleans: true
-	}).input(z$1.tuple([ProjectNameSchema.optional(), z$1.object({
+	}).input(z.tuple([ProjectNameSchema.optional(), z.object({
 		template: TemplateSchema.optional().describe("Use a predefined template"),
-		yes: z$1.boolean().optional().default(false).describe("Use default configuration"),
-		yolo: z$1.boolean().optional().default(false).describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
-		verbose: z$1.boolean().optional().default(false).describe("Show detailed result information"),
+		yes: z.boolean().optional().default(false).describe("Use default configuration"),
+		yolo: z.boolean().optional().default(false).describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
+		verbose: z.boolean().optional().default(false).describe("Show detailed result information"),
 		database: DatabaseSchema.optional(),
 		orm: ORMSchema.optional(),
 		auth: AuthSchema.optional(),
 		payments: PaymentsSchema.optional(),
-		frontend: z$1.array(FrontendSchema).optional(),
-		addons: z$1.array(AddonsSchema).optional(),
-		examples: z$1.array(ExamplesSchema).optional(),
-		git: z$1.boolean().optional(),
+		frontend: z.array(FrontendSchema).optional(),
+		addons: z.array(AddonsSchema).optional(),
+		examples: z.array(ExamplesSchema).optional(),
+		git: z.boolean().optional(),
 		packageManager: PackageManagerSchema.optional(),
-		install: z$1.boolean().optional(),
+		install: z.boolean().optional(),
 		dbSetup: DatabaseSetupSchema.optional(),
 		backend: BackendSchema.optional(),
 		runtime: RuntimeSchema.optional(),
@@ -7116,9 +6966,9 @@ const router = os.router({
 		webDeploy: WebDeploySchema.optional(),
 		serverDeploy: ServerDeploySchema.optional(),
 		directoryConflict: DirectoryConflictSchema.optional(),
-		renderTitle: z$1.boolean().optional(),
-		disableAnalytics: z$1.boolean().optional().default(false).describe("Disable analytics"),
-		manualDb: z$1.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup")
+		renderTitle: z.boolean().optional(),
+		disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
+		manualDb: z.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup")
 	})])).handler(async ({ input }) => {
 		const [projectName, options] = input;
 		const result = await createProjectHandler({
@@ -7127,12 +6977,12 @@ const router = os.router({
 		});
 		if (options.verbose) return result;
 	}),
-	add: os.meta({ description: "Add addons or deployment configurations to an existing Better-T-Stack project" }).input(z$1.tuple([z$1.object({
-		addons: z$1.array(AddonsSchema).optional().default([]),
+	add: os.meta({ description: "Add addons or deployment configurations to an existing Better-T-Stack project" }).input(z.tuple([z.object({
+		addons: z.array(AddonsSchema).optional().default([]),
 		webDeploy: WebDeploySchema.optional(),
 		serverDeploy: ServerDeploySchema.optional(),
-		projectDir: z$1.string().optional(),
-		install: z$1.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
+		projectDir: z.string().optional(),
+		install: z.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
 		packageManager: PackageManagerSchema.optional()
 	})])).handler(async ({ input }) => {
 		const [options] = input;