create-better-t-stack 2.49.1-canary.80158905 → 2.50.0

package/dist/{src-CyG8-I-3.js → src-BFx0Xu3C.js}

@@ -65,13 +65,12 @@ const dependencyVersionMap = {
 	"@better-auth/expo": "^1.3.13",
 	"@clerk/nextjs": "^6.31.5",
 	"@clerk/clerk-react": "^5.45.0",
-	"@clerk/tanstack-react-start": "^0.23.1",
+	"@clerk/tanstack-react-start": "^0.25.1",
 	"@clerk/clerk-expo": "^2.14.25",
 	"drizzle-orm": "^0.44.2",
 	"drizzle-kit": "^0.31.2",
 	"@planetscale/database": "^1.19.0",
 	"@libsql/client": "^0.15.9",
-	libsql: "^0.5.22",
 	"@neondatabase/serverless": "^1.0.1",
 	pg: "^8.14.1",
 	"@types/pg": "^8.11.11",
@@ -139,17 +138,15 @@ const dependencyVersionMap = {
 	"@tanstack/solid-query": "^5.87.4",
 	"@tanstack/solid-query-devtools": "^5.87.4",
 	"@tanstack/solid-router-devtools": "^1.131.44",
-	wrangler: "^4.23.0",
-	"@cloudflare/vite-plugin": "^1.9.0",
+	wrangler: "^4.40.3",
+	"@cloudflare/vite-plugin": "^1.13.8",
 	"@opennextjs/cloudflare": "^1.6.5",
 	"nitro-cloudflare-dev": "^0.2.2",
 	"@sveltejs/adapter-cloudflare": "^7.2.1",
 	"@cloudflare/workers-types": "^4.20250822.0",
-	alchemy: "^0.67.0",
+	alchemy: "^0.70.0",
 	nitropack: "^2.12.4",
-	dotenv: "^17.2.2",
-	tsdown: "^0.15.5",
-	zod: "^4.1.11",
+	dotenv: "^17.2.1",
 	"@polar-sh/better-auth": "^1.1.3",
 	"@polar-sh/sdk": "^0.34.16"
 };
@@ -1378,7 +1375,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;
@@ -1386,8 +1383,8 @@ function isTelemetryEnabled() {
 
 //#endregion
 //#region src/utils/analytics.ts
-const POSTHOG_API_KEY = "random";
-const POSTHOG_HOST = "random";
+const POSTHOG_API_KEY = "phc_8ZUxEwwfKMajJLvxz1daGd931dYbQrwKNficBmsdIrs";
+const POSTHOG_HOST = "https://us.i.posthog.com";
 function generateSessionId() {
 	const rand = Math.random().toString(36).slice(2);
 	return `cli_${Date.now().toString(36)}${rand}`;
@@ -1995,17 +1992,15 @@ const addPackageDependency = async (opts) => {
 	if (!pkgJson.dependencies) pkgJson.dependencies = {};
 	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
 	for (const pkgName of dependencies) {
-		const version = dependencyVersionMap[pkgName];
+		const version = customDependencies[pkgName] || dependencyVersionMap[pkgName];
 		if (version) pkgJson.dependencies[pkgName] = version;
 		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
 	}
 	for (const pkgName of devDependencies) {
-		const version = dependencyVersionMap[pkgName];
+		const version = customDevDependencies[pkgName] || dependencyVersionMap[pkgName];
 		if (version) pkgJson.devDependencies[pkgName] = version;
 		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
 	}
-	for (const [pkgName, version] of Object.entries(customDependencies)) pkgJson.dependencies[pkgName] = version;
-	for (const [pkgName, version] of Object.entries(customDevDependencies)) pkgJson.devDependencies[pkgName] = version;
 	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 };
 
@@ -2775,29 +2770,24 @@ async function setupBackendFramework(projectDir, context) {
 		return;
 	}
 	await fs.ensureDir(serverAppDir);
-	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/base");
+	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/server-base");
 	if (await fs.pathExists(serverBaseDir)) await processAndCopyFiles("**/*", serverBaseDir, serverAppDir, context);
 	const frameworkSrcDir = path.join(PKG_ROOT, `templates/backend/server/${context.backend}`);
 	if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, serverAppDir, context, true);
 	if (context.api !== "none") {
-		const apiPackageDir = path.join(projectDir, "packages/api");
-		await fs.ensureDir(apiPackageDir);
 		const apiServerBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/base`);
-		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, apiPackageDir, context);
-		let apiServerFrameworkDir = "";
-		if (context.backend === "next") apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
-		else apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/rest`);
-		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, apiPackageDir, context, true);
-	}
-	if (context.database !== "none" && context.orm !== "none") {
-		const dbPackageDir = path.join(projectDir, "packages/db");
-		await fs.ensureDir(dbPackageDir);
-		const dbBaseDir = path.join(PKG_ROOT, "templates/db/base");
-		if (await fs.pathExists(dbBaseDir)) await processAndCopyFiles("**/*", dbBaseDir, dbPackageDir, context);
-		const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
-		if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, dbPackageDir, context);
+		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, serverAppDir, context, true);
+		const apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
+		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, serverAppDir, context, true);
 	}
 }
+async function setupDbOrmTemplates(projectDir, context) {
+	if (context.backend === "convex" || context.orm === "none" || context.database === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	await fs.ensureDir(serverAppDir);
+	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
+	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, serverAppDir, context);
+}
 async function setupAuthTemplate(projectDir, context) {
 	if (!context.auth || context.auth === "none") return;
 	const serverAppDir = path.join(projectDir, "apps/server");
@@ -2877,24 +2867,20 @@ async function setupAuthTemplate(projectDir, context) {
 		return;
 	}
 	if (serverAppDirExists && context.backend !== "convex") {
-		const authPackageDir = path.join(projectDir, "packages/auth");
-		await fs.ensureDir(authPackageDir);
 		const authServerBaseSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/base`);
-		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, authPackageDir, context);
+		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, serverAppDir, context);
 		if (context.backend === "next") {
 			const authServerNextSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/next`);
-			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, authPackageDir, context);
+			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, serverAppDir, context);
 		}
 		if (context.orm !== "none" && context.database !== "none") {
-			const dbPackageDir = path.join(projectDir, "packages/db");
-			await fs.ensureDir(dbPackageDir);
 			const orm = context.orm;
 			const db = context.database;
 			let authDbSrc = "";
 			if (orm === "drizzle") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/drizzle/${db}`);
 			else if (orm === "prisma") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/prisma/${db}`);
 			else if (orm === "mongoose") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/mongoose/${db}`);
-			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, dbPackageDir, context);
+			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, serverAppDir, context);
 		}
 	}
 	if ((hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) && webAppDirExists) {
@@ -2941,10 +2927,8 @@ async function setupPaymentsTemplate(projectDir, context) {
 	const serverAppDirExists = await fs.pathExists(serverAppDir);
 	const webAppDirExists = await fs.pathExists(webAppDir);
 	if (serverAppDirExists && context.backend !== "convex") {
-		const authPackageDir = path.join(projectDir, "packages/auth");
-		await fs.ensureDir(authPackageDir);
 		const paymentsServerSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/server/base`);
-		if (await fs.pathExists(paymentsServerSrc)) await processAndCopyFiles("**/*", paymentsServerSrc, authPackageDir, context);
+		if (await fs.pathExists(paymentsServerSrc)) await processAndCopyFiles("**/*", paymentsServerSrc, serverAppDir, context);
 	}
 	const hasReactWeb = context.frontend.some((f) => [
 		"tanstack-router",
@@ -3022,22 +3006,16 @@ async function setupExamplesTemplate(projectDir, context) {
 		const exampleBaseDir = path.join(PKG_ROOT, `templates/examples/${example}`);
 		if (serverAppDirExists && context.backend !== "convex" && context.backend !== "none") {
 			const exampleServerSrc = path.join(exampleBaseDir, "server");
-			if (context.api !== "none") {
-				const apiPackageDir = path.join(projectDir, "packages/api");
-				await fs.ensureDir(apiPackageDir);
-				const exampleOrmBaseSrc = path.join(exampleServerSrc, context.orm, "base");
-				if (await fs.pathExists(exampleOrmBaseSrc)) await processAndCopyFiles("**/*", exampleOrmBaseSrc, apiPackageDir, context, false);
-			}
-			if (context.orm !== "none" && context.database !== "none") {
-				const dbPackageDir = path.join(projectDir, "packages/db");
-				await fs.ensureDir(dbPackageDir);
-				const exampleDbSchemaSrc = path.join(exampleServerSrc, context.orm, context.database);
-				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, dbPackageDir, context, false);
-			}
 			if (example === "ai" && context.backend === "next") {
 				const aiNextServerSrc = path.join(exampleServerSrc, "next");
 				if (await fs.pathExists(aiNextServerSrc)) await processAndCopyFiles("**/*", aiNextServerSrc, serverAppDir, context, false);
 			}
+			if (context.orm !== "none" && context.database !== "none") {
+				const exampleOrmBaseSrc = path.join(exampleServerSrc, context.orm, "base");
+				if (await fs.pathExists(exampleOrmBaseSrc)) await processAndCopyFiles("**/*", exampleOrmBaseSrc, serverAppDir, context, false);
+				const exampleDbSchemaSrc = path.join(exampleServerSrc, context.orm, context.database);
+				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, serverAppDir, context, false);
+			}
 		}
 		if (webAppDirExists) {
 			if (hasReactWeb) {
@@ -3103,9 +3081,9 @@ async function handleExtras(projectDir, context) {
 }
 async function setupDockerComposeTemplates(projectDir, context) {
 	if (context.dbSetup !== "docker" || context.database === "none") return;
-	const dbPackageDir = path.join(projectDir, "packages/db");
+	const serverAppDir = path.join(projectDir, "apps/server");
 	const dockerSrcDir = path.join(PKG_ROOT, `templates/db-setup/docker-compose/${context.database}`);
-	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, dbPackageDir, context);
+	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, serverAppDir, context);
 }
 async function setupDeploymentTemplates(projectDir, context) {
 	if (context.webDeploy === "alchemy" || context.serverDeploy === "alchemy") if (context.webDeploy === "alchemy" && context.serverDeploy === "alchemy") {
@@ -3526,8 +3504,8 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 	await addPackageDependency({
 		devDependencies: [
 			"alchemy",
-			"nitropack",
-			"dotenv"
+			"dotenv",
+			"@cloudflare/vite-plugin"
 		],
 		projectDir: webAppDir
 	});
@@ -3555,17 +3533,6 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 			defaultImport: "alchemy"
 		});
 		else alchemyImport.setModuleSpecifier("alchemy/cloudflare/tanstack-start");
-		const reactImport = sourceFile.getImportDeclaration("@vitejs/plugin-react");
-		let reactPluginIdentifier = "viteReact";
-		if (!reactImport) sourceFile.addImportDeclaration({
-			moduleSpecifier: "@vitejs/plugin-react",
-			defaultImport: "viteReact"
-		});
-		else {
-			const defaultImport = reactImport.getDefaultImport();
-			if (defaultImport) reactPluginIdentifier = defaultImport.getText();
-			else reactImport.setDefaultImport("viteReact");
-		}
 		const exportAssignment = sourceFile.getExportAssignment((d) => !d.isExportEquals());
 		if (!exportAssignment) return;
 		const defineConfigCall = exportAssignment.getExpression();
@@ -3573,47 +3540,11 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 		let configObject = defineConfigCall.getArguments()[0];
 		if (!configObject) configObject = defineConfigCall.addArgument("{}");
 		if (Node.isObjectLiteralExpression(configObject)) {
-			if (!configObject.getProperty("build")) configObject.addPropertyAssignment({
-				name: "build",
-				initializer: `{
-    target: "esnext",
-    rollupOptions: {
-      external: ["node:async_hooks", "cloudflare:workers"],
-    },
-  }`
-			});
 			const pluginsProperty = configObject.getProperty("plugins");
 			if (pluginsProperty && Node.isPropertyAssignment(pluginsProperty)) {
 				const initializer = pluginsProperty.getInitializer();
 				if (Node.isArrayLiteralExpression(initializer)) {
-					if (!initializer.getElements().some((el) => el.getText().includes("alchemy"))) initializer.addElement("alchemy()");
-					const tanstackElements = initializer.getElements().filter((el) => el.getText().includes("tanstackStart"));
-					let needsReactPlugin = false;
-					tanstackElements.forEach((element) => {
-						if (Node.isCallExpression(element)) {
-							const args = element.getArguments();
-							if (args.length === 0) {
-								element.addArgument(`{
-      target: "cloudflare-module",
-      customViteReactPlugin: true,
-    }`);
-								needsReactPlugin = true;
-							} else if (args.length === 1 && Node.isObjectLiteralExpression(args[0])) {
-								const configObj = args[0];
-								if (!configObj.getProperty("target")) configObj.addPropertyAssignment({
-									name: "target",
-									initializer: "\"cloudflare-module\""
-								});
-								if (!!!configObj.getProperty("customViteReactPlugin")) configObj.addPropertyAssignment({
-									name: "customViteReactPlugin",
-									initializer: "true"
-								});
-								needsReactPlugin = true;
-							}
-						}
-					});
-					const hasReactPlugin = initializer.getElements().some((el) => Node.isCallExpression(el) && el.getExpression().getText() === reactPluginIdentifier);
-					if (needsReactPlugin && !hasReactPlugin) initializer.addElement(`${reactPluginIdentifier}()`);
+					if (!initializer.getElements().some((el) => el.getText().includes("alchemy("))) initializer.addElement("alchemy()");
 				}
 			} else configObject.addPropertyAssignment({
 				name: "plugins",
@@ -3624,16 +3555,6 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 	} catch (error) {
 		console.warn("Failed to update vite.config.ts:", error);
 	}
-	const nitroConfigPath = path.join(webAppDir, "nitro.config.ts");
-	await fs.writeFile(nitroConfigPath, `import { defineNitroConfig } from "nitropack/config";
-
-export default defineNitroConfig({
-    preset: "cloudflare-module",
-    cloudflare: {
-        nodeCompat: true,
-    },
-});
-`, "utf-8");
 }
 
 //#endregion
@@ -3800,7 +3721,7 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: ["wrangler"],
+		devDependencies: ["wrangler", "@cloudflare/vite-plugin"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3817,6 +3738,12 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	if (!await fs.pathExists(viteConfigPath)) return;
 	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
 	if (!sourceFile) return;
+	const cfImport = sourceFile.getImportDeclaration("@cloudflare/vite-plugin");
+	if (!cfImport) sourceFile.addImportDeclaration({
+		moduleSpecifier: "@cloudflare/vite-plugin",
+		namedImports: [{ name: "cloudflare" }]
+	});
+	else if (!cfImport.getNamedImports().some((ni) => ni.getName() === "cloudflare")) cfImport.addNamedImport({ name: "cloudflare" });
 	const reactImport = sourceFile.getImportDeclaration("@vitejs/plugin-react");
 	let reactPluginIdentifier = "viteReact";
 	if (!reactImport) sourceFile.addImportDeclaration({
@@ -3836,10 +3763,7 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	const configObj = defineCall.getArguments()[0];
 	if (!configObj) return;
 	const pluginsArray = ensureArrayProperty(configObj, "plugins");
-	const tanstackPluginIndex = pluginsArray.getElements().findIndex((el) => el.getText().includes("tanstackStart("));
-	const tanstackPluginText = "tanstackStart({ target: \"cloudflare-module\", customViteReactPlugin: true })";
-	if (tanstackPluginIndex === -1) pluginsArray.addElement(tanstackPluginText);
-	else pluginsArray.getElements()[tanstackPluginIndex].replaceWithText(tanstackPluginText);
+	if (!pluginsArray.getElements().some((el) => el.getText().includes("cloudflare("))) pluginsArray.insertElement(0, "cloudflare({ viteEnvironment: { name: 'ssr' } })");
 	if (!pluginsArray.getElements().some((el) => Node.isCallExpression(el) && el.getExpression().getText() === reactPluginIdentifier)) {
 		const nextIndex = pluginsArray.getElements().findIndex((el) => el.getText().includes("tanstackStart(")) + 1;
 		if (nextIndex > 0) pluginsArray.insertElement(nextIndex, `${reactPluginIdentifier}()`);
@@ -3985,10 +3909,10 @@ async function setupExamples(config) {
 	if (examples.includes("ai")) {
 		const webClientDir = path.join(projectDir, "apps/web");
 		const nativeClientDir = path.join(projectDir, "apps/native");
-		const apiDir = path.join(projectDir, "packages/api");
+		const serverDir = path.join(projectDir, "apps/server");
 		const webClientDirExists = await fs.pathExists(webClientDir);
 		const nativeClientDirExists = await fs.pathExists(nativeClientDir);
-		const apiDirExists = await fs.pathExists(apiDir);
+		const serverDirExists = await fs.pathExists(serverDir);
 		const hasNuxt = frontend.includes("nuxt");
 		const hasSvelte = frontend.includes("svelte");
 		const hasReactWeb = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next") || frontend.includes("tanstack-start");
@@ -4009,9 +3933,9 @@ async function setupExamples(config) {
 			dependencies: ["ai", "@ai-sdk/react"],
 			projectDir: nativeClientDir
 		});
-		if (apiDirExists && backend !== "none") await addPackageDependency({
+		if (serverDirExists && backend !== "none") await addPackageDependency({
 			dependencies: ["ai", "@ai-sdk/google"],
-			projectDir: apiDir
+			projectDir: serverDir
 		});
 	}
 }
@@ -4127,54 +4051,32 @@ function getConvexDependencies(frontend) {
 	return deps;
 }
 async function setupApi(config) {
-	const { api, projectName, frontend, backend, packageManager, projectDir, auth } = 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");
 	const serverDir = path.join(projectDir, "apps/server");
 	const webDirExists = await fs.pathExists(webDir);
 	const nativeDirExists = await fs.pathExists(nativeDir);
-	await fs.pathExists(serverDir);
+	const serverDirExists = await fs.pathExists(serverDir);
 	const frontendType = getFrontendType(frontend);
 	if (!isConvex && api !== "none") {
 		const apiDeps = getApiDependencies(api, frontendType);
-		const apiPackageDir = path.join(projectDir, "packages/api");
-		if (apiDeps.server) {
+		if (serverDirExists && apiDeps.server) {
 			await addPackageDependency({
 				dependencies: apiDeps.server.dependencies,
-				projectDir: apiPackageDir
-			});
-			const frameworkDeps = [];
-			if (backend === "hono") frameworkDeps.push("hono");
-			else if (backend === "elysia") frameworkDeps.push("elysia");
-			else if (backend === "express") frameworkDeps.push("express", "@types/express");
-			else if (backend === "fastify") frameworkDeps.push("fastify");
-			if (frameworkDeps.length > 0) await addPackageDependency({
-				dependencies: frameworkDeps,
-				projectDir: apiPackageDir
+				projectDir: serverDir
 			});
 			if (api === "trpc") {
 				if (backend === "hono") await addPackageDependency({
 					dependencies: ["@hono/trpc-server"],
-					projectDir: apiPackageDir
+					projectDir: serverDir
 				});
 				else if (backend === "elysia") await addPackageDependency({
 					dependencies: ["@elysiajs/trpc"],
-					projectDir: apiPackageDir
-				});
-				else if (backend === "express") await addPackageDependency({
-					dependencies: ["@trpc/server"],
-					projectDir: apiPackageDir
-				});
-				else if (backend === "fastify") await addPackageDependency({
-					dependencies: ["@trpc/server"],
-					projectDir: apiPackageDir
+					projectDir: serverDir
 				});
 			}
-			if (auth === "better-auth") await addPackageDependency({
-				dependencies: ["better-auth"],
-				projectDir: apiPackageDir
-			});
 		}
 		if (webDirExists && apiDeps.web) await addPackageDependency({
 			dependencies: apiDeps.web.dependencies,
@@ -4218,7 +4120,7 @@ async function setupApi(config) {
 //#endregion
 //#region src/helpers/core/backend-setup.ts
 async function setupBackendDependencies(config) {
-	const { backend, runtime, api, auth, examples, projectDir } = config;
+	const { backend, runtime, api, projectDir } = config;
 	if (backend === "convex") return;
 	const framework = backend;
 	const serverDir = path.join(projectDir, "apps/server");
@@ -4246,13 +4148,6 @@ async function setupBackendDependencies(config) {
 		dependencies.push("fastify", "@fastify/cors");
 		if (runtime === "node") devDependencies.push("tsx", "@types/node");
 	}
-	if (api === "trpc") {
-		if (framework === "express") dependencies.push("@trpc/server");
-		else if (framework === "fastify") dependencies.push("@trpc/server");
-		else if (runtime === "workers") dependencies.push("@trpc/server");
-	} else if (api === "orpc") dependencies.push("@orpc/server", "@orpc/openapi", "@orpc/zod");
-	if (auth === "better-auth") dependencies.push("better-auth");
-	if (examples.includes("ai")) dependencies.push("ai", "@ai-sdk/google");
 	if (runtime === "bun") devDependencies.push("@types/bun");
 	if (dependencies.length > 0 || devDependencies.length > 0) await addPackageDependency({
 		dependencies,
@@ -4271,7 +4166,7 @@ async function setupAuth(config) {
 	const nativeDir = path.join(projectDir, "apps/native");
 	const clientDirExists = await fs.pathExists(clientDir);
 	const nativeDirExists = await fs.pathExists(nativeDir);
-	await fs.pathExists(serverDir);
+	const serverDirExists = await fs.pathExists(serverDir);
 	try {
 		if (backend === "convex") {
 			if (auth === "clerk" && clientDirExists) {
@@ -4327,11 +4222,9 @@ async function setupAuth(config) {
 			});
 			return;
 		}
-		const authPackageDir = path.join(projectDir, "packages/auth");
-		const authPackageDirExists = await fs.pathExists(authPackageDir);
-		if (authPackageDirExists && auth === "better-auth") await addPackageDependency({
+		if (serverDirExists && auth === "better-auth") await addPackageDependency({
 			dependencies: ["better-auth"],
-			projectDir: authPackageDir
+			projectDir: serverDir
 		});
 		if (frontend.some((f) => [
 			"react-router",
@@ -4353,9 +4246,9 @@ async function setupAuth(config) {
 					dependencies: ["better-auth", "@better-auth/expo"],
 					projectDir: nativeDir
 				});
-				if (authPackageDirExists) await addPackageDependency({
+				if (serverDirExists) await addPackageDependency({
 					dependencies: ["@better-auth/expo"],
-					projectDir: authPackageDir
+					projectDir: serverDir
 				});
 			}
 		}
@@ -4538,6 +4431,8 @@ async function setupEnvironmentVariables(config) {
 		return;
 	}
 	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	const envPath = path.join(serverDir, ".env");
 	let corsOrigin = "http://localhost:3001";
 	if (hasReactRouter || hasSvelte) corsOrigin = "http://localhost:5173";
 	let databaseUrl = null;
@@ -4553,50 +4448,47 @@ async function setupEnvironmentVariables(config) {
 			break;
 		case "sqlite":
 			if (config.runtime === "workers") databaseUrl = "http://127.0.0.1:8080";
-			else databaseUrl = `file:${path.join(config.projectDir, "apps/server", "local.db")}`;
+			else databaseUrl = "file:./local.db";
 			break;
 	}
-	if (await fs.pathExists(serverDir)) {
-		const serverEnvPath = path.join(serverDir, ".env");
-		const serverVars = [
-			{
-				key: "BETTER_AUTH_SECRET",
-				value: generateAuthSecret(),
-				condition: !!auth
-			},
-			{
-				key: "BETTER_AUTH_URL",
-				value: "http://localhost:3000",
-				condition: !!auth
-			},
-			{
-				key: "POLAR_ACCESS_TOKEN",
-				value: "",
-				condition: config.payments === "polar"
-			},
-			{
-				key: "POLAR_SUCCESS_URL",
-				value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
-				condition: config.payments === "polar"
-			},
-			{
-				key: "CORS_ORIGIN",
-				value: corsOrigin,
-				condition: true
-			},
-			{
-				key: "GOOGLE_GENERATIVE_AI_API_KEY",
-				value: "",
-				condition: examples?.includes("ai") || false
-			},
-			{
-				key: "DATABASE_URL",
-				value: databaseUrl,
-				condition: database !== "none" && dbSetup === "none"
-			}
-		];
-		await addEnvVariablesToFile(serverEnvPath, serverVars);
-	}
+	const serverVars = [
+		{
+			key: "CORS_ORIGIN",
+			value: corsOrigin,
+			condition: true
+		},
+		{
+			key: "BETTER_AUTH_SECRET",
+			value: generateAuthSecret(),
+			condition: !!auth
+		},
+		{
+			key: "BETTER_AUTH_URL",
+			value: "http://localhost:3000",
+			condition: !!auth
+		},
+		{
+			key: "DATABASE_URL",
+			value: databaseUrl,
+			condition: database !== "none" && dbSetup === "none"
+		},
+		{
+			key: "GOOGLE_GENERATIVE_AI_API_KEY",
+			value: "",
+			condition: examples?.includes("ai") || false
+		},
+		{
+			key: "POLAR_ACCESS_TOKEN",
+			value: "",
+			condition: config.payments === "polar"
+		},
+		{
+			key: "POLAR_SUCCESS_URL",
+			value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
+			condition: config.payments === "polar"
+		}
+	];
+	await addEnvVariablesToFile(envPath, serverVars);
 	const isUnifiedAlchemy = webDeploy === "alchemy" && serverDeploy === "alchemy";
 	const isIndividualAlchemy = webDeploy === "alchemy" || serverDeploy === "alchemy";
 	if (isUnifiedAlchemy) {
@@ -4615,11 +4507,14 @@ async function setupEnvironmentVariables(config) {
 				condition: true
 			}]);
 		}
-		if (serverDeploy === "alchemy") await addEnvVariablesToFile(path.join(serverDir, ".env"), [{
-			key: "ALCHEMY_PASSWORD",
-			value: "please-change-this",
-			condition: true
-		}]);
+		if (serverDeploy === "alchemy") {
+			const serverDir$1 = path.join(projectDir, "apps/server");
+			if (await fs.pathExists(serverDir$1)) await addEnvVariablesToFile(path.join(serverDir$1, ".env"), [{
+				key: "ALCHEMY_PASSWORD",
+				value: "please-change-this",
+				condition: true
+			}]);
+		}
 	}
 }
 
@@ -4654,7 +4549,7 @@ async function setupCloudflareD1(config) {
 		const envPath = path.join(projectDir, "apps/server", ".env");
 		const variables = [{
 			key: "DATABASE_URL",
-			value: `file:${path.join(projectDir, "apps/server", "local.db")}`,
+			value: "file:./local.db",
 			condition: true
 		}];
 		try {
@@ -5184,9 +5079,9 @@ async function writeEnvFile$1(projectDir, config) {
 }
 async function addDotenvImportToPrismaConfig(projectDir) {
 	try {
-		const prismaConfigPath = path.join(projectDir, "packages/db/prisma.config.ts");
+		const prismaConfigPath = path.join(projectDir, "apps/server/prisma.config.ts");
 		let content = await fs.readFile(prismaConfigPath, "utf8");
-		content = `import dotenv from "dotenv";\ndotenv.config({ path: "../../apps/server/.env" });\n${content}`;
+		content = `import "dotenv/config";\n${content}`;
 		await fs.writeFile(prismaConfigPath, content);
 	} catch (_error) {
 		consola$1.error("Failed to update prisma.config.ts");
@@ -5202,12 +5097,11 @@ function displayManualSetupInstructions$1() {
 
 DATABASE_URL="your_database_url"`);
 }
-async function addPrismaAccelerateExtension(projectDir) {
+async function addPrismaAccelerateExtension(serverDir) {
 	try {
-		const dbPackageDir = path.join(projectDir, "packages/db");
 		await addPackageDependency({
 			dependencies: ["@prisma/extension-accelerate"],
-			projectDir: dbPackageDir
+			projectDir: serverDir
 		});
 		return true;
 	} catch (_error) {
@@ -5268,7 +5162,7 @@ async function setupPrismaPostgres(config, cliInput) {
 			await writeEnvFile$1(projectDir, prismaConfig);
 			if (orm === "prisma") {
 				await addDotenvImportToPrismaConfig(projectDir);
-				await addPrismaAccelerateExtension(projectDir);
+				await addPrismaAccelerateExtension(serverDir);
 			}
 			const connectionType = orm === "drizzle" ? "direct connection" : "Prisma Accelerate";
 			log.success(pc.green(`Prisma Postgres database configured successfully with ${connectionType}!`));
@@ -5368,18 +5262,18 @@ function displayManualSupabaseInstructions(output) {
 	log.info(`"Manual Supabase Setup Instructions:"
 1. Ensure Docker is installed and running.
 2. Install the Supabase CLI (e.g., \`npm install -g supabase\`).
-3. Run \`supabase init\` in your project's \`packages/db\` directory.
-4. Run \`supabase start\` in your project's \`packages/db\` directory.
+3. Run \`supabase init\` in your project's \`apps/server\` directory.
+4. Run \`supabase start\` in your project's \`apps/server\` directory.
 5. Copy the 'DB URL' from the output.${output ? `
 ${pc.bold("Relevant output from `supabase start`:")}
 ${pc.dim(output)}` : ""}
-6. Add the DB URL to the .env file in \`packages/db/.env\` as \`DATABASE_URL\`:
+6. Add the DB URL to the .env file in \`apps/server/.env\` as \`DATABASE_URL\`:
 			${pc.gray("DATABASE_URL=\"your_supabase_db_url\"")}`);
 }
 async function setupSupabase(config, cliInput) {
 	const { projectDir, packageManager } = config;
 	const manualDb = cliInput?.manualDb ?? false;
-	const serverDir = path.join(projectDir, "packages", "db");
+	const serverDir = path.join(projectDir, "apps", "server");
 	try {
 		await fs.ensureDir(serverDir);
 		if (manualDb) {
@@ -5662,15 +5556,15 @@ async function setupDatabase(config, cliInput) {
 	const { database, orm, dbSetup, backend, projectDir } = config;
 	if (backend === "convex" || database === "none") {
 		if (backend !== "convex") {
-			const serverDir = path.join(projectDir, "apps/server");
-			const serverDbDir = path.join(serverDir, "src/db");
+			const serverDir$1 = path.join(projectDir, "apps/server");
+			const serverDbDir = path.join(serverDir$1, "src/db");
 			if (await fs.pathExists(serverDbDir)) await fs.remove(serverDbDir);
 		}
 		return;
 	}
 	const s = spinner();
-	const dbPackageDir = path.join(projectDir, "packages/db");
-	if (!await fs.pathExists(dbPackageDir)) return;
+	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
 	try {
 		if (orm === "prisma") if (database === "mysql" && dbSetup === "planetscale") await addPackageDependency({
 			dependencies: [
@@ -5679,27 +5573,23 @@ async function setupDatabase(config, cliInput) {
 				"@planetscale/database"
 			],
 			devDependencies: ["prisma"],
-			projectDir: dbPackageDir
+			projectDir: serverDir
 		});
 		else if (database === "sqlite" && dbSetup === "turso") await addPackageDependency({
 			dependencies: ["@prisma/client", "@prisma/adapter-libsql"],
 			devDependencies: ["prisma"],
-			projectDir: dbPackageDir
+			projectDir: serverDir
 		});
 		else await addPackageDependency({
 			dependencies: ["@prisma/client"],
 			devDependencies: ["prisma"],
-			projectDir: dbPackageDir
+			projectDir: serverDir
 		});
 		else if (orm === "drizzle") {
 			if (database === "sqlite") await addPackageDependency({
-				dependencies: [
-					"drizzle-orm",
-					"@libsql/client",
-					"libsql"
-				],
+				dependencies: ["drizzle-orm", "@libsql/client"],
 				devDependencies: ["drizzle-kit"],
-				projectDir: dbPackageDir
+				projectDir: serverDir
 			});
 			else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
 				dependencies: [
@@ -5708,32 +5598,32 @@ async function setupDatabase(config, cliInput) {
 					"ws"
 				],
 				devDependencies: ["drizzle-kit", "@types/ws"],
-				projectDir: dbPackageDir
+				projectDir: serverDir
 			});
 			else if (dbSetup === "planetscale") await addPackageDependency({
 				dependencies: ["drizzle-orm", "pg"],
 				devDependencies: ["drizzle-kit", "@types/pg"],
-				projectDir: dbPackageDir
+				projectDir: serverDir
 			});
 			else await addPackageDependency({
 				dependencies: ["drizzle-orm", "pg"],
 				devDependencies: ["drizzle-kit", "@types/pg"],
-				projectDir: dbPackageDir
+				projectDir: serverDir
 			});
 			else if (database === "mysql") if (dbSetup === "planetscale") await addPackageDependency({
 				dependencies: ["drizzle-orm", "@planetscale/database"],
 				devDependencies: ["drizzle-kit"],
-				projectDir: dbPackageDir
+				projectDir: serverDir
 			});
 			else await addPackageDependency({
 				dependencies: ["drizzle-orm", "mysql2"],
 				devDependencies: ["drizzle-kit"],
-				projectDir: dbPackageDir
+				projectDir: serverDir
 			});
 		} else if (orm === "mongoose") await addPackageDependency({
 			dependencies: ["mongoose"],
 			devDependencies: [],
-			projectDir: dbPackageDir
+			projectDir: serverDir
 		});
 		if (dbSetup === "docker") await setupDockerCompose(config);
 		else if (database === "sqlite" && dbSetup === "turso") await setupTurso(config, cliInput);
@@ -6390,66 +6280,12 @@ function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy) {
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
-//#endregion
-//#region src/helpers/core/workspace-setup.ts
-async function setupWorkspaceDependencies(projectDir, options) {
-	const projectName = options.projectName;
-	const workspaceVersion = options.packageManager === "npm" ? "*" : "workspace:*";
-	const commonDeps = ["dotenv", "zod"];
-	const commonDevDeps = ["tsdown"];
-	const dbPackageDir = path.join(projectDir, "packages/db");
-	if (await fs.pathExists(dbPackageDir)) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
-		projectDir: dbPackageDir
-	});
-	const authPackageDir = path.join(projectDir, "packages/auth");
-	if (await fs.pathExists(authPackageDir)) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
-		customDependencies: { [`@${projectName}/db`]: workspaceVersion },
-		projectDir: authPackageDir
-	});
-	const apiPackageDir = path.join(projectDir, "packages/api");
-	if (await fs.pathExists(apiPackageDir)) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
-		customDependencies: {
-			[`@${projectName}/auth`]: workspaceVersion,
-			[`@${projectName}/db`]: workspaceVersion
-		},
-		projectDir: apiPackageDir
-	});
-	const serverPackageDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverPackageDir)) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
-		customDependencies: {
-			[`@${projectName}/api`]: workspaceVersion,
-			[`@${projectName}/auth`]: workspaceVersion,
-			[`@${projectName}/db`]: workspaceVersion
-		},
-		projectDir: serverPackageDir
-	});
-	if (options.api && options.api !== "none") {
-		const webPackageDir = path.join(projectDir, "apps/web");
-		if (await fs.pathExists(webPackageDir)) await addPackageDependency({
-			customDependencies: { [`@${projectName}/api`]: workspaceVersion },
-			projectDir: webPackageDir
-		});
-	}
-}
-
 //#endregion
 //#region src/helpers/core/project-config.ts
 async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(projectDir, options);
-	if (options.backend !== "convex") {
-		await updateServerPackageJson(projectDir, options);
-		await updateAuthPackageJson(projectDir, options);
-		await updateApiPackageJson(projectDir, options);
-		await setupWorkspaceDependencies(projectDir, options);
-	} else await updateConvexPackageJson(projectDir, options);
+	if (options.backend !== "convex") await updateServerPackageJson(projectDir, options);
+	else await updateConvexPackageJson(projectDir, options);
 }
 async function updateRootPackageJson(projectDir, options) {
 	const rootPackageJsonPath = path.join(projectDir, "package.json");
@@ -6459,7 +6295,6 @@ async function updateRootPackageJson(projectDir, options) {
 	if (!packageJson.scripts) packageJson.scripts = {};
 	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`;
@@ -6479,14 +6314,14 @@ async function updateRootPackageJson(projectDir, options) {
 		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`;
+			scripts["db:push"] = `turbo -F ${backendPackageName} db:push`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `turbo -F ${backendPackageName} db:studio`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `turbo -F ${dbPackageName} db:generate`;
-				scripts["db:migrate"] = `turbo -F ${dbPackageName} db:migrate`;
+				scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `turbo -F ${backendPackageName} 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`;
+				scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
 			}
 		}
 		if (options.dbSetup === "docker") {
@@ -6504,14 +6339,14 @@ async function updateRootPackageJson(projectDir, options) {
 		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`;
+			scripts["db:push"] = `pnpm --filter ${backendPackageName} db:push`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `pnpm --filter ${backendPackageName} db:studio`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `pnpm --filter ${dbPackageName} db:generate`;
-				scripts["db:migrate"] = `pnpm --filter ${dbPackageName} db:migrate`;
+				scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `pnpm --filter ${backendPackageName} 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`;
+				scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
 			}
 		}
 		if (options.dbSetup === "docker") {
@@ -6529,14 +6364,14 @@ async function updateRootPackageJson(projectDir, options) {
 		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}`;
+			scripts["db:push"] = `npm run db:push --workspace ${backendPackageName}`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `npm run db:studio --workspace ${backendPackageName}`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `npm run db:generate --workspace ${dbPackageName}`;
-				scripts["db:migrate"] = `npm run db:migrate --workspace ${dbPackageName}`;
+				scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
+				scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
 			} 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}`;
+				scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
 			}
 		}
 		if (options.dbSetup === "docker") {
@@ -6554,14 +6389,14 @@ async function updateRootPackageJson(projectDir, options) {
 		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`;
+			scripts["db:push"] = `bun run --filter ${backendPackageName} db:push`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `bun run --filter ${backendPackageName} db:studio`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `bun run --filter ${dbPackageName} db:generate`;
-				scripts["db:migrate"] = `bun run --filter ${dbPackageName} db:migrate`;
+				scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `bun run --filter ${backendPackageName} 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`;
+				scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
 			}
 		}
 		if (options.dbSetup === "docker") {
@@ -6594,22 +6429,6 @@ async function updateServerPackageJson(projectDir, options) {
 	const serverPackageJson = await fs.readJson(serverPackageJsonPath);
 	if (!serverPackageJson.scripts) serverPackageJson.scripts = {};
 	const scripts = serverPackageJson.scripts;
-	if (options.dbSetup === "docker") {
-		scripts["db:start"] = "docker compose up -d";
-		scripts["db:watch"] = "docker compose up";
-		scripts["db:stop"] = "docker compose stop";
-		scripts["db:down"] = "docker compose down";
-	}
-	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
-	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 = {};
-	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") {
@@ -6624,21 +6443,13 @@ async function updateDbPackageJson(projectDir, options) {
 			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = "drizzle-kit migrate";
 		}
 	}
-	await fs.writeJson(dbPackageJsonPath, dbPackageJson, { spaces: 2 });
-}
-async function updateAuthPackageJson(projectDir, options) {
-	const authPackageJsonPath = path.join(projectDir, "packages/auth/package.json");
-	if (!await fs.pathExists(authPackageJsonPath)) return;
-	const authPackageJson = await fs.readJson(authPackageJsonPath);
-	authPackageJson.name = `@${options.projectName}/auth`;
-	await fs.writeJson(authPackageJsonPath, authPackageJson, { spaces: 2 });
-}
-async function updateApiPackageJson(projectDir, options) {
-	const apiPackageJsonPath = path.join(projectDir, "packages/api/package.json");
-	if (!await fs.pathExists(apiPackageJsonPath)) return;
-	const apiPackageJson = await fs.readJson(apiPackageJsonPath);
-	apiPackageJson.name = `@${options.projectName}/api`;
-	await fs.writeJson(apiPackageJsonPath, apiPackageJson, { spaces: 2 });
+	if (options.dbSetup === "docker") {
+		scripts["db:start"] = "docker compose up -d";
+		scripts["db:watch"] = "docker compose up";
+		scripts["db:stop"] = "docker compose stop";
+		scripts["db:down"] = "docker compose down";
+	}
+	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
 }
 async function updateConvexPackageJson(projectDir, options) {
 	const convexPackageJsonPath = path.join(projectDir, "packages/backend/package.json");
@@ -6659,7 +6470,10 @@ async function createProject(options, cliInput) {
 		await copyBaseTemplate(projectDir, options);
 		await setupFrontendTemplates(projectDir, options);
 		await setupBackendFramework(projectDir, options);
-		if (!isConvex) await setupDockerComposeTemplates(projectDir, options);
+		if (!isConvex) {
+			await setupDbOrmTemplates(projectDir, options);
+			await setupDockerComposeTemplates(projectDir, options);
+		}
 		await setupAuthTemplate(projectDir, options);
 		if (options.payments && options.payments !== "none") await setupPaymentsTemplate(projectDir, options);
 		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamplesTemplate(projectDir, options);