@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.5

package/dist/controllers/branch.js

@@ -1,73 +1,99 @@
-import { featureUnavailableError, usageError } from "../shell/errors.js";
-import { canPrompt } from "../shell/runtime.js";
+import { CliError, authRequiredError, workspaceRequiredError } from "../shell/errors.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { resolveProjectTarget } from "../lib/project/resolution.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
 import { createSelectPromptPort } from "./select-prompt-port.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listRealWorkspaceProjects } from "./project.js";
 import { createBranchUseCases } from "../use-cases/branch.js";
 //#region src/controllers/branch.ts
-const PREVIEW_BRANCH_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
 async function runBranchList(context) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	return {
+	if (isRealMode(context)) return {
 		command: "branch.list",
-		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
+		result: await listRealBranches(context),
 		warnings: [],
 		nextSteps: []
 	};
-}
-async function runBranchShow(context) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	const result = await createBranchUseCases(createCliUseCaseGateways(context)).show();
 	return {
-		command: "branch.show",
-		result,
+		command: "branch.list",
+		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
 		warnings: [],
-		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma-cli app deploy"] : []
+		nextSteps: []
 	};
 }
-async function runBranchUse(context, branchName) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	const useCases = createBranchUseCases(createCliUseCaseGateways(context));
-	const resolvedBranchName = await resolveBranchNameForUse(context, useCases, branchName);
-	validateBranchName(resolvedBranchName);
-	const result = await useCases.use(resolvedBranchName);
+async function listRealBranches(context) {
+	const authState = await requireAuthenticatedAuthState(context);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	const workspace = authState.workspace;
+	if (!workspace) throw workspaceRequiredError();
+	const target = await resolveProjectTarget({
+		context,
+		workspace,
+		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+		prompt: createSelectPromptPort(context),
+		remember: true
+	});
+	const branches = await listBranches(client, target.project.id, context.runtime.signal);
 	return {
-		command: "branch.use",
-		result,
-		warnings: result.branch.kind === "production" ? ["Production is protected and durable. Use with care."] : [],
-		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma-cli branch show", "prisma-cli app deploy"] : ["prisma-cli branch show"]
+		projectId: target.project.id,
+		projectName: target.project.name,
+		branches: sortBranches(branches.map(toBranchSummary))
 	};
 }
-async function resolveBranchNameForUse(context, useCases, branchName) {
-	if (branchName) return branchName;
-	if (!canPrompt(context)) throw branchSelectionRequiredError();
-	const result = await useCases.list();
-	return createSelectPromptPort(context).select({
-		message: "Select a branch",
-		choices: result.branches.map((branch) => ({
-			label: renderBranchChoiceLabel(branch),
-			value: branch.name
-		}))
+function sortBranches(branches) {
+	return branches.slice().sort((left, right) => {
+		const leftRank = branchOrder(left);
+		const rightRank = branchOrder(right);
+		if (leftRank !== rightRank) return leftRank - rightRank;
+		return left.name.localeCompare(right.name);
 	});
 }
-function renderBranchChoiceLabel(branch) {
-	const markers = [];
-	if (branch.active) markers.push("active");
-	if (!branch.remoteState) markers.push("not created yet");
-	return markers.length > 0 ? `${branch.name} (${markers.join(", ")})` : branch.name;
+function branchOrder(branch) {
+	return branch.role === "production" ? 0 : 1;
 }
-function validateBranchName(branchName) {
-	if (branchName === "production") return;
-	if (PREVIEW_BRANCH_PATTERN.test(branchName)) return;
-	throw usageError("Branch name must use the documented form", "Branch names must be production or a lowercase preview slug such as preview or feat-auth.", "Use production or a lowercase preview branch name with letters, numbers, and hyphens.", ["prisma-cli branch list"], "branch");
+async function listBranches(client, projectId, signal) {
+	const collected = [];
+	let cursor;
+	while (true) {
+		const query = {};
+		if (cursor !== void 0) query.cursor = cursor;
+		const { data, error, response } = await client.GET("/v1/projects/{projectId}/branches", {
+			params: {
+				path: { projectId },
+				query
+			},
+			signal
+		});
+		if (error || !data) throw branchApiError("Failed to list branches", response, error);
+		collected.push(...data.data);
+		if (!data.pagination.hasMore || !data.pagination.nextCursor) break;
+		cursor = data.pagination.nextCursor;
+	}
+	return collected;
 }
-function branchSelectionRequiredError() {
-	return usageError("Branch use requires a target in non-interactive mode", "This command cannot prompt for branch selection in the current mode.", "Re-run prisma-cli branch use in a TTY, or pass a branch name explicitly.", ["prisma-cli branch list"], "branch");
+function toBranchSummary(branch) {
+	return {
+		id: branch.id,
+		name: branch.gitName,
+		role: branch.role,
+		envMap: branch.role
+	};
 }
-function branchCommandsUnavailableError() {
-	return featureUnavailableError("Branch commands are not available in this preview", "The current preview cannot resolve or change remote branch context yet.", "Use prisma-cli app deploy for preview app deployment workflows.", ["prisma-cli app deploy --app <name>"], "branch");
+function branchApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "BRANCH_API_ERROR",
+		domain: "branch",
+		summary,
+		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
 }
 //#endregion
-export { runBranchList, runBranchShow, runBranchUse };
+export { runBranchList };

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