create-better-t-stack 3.7.1 → 3.7.3-canary.53fc0031

package/dist/{src-BmyCNYPk.js → src-B1ogWZqk.js}

@@ -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 "@create-better-t-stack/types";
 import gradient from "gradient-string";
 import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
@@ -62,20 +63,21 @@ function getDefaultConfig() {
 }
 const DEFAULT_CONFIG = getDefaultConfig();
 const dependencyVersionMap = {
+	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.44.2",
-	"drizzle-kit": "^0.31.2",
+	"drizzle-orm": "^0.45.0",
+	"drizzle-kit": "^0.31.8",
 	"@planetscale/database": "^1.19.0",
 	"@libsql/client": "^0.14.0",
 	libsql: "^0.5.22",
 	"@neondatabase/serverless": "^1.0.2",
-	pg: "^8.14.1",
-	"@types/pg": "^8.11.11",
+	pg: "^8.16.3",
+	"@types/pg": "^8.15.6",
 	"@types/ws": "^8.18.1",
 	ws: "^8.18.3",
 	mysql2: "^3.14.0",
@@ -98,7 +100,7 @@ const dependencyVersionMap = {
 	"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",
@@ -128,7 +130,7 @@ const dependencyVersionMap = {
 	"@trpc/tanstack-react-query": "^11.5.0",
 	"@trpc/server": "^11.5.0",
 	"@trpc/client": "^11.5.0",
-	next: "15.5.4",
+	next: "^16.0.7",
 	convex: "^1.29.3",
 	"@convex-dev/react-query": "^0.1.0",
 	"convex-svelte": "^0.0.12",
@@ -153,7 +155,7 @@ const dependencyVersionMap = {
 	alchemy: "^0.77.0",
 	dotenv: "^17.2.2",
 	tsdown: "^0.16.5",
-	zod: "^4.1.11",
+	zod: "^4.1.13",
 	srvx: "0.8.15",
 	"@polar-sh/better-auth": "^1.1.3",
 	"@polar-sh/sdk": "^0.34.16"
@@ -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 = [
@@ -1045,7 +932,7 @@ async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
 	if (orm !== void 0) return orm;
 	const response = await select({
 		message: "Select ORM",
-		options: [...database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [ormOptions.drizzle, ormOptions.prisma]],
+		options: database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [ormOptions.drizzle, ormOptions.prisma],
 		initialValue: database === "mongodb" ? "prisma" : runtime === "workers" ? "drizzle" : DEFAULT_CONFIG.orm
 	});
 	if (isCancel(response)) return exitCancelled("Operation cancelled");
@@ -1165,7 +1052,6 @@ async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 		}
 	}
 	if (existingDeployment && existingDeployment !== "none") return "none";
-	if (options.length > 0) {}
 	if (options.length === 0) return "none";
 	const response = await select({
 		message: "Select server deployment",
@@ -1347,7 +1233,7 @@ const getLatestCLIVersion = () => {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "1";
+	const BTS_TELEMETRY = "0";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
 	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
@@ -1363,20 +1249,19 @@ async function sendConvexEvent(payload) {
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(payload)
 		});
-	} catch (_error) {}
+	} catch {}
 }
 async function trackProjectCreation(config, disableAnalytics = false) {
 	if (!isTelemetryEnabled() || disableAnalytics) return;
-	const { projectName, projectDir, relativePath,...safeConfig } = config;
+	const { projectName: _projectName, projectDir: _projectDir, relativePath: _relativePath,...safeConfig } = config;
 	try {
 		await sendConvexEvent({
-			event: "project_created",
 			...safeConfig,
 			cli_version: getLatestCLIVersion(),
 			node_version: typeof process !== "undefined" ? process.version : "",
 			platform: typeof process !== "undefined" ? process.platform : ""
 		});
-	} catch (_error) {}
+	} catch {}
 }
 
 //#endregion
@@ -1980,6 +1865,7 @@ async function writeBtsConfig(projectConfig) {
 		addons: btsConfig.addons,
 		examples: btsConfig.examples,
 		auth: btsConfig.auth,
+		payments: btsConfig.payments,
 		packageManager: btsConfig.packageManager,
 		dbSetup: btsConfig.dbSetup,
 		api: btsConfig.api,
@@ -2015,7 +1901,7 @@ async function readBtsConfig(projectDir) {
 			return null;
 		}
 		return config;
-	} catch (_error) {
+	} catch {
 		return null;
 	}
 }
@@ -2033,7 +1919,7 @@ async function updateBtsConfig(projectDir, updates) {
 			modifiedContent = JSONC.applyEdits(modifiedContent, editResult);
 		}
 		await fs.writeFile(configPath, modifiedContent, "utf-8");
-	} catch (_error) {}
+	} catch {}
 }
 
 //#endregion
@@ -2212,7 +2098,7 @@ async function setupRuler(config) {
 				shell: true
 			});
 			s.stop("Applied rules with Ruler");
-		} catch (_error) {
+		} catch {
 			s.stop(pc.red("Failed to apply rules"));
 		}
 	} catch (error) {
@@ -2636,14 +2522,14 @@ async function detectProjectConfig(projectDir) {
 			serverDeploy: btsConfig.serverDeploy
 		};
 		return null;
-	} catch (_error) {
+	} catch {
 		return null;
 	}
 }
 async function isBetterTStackProject(projectDir) {
 	try {
 		return await fs.pathExists(path.join(projectDir, "bts.jsonc"));
-	} catch (_error) {
+	} catch {
 		return false;
 	}
 }
@@ -2686,7 +2572,7 @@ function initializeBiome() {
 			biome,
 			projectKey
 		};
-	} catch (_error) {
+	} catch {
 		return null;
 	}
 }
@@ -2721,7 +2607,7 @@ function formatFileWithBiome(filePath, content) {
 		const result = biome.formatContent(projectKey, content, { filePath: path.basename(filePath) });
 		if (result.diagnostics && result.diagnostics.length > 0) consola.debug(`Biome formatting diagnostics for ${filePath}:`, result.diagnostics);
 		return result.content;
-	} catch (_error) {
+	} catch {
 		return null;
 	}
 }
@@ -3864,6 +3750,7 @@ async function addDeploymentToProject(input) {
 async function setupCatalogs(projectDir, options) {
 	if (options.packageManager === "npm") return;
 	const packagePaths = [
+		".",
 		"apps/server",
 		"apps/web",
 		"apps/native",
@@ -3872,7 +3759,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) {
@@ -3971,15 +3859,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"],
-			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
 		});
@@ -4028,15 +3919,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 (_error) {}
-}
 function getFrontendType(frontend) {
 	const reactBasedFrontends = [
 		"tanstack-router",
@@ -4154,7 +4036,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");
@@ -4224,10 +4106,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);
 	}
 }
 
@@ -4754,15 +4632,11 @@ async function setupCloudflareD1(config) {
 	const { projectDir, serverDeploy, orm, backend } = config;
 	if (serverDeploy === "alchemy" && orm === "prisma") {
 		const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
-		const envPath = path.join(projectDir, targetApp2, ".env");
-		const variables = [{
+		await addEnvVariablesToFile(path.join(projectDir, targetApp2, ".env"), [{
 			key: "DATABASE_URL",
 			value: `file:${path.join(projectDir, "apps/server", "local.db")}`,
 			condition: true
-		}];
-		try {
-			await addEnvVariablesToFile(envPath, variables);
-		} catch (_err) {}
+		}]);
 		await addPackageDependency({
 			dependencies: ["@prisma/adapter-d1"],
 			projectDir: path.join(projectDir, backend === "self" ? "apps/web" : "apps/server")
@@ -4817,7 +4691,7 @@ async function checkAtlasCLI() {
 		if (exists) log.info("MongoDB Atlas CLI found");
 		else log.warn(pc.yellow("MongoDB Atlas CLI not found"));
 		return exists;
-	} catch (_error) {
+	} catch {
 		log.error(pc.red("Error checking MongoDB Atlas CLI"));
 		return false;
 	}
@@ -4862,7 +4736,7 @@ async function writeEnvFile$3(projectDir, backend, config) {
 			value: config?.connectionString ?? "mongodb://localhost:27017/mydb",
 			condition: true
 		}]);
-	} catch (_error) {
+	} catch {
 		consola.error("Failed to update environment configuration");
 	}
 }
@@ -4999,7 +4873,7 @@ async function createNeonProject(projectName, regionId, packageManager) {
 		}
 		consola$1.error(pc.red("Failed to extract connection information from response"));
 		return null;
-	} catch (_error) {
+	} catch {
 		consola$1.error(pc.red("Failed to create Neon project"));
 	}
 }
@@ -5247,7 +5121,7 @@ async function writeEnvFile$1(projectDir, backend, config) {
 			condition: true
 		});
 		await addEnvVariablesToFile(envPath, variables);
-	} catch (_error) {
+	} catch {
 		consola$1.error("Failed to update environment configuration");
 	}
 }
@@ -5474,7 +5348,7 @@ async function loginToTurso() {
 		await $`turso auth login`;
 		s.stop("Logged into Turso");
 		return true;
-	} catch (_error) {
+	} catch {
 		s.stop(pc.red("Failed to log in to Turso"));
 	}
 }
@@ -5562,7 +5436,7 @@ async function createTursoDatabase(dbName, groupName) {
 			dbUrl: dbUrl.trim(),
 			authToken: authToken.trim()
 		};
-	} catch (_error) {
+	} catch {
 		s.stop(pc.red("Failed to retrieve database connection details"));
 	}
 }
@@ -5688,7 +5562,6 @@ async function setupDatabase(config, cliInput) {
 		}
 		return;
 	}
-	const s = spinner();
 	const dbPackageDir = path.join(projectDir, "packages/db");
 	const webDir = path.join(projectDir, "apps/web");
 	const webDirExists = await fs.pathExists(webDir);
@@ -5791,7 +5664,6 @@ async function setupDatabase(config, cliInput) {
 			if (dbSetup === "planetscale") await setupPlanetScale(config);
 		} else if (database === "mongodb" && dbSetup === "mongodb-atlas") await setupMongoDBAtlas(config, cliInput);
 	} catch (error) {
-		s.stop(pc.red("Failed to set up database"));
 		if (error instanceof Error) consola.error(pc.red(error.message));
 	}
 }
@@ -6438,93 +6310,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 [];
 }
 
@@ -6533,185 +6425,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()}`;
-	} catch (_e) {
-		log.warn(`Could not determine ${options.packageManager} version.`);
+		const { stdout } = await execa(packageManager, ["-v"], { cwd: projectDir });
+		packageJson.packageManager = `${packageManager}@${stdout.trim()}`;
+	} catch {
+		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";
@@ -6738,7 +6575,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 });
 }
 
@@ -7101,21 +6938,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(),
@@ -7123,9 +6960,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({
@@ -7134,12 +6971,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;