@prisma/cli 3.0.0-dev.58.1 → 3.0.0-dev.61.1

package/dist/commands/app/index.js

@@ -1,3 +1,4 @@
+import { usageError } from "../../shell/errors.js";
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
@@ -64,7 +65,7 @@ function createDeployCommand(runtime) {
 		"hono",
 		"tanstack-start",
 		"bun"
-	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues)).addOption(new Option("--prod", "Confirm intent to deploy to production"));
+	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues)).addOption(new Option("--db", "Create and wire an isolated database for the preview Branch")).addOption(new Option("--no-db", "Skip branch database setup")).addOption(new Option("--prod", "Confirm intent to deploy to production"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
@@ -76,22 +77,31 @@ function createDeployCommand(runtime) {
 		const projectRef = options.project;
 		const createProjectName = options.createProject;
 		const prod = options.prod;
-		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
-			projectRef,
-			createProjectName,
-			branchName,
-			entrypoint: entry,
-			framework,
-			httpPort,
-			envAssignments,
-			prod: prod === true
-		}), {
+		const db = options.db;
+		const hasDbConflict = hasFlag(runtime.argv, "--db") && hasFlag(runtime.argv, "--no-db");
+		await runCommand(runtime, "app.deploy", options, (context) => {
+			if (hasDbConflict) throw usageError("app deploy accepts either --db or --no-db", "--db requests branch database setup, while --no-db disables it.", "Pass exactly one database setup flag.", ["prisma-cli app deploy --db", "prisma-cli app deploy --no-db"], "app");
+			return runAppDeploy(context, appName, {
+				projectRef,
+				createProjectName,
+				branchName,
+				entrypoint: entry,
+				framework,
+				httpPort,
+				envAssignments,
+				prod: prod === true,
+				db
+			});
+		}, {
 			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
 			renderJson: (result) => serializeAppDeploy(result)
 		});
 	});
 	return command;
 }
+function hasFlag(argv, flag) {
+	return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
 function createShowCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
 	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));

package/dist/controllers/app.js

@@ -19,6 +19,7 @@ import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
+import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
 import { createPreviewDeployProgress, createPreviewDeployProgressState, createPreviewPromoteProgress } from "../lib/app/preview-progress.js";
 import { PreviewDomainApiError, createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { enforceProductionDeployGate } from "../lib/app/production-deploy-gate.js";
@@ -170,6 +171,10 @@ async function runAppDeploy(context, appName, options) {
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
 	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint, context.runtime.signal);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
+	const branchDatabaseSetup = await maybeSetupBranchDatabase(context, provider, projectId, toBranchDatabaseDeployBranch(target.branch), {
+		db: options?.db,
+		inlineEnvVars: envVars
+	});
 	const progressState = createPreviewDeployProgressState();
 	const deployStartedAt = Date.now();
 	const deployResult = await provider.deployApp({
@@ -200,8 +205,9 @@ async function runAppDeploy(context, appName, options) {
 		result: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			resolution: target.resolution,
+			branchDatabase: branchDatabaseSetup.result,
 			app: {
 				id: deployResult.app.id,
 				name: deployResult.app.name
@@ -210,7 +216,7 @@ async function runAppDeploy(context, appName, options) {
 			durationMs: deployDurationMs,
 			localPin: localPinResult
 		},
-		warnings: [],
+		warnings: branchDatabaseSetup.warnings,
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
@@ -757,7 +763,7 @@ async function resolveAppDomainTarget(context, options, commandName = "app domai
 		resultTarget: {
 			workspace: target.workspace,
 			project: target.project,
-			branch: target.branch,
+			branch: toResultBranch(target.branch),
 			app: {
 				id: selectedApp.id,
 				name: selectedApp.name
@@ -1320,6 +1326,7 @@ async function resolveProjectContext(context, client, explicitProject, options)
 	return {
 		...resolved,
 		branch: {
+			id: null,
 			name: branch.name,
 			kind: toBranchKind(branch.name)
 		}
@@ -1446,6 +1453,7 @@ async function withRemoteDeployBranch(provider, target, branch, signal) {
 	return {
 		...target,
 		branch: {
+			id: remoteBranch.id,
 			name: remoteBranch.name,
 			kind: remoteBranch.role
 		}
@@ -1454,6 +1462,20 @@ async function withRemoteDeployBranch(provider, target, branch, signal) {
 function toBranchKind(name) {
 	return name === "production" || name === "main" ? "production" : "preview";
 }
+function toResultBranch(branch) {
+	return {
+		name: branch.name,
+		kind: branch.kind
+	};
+}
+function toBranchDatabaseDeployBranch(branch) {
+	if (!branch.id) throw new Error(`Deploy branch "${branch.name}" was not resolved remotely.`);
+	return {
+		id: branch.id,
+		name: branch.name,
+		kind: branch.kind
+	};
+}
 function assertExclusiveDeployProjectInputs(options) {
 	const provided = [
 		options.projectRef ? "--project" : null,

package/dist/lib/app/branch-database-deploy.js

@@ -0,0 +1,323 @@
+import { CliError, usageError } from "../../shell/errors.js";
+import { renderSummaryLine } from "../../shell/ui.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { confirmPrompt } from "../../shell/prompt.js";
+import { formatCommandArgument } from "../../shell/command-arguments.js";
+import { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup } from "./branch-database.js";
+import path from "node:path";
+//#region src/lib/app/branch-database-deploy.ts
+async function maybeSetupBranchDatabase(context, provider, projectId, branch, options) {
+	if (options.db === false) return emptyBranchDatabaseSetupOutcome();
+	if (hasInlineDatabaseEnvVars(options.inlineEnvVars)) {
+		if (options.db === true) throw usageError("Branch database setup cannot be combined with inline database env vars", "The deploy command received --db and an inline DATABASE_URL or DIRECT_URL value.", "Remove the inline --env database value to let --db create a branch override, or remove --db to deploy with the provided value.", ["prisma-cli app deploy --db", "prisma-cli app deploy --env DATABASE_URL=postgresql://example"], "app");
+		return emptyBranchDatabaseSetupOutcome();
+	}
+	if (branch.kind === "production") {
+		if (options.db === true) throw usageError("Branch database setup is only available for preview branches", "Production database wiring is a durable environment decision and is not created implicitly by app deploy.", "Use project env commands to manage production DATABASE_URL, or deploy a preview branch with --db.", ["prisma-cli project env add DATABASE_URL=<value> --role production", "prisma-cli app deploy --branch feature/db --db"], "app");
+		return emptyBranchDatabaseSetupOutcome();
+	}
+	const localSignal = await inspectBranchDatabaseSignal(context.runtime.cwd, context.runtime.signal);
+	const envState = await inspectBranchDatabaseEnv(provider, projectId, branch.id, context.runtime.signal);
+	const branchEnvVars = [envState.branchDatabaseUrl, envState.branchDirectUrl].filter((variable) => Boolean(variable)).map((variable) => variable.key).sort();
+	if (envState.branchDatabaseUrl) {
+		const warning = options.db === true ? `Branch "${branch.name}" already has DATABASE_URL. Leaving branch database env vars unchanged.` : null;
+		if (warning) emitBranchDatabaseWarning(context, warning);
+		return {
+			result: options.db === true ? {
+				status: "skipped",
+				reason: "branch-env-exists",
+				envVars: branchEnvVars,
+				schema: null
+			} : void 0,
+			warnings: warning ? [warning] : []
+		};
+	}
+	if (localSignal.unsupportedSchema) {
+		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch.name, context);
+		return emptyBranchDatabaseSetupOutcome();
+	}
+	const hasSignal = hasBranchDatabaseSignal(localSignal) || Boolean(envState.previewDatabaseUrl);
+	if (options.db !== true) {
+		if (!hasSignal) return emptyBranchDatabaseSetupOutcome();
+		if (!canPrompt(context) || context.flags.yes) {
+			const warning = "This app appears to use DATABASE_URL. Run prisma-cli app deploy --db to create an isolated database for this preview branch.";
+			emitBranchDatabaseWarning(context, warning);
+			return {
+				result: void 0,
+				warnings: [warning]
+			};
+		}
+		maybeRenderBranchDatabaseSignal(context, branch.name, localSignal, envState);
+		if (!await confirmPrompt({
+			input: context.runtime.stdin,
+			output: context.output.stderr,
+			message: `Create an isolated database for branch "${branch.name}"?`,
+			initialValue: false
+		})) return emptyBranchDatabaseSetupOutcome();
+	}
+	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState);
+}
+async function setupBranchDatabase(context, provider, projectId, branch, signal, envState) {
+	emitBranchDatabaseProgress(context, "pending", "Creating branch database");
+	const database = await provider.createBranchDatabase({
+		projectId,
+		branchId: branch.id,
+		branchName: branch.name,
+		signal: context.runtime.signal
+	}).catch((error) => {
+		throw branchDatabaseSetupFailedError("Failed to create branch database", error, branch.name);
+	});
+	emitBranchDatabaseProgress(context, "success", "Created branch database");
+	try {
+		let schemaSetup = null;
+		const warnings = [];
+		let skippedSchemaWarning = null;
+		if (signal.schema) {
+			emitBranchDatabaseProgress(context, "pending", `Applying database schema with ${formatSchemaSetupCommand(signal.schema.command)}`);
+			schemaSetup = await runBranchDatabaseSchemaSetup({
+				context,
+				schema: signal.schema,
+				databaseUrl: database.databaseUrl,
+				directUrl: database.directUrl
+			}).catch((error) => {
+				throw schemaSetupFailedError(error, signal.schema, branch.name, context.runtime.cwd);
+			});
+			emitBranchDatabaseProgress(context, "success", "Applied database schema");
+		} else skippedSchemaWarning = "No supported Prisma schema source was found. Branch database env vars were created, but schema setup was skipped.";
+		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
+		emitBranchDatabaseProgress(context, "success", `Added branch env override${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")}`);
+		if (skippedSchemaWarning) {
+			emitBranchDatabaseWarning(context, skippedSchemaWarning);
+			warnings.push(skippedSchemaWarning);
+		}
+		return {
+			result: {
+				status: "created",
+				database: {
+					id: database.id,
+					name: database.name
+				},
+				envVars,
+				schema: schemaSetup ? {
+					command: schemaSetup.command,
+					source: schemaSetup.source,
+					path: schemaSetup.schemaPath
+				} : null
+			},
+			warnings
+		};
+	} catch (error) {
+		throw await cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch.name, error);
+	}
+}
+async function upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState) {
+	const written = [];
+	await upsertBranchDatabaseEnvVar(context, provider, {
+		projectId,
+		branchId: branch.id,
+		className: "preview",
+		key: "DATABASE_URL",
+		value: database.databaseUrl,
+		existing: envState.branchDatabaseUrl,
+		branchName: branch.name
+	});
+	written.push("DATABASE_URL");
+	if (database.directUrl) {
+		await upsertBranchDatabaseEnvVar(context, provider, {
+			projectId,
+			branchId: branch.id,
+			className: "preview",
+			key: "DIRECT_URL",
+			value: database.directUrl,
+			existing: envState.branchDirectUrl,
+			branchName: branch.name
+		});
+		written.push("DIRECT_URL");
+	} else if (envState.branchDirectUrl) await provider.deleteEnvironmentVariable({
+		envVarId: envState.branchDirectUrl.id,
+		signal: context.runtime.signal
+	}).catch((error) => {
+		throw branchDatabaseSetupFailedError("Failed to remove stale DIRECT_URL", error, branch.name);
+	});
+	return written;
+}
+async function upsertBranchDatabaseEnvVar(context, provider, options) {
+	if (options.existing) {
+		await provider.updateEnvironmentVariable({
+			envVarId: options.existing.id,
+			value: options.value,
+			signal: context.runtime.signal
+		}).catch((error) => {
+			throw branchDatabaseSetupFailedError(`Failed to update ${options.key}`, error, options.branchName);
+		});
+		return;
+	}
+	await provider.createEnvironmentVariable({
+		projectId: options.projectId,
+		branchId: options.branchId,
+		className: options.className,
+		key: options.key,
+		value: options.value,
+		signal: context.runtime.signal
+	}).catch((error) => {
+		throw branchDatabaseSetupFailedError(`Failed to write ${options.key}`, error, options.branchName);
+	});
+}
+async function inspectBranchDatabaseEnv(provider, projectId, branchId, signal) {
+	const [databaseUrlRows, directUrlRows] = await Promise.all([provider.listEnvironmentVariables({
+		projectId,
+		className: "preview",
+		key: "DATABASE_URL",
+		signal
+	}), provider.listEnvironmentVariables({
+		projectId,
+		className: "preview",
+		key: "DIRECT_URL",
+		signal
+	})]);
+	return {
+		branchDatabaseUrl: findEnvVar(databaseUrlRows, { branchId }),
+		branchDirectUrl: findEnvVar(directUrlRows, { branchId }),
+		previewDatabaseUrl: findEnvVar(databaseUrlRows, { branchId: null })
+	};
+}
+function findEnvVar(rows, options) {
+	return rows.find((row) => row.branchId === options.branchId) ?? null;
+}
+function hasInlineDatabaseEnvVars(envVars) {
+	return Boolean(envVars && ("DATABASE_URL" in envVars || "DIRECT_URL" in envVars));
+}
+function maybeRenderBranchDatabaseSignal(context, branchName, signal, envState) {
+	if (context.flags.json || context.flags.quiet) return;
+	const rows = [
+		signal.schema ? `  Schema  ${path.relative(context.runtime.cwd, signal.schema.path) || defaultSchemaSourcePath(signal.schema)}` : null,
+		signal.databaseUrlReferences.length > 0 ? `  Code    ${signal.databaseUrlReferences.slice(0, 3).join(", ")}` : null,
+		envState.previewDatabaseUrl ? "  Env     preview DATABASE_URL is inherited by this branch" : null
+	].filter((row) => Boolean(row));
+	context.output.stderr.write(`Database signal found for branch "${branchName}"\n${rows.join("\n")}\n\n`);
+}
+function emitBranchDatabaseProgress(context, status, message) {
+	if (context.flags.json || context.flags.quiet) return;
+	const line = status === "pending" ? `${context.ui.warning("◇")} ${message}...` : renderSummaryLine(context.ui, "success", message);
+	context.output.stderr.write(`${line}\n`);
+}
+function emitBranchDatabaseWarning(context, warning) {
+	if (context.flags.json || context.flags.quiet) return;
+	context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", warning)}\n`);
+}
+function emptyBranchDatabaseSetupOutcome() {
+	return {
+		result: void 0,
+		warnings: []
+	};
+}
+function formatSchemaSetupCommand(command) {
+	switch (command) {
+		case "migrate-deploy": return "prisma migrate deploy";
+		case "db-push": return "prisma db push";
+		case "prisma-next-db-init": return "prisma-next db init";
+	}
+}
+function branchDatabaseSetupFailedError(summary, error, branchName) {
+	return new CliError({
+		code: "BRANCH_DATABASE_SETUP_FAILED",
+		domain: "app",
+		summary,
+		why: error instanceof Error ? error.message : String(error),
+		fix: "Retry the command, or create the branch database and env vars manually with project env commands.",
+		debug: formatDebugDetails(error),
+		meta: { branch: branchName },
+		exitCode: 1,
+		nextSteps: [`prisma-cli app deploy --branch ${formatCommandArgument(branchName)} --db`, `prisma-cli project env list --branch ${formatCommandArgument(branchName)}`]
+	});
+}
+async function cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branchName, error) {
+	const setupError = error instanceof CliError ? error : branchDatabaseSetupFailedError("Branch database setup failed", error, branchName);
+	emitBranchDatabaseProgress(context, "pending", "Removing branch database after setup failed");
+	try {
+		await provider.deleteBranchDatabase({
+			databaseId: database.id,
+			signal: context.runtime.signal
+		});
+		emitBranchDatabaseProgress(context, "success", "Removed branch database after setup failed");
+	} catch (cleanupError) {
+		return branchDatabaseCleanupFailedError(setupError, cleanupError, database, branchName);
+	}
+	return setupError;
+}
+function branchDatabaseCleanupFailedError(setupError, cleanupError, database, branchName) {
+	const cleanupWhy = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+	const setupWhy = setupError.why ?? "Branch database setup failed.";
+	return new CliError({
+		code: setupError.code,
+		domain: setupError.domain,
+		summary: setupError.summary,
+		why: `${setupWhy} Prisma could not delete the created database "${database.name}" (${database.id}): ${cleanupWhy}`,
+		fix: "Delete the created branch database from Console or contact Prisma support, then rerun deploy with --db.",
+		debug: formatCombinedDebugDetails(setupError, cleanupError),
+		meta: {
+			...setupError.meta,
+			branch: branchName,
+			databaseId: database.id,
+			databaseName: database.name,
+			cleanupFailed: true
+		},
+		exitCode: setupError.exitCode,
+		nextSteps: []
+	});
+}
+function schemaSetupFailedError(error, schema, branchName, cwd) {
+	return new CliError({
+		code: "SCHEMA_SETUP_FAILED",
+		domain: "app",
+		summary: "Database schema setup failed",
+		why: error instanceof Error ? error.message : String(error),
+		fix: "Fix the Prisma schema or migrations, then rerun deploy with --db.",
+		debug: formatDebugDetails(error),
+		meta: {
+			branch: branchName,
+			schemaPath: schema.path,
+			source: schema.kind,
+			command: schema.command
+		},
+		exitCode: 1,
+		nextSteps: [...formatSchemaSetupNextSteps(schema, cwd), `prisma-cli app deploy --branch ${formatCommandArgument(branchName)} --db`]
+	});
+}
+function unsupportedBranchDatabaseSchemaError(schema, branchName, context) {
+	return usageError("Branch database setup is not available for this Prisma schema", `${path.relative(context.runtime.cwd, schema.path) || defaultUnsupportedSchemaSourcePath(schema)} targets ${formatUnsupportedSchemaTarget(schema.target)}, but --db creates Prisma Postgres databases.`, "Use project env commands to provide a database URL for this branch, or switch the Prisma schema source to PostgreSQL before using --db.", [`prisma-cli project env add DATABASE_URL=<value> --branch ${formatCommandArgument(branchName)}`, `prisma-cli app deploy --branch ${formatCommandArgument(branchName)}`], "app");
+}
+function formatSchemaSetupNextSteps(schema, cwd) {
+	const sourcePath = path.relative(cwd, schema.path) || defaultSchemaSourcePath(schema);
+	switch (schema.command) {
+		case "migrate-deploy": return [`npx --no-install prisma migrate deploy --schema ${formatCommandArgument(sourcePath)}`];
+		case "db-push": return [`npx --no-install prisma db push --schema ${formatCommandArgument(sourcePath)}`];
+		case "prisma-next-db-init": return [`npx --no-install prisma-next contract emit --config ${formatCommandArgument(sourcePath)}`, `npx --no-install prisma-next db init --config ${formatCommandArgument(sourcePath)} --db <DATABASE_URL>`];
+	}
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+function defaultUnsupportedSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+function formatUnsupportedSchemaTarget(target) {
+	switch (target) {
+		case "cockroachdb": return "CockroachDB";
+		case "mongodb": return "MongoDB";
+		case "mysql": return "MySQL";
+		case "sqlite": return "SQLite";
+		case "sqlserver": return "SQL Server";
+	}
+}
+function formatDebugDetails(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return typeof error === "string" ? error : null;
+}
+function formatCombinedDebugDetails(setupError, cleanupError) {
+	const setupDebug = setupError.debug ?? setupError.stack ?? setupError.message;
+	const cleanupDebug = formatDebugDetails(cleanupError);
+	return [setupDebug ? `Setup error:\n${setupDebug}` : null, cleanupDebug ? `Cleanup error:\n${cleanupDebug}` : null].filter((line) => Boolean(line)).join("\n\n") || null;
+}
+//#endregion
+export { maybeSetupBranchDatabase };

package/dist/lib/app/branch-database.js

@@ -0,0 +1,316 @@
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region src/lib/app/branch-database.ts
+const SKIPPED_DIRECTORIES = new Set([
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".prisma",
+	".turbo",
+	".vercel",
+	".wrangler",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out"
+]);
+const DATABASE_URL_SCAN_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".env",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".prisma",
+	".ts",
+	".tsx"
+]);
+const MAX_SCAN_DEPTH = 6;
+const MAX_SCAN_FILES = 1e3;
+const MAX_DATABASE_URL_REFERENCE_FILES = 10;
+const MAX_TEXT_FILE_BYTES = 1024 * 1024;
+async function inspectBranchDatabaseSignal(cwd, signal) {
+	const state = {
+		filesVisited: 0,
+		schemaCandidates: [],
+		prismaNextConfigCandidates: [],
+		databaseUrlReferences: []
+	};
+	await scanDirectory(cwd, cwd, 0, state, signal);
+	const prismaNextConfigs = await Promise.all(state.prismaNextConfigCandidates.map((configPath) => classifyPrismaNextConfig(configPath, signal)));
+	const supportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "supported");
+	const unsupportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "unsupported");
+	const selectedPrismaOrmSchema = await selectPrismaOrmSchema(cwd, state.schemaCandidates, signal);
+	const schema = supportedPrismaNextConfig ? {
+		kind: "prisma-next",
+		path: supportedPrismaNextConfig.path,
+		hasMigrations: false,
+		command: "prisma-next-db-init",
+		target: supportedPrismaNextConfig.target
+	} : selectedPrismaOrmSchema.schema;
+	return {
+		schema,
+		unsupportedSchema: schema ? null : unsupportedPrismaNextConfig ? {
+			kind: "prisma-next",
+			path: unsupportedPrismaNextConfig.path,
+			target: unsupportedPrismaNextConfig.target
+		} : selectedPrismaOrmSchema.unsupportedSchema,
+		databaseUrlReferences: state.databaseUrlReferences
+	};
+}
+function hasBranchDatabaseSignal(signal) {
+	if (signal.unsupportedSchema) return false;
+	return Boolean(signal.schema || signal.databaseUrlReferences.length > 0);
+}
+async function runBranchDatabaseSchemaSetup(options) {
+	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || defaultSchemaSourcePath(options.schema);
+	const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl);
+	for (const command of commands) await runPrismaCommand({
+		context: options.context,
+		...command,
+		env: {
+			DATABASE_URL: options.databaseUrl,
+			...options.directUrl ? { DIRECT_URL: options.directUrl } : {}
+		}
+	});
+	return {
+		command: options.schema.command,
+		source: options.schema.kind,
+		schemaPath
+	};
+}
+async function scanDirectory(cwd, directory, depth, state, signal) {
+	signal.throwIfAborted();
+	if (depth > MAX_SCAN_DEPTH || state.filesVisited >= MAX_SCAN_FILES) return;
+	let entries;
+	try {
+		entries = await readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	entries.sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		signal.throwIfAborted();
+		if (state.filesVisited >= MAX_SCAN_FILES) return;
+		const entryPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) {
+			if (!SKIPPED_DIRECTORIES.has(entry.name)) await scanDirectory(cwd, entryPath, depth + 1, state, signal);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		state.filesVisited += 1;
+		if (entry.name === "schema.prisma") state.schemaCandidates.push(entryPath);
+		if (isPrismaNextConfigFile(entry.name)) state.prismaNextConfigCandidates.push(entryPath);
+		if (state.databaseUrlReferences.length < MAX_DATABASE_URL_REFERENCE_FILES && shouldScanForDatabaseUrl(entry.name) && await fileContainsDatabaseUrl(entryPath, signal)) state.databaseUrlReferences.push(path.relative(cwd, entryPath) || entry.name);
+	}
+}
+async function selectPrismaOrmSchema(cwd, candidates, signal) {
+	const sorted = sortByPreferredRelativePath(cwd, candidates, "schema.prisma");
+	for (const schemaPath of sorted) {
+		const target = await classifyPrismaOrmSchemaTarget(schemaPath, signal);
+		if (target === "postgresql" || target === "unknown") {
+			const hasMigrations = await hasMigrationsDirectory(path.dirname(schemaPath), signal);
+			return {
+				schema: {
+					kind: "prisma-orm",
+					path: schemaPath,
+					hasMigrations,
+					command: hasMigrations ? "migrate-deploy" : "db-push",
+					target
+				},
+				unsupportedSchema: null
+			};
+		}
+		return {
+			schema: null,
+			unsupportedSchema: {
+				kind: "prisma-orm",
+				path: schemaPath,
+				target
+			}
+		};
+	}
+	return {
+		schema: null,
+		unsupportedSchema: null
+	};
+}
+function selectPrismaNextConfig(cwd, candidates, mode) {
+	const matches = candidates.filter((candidate) => {
+		const isSupported = candidate.target === "postgresql" || candidate.target === "unknown";
+		return mode === "supported" ? isSupported : !isSupported;
+	});
+	return sortByPreferredRelativePath(cwd, matches.map((candidate) => candidate.path), "prisma-next.config.ts").map((candidatePath) => matches.find((candidate) => candidate.path === candidatePath)).find((candidate) => Boolean(candidate)) ?? null;
+}
+function sortByPreferredRelativePath(cwd, candidates, preferredRootFile) {
+	return candidates.map((candidate) => ({
+		absolute: candidate,
+		relative: path.relative(cwd, candidate) || preferredRootFile
+	})).sort((left, right) => {
+		if (left.relative === preferredRootFile) return -1;
+		if (right.relative === preferredRootFile) return 1;
+		return left.relative.length - right.relative.length || left.relative.localeCompare(right.relative);
+	}).map((candidate) => candidate.absolute);
+}
+async function hasMigrationsDirectory(schemaDirectory, signal) {
+	signal.throwIfAborted();
+	const migrationsPath = path.join(schemaDirectory, "migrations");
+	try {
+		await access(migrationsPath);
+		return (await readdir(migrationsPath)).length > 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function classifyPrismaNextConfig(configPath, signal) {
+	const content = await readTextFileIfSmall(configPath, signal);
+	if (!content) return {
+		path: configPath,
+		target: "unknown"
+	};
+	if (content.includes("@prisma-next/postgres/config")) return {
+		path: configPath,
+		target: "postgresql"
+	};
+	if (content.includes("@prisma-next/mongo/config")) return {
+		path: configPath,
+		target: "mongodb"
+	};
+	if (content.includes("@prisma-next/sqlite/config")) return {
+		path: configPath,
+		target: "sqlite"
+	};
+	return {
+		path: configPath,
+		target: "unknown"
+	};
+}
+async function classifyPrismaOrmSchemaTarget(schemaPath, signal) {
+	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(/\bprovider\s*=\s*"([^"]+)"/)?.[1] ?? null) {
+		case "postgresql": return "postgresql";
+		case "mongodb": return "mongodb";
+		case "mysql": return "mysql";
+		case "sqlite": return "sqlite";
+		case "sqlserver": return "sqlserver";
+		case "cockroachdb": return "cockroachdb";
+		default: return "unknown";
+	}
+}
+function shouldScanForDatabaseUrl(fileName) {
+	if (fileName === ".env" || fileName.startsWith(".env.")) return true;
+	return DATABASE_URL_SCAN_EXTENSIONS.has(path.extname(fileName));
+}
+function isPrismaNextConfigFile(fileName) {
+	if (!fileName.startsWith("prisma-next.config.")) return false;
+	return [
+		".cjs",
+		".cts",
+		".js",
+		".mjs",
+		".mts",
+		".ts"
+	].some((extension) => fileName.endsWith(extension));
+}
+async function fileContainsDatabaseUrl(filePath, signal) {
+	return (await readTextFileIfSmall(filePath, signal))?.includes("DATABASE_URL") ?? false;
+}
+async function readTextFileIfSmall(filePath, signal) {
+	signal.throwIfAborted();
+	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return null;
+	return readFile(filePath, {
+		encoding: "utf8",
+		signal
+	});
+}
+function buildSchemaSetupCommands(schema, schemaPath, databaseUrl) {
+	if (schema.command === "migrate-deploy") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"migrate",
+			"deploy",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma migrate deploy"
+	}];
+	if (schema.command === "db-push") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"db",
+			"push",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma db push"
+	}];
+	return [{
+		args: [
+			"--no-install",
+			"prisma-next",
+			"contract",
+			"emit",
+			"--config",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma-next contract emit"
+	}, {
+		args: [
+			"--no-install",
+			"prisma-next",
+			"db",
+			"init",
+			"--config",
+			schemaPath,
+			"--db",
+			databaseUrl
+		],
+		displayCommand: "npx --no-install prisma-next db init"
+	}];
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+async function runPrismaCommand(options) {
+	const shouldPipeOutput = !options.context.flags.json && !options.context.flags.quiet;
+	const child = spawn("npx", options.args, {
+		cwd: options.context.runtime.cwd,
+		env: {
+			...options.context.runtime.env,
+			...options.env
+		},
+		signal: options.context.runtime.signal,
+		stdio: shouldPipeOutput ? [
+			"ignore",
+			"pipe",
+			"pipe"
+		] : [
+			"ignore",
+			"ignore",
+			"ignore"
+		]
+	});
+	if (shouldPipeOutput) {
+		child.stdout?.pipe(options.context.output.stderr, { end: false });
+		child.stderr?.pipe(options.context.output.stderr, { end: false });
+	}
+	const exit = await new Promise((resolve, reject) => {
+		child.once("error", reject);
+		child.once("close", (code, signal) => resolve({
+			code,
+			signal
+		}));
+	});
+	if (exit.signal) throw new Error(`${options.displayCommand} was terminated by ${exit.signal}.`);
+	if (exit.code !== 0) throw new Error(`${options.displayCommand} exited with code ${exit.code ?? 1}.`);
+}
+//#endregion
+export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup };

package/dist/lib/app/preview-branch-database.js

@@ -0,0 +1,102 @@
+//#region src/lib/app/preview-branch-database.ts
+async function createBranchDatabase(client, options) {
+	const result = await client.POST("/v1/databases", {
+		body: {
+			projectId: options.projectId,
+			branchId: options.branchId,
+			name: options.branchName,
+			source: { type: "empty" }
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to create database for branch "${options.branchName}"`, result.response, result.error);
+	return normalizeBranchDatabaseRecord(result.data.data);
+}
+async function listEnvironmentVariables(client, options) {
+	const variables = [];
+	let cursor;
+	while (true) {
+		const result = await client.GET("/v1/environment-variables", {
+			params: { query: {
+				projectId: options.projectId,
+				class: options.className,
+				key: options.key,
+				branchId: options.branchId,
+				cursor
+			} },
+			signal: options.signal
+		});
+		if (result.error || !result.data) throw apiCallError("Failed to list environment variables", result.response, result.error);
+		variables.push(...result.data.data);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return variables.map((variable) => normalizeEnvironmentVariable(variable));
+}
+async function createEnvironmentVariable(client, options) {
+	const result = await client.POST("/v1/environment-variables", {
+		body: {
+			projectId: options.projectId,
+			class: options.className,
+			key: options.key,
+			value: options.value,
+			...options.branchId ? { branchId: options.branchId } : {}
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to add ${options.key}`, result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteBranchDatabase(client, options) {
+	const result = await client.DELETE("/v1/databases/{databaseId}", {
+		params: { path: { databaseId: options.databaseId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete branch database", result.response, result.error);
+}
+async function updateEnvironmentVariable(client, options) {
+	const result = await client.PATCH("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		body: { value: options.value },
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError("Failed to update environment variable", result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteEnvironmentVariable(client, options) {
+	const result = await client.DELETE("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete environment variable", result.response, result.error);
+}
+function normalizeEnvironmentVariable(variable) {
+	return {
+		id: variable.id,
+		key: variable.key,
+		branchId: variable.branchId,
+		className: variable.class,
+		isManagedBySystem: variable.isManagedBySystem
+	};
+}
+function normalizeBranchDatabaseRecord(database) {
+	const connection = database.connections?.[0];
+	const databaseUrl = connection?.endpoints?.pooled?.connectionString;
+	const directUrl = connection?.endpoints?.direct?.connectionString ?? null;
+	if (!databaseUrl) throw new Error("Created database did not return a pooled connection string.");
+	return {
+		id: database.id,
+		name: database.name,
+		branchId: database.branchId,
+		databaseUrl,
+		directUrl
+	};
+}
+function apiCallError(summary, response, error) {
+	if (response.status === 404) return /* @__PURE__ */ new Error("Resource Not Found");
+	const message = error.error?.message ?? `Management API returned HTTP ${response.status}.`;
+	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
+	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
+}
+//#endregion
+export { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable };

package/dist/lib/app/preview-provider.js

@@ -1,5 +1,6 @@
 import { envVarNames } from "./env-vars.js";
 import { PreviewBuildStrategy } from "./preview-build.js";
+import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./preview-branch-database.js";
 import path from "node:path";
 import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
@@ -48,6 +49,24 @@ function createPreviewAppProvider(client, options) {
 				role: branch.role
 			};
 		},
+		async createBranchDatabase(options) {
+			return createBranchDatabase(client, options);
+		},
+		async deleteBranchDatabase(options) {
+			return deleteBranchDatabase(client, options);
+		},
+		async listEnvironmentVariables(options) {
+			return listEnvironmentVariables(client, options);
+		},
+		async createEnvironmentVariable(options) {
+			return createEnvironmentVariable(client, options);
+		},
+		async updateEnvironmentVariable(options) {
+			return updateEnvironmentVariable(client, options);
+		},
+		async deleteEnvironmentVariable(options) {
+			return deleteEnvironmentVariable(client, options);
+		},
 		async removeApp(appId, options) {
 			const appResult = await sdk.showService({
 				serviceId: appId,

package/dist/presenters/app.js

@@ -30,6 +30,7 @@ function renderAppDeploy(context, descriptor, result) {
 	return [
 		`Live in ${formatDuration(result.durationMs)}`,
 		...result.deployment.url ? [context.ui.link(result.deployment.url)] : [],
+		...renderBranchDatabaseDeploySummary(context, result),
 		"",
 		...renderDeployOutputRows(context.ui, [{
 			label: "Logs",
@@ -41,6 +42,30 @@ function serializeAppDeploy(result) {
 	const { localPin: _localPin, ...serialized } = result;
 	return serialized;
 }
+function renderBranchDatabaseDeploySummary(context, result) {
+	if (!result.branchDatabase || result.branchDatabase.status !== "created") return [];
+	return ["", ...renderDeployOutputRows(context.ui, [
+		{
+			label: "Database",
+			value: result.branchDatabase.database?.name ?? "created"
+		},
+		{
+			label: "Env",
+			value: result.branchDatabase.envVars.join(", ")
+		},
+		...result.branchDatabase.schema ? [{
+			label: "Schema",
+			value: formatBranchDatabaseSchemaCommand(result.branchDatabase.schema.command)
+		}] : []
+	])];
+}
+function formatBranchDatabaseSchemaCommand(command) {
+	switch (command) {
+		case "migrate-deploy": return "prisma migrate deploy";
+		case "db-push": return "prisma db push";
+		case "prisma-next-db-init": return "prisma-next db init";
+	}
+}
 function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
 	return `${(durationMs / 1e3).toFixed(1)}s`;

package/dist/shell/command-meta.js

@@ -194,6 +194,8 @@ const DESCRIPTORS = [
 			"prisma-cli app deploy --project proj_123",
 			"prisma-cli app deploy --create-project my-app --yes",
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
+			"prisma-cli app deploy --db",
+			"prisma-cli app deploy --db --yes",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
 			"prisma-cli app deploy --branch feat-login --framework hono",
 			"prisma-cli app deploy --prod --yes",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.58.1",
+  "version": "3.0.0-dev.61.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {