@prisma/cli 3.0.0-beta.7 → 3.0.0-beta.9

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

@@ -165,7 +165,8 @@ function createPreviewAppProvider(client, options) {
 					appPath: path.resolve(options.cwd),
 					entrypoint: options.entrypoint,
 					buildType: options.buildType,
-					signal: options.signal
+					signal: options.signal,
+					buildSettings: options.buildSettings
 				}),
 				projectId: options.projectId,
 				serviceId: resolvedApp.appId,

package/dist/lib/app/production-deploy-gate.js

@@ -3,22 +3,22 @@ import { canPrompt } from "../../shell/runtime.js";
 import { confirmPrompt } from "../../shell/prompt.js";
 //#region src/lib/app/production-deploy-gate.ts
 async function enforceProductionDeployGate(context, provider, options) {
-	if (options.branchKind !== "production") return;
+	if (options.branchKind !== "production") return { firstProductionDeploy: false };
 	if (!options.appId) {
 		renderFirstProductionDeployLine(context, options.appName);
-		return;
+		return { firstProductionDeploy: true };
 	}
 	const currentLiveDeployment = resolveCurrentProductionDeployment(await provider.listDeployments(options.appId).catch((error) => {
 		throw productionDeployInspectionFailedError(error);
 	}));
 	if (!currentLiveDeployment) {
 		renderFirstProductionDeployLine(context, options.appName);
-		return;
+		return { firstProductionDeploy: true };
 	}
 	if (!options.prod) throw productionDeployRequiresFlagError();
 	if (context.flags.yes) {
 		renderProductionDeployYesLine(context);
-		return;
+		return { firstProductionDeploy: false };
 	}
 	if (!canPrompt(context)) throw productionDeployConfirmationRequiredError(options.appName);
 	renderProductionDeployConfirmation(context, currentLiveDeployment);
@@ -28,6 +28,7 @@ async function enforceProductionDeployGate(context, provider, options) {
 		message: "Deploy to production?",
 		initialValue: false
 	})) throw productionDeployCancelledError();
+	return { firstProductionDeploy: false };
 }
 function resolveCurrentProductionDeployment(result) {
 	if (result.deployments.length === 0) return null;

package/dist/lib/database/provider.js

@@ -0,0 +1,167 @@
+import { CliError } from "../../shell/errors.js";
+//#region src/lib/database/provider.ts
+function createManagementDatabaseProvider(client) {
+	return {
+		async listDatabases(options) {
+			const databases = [];
+			let cursor;
+			while (true) {
+				const result = await client.GET("/v1/databases", {
+					params: { query: {
+						projectId: options.projectId,
+						branchGitName: options.branchName,
+						cursor
+					} },
+					signal: options.signal
+				});
+				if (result.error || !result.data) throw databaseApiError("Failed to list databases", result.response, result.error);
+				databases.push(...result.data.data);
+				if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+				cursor = result.data.pagination.nextCursor;
+			}
+			return databases.map((database) => normalizeDatabase(database, options.projectId));
+		},
+		async showDatabase(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.response?.status === 404) return null;
+			if (result.error || !result.data) throw databaseApiError("Failed to show database", result.response, result.error);
+			const database = result.data.data;
+			return normalizeDatabase(database, requireDatabaseProjectId(database, options?.projectId));
+		},
+		async createDatabase(options) {
+			const result = await client.POST("/v1/databases", {
+				body: {
+					projectId: options.projectId,
+					name: options.name,
+					source: { type: "empty" },
+					...options.branchName ? { branchGitName: options.branchName } : {},
+					...options.region ? { region: options.region } : {}
+				},
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to create database", result.response, result.error);
+			return normalizeCreatedDatabase(result.data.data, options.projectId);
+		},
+		async removeDatabase(databaseId, options) {
+			const result = await client.DELETE("/v1/databases/{databaseId}", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.error) throw databaseApiError("Failed to remove database", result.response, result.error);
+		},
+		async listConnections(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/connections", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to list database connections", result.response, result.error);
+			return result.data.data.map((connection) => normalizeConnection(connection, databaseId));
+		},
+		async createConnection(options) {
+			const result = await client.POST("/v1/databases/{databaseId}/connections", {
+				params: { path: { databaseId: options.databaseId } },
+				body: { name: options.name },
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to create database connection", result.response, result.error);
+			return normalizeCreatedConnection(result.data.data, options.databaseId);
+		},
+		async removeConnection(connectionId, options) {
+			const result = await client.DELETE("/v1/connections/{id}", {
+				params: { path: { id: connectionId } },
+				signal: options?.signal
+			});
+			if (result.error) throw databaseApiError("Failed to remove database connection", result.response, result.error);
+		}
+	};
+}
+function normalizeDatabase(database, fallbackProjectId) {
+	return {
+		id: database.id,
+		name: database.name,
+		projectId: database.projectId ?? fallbackProjectId,
+		branchId: database.branchId ?? database.branch?.id ?? null,
+		branchName: database.branchGitName ?? database.branchName ?? database.branch?.gitName ?? database.branch?.name ?? null,
+		region: normalizeRegion(database),
+		status: database.status ?? null,
+		isDefault: database.isDefault ?? null,
+		createdAt: database.createdAt ?? null
+	};
+}
+function normalizeConnection(connection, fallbackDatabaseId) {
+	return {
+		id: connection.id,
+		name: connection.name ?? connection.id,
+		databaseId: connection.databaseId ?? fallbackDatabaseId,
+		createdAt: connection.createdAt ?? null
+	};
+}
+function normalizeCreatedDatabase(database, fallbackProjectId) {
+	const rawConnection = database.connections?.[0];
+	if (!rawConnection) throw new CliError({
+		code: "DATABASE_CONNECTION_MISSING",
+		domain: "database",
+		summary: "Created database did not return a connection string",
+		why: "The Management API created the database but did not include the one-time connection payload.",
+		fix: "Create a connection explicitly with prisma-cli database connection create <database>.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli database connection create ${database.id}`]
+	});
+	return {
+		database: normalizeDatabase(database, fallbackProjectId),
+		...normalizeCreatedConnection(rawConnection, database.id)
+	};
+}
+function normalizeCreatedConnection(connection, fallbackDatabaseId) {
+	const connectionString = extractConnectionString(connection);
+	if (!connectionString) throw new CliError({
+		code: "DATABASE_CONNECTION_STRING_MISSING",
+		domain: "database",
+		summary: "Created connection did not return a connection string",
+		why: "Database connection strings are one-time-view secrets, but the Management API did not include one in this create response.",
+		fix: "Create another database connection and store the returned URL immediately.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli database connection create ${fallbackDatabaseId}`]
+	});
+	return {
+		connection: normalizeConnection(connection, fallbackDatabaseId),
+		connectionString
+	};
+}
+function normalizeRegion(database) {
+	if (typeof database.region === "string") return database.region;
+	return database.region?.id ?? database.regionId ?? null;
+}
+function requireDatabaseProjectId(database, fallbackProjectId) {
+	const projectId = database.projectId ?? fallbackProjectId;
+	if (projectId) return projectId;
+	throw new CliError({
+		code: "DATABASE_API_ERROR",
+		domain: "database",
+		summary: "Database response did not include a project id",
+		why: "The Management API returned database metadata without project context.",
+		fix: "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function extractConnectionString(connection) {
+	return connection.endpoints?.pooled?.connectionString ?? connection.connectionString ?? connection.endpoints?.direct?.connectionString ?? connection.endpoints?.accelerate?.connectionString ?? null;
+}
+function databaseApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "DATABASE_API_ERROR",
+		domain: "database",
+		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 { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase };

package/dist/lib/project/local-pin.js

@@ -1,25 +1,75 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { Result, TaggedError, UnhandledException } from "better-result";
 //#region src/lib/project/local-pin.ts
 const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";
-async function readLocalResolutionPin(cwd, signal) {
-	signal?.throwIfAborted();
-	try {
-		const raw = await readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), {
-			encoding: "utf8",
-			signal
+var LocalResolutionPinInvalidJsonError = class extends TaggedError("LocalResolutionPinInvalidJsonError")() {
+	constructor(cause) {
+		super({
+			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} contains invalid JSON.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinInvalidShapeError = class extends TaggedError("LocalResolutionPinInvalidShapeError")() {
+	constructor() {
+		super({
+			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} must contain workspaceId and projectId string fields only.`,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinReadAbortedError = class extends TaggedError("LocalResolutionPinReadAbortedError")() {
+	constructor(cause) {
+		super({
+			message: `Reading ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
 		});
-		const parsed = JSON.parse(raw);
-		if (!isLocalResolutionPin(parsed)) return { kind: "invalid" };
-		return {
+	}
+};
+async function readLocalResolutionPin(cwd, signal) {
+	return Result.gen(async function* () {
+		yield* ensureLocalResolutionPinReadNotAborted(signal);
+		const file = yield* Result.await(readLocalResolutionPinFile(cwd, signal));
+		if (file.kind === "missing") return Result.ok({ kind: "missing" });
+		const parsed = yield* parseLocalResolutionPin(file.raw);
+		if (!isLocalResolutionPin(parsed)) return Result.err(new LocalResolutionPinInvalidShapeError());
+		return Result.ok({
 			kind: "present",
 			pin: parsed
-		};
-	} catch (error) {
-		if (error.code === "ENOENT") return { kind: "missing" };
-		if (error instanceof SyntaxError) return { kind: "invalid" };
-		throw error;
+		});
+	});
+}
+function ensureLocalResolutionPinReadNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinReadAbortedError(cause)
+	});
+}
+async function readLocalResolutionPinFile(cwd, signal) {
+	const readResult = await Result.tryPromise({
+		try: () => readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), {
+			encoding: "utf8",
+			signal
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinReadAbortedError(cause) : new UnhandledException({ cause })
+	});
+	if (readResult.isErr()) {
+		if (readResult.error instanceof UnhandledException && readResult.error.cause.code === "ENOENT") return Result.ok({ kind: "missing" });
+		return Result.err(readResult.error);
 	}
+	return Result.ok({
+		kind: "present",
+		raw: readResult.value
+	});
+}
+function parseLocalResolutionPin(raw) {
+	return Result.try({
+		try: () => JSON.parse(raw),
+		catch: (cause) => cause instanceof SyntaxError ? new LocalResolutionPinInvalidJsonError(cause) : new UnhandledException({ cause })
+	});
 }
 async function writeLocalResolutionPin(cwd, pin, signal) {
 	const prismaDir = path.join(cwd, ".prisma");

package/dist/lib/project/resolution.js

@@ -3,6 +3,7 @@ import { formatCommandArgument } from "../../shell/command-arguments.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { matchError } from "better-result";
 //#region src/lib/project/resolution.ts
 async function resolveProjectTarget(options) {
 	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: true });
@@ -224,7 +225,6 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 	}
 	const localPin = settings.localPin;
 	if (!localPin) return null;
-	if (localPin.kind === "invalid") throw localStateStaleError();
 	if (localPin.kind === "present") {
 		if (localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
 			pinnedWorkspaceId: localPin.pin.workspaceId,
@@ -247,7 +247,9 @@ async function resolveBoundProjectTarget(options, projects, settings) {
 }
 async function readImplicitLocalPin(options, settings) {
 	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return null;
-	const localPin = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
+	const localPinResult = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
+	if (localPinResult.isErr()) throw localPinReadErrorToProjectError(localPinResult.error);
+	const localPin = localPinResult.value;
 	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
 		pinnedWorkspaceId: localPin.pin.workspaceId,
 		pinnedProjectId: localPin.pin.projectId,
@@ -255,6 +257,18 @@ async function readImplicitLocalPin(options, settings) {
 	});
 	return localPin;
 }
+function localPinReadErrorToProjectError(error) {
+	return matchError(error, {
+		LocalResolutionPinInvalidJsonError: () => localStateStaleError(),
+		LocalResolutionPinInvalidShapeError: () => localStateStaleError(),
+		LocalResolutionPinReadAbortedError: (error) => {
+			throw error;
+		},
+		UnhandledException: (error) => {
+			throw error;
+		}
+	});
+}
 function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
 	return {
 		workspace,

package/dist/presenters/app.js

@@ -43,11 +43,16 @@ function renderAppDeploy(context, descriptor, result) {
 	];
 }
 function serializeAppDeploy(result) {
-	const { deploySettings: _deploySettings, localPin: _localPin, ...serialized } = result;
+	const { deploySettings, localPin: _localPin, ...serialized } = result;
 	const { id: _branchId, ...branch } = serialized.branch;
 	return {
 		...serialized,
-		branch
+		branch,
+		deploySettings: {
+			config: deploySettings.config,
+			buildCommand: deploySettings.buildCommand,
+			outputDirectory: deploySettings.outputDirectory
+		}
 	};
 }
 function renderBranchDatabaseDeploySummary(context, result) {

package/dist/presenters/database.js

@@ -0,0 +1,274 @@
+import { formatColumns, renderSummaryLine } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
+import { renderMutate, renderShow, serializeList } from "../output/patterns.js";
+import { renderResolvedProjectContextBlock, stripVerboseContext } from "./verbose-context.js";
+//#region src/presenters/database.ts
+function renderDatabaseList(context, descriptor, result) {
+	const ui = context.ui;
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing databases for the resolved project.")}`, ""];
+	const rail = ui.dim("│");
+	lines.push(`${rail}  ${ui.accent("project:")}  ${result.projectName}`);
+	if (result.branchName) lines.push(`${rail}  ${ui.accent("branch:")}   ${result.branchName}`);
+	lines.push(rail);
+	if (result.databases.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No databases found.")}`);
+		lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+		return lines;
+	}
+	const rows = result.databases.map((database) => [
+		database.name,
+		database.branchName ?? "unscoped",
+		database.region ?? "unknown",
+		formatStatus(database),
+		database.id
+	]);
+	const widths = [
+		Math.max(4, ...rows.map((row) => row[0].length)),
+		Math.max(6, ...rows.map((row) => row[1].length)),
+		Math.max(6, ...rows.map((row) => row[2].length)),
+		Math.max(6, ...rows.map((row) => row[3].length)),
+		Math.max(2, ...rows.map((row) => row[4].length))
+	];
+	lines.push(`${rail}  ${ui.accent(formatColumns([
+		"Name",
+		"Branch",
+		"Region",
+		"Status",
+		"Id"
+	], widths))}`);
+	for (const row of rows) lines.push(`${rail}  ${formatColumns(row, widths)}`);
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseList(result) {
+	return {
+		...serializeList({
+			context: {
+				project: result.projectName,
+				...result.branchName ? { branch: result.branchName } : {}
+			},
+			items: result.databases.map((database) => ({
+				noun: "database",
+				label: database.name,
+				id: database.id,
+				status: database.isDefault ? "default" : null
+			}))
+		}),
+		projectId: result.projectId,
+		branchName: result.branchName,
+		databases: result.databases
+	};
+}
+function renderDatabaseShow(context, descriptor, result) {
+	const lines = renderShow({
+		title: "Showing database metadata.",
+		descriptor,
+		fields: [
+			{
+				key: "project",
+				value: result.projectName
+			},
+			{
+				key: "database",
+				value: result.database.name
+			},
+			{
+				key: "id",
+				value: result.database.id,
+				tone: "dim"
+			},
+			{
+				key: "branch",
+				value: result.database.branchName ?? "unscoped",
+				tone: result.database.branchName ? "default" : "dim"
+			},
+			{
+				key: "region",
+				value: result.database.region ?? "unknown",
+				tone: result.database.region ? "default" : "dim"
+			},
+			{
+				key: "status",
+				value: formatStatus(result.database)
+			},
+			{
+				key: "connections",
+				value: String(result.connections.length)
+			}
+		]
+	}, context.ui);
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseShow(result) {
+	return stripVerboseContext(result);
+}
+function renderDatabaseCreateStdout(_context, _descriptor, result) {
+	return [result.connectionString];
+}
+function renderDatabaseCreate(context, _descriptor, result) {
+	const ui = context.ui;
+	const lines = [
+		"Creating database...",
+		renderSummaryLine(ui, "success", `Created database "${result.database.name}" in ${formatDatabaseTarget(result.projectName, result.database.branchName)}.`),
+		"  The connection URL below is shown once, so save it now."
+	];
+	if (ui.verbose) {
+		lines.push("");
+		lines.push(...renderDatabaseCreateVerboseRows(context, result));
+	}
+	return lines;
+}
+function serializeDatabaseCreate(result) {
+	return stripVerboseContext(result);
+}
+function renderDatabaseRemove(context, descriptor, result) {
+	const lines = renderMutate({
+		title: "Removing database.",
+		descriptor,
+		context: [
+			{
+				key: "project",
+				value: result.projectName
+			},
+			{
+				key: "database",
+				value: result.database.name
+			},
+			{
+				key: "id",
+				value: result.database.id,
+				tone: "dim"
+			}
+		],
+		operationDescription: "Removing database",
+		operationCount: 1,
+		details: ["Database and its connection metadata were removed."]
+	}, context.ui);
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseRemove(result) {
+	return stripVerboseContext(result);
+}
+function renderDatabaseConnectionList(context, descriptor, result) {
+	const ui = context.ui;
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing database connection metadata.")}`, ""];
+	const rail = ui.dim("│");
+	lines.push(`${rail}  ${ui.accent("database:")}  ${result.database.name}`);
+	lines.push(rail);
+	if (result.connections.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No database connections found.")}`);
+		lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+		return lines;
+	}
+	const rows = result.connections.map((connection) => [
+		connection.name,
+		connection.id,
+		connection.createdAt ?? "unknown"
+	]);
+	const widths = [
+		Math.max(4, ...rows.map((row) => row[0].length)),
+		Math.max(2, ...rows.map((row) => row[1].length)),
+		Math.max(7, ...rows.map((row) => row[2].length))
+	];
+	lines.push(`${rail}  ${ui.accent(formatColumns([
+		"Name",
+		"Id",
+		"Created"
+	], widths))}`);
+	for (const row of rows) lines.push(`${rail}  ${formatColumns(row, widths)}`);
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseConnectionList(result) {
+	return {
+		...serializeList({
+			context: {
+				project: result.projectName,
+				database: result.database.name
+			},
+			items: result.connections.map((connection) => ({
+				noun: "connection",
+				label: connection.name,
+				id: connection.id,
+				status: null
+			}))
+		}),
+		projectId: result.projectId,
+		database: result.database,
+		connections: result.connections
+	};
+}
+function renderDatabaseConnectionCreateStdout(_context, _descriptor, result) {
+	return [result.connectionString];
+}
+function renderDatabaseConnectionCreate(context, _descriptor, result) {
+	const ui = context.ui;
+	const lines = [
+		"Creating connection...",
+		renderSummaryLine(ui, "success", `Added a connection to "${result.database.name}" in ${formatDatabaseTarget(result.projectName, result.database.branchName)}.`),
+		"  The connection URL below is shown once, so save it now."
+	];
+	if (ui.verbose) {
+		lines.push("");
+		lines.push(...renderDatabaseConnectionCreateVerboseRows(context, result));
+	}
+	return lines;
+}
+function serializeDatabaseConnectionCreate(result) {
+	return stripVerboseContext(result);
+}
+function renderDatabaseConnectionRemove(context, descriptor, result) {
+	return renderMutate({
+		title: "Removing database connection.",
+		descriptor,
+		context: [{
+			key: "connection",
+			value: result.connection.id,
+			tone: "dim"
+		}],
+		operationDescription: "Removing database connection",
+		operationCount: 1,
+		details: ["The connection metadata was removed. Existing one-time secrets were not shown."]
+	}, context.ui);
+}
+function serializeDatabaseConnectionRemove(result) {
+	return result;
+}
+function formatStatus(database) {
+	return database.status ?? (database.isDefault ? "default" : "unknown");
+}
+function formatDatabaseTarget(projectName, branchName) {
+	return branchName ? `${projectName} / ${branchName}` : projectName;
+}
+function renderDatabaseCreateVerboseRows(context, result) {
+	return renderMetadataRows([
+		...renderWorkspaceProjectRows(result),
+		["branch", result.database.branchName ?? "unscoped"],
+		["database", formatResourceWithId(context, result.database.name, result.database.id)],
+		["region", result.database.region ?? "unknown"],
+		["status", formatStatus(result.database)],
+		["connection", formatResourceWithId(context, result.connection.name, result.connection.id)]
+	]);
+}
+function renderDatabaseConnectionCreateVerboseRows(context, result) {
+	return renderMetadataRows([
+		...renderWorkspaceProjectRows(result),
+		["branch", result.database.branchName ?? "unscoped"],
+		["database", formatResourceWithId(context, result.database.name, result.database.id)],
+		["connection", formatResourceWithId(context, result.connection.name, result.connection.id)]
+	]);
+}
+function renderWorkspaceProjectRows(result) {
+	return [...result.verboseContext ? [["workspace", result.verboseContext.workspace.name]] : [], ["project", result.projectName]];
+}
+function formatResourceWithId(context, name, id) {
+	return `${name}  ${context.ui.dim(`(${id})`)}`;
+}
+function renderMetadataRows(rows) {
+	const widths = [Math.max(...rows.map((row) => row[0].length)), 0];
+	return rows.map(([key, value]) => `  ${formatColumns([key, value], widths)}`);
+}
+//#endregion
+export { renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseShow, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseShow };