@prisma/cli 3.0.0-beta.4 → 3.0.0-beta.6

package/dist/controllers/app.js

@@ -7,7 +7,7 @@ import { canPrompt } from "../shell/runtime.js";
 import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readAuthState } from "../lib/auth/auth-ops.js";
-import { parseEnvAssignments } from "../lib/app/env-vars.js";
+import { envVarNames, parseEnvAssignments } from "../lib/app/env-vars.js";
 import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
 import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.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,17 +205,30 @@ 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
 			},
 			deployment: deployResult.deployment,
+			deploySettings: {
+				framework: {
+					key: framework.key,
+					buildType,
+					name: framework.displayName,
+					source: framework.annotation
+				},
+				entrypoint: entrypoint ?? null,
+				httpPort: runtime.port,
+				region: selectedApp.region ?? null,
+				envVars: envVarNames(envVars)
+			},
 			durationMs: deployDurationMs,
 			localPin: localPinResult
 		},
-		warnings: [],
+		warnings: branchDatabaseSetup.warnings,
 		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
@@ -222,6 +240,7 @@ async function runAppListDeploys(context, appName, projectRef) {
 		command: "app.list-deploys",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: null,
 			deployments: []
 		},
@@ -241,6 +260,7 @@ async function runAppListDeploys(context, appName, projectRef) {
 		command: "app.list-deploys",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -259,6 +279,7 @@ async function runAppShow(context, appName, projectRef) {
 		command: "app.show",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: null,
 			liveDeployment: null,
 			liveUrl: null,
@@ -281,6 +302,7 @@ async function runAppShow(context, appName, projectRef) {
 		command: "app.show",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -354,6 +376,7 @@ async function runAppOpen(context, appName, projectRef) {
 		command: "app.open",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -644,6 +667,7 @@ async function runAppPromote(context, deploymentId, appName, projectRef) {
 		command: "app.promote",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -686,6 +710,7 @@ async function runAppRollback(context, appName, deploymentId, projectRef) {
 		command: "app.rollback",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: deploymentsResult.app.id,
 				name: deploymentsResult.app.name
@@ -714,6 +739,7 @@ async function runAppRemove(context, appName, projectRef) {
 		command: "app.remove",
 		result: {
 			projectId,
+			verboseContext: toAppVerboseContext(target),
 			app: {
 				id: removedApp.id,
 				name: removedApp.name
@@ -757,7 +783,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 +1346,7 @@ async function resolveProjectContext(context, client, explicitProject, options)
 	return {
 		...resolved,
 		branch: {
+			id: null,
 			name: branch.name,
 			kind: toBranchKind(branch.name)
 		}
@@ -1446,6 +1473,7 @@ async function withRemoteDeployBranch(provider, target, branch, signal) {
 	return {
 		...target,
 		branch: {
+			id: remoteBranch.id,
 			name: remoteBranch.name,
 			kind: remoteBranch.role
 		}
@@ -1454,6 +1482,29 @@ async function withRemoteDeployBranch(provider, target, branch, signal) {
 function toBranchKind(name) {
 	return name === "production" || name === "main" ? "production" : "preview";
 }
+function toResultBranch(branch) {
+	return {
+		id: branch.id,
+		name: branch.name,
+		kind: branch.kind
+	};
+}
+function toAppVerboseContext(target) {
+	return {
+		workspace: target.workspace,
+		project: target.project,
+		branch: target.branch,
+		resolution: target.resolution
+	};
+}
+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/controllers/branch.js

@@ -41,6 +41,11 @@ async function listRealBranches(context) {
 	return {
 		projectId: target.project.id,
 		projectName: target.project.name,
+		verboseContext: {
+			workspace,
+			project: target.project,
+			resolution: target.resolution
+		},
 		branches: sortBranches(branches.map(toBranchSummary))
 	};
 }

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 };