create-better-t-stack 3.7.3-canary.fe324be3 → 3.7.4

package/dist/{src-yXf02Wox.js → src-B6YuFjPr.js}

@@ -3,12 +3,11 @@ import { autocompleteMultiselect, cancel, confirm, group, groupMultiselect, intr
 import { createRouterClient, os } from "@orpc/server";
 import pc from "picocolors";
 import { createCli } from "trpc-cli";
-import z from "zod";
+import z$1, { 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";
@@ -63,7 +62,6 @@ 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",
@@ -100,7 +98,7 @@ const dependencyVersionMap = {
 	"lint-staged": "^16.1.2",
 	tsx: "^4.19.2",
 	"@types/node": "^22.13.11",
-	"@types/bun": "^1.3.4",
+	"@types/bun": "^1.2.6",
 	"@elysiajs/node": "^1.3.1",
 	"@elysiajs/cors": "^1.3.3",
 	"@elysiajs/trpc": "^1.1.0",
@@ -120,17 +118,17 @@ const dependencyVersionMap = {
 	"@ai-sdk/vue": "^2.0.49",
 	"@ai-sdk/svelte": "^3.0.39",
 	"@ai-sdk/react": "^2.0.39",
-	streamdown: "^1.3.0",
+	streamdown: "^1.6.10",
 	shiki: "^3.12.2",
-	"@orpc/server": "^1.10.0",
-	"@orpc/client": "^1.10.0",
-	"@orpc/openapi": "^1.10.0",
-	"@orpc/zod": "^1.10.0",
-	"@orpc/tanstack-query": "^1.10.0",
-	"@trpc/tanstack-react-query": "^11.5.0",
-	"@trpc/server": "^11.5.0",
-	"@trpc/client": "^11.5.0",
-	next: "^16.0.7",
+	"@orpc/server": "^1.12.2",
+	"@orpc/client": "^1.12.2",
+	"@orpc/openapi": "^1.12.2",
+	"@orpc/zod": "^1.12.2",
+	"@orpc/tanstack-query": "^1.12.2",
+	"@trpc/tanstack-react-query": "^11.7.2",
+	"@trpc/server": "^11.7.2",
+	"@trpc/client": "^11.7.2",
+	next: "^16.0.10",
 	convex: "^1.29.3",
 	"@convex-dev/react-query": "^0.1.0",
 	"convex-svelte": "^0.0.12",
@@ -141,8 +139,8 @@ const dependencyVersionMap = {
 	"@tanstack/svelte-query-devtools": "^5.85.3",
 	"@tanstack/vue-query-devtools": "^5.90.2",
 	"@tanstack/vue-query": "^5.90.2",
-	"@tanstack/react-query-devtools": "^5.85.5",
-	"@tanstack/react-query": "^5.85.5",
+	"@tanstack/react-query-devtools": "^5.91.1",
+	"@tanstack/react-query": "^5.90.12",
 	"@tanstack/solid-query": "^5.87.4",
 	"@tanstack/solid-query-devtools": "^5.87.4",
 	"@tanstack/solid-router-devtools": "^1.131.44",
@@ -186,6 +184,121 @@ 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 = [
@@ -1233,7 +1346,7 @@ const getLatestCLIVersion = () => {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "0";
+	const BTS_TELEMETRY = "1";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
 	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
@@ -3750,7 +3863,6 @@ async function addDeploymentToProject(input) {
 async function setupCatalogs(projectDir, options) {
 	if (options.packageManager === "npm") return;
 	const packagePaths = [
-		".",
 		"apps/server",
 		"apps/web",
 		"apps/native",
@@ -3759,8 +3871,7 @@ async function setupCatalogs(projectDir, options) {
 		"packages/api",
 		"packages/db",
 		"packages/auth",
-		"packages/backend",
-		"packages/config"
+		"packages/backend"
 	];
 	const packagesInfo = [];
 	for (const pkgPath of packagePaths) {
@@ -3859,18 +3970,15 @@ async function updatePackageJsonsWithCatalogs(packagesInfo, catalog) {
 //#endregion
 //#region src/helpers/addons/examples-setup.ts
 async function setupExamples(config) {
-	const { examples, frontend, backend, projectDir, orm, database } = config;
+	const { examples, frontend, backend, projectDir, orm } = 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") {
-			const dependencies = ["drizzle-orm"];
-			if (database === "postgres") dependencies.push("@types/pg");
-			await addPackageDependency({
-				dependencies,
-				projectDir: apiDir
-			});
-		} else if (orm === "prisma") await addPackageDependency({
+		if (orm === "drizzle") await addPackageDependency({
+			dependencies: ["drizzle-orm", "@types/pg"],
+			projectDir: apiDir
+		});
+		else if (orm === "prisma") await addPackageDependency({
 			dependencies: ["@prisma/client"],
 			projectDir: apiDir
 		});
@@ -3919,6 +4027,15 @@ 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",
@@ -4036,7 +4153,7 @@ function getConvexDependencies(frontend) {
 	return deps;
 }
 async function setupApi(config) {
-	const { api, frontend, backend, projectDir } = config;
+	const { api, projectName, frontend, backend, packageManager, projectDir } = config;
 	const isConvex = backend === "convex";
 	const webDir = path.join(projectDir, "apps/web");
 	const nativeDir = path.join(projectDir, "apps/native");
@@ -4106,6 +4223,10 @@ 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);
 	}
 }
 
@@ -6310,113 +6431,93 @@ function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend)
 //#endregion
 //#region src/helpers/core/workspace-setup.ts
 async function setupWorkspaceDependencies(projectDir, options) {
-	const { projectName, packageManager, database, auth, api, runtime, backend } = options;
-	const workspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
+	const projectName = options.projectName;
+	const workspaceVersion = options.packageManager === "npm" ? "*" : "workspace:*";
 	const commonDeps = ["dotenv", "zod"];
-	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({
+	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({
 		dependencies: commonDeps,
 		devDependencies: commonDevDeps,
 		customDevDependencies: configDep,
-		projectDir: dbDir
+		projectDir: dbPackageDir
 	});
-	if (authExists) {
+	const authPackageDir = path.join(projectDir, "packages/auth");
+	if (await fs.pathExists(authPackageDir)) {
 		const authDeps = {};
-		if (database !== "none" && dbExists) authDeps[`@${projectName}/db`] = workspaceVersion;
+		if (options.database !== "none" && await fs.pathExists(dbPackageDir)) authDeps[`@${projectName}/db`] = workspaceVersion;
 		await addPackageDependency({
 			dependencies: commonDeps,
 			devDependencies: commonDevDeps,
 			customDependencies: authDeps,
 			customDevDependencies: configDep,
-			projectDir: authDir
+			projectDir: authPackageDir
 		});
 	}
-	if (apiExists) {
+	const apiPackageDir = path.join(projectDir, "packages/api");
+	if (await fs.pathExists(apiPackageDir)) {
 		const apiDeps = {};
-		if (auth !== "none" && authExists) apiDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (database !== "none" && dbExists) apiDeps[`@${projectName}/db`] = workspaceVersion;
+		if (options.auth !== "none" && await fs.pathExists(authPackageDir)) apiDeps[`@${projectName}/auth`] = workspaceVersion;
+		if (options.database !== "none" && await fs.pathExists(dbPackageDir)) apiDeps[`@${projectName}/db`] = workspaceVersion;
 		await addPackageDependency({
 			dependencies: commonDeps,
 			devDependencies: commonDevDeps,
 			customDependencies: apiDeps,
 			customDevDependencies: configDep,
-			projectDir: apiDir
+			projectDir: apiPackageDir
 		});
 	}
-	if (backendExists) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
-		customDevDependencies: configDep,
-		projectDir: backendDir
-	});
-	if (serverExists) {
+	const serverPackageDir = path.join(projectDir, "apps/server");
+	if (await fs.pathExists(serverPackageDir)) {
 		const serverDeps = {};
-		if (api !== "none" && apiExists) serverDeps[`@${projectName}/api`] = workspaceVersion;
-		if (auth !== "none" && authExists) serverDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (database !== "none" && dbExists) serverDeps[`@${projectName}/db`] = workspaceVersion;
+		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;
 		await addPackageDependency({
 			dependencies: commonDeps,
 			devDependencies: [...commonDevDeps, "tsdown"],
 			customDependencies: serverDeps,
 			customDevDependencies: configDep,
-			projectDir: serverDir
+			projectDir: serverPackageDir
 		});
 	}
-	if (webExists) {
+	const webPackageDir = path.join(projectDir, "apps/web");
+	if (await fs.pathExists(webPackageDir)) {
 		const webDeps = {};
-		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,
+		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({
 			customDependencies: webDeps,
 			customDevDependencies: configDep,
-			projectDir: webDir
+			projectDir: webPackageDir
 		});
 	}
-	if (nativeExists) {
+	const nativePackageDir = path.join(projectDir, "apps/native");
+	if (await fs.pathExists(nativePackageDir)) {
 		const nativeDeps = {};
-		if (api !== "none" && apiExists) nativeDeps[`@${projectName}/api`] = workspaceVersion;
-		if (backend === "convex" && backendExists) nativeDeps[`@${projectName}/backend`] = workspaceVersion;
-		await addPackageDependency({
-			dependencies: commonDeps,
-			devDependencies: commonDevDeps,
+		if (options.api !== "none" && await fs.pathExists(apiPackageDir)) nativeDeps[`@${projectName}/api`] = workspaceVersion;
+		if (Object.keys(nativeDeps).length > 0) await addPackageDependency({
 			customDependencies: nativeDeps,
 			customDevDependencies: configDep,
-			projectDir: nativeDir
+			projectDir: nativePackageDir
 		});
 	}
-	const runtimeDevDeps = getRuntimeDevDeps(runtime, backend);
+	const runtimeDevDeps = getRuntimeDevDeps(options);
 	await addPackageDependency({
 		dependencies: commonDeps,
 		devDependencies: [...commonDevDeps, ...runtimeDevDeps],
 		projectDir
 	});
 }
-function getRuntimeDevDeps(runtime, backend) {
+function getRuntimeDevDeps(options) {
+	const { runtime, backend } = options;
 	if (runtime === "none" && backend === "self") return ["@types/node"];
-	if (runtime === "node" || runtime === "workers") return ["@types/node"];
+	if (runtime === "node") return ["@types/node"];
 	if (runtime === "bun") return ["@types/bun"];
+	if (runtime === "workers") return ["@types/node"];
 	return [];
 }
 
@@ -6425,130 +6526,185 @@ function getRuntimeDevDeps(runtime, backend) {
 async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(projectDir, options);
 	if (options.backend === "convex") await updateConvexPackageJson(projectDir, options);
-	else if (options.backend !== "none") {
+	else if (options.backend === "self") {
 		await updateDbPackageJson(projectDir, options);
 		await updateAuthPackageJson(projectDir, options);
 		await updateApiPackageJson(projectDir, options);
-		if (options.backend !== "self") await updateServerPackageJson(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);
 	}
-	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;
-	packageJson.scripts = packageJson.scripts || {};
-	packageJson.workspaces = packageJson.workspaces || [];
+	if (!packageJson.scripts) packageJson.scripts = {};
 	const scripts = packageJson.scripts;
-	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");
+	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`;
 		}
-	}
-	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(packageManager, ["-v"], { cwd: projectDir });
-		packageJson.packageManager = `${packageManager}@${stdout.trim()}`;
+		const { stdout } = await execa(options.packageManager, ["-v"], { cwd: projectDir });
+		packageJson.packageManager = `${options.packageManager}@${stdout.trim()}`;
 	} catch {
-		log.warn(`Could not determine ${packageManager} version.`);
+		log.warn(`Could not determine ${options.packageManager} version.`);
 	}
-	if (backend === "convex") {
+	if (!packageJson.workspaces) packageJson.workspaces = [];
+	const workspaces = packageJson.workspaces;
+	if (options.backend === "convex") {
 		if (!workspaces.includes("packages/*")) workspaces.push("packages/*");
-		if ((options.frontend.length > 0 || addons.includes("starlight")) && !workspaces.includes("apps/*")) workspaces.push("apps/*");
+		if ((options.frontend.length > 0 || options.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 });
 }
-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) {
+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);
-	serverPackageJson.scripts = serverPackageJson.scripts || {};
+	if (!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`;
-	dbPackageJson.scripts = dbPackageJson.scripts || {};
+	if (!dbPackageJson.scripts) dbPackageJson.scripts = {};
 	const scripts = dbPackageJson.scripts;
-	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") {
+	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") {
 			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";
-			if (!isD1Alchemy) scripts["db:studio"] = "prisma studio";
-		} else if (orm === "drizzle") {
+		} else if (options.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 (!isD1Alchemy) {
-				scripts["db:studio"] = "drizzle-kit studio";
-				scripts["db:migrate"] = "drizzle-kit migrate";
-			}
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = "drizzle-kit migrate";
 		}
 	}
-	if (dbSetup === "docker") {
+	if (options.dbSetup === "docker") {
 		scripts["db:start"] = "docker compose up -d";
 		scripts["db:watch"] = "docker compose up";
 		scripts["db:stop"] = "docker compose stop";
@@ -6575,7 +6731,7 @@ async function updateConvexPackageJson(projectDir, options) {
 	if (!await fs.pathExists(convexPackageJsonPath)) return;
 	const convexPackageJson = await fs.readJson(convexPackageJsonPath);
 	convexPackageJson.name = `@${options.projectName}/backend`;
-	convexPackageJson.scripts = convexPackageJson.scripts || {};
+	if (!convexPackageJson.scripts) convexPackageJson.scripts = {};
 	await fs.writeJson(convexPackageJsonPath, convexPackageJson, { spaces: 2 });
 }
 
@@ -6938,21 +7094,21 @@ const router = os.router({
 		description: "Create a new Better-T-Stack project",
 		default: true,
 		negateBooleans: true
-	}).input(z.tuple([ProjectNameSchema.optional(), z.object({
+	}).input(z$1.tuple([ProjectNameSchema.optional(), z$1.object({
 		template: TemplateSchema.optional().describe("Use a predefined template"),
-		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"),
+		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"),
 		database: DatabaseSchema.optional(),
 		orm: ORMSchema.optional(),
 		auth: AuthSchema.optional(),
 		payments: PaymentsSchema.optional(),
-		frontend: z.array(FrontendSchema).optional(),
-		addons: z.array(AddonsSchema).optional(),
-		examples: z.array(ExamplesSchema).optional(),
-		git: z.boolean().optional(),
+		frontend: z$1.array(FrontendSchema).optional(),
+		addons: z$1.array(AddonsSchema).optional(),
+		examples: z$1.array(ExamplesSchema).optional(),
+		git: z$1.boolean().optional(),
 		packageManager: PackageManagerSchema.optional(),
-		install: z.boolean().optional(),
+		install: z$1.boolean().optional(),
 		dbSetup: DatabaseSetupSchema.optional(),
 		backend: BackendSchema.optional(),
 		runtime: RuntimeSchema.optional(),
@@ -6960,9 +7116,9 @@ const router = os.router({
 		webDeploy: WebDeploySchema.optional(),
 		serverDeploy: ServerDeploySchema.optional(),
 		directoryConflict: DirectoryConflictSchema.optional(),
-		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")
+		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")
 	})])).handler(async ({ input }) => {
 		const [projectName, options] = input;
 		const result = await createProjectHandler({
@@ -6971,12 +7127,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.tuple([z.object({
-		addons: z.array(AddonsSchema).optional().default([]),
+	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([]),
 		webDeploy: WebDeploySchema.optional(),
 		serverDeploy: ServerDeploySchema.optional(),
-		projectDir: z.string().optional(),
-		install: z.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
+		projectDir: z$1.string().optional(),
+		install: z$1.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
 		packageManager: PackageManagerSchema.optional()
 	})])).handler(async ({ input }) => {
 		const [options] = input;