fix(cli): use ppg adapter for prisma postgres

Author: AmanVarshney01

apps/cli/src/constants.ts

@@ -72,6 +72,7 @@ export const dependencyVersionMap = {
 	"@prisma/adapter-better-sqlite3": "^7.0.0",
 	"@prisma/adapter-pg": "^7.0.0",
 	"@prisma/adapter-planetscale": "^7.0.0",
+	"@prisma/adapter-ppg": "^7.0.0",
 
 	mongoose: "^8.14.0",
 

apps/cli/src/helpers/core/db-setup.ts

@@ -78,6 +78,8 @@ export async function setupDatabase(
 							"ws",
 						);
 						prismaDevDependencies.push("@types/ws");
+					} else if (dbSetup === "prisma-postgres") {
+						prismaDependencies.push("@prisma/adapter-ppg");
 					} else {
 						prismaDependencies.push("@prisma/adapter-pg");
 						prismaDependencies.push("pg");

apps/cli/src/helpers/core/post-installation.ts

@@ -60,7 +60,7 @@ export async function displayPostInstallInstructions(
 		: "";
 	const nativeInstructions =
 		(frontend?.includes("native-bare") ||
-			frontend?.includes("native-uniwind") ||
+		frontend?.includes("native-uniwind") ||
 			frontend?.includes("native-unistyles")) &&
 		backend !== "none"
 			? getNativeInstructions(isConvex, isBackendSelf, frontend || [])
@@ -165,34 +165,34 @@ export async function displayPostInstallInstructions(
 		addons?.includes("fumadocs");
 
 	if (hasAnyService) {
-		output += `${pc.bold("Your project will be available at:")}\n`;
-
-		if (hasWeb) {
-			output += `${pc.cyan("•")} Frontend: http://localhost:${webPort}\n`;
-		} else if (!hasNative && !addons?.includes("starlight")) {
-			output += `${pc.yellow(
-				"NOTE:",
-			)} You are creating a backend-only app\n   (no frontend selected)\n`;
-		}
+	output += `${pc.bold("Your project will be available at:")}\n`;
+
+	if (hasWeb) {
+		output += `${pc.cyan("•")} Frontend: http://localhost:${webPort}\n`;
+	} else if (!hasNative && !addons?.includes("starlight")) {
+		output += `${pc.yellow(
+			"NOTE:",
+		)} You are creating a backend-only app\n   (no frontend selected)\n`;
+	}
 
 		if (!isConvex && !isBackendSelf && hasStandaloneBackend) {
-			output += `${pc.cyan("•")} Backend API: http://localhost:3000\n`;
+		output += `${pc.cyan("•")} Backend API: http://localhost:3000\n`;
 
-			if (api === "orpc") {
-				output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/api-reference\n`;
-			}
+		if (api === "orpc") {
+			output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/api-reference\n`;
 		}
+	}
 
-		if (isBackendSelf && api === "orpc") {
-			output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:${webPort}/api/rpc/api-reference\n`;
-		}
+	if (isBackendSelf && api === "orpc") {
+		output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:${webPort}/api/rpc/api-reference\n`;
+	}
 
-		if (addons?.includes("starlight")) {
-			output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
-		}
+	if (addons?.includes("starlight")) {
+		output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
+	}
 
-		if (addons?.includes("fumadocs")) {
-			output += `${pc.cyan("•")} Fumadocs: http://localhost:4000\n`;
+	if (addons?.includes("fumadocs")) {
+		output += `${pc.cyan("•")} Fumadocs: http://localhost:4000\n`;
 		}
 	}
 

apps/cli/src/helpers/database-providers/prisma-postgres-setup.ts

@@ -1,11 +1,10 @@
 import path from "node:path";
-import { isCancel, log, select, spinner, text } from "@clack/prompts";
+import { isCancel, log, select, spinner } from "@clack/prompts";
 import { consola } from "consola";
 import { execa } from "execa";
 import fs from "fs-extra";
 import pc from "picocolors";
 import type { PackageManager, ProjectConfig } from "../../types";
-import { exitCancelled } from "../../utils/errors";
 import { getPackageExecutionCommand } from "../../utils/package-runner";
 import { addEnvVariablesToFile, type EnvVariable } from "../core/env-setup";
 
@@ -83,56 +82,6 @@ async function setupWithCreateDb(
 	}
 }
 
-async function initPrismaDatabase(
-	serverDir: string,
-	packageManager: PackageManager,
-) {
-	try {
-		const prismaDir = path.join(serverDir, "prisma");
-		await fs.ensureDir(prismaDir);
-
-		log.info("Starting Prisma PostgreSQL setup.");
-
-		const prismaInitCommand = getPackageExecutionCommand(
-			packageManager,
-			"prisma init --db",
-		);
-
-		await execa(prismaInitCommand, {
-			cwd: serverDir,
-			stdio: "inherit",
-			shell: true,
-		});
-
-		log.info(
-			pc.yellow(
-				"Please copy the Prisma Postgres URL.\nIt looks like: postgresql://user:password@host:5432/db?sslmode=require",
-			),
-		);
-
-		const databaseUrl = await text({
-			message: "Paste your Prisma Postgres database URL:",
-			validate(value) {
-				if (!value) return "Please enter a database URL";
-				if (!value.startsWith("postgresql://")) {
-					return "URL should start with postgresql://";
-				}
-			},
-		});
-
-		if (isCancel(databaseUrl)) return null;
-
-		return {
-			databaseUrl: databaseUrl as string,
-		};
-	} catch (error) {
-		if (error instanceof Error) {
-			consola.error(error.message);
-		}
-		return null;
-	}
-}
-
 async function writeEnvFile(
 	projectDir: string,
 	backend: ProjectConfig["backend"],
@@ -165,25 +114,6 @@ async function writeEnvFile(
 	}
 }
 
-async function addDotenvImportToPrismaConfig(
-	projectDir: string,
-	backend: ProjectConfig["backend"],
-) {
-	try {
-		const prismaConfigPath = path.join(
-			projectDir,
-			"packages/db/prisma.config.ts",
-		);
-		let content = await fs.readFile(prismaConfigPath, "utf8");
-		const envPath =
-			backend === "self" ? "../../apps/web/.env" : "../../apps/server/.env";
-		content = `import dotenv from "dotenv";\ndotenv.config({ path: "${envPath}" });\n${content}`;
-		await fs.writeFile(prismaConfigPath, content);
-	} catch (_error) {
-		consola.error("Failed to update prisma.config.ts");
-	}
-}
-
 function displayManualSetupInstructions(target: "apps/web" | "apps/server") {
 	log.info(`Manual Prisma PostgreSQL Setup Instructions:
 
@@ -199,7 +129,7 @@ export async function setupPrismaPostgres(
 	config: ProjectConfig,
 	cliInput?: { manualDb?: boolean },
 ) {
-	const { packageManager, projectDir, orm, backend } = config;
+	const { packageManager, projectDir, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
 	const dbDir = path.join(projectDir, "packages/db");
 
@@ -214,72 +144,38 @@ export async function setupPrismaPostgres(
 			return;
 		}
 
-		const mode = await select({
+		const setupMode = await select({
 			message: "Prisma Postgres setup: choose mode",
 			options: [
 				{
-					label: "Automatic",
+					label: "Automatic (create-db)",
 					value: "auto",
-					hint: "Automated setup with provider CLI, sets .env",
+					hint: "Provision a database via Prisma's create-db CLI",
 				},
 				{
 					label: "Manual",
 					value: "manual",
-					hint: "Manual setup, add env vars yourself",
+					hint: "Add your own DATABASE_URL later",
 				},
 			],
 			initialValue: "auto",
 		});
 
-		if (isCancel(mode)) return exitCancelled("Operation cancelled");
+		if (isCancel(setupMode)) return;
 
-		if (mode === "manual") {
+		if (setupMode === "manual") {
 			await writeEnvFile(projectDir, backend);
 			displayManualSetupInstructions(
 				backend === "self" ? "apps/web" : "apps/server",
 			);
 			return;
 		}
 
-		const setupOptions = [
-			{
-				label: "Quick setup with create-db",
-				value: "create-db",
-				hint: "Fastest, automated database creation (no auth)",
-			},
-		];
-
-		if (orm === "prisma") {
-			setupOptions.push({
-				label: "Custom setup with Prisma Init",
-				value: "custom",
-				hint: "More control (requires auth)",
-			});
-		}
-
-		const setupMethod = await select({
-			message: "Choose your Prisma Postgres setup method:",
-			options: setupOptions,
-			initialValue: "create-db",
-		});
-
-		if (isCancel(setupMethod)) return exitCancelled("Operation cancelled");
-
-		let prismaConfig: PrismaConfig | null = null;
-
-		if (setupMethod === "create-db") {
-			prismaConfig = await setupWithCreateDb(dbDir, packageManager);
-		} else {
-			prismaConfig = await initPrismaDatabase(dbDir, packageManager);
-		}
+		const prismaConfig = await setupWithCreateDb(dbDir, packageManager);
 
 		if (prismaConfig) {
 			await writeEnvFile(projectDir, backend, prismaConfig);
 
-			if (orm === "prisma") {
-				await addDotenvImportToPrismaConfig(projectDir, backend);
-			}
-
 			log.success(
 				pc.green("Prisma Postgres database configured successfully!"),
 			);

apps/cli/templates/db/prisma/postgres/prisma.config.ts.hbs

@@ -1,6 +1,5 @@
 import path from "node:path";
 import { defineConfig, env } from 'prisma/config'
-{{#unless (eq dbSetup "prisma-postgres")}}
 import dotenv from 'dotenv'
 
 dotenv.config({
@@ -10,7 +9,6 @@ dotenv.config({
     path: "../../apps/server/.env",
     {{/if}}
 })
-{{/unless}}
 
 export default defineConfig({
   schema: path.join("prisma", "schema"),

apps/cli/templates/db/prisma/postgres/src/index.ts.hbs

@@ -13,6 +13,15 @@ const prisma = new PrismaClient({
   }),
 });
 
+{{else if (eq dbSetup "prisma-postgres")}}
+import { PrismaPostgresAdapter } from "@prisma/adapter-ppg";
+
+const adapter = new PrismaPostgresAdapter({
+  connectionString: env.DATABASE_URL || "",
+});
+
+const prisma = new PrismaClient({ adapter });
+
 {{else}}
 import { PrismaPg } from "@prisma/adapter-pg";
 
@@ -38,6 +47,15 @@ const adapter = new PrismaNeon({
 
 const prisma = new PrismaClient({ adapter });
 
+{{else if (eq dbSetup "prisma-postgres")}}
+import { PrismaPostgresAdapter } from "@prisma/adapter-ppg";
+
+const adapter = new PrismaPostgresAdapter({
+    connectionString: process.env.DATABASE_URL || "",
+});
+
+const prisma = new PrismaClient({ adapter });
+
 {{else}}
 import { PrismaPg } from "@prisma/adapter-pg";