@prisma/cli 3.0.0-dev.73.1 → 3.0.0-dev.75.1

package/dist/adapters/mock-api.js

@@ -56,6 +56,81 @@ var MockApi = class MockApi {
 	getDeployment(deploymentId) {
 		return this.data.deployments.find((deployment) => deployment.id === deploymentId);
 	}
+	listDatabasesForProject(projectId, branchName) {
+		return (this.data.databases ?? []).filter((database) => database.projectId === projectId && (!branchName || database.branchName === branchName));
+	}
+	getDatabase(databaseId) {
+		return (this.data.databases ?? []).find((database) => database.id === databaseId);
+	}
+	createDatabase(input) {
+		this.data.databases ??= [];
+		this.data.databaseConnections ??= [];
+		const database = {
+			id: `db_${this.data.databases.length + 1e3}`,
+			projectId: input.projectId,
+			branchId: input.branchName ? this.getBranchForProject(input.projectId, input.branchName)?.id ?? null : null,
+			branchName: input.branchName ?? null,
+			name: input.name,
+			region: input.region ?? null,
+			status: "ready",
+			isDefault: false,
+			createdAt: "2026-06-09T00:00:00.000Z"
+		};
+		const connectionString = `postgresql://${database.id}.example.prisma.io/postgres`;
+		const connection = {
+			id: `conn_${this.data.databaseConnections.length + 1e3}`,
+			databaseId: database.id,
+			name: "primary",
+			createdAt: "2026-06-09T00:00:00.000Z",
+			connectionString
+		};
+		this.data.databases.push(database);
+		this.data.databaseConnections.push(connection);
+		return {
+			database,
+			connection,
+			connectionString
+		};
+	}
+	removeDatabase(databaseId) {
+		this.data.databases ??= [];
+		this.data.databaseConnections ??= [];
+		const database = this.getDatabase(databaseId);
+		if (!database) return;
+		this.data.databases = this.data.databases.filter((candidate) => candidate.id !== databaseId);
+		this.data.databaseConnections = this.data.databaseConnections.filter((connection) => connection.databaseId !== databaseId);
+		return database;
+	}
+	listDatabaseConnections(databaseId) {
+		return (this.data.databaseConnections ?? []).filter((connection) => connection.databaseId === databaseId);
+	}
+	getDatabaseConnection(connectionId) {
+		return (this.data.databaseConnections ?? []).find((connection) => connection.id === connectionId);
+	}
+	createDatabaseConnection(input) {
+		if (!this.getDatabase(input.databaseId)) return;
+		this.data.databaseConnections ??= [];
+		const connectionString = `postgresql://${input.databaseId}-${this.data.databaseConnections.length + 1}.example.prisma.io/postgres`;
+		const connection = {
+			id: `conn_${this.data.databaseConnections.length + 1e3}`,
+			databaseId: input.databaseId,
+			name: input.name,
+			createdAt: "2026-06-09T00:00:00.000Z",
+			connectionString
+		};
+		this.data.databaseConnections.push(connection);
+		return {
+			connection,
+			connectionString
+		};
+	}
+	removeDatabaseConnection(connectionId) {
+		this.data.databaseConnections ??= [];
+		const connection = this.getDatabaseConnection(connectionId);
+		if (!connection) return;
+		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
+		return connection;
+	}
 };
 //#endregion
 export { MockApi };

package/dist/cli2.js

@@ -8,6 +8,7 @@ import "./shell/prompt.js";
 import { createAppCommand } from "./commands/app/index.js";
 import { createAuthCommand } from "./commands/auth/index.js";
 import { createBranchCommand } from "./commands/branch/index.js";
+import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
@@ -49,6 +50,7 @@ function createProgram(runtime) {
 	program.addCommand(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createDatabaseCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;
 }

package/dist/commands/database/index.js

@@ -0,0 +1,159 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow } from "../../controllers/database.js";
+import { renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseShow, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseShow } from "../../presenters/database.js";
+import { Command, Option } from "commander";
+//#region src/commands/database/index.ts
+function createDatabaseCommand(runtime) {
+	const database = attachCommandDescriptor(configureRuntimeCommand(new Command("database"), runtime), "database");
+	addCompactGlobalFlags(database);
+	database.addCommand(createDatabaseListCommand(runtime));
+	database.addCommand(createDatabaseShowCommand(runtime));
+	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseConnectionCommand(runtime));
+	return database;
+}
+function addProjectAndBranchOptions(command) {
+	return command.addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <git-name>", "Branch git name"));
+}
+function createDatabaseListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.list");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.list", options, (context) => runDatabaseList(context, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "database.show");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.show", options, (context) => runDatabaseShow(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseShow(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseShow(result)
+		});
+	});
+	return command;
+}
+function createDatabaseCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.create");
+	command.argument("<name>", "Database name").addOption(new Option("--region <region>", "Prisma Postgres region id"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const region = options.region;
+		await runCommand(runtime, "database.create", options, (context) => runDatabaseCreate(context, name, {
+			projectRef,
+			branchName,
+			region
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.remove");
+	command.argument("<database>", "Database id or name").addOption(new Option("--confirm <database-id>", "Exact database id required to remove"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.remove", options, (context) => runDatabaseRemove(context, databaseRef, {
+			projectRef,
+			branchName,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRemove(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCommand(runtime) {
+	const connection = attachCommandDescriptor(configureRuntimeCommand(new Command("connection"), runtime), "database.connection");
+	addCompactGlobalFlags(connection);
+	connection.addCommand(createDatabaseConnectionListCommand(runtime));
+	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
+	return connection;
+}
+function createDatabaseConnectionListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.connection.list", options, (context) => runDatabaseConnectionList(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.connection.create");
+	command.argument("<database>", "Database id or name").addOption(new Option("--name <name>", "Connection name"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const name = options.name;
+		await runCommand(runtime, "database.connection.create", options, (context) => runDatabaseConnectionCreate(context, databaseRef, {
+			projectRef,
+			branchName,
+			name
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.connection.remove");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.remove", options, (context) => runDatabaseConnectionRemove(context, connectionRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createDatabaseCommand };

package/dist/controllers/database.js

@@ -0,0 +1,316 @@
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listFixtureWorkspaceProjects, listRealWorkspaceProjects } from "./project.js";
+import { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase } from "../lib/database/provider.js";
+import { randomBytes } from "node:crypto";
+//#region src/controllers/database.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runDatabaseList(context, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database list");
+	const databases = sortDatabases(await provider.listDatabases({
+		projectId: target.project.id,
+		branchName: flags.branchName,
+		signal: context.runtime.signal
+	}));
+	return {
+		command: "database.list",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			branchName: flags.branchName ?? null,
+			verboseContext: target,
+			databases
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseShow(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database show");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const connections = await provider.listConnections(database.id, { signal: context.runtime.signal });
+	return {
+		command: "database.show",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			connections
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseCreate(context, name, flags) {
+	const databaseName = name.trim();
+	if (!databaseName) throw usageError("Database name required", "Database create needs a non-empty name.", "Pass a database name.", ["prisma-cli database create <name>"], "database");
+	const { provider, target } = await requireDatabaseContext(context, flags, "database create");
+	const created = await provider.createDatabase({
+		projectId: target.project.id,
+		name: databaseName,
+		branchName: flags.branchName,
+		region: flags.region,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.create",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database: ensureProjectId(created.database, target.project.id),
+			connection: created.connection,
+			connectionString: created.connectionString
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseRemove(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database remove");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	requireExactConfirmation({
+		resourceName: "database",
+		commandName: "database remove",
+		id: database.id,
+		confirm: flags.confirm
+	});
+	await provider.removeDatabase(database.id, { signal: context.runtime.signal });
+	return {
+		command: "database.remove",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseConnectionList(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database connection list");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const connections = await provider.listConnections(database.id, { signal: context.runtime.signal });
+	return {
+		command: "database.connection.list",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			connections
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseConnectionCreate(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database connection create");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const created = await provider.createConnection({
+		databaseId: database.id,
+		name: flags.name?.trim() || defaultConnectionName(),
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.connection.create",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			connection: created.connection,
+			connectionString: created.connectionString
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseConnectionRemove(context, connectionRef, flags) {
+	const connectionId = connectionRef.trim();
+	if (!connectionId) throw usageError("Connection id required", "Database connection removal needs a connection id.", "Pass the connection id to remove.", ["prisma-cli database connection remove <connection-id> --confirm <connection-id>"], "database");
+	requireExactConfirmation({
+		resourceName: "database connection",
+		commandName: "database connection remove",
+		id: connectionId,
+		confirm: flags.confirm
+	});
+	await (await requireDatabaseProviderOnly(context)).removeConnection(connectionId, { signal: context.runtime.signal });
+	return {
+		command: "database.connection.remove",
+		result: { connection: { id: connectionId } },
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function requireDatabaseContext(context, flags, commandName) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+		if (!client) throw authRequiredError();
+		const target = await resolveProjectTarget({
+			context,
+			workspace,
+			explicitProject: flags.projectRef,
+			listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+			commandName
+		});
+		return {
+			provider: createManagementDatabaseProvider(client),
+			target
+		};
+	}
+	const target = await resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject: flags.projectRef,
+		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
+		commandName
+	});
+	return {
+		provider: createFixtureDatabaseProvider(context),
+		target
+	};
+}
+async function requireDatabaseProviderOnly(context) {
+	await requireAuthenticatedAuthState(context);
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+		if (!client) throw authRequiredError();
+		return createManagementDatabaseProvider(client);
+	}
+	return createFixtureDatabaseProvider(context);
+}
+function createFixtureDatabaseProvider(context) {
+	return {
+		async listDatabases(options) {
+			return context.api.listDatabasesForProject(options.projectId, options.branchName).map((database) => normalizeDatabase(database, database.projectId));
+		},
+		async showDatabase(databaseId) {
+			const database = context.api.getDatabase(databaseId);
+			return database ? normalizeDatabase(database, database.projectId) : null;
+		},
+		async createDatabase(options) {
+			const created = context.api.createDatabase(options);
+			return {
+				database: normalizeDatabase(created.database, created.database.projectId),
+				connection: normalizeConnection(created.connection, created.connection.databaseId),
+				connectionString: created.connectionString
+			};
+		},
+		async removeDatabase(databaseId) {
+			if (!context.api.removeDatabase(databaseId)) throw databaseNotFoundError(databaseId);
+		},
+		async listConnections(databaseId) {
+			if (!context.api.getDatabase(databaseId)) throw databaseNotFoundError(databaseId);
+			return context.api.listDatabaseConnections(databaseId).map((connection) => normalizeConnection(connection, connection.databaseId));
+		},
+		async createConnection(options) {
+			const created = context.api.createDatabaseConnection(options);
+			if (!created) throw databaseNotFoundError(options.databaseId);
+			return {
+				connection: normalizeConnection(created.connection, created.connection.databaseId),
+				connectionString: created.connectionString
+			};
+		},
+		async removeConnection(connectionId) {
+			if (!context.api.removeDatabaseConnection(connectionId)) throw connectionNotFoundError(connectionId);
+		}
+	};
+}
+async function resolveDatabase(provider, target, databaseRef, branchName, signal) {
+	const ref = databaseRef.trim();
+	if (!ref) throw usageError("Database id or name required", "This command needs a database id or name.", "Pass a database id or name.", ["prisma-cli database list"], "database");
+	const matches = (await provider.listDatabases({
+		projectId: target.project.id,
+		branchName,
+		signal
+	})).filter((database) => database.id === ref || database.name === ref);
+	if (matches.length === 0) throw databaseNotFoundError(ref, target.project.name, branchName);
+	if (matches.length > 1) throw databaseAmbiguousError(ref, matches, branchName);
+	const selected = matches[0];
+	return ensureProjectId(await provider.showDatabase(selected.id, {
+		projectId: target.project.id,
+		signal
+	}) ?? selected, target.project.id);
+}
+function ensureProjectId(database, projectId) {
+	return database.projectId ? database : {
+		...database,
+		projectId
+	};
+}
+function sortDatabases(databases) {
+	return databases.slice().sort((left, right) => {
+		const branchOrder = (left.branchName ?? "").localeCompare(right.branchName ?? "");
+		if (branchOrder !== 0) return branchOrder;
+		const nameOrder = left.name.localeCompare(right.name);
+		return nameOrder !== 0 ? nameOrder : left.id.localeCompare(right.id);
+	});
+}
+function requireExactConfirmation(options) {
+	if (options.confirm === options.id) return;
+	throw new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "database",
+		summary: `Confirm ${options.resourceName} removal`,
+		why: `Removing this ${options.resourceName} is destructive and requires the exact id.`,
+		fix: `Rerun with --confirm ${options.id}.`,
+		exitCode: 2,
+		nextSteps: [`prisma-cli ${options.commandName} ${options.id} --confirm ${options.id}`],
+		meta: {
+			expectedConfirm: options.id,
+			receivedConfirm: options.confirm ?? null
+		}
+	});
+}
+function defaultConnectionName() {
+	return `cli-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 17)}-${randomBytes(2).toString("hex")}`;
+}
+function databaseNotFoundError(databaseRef, projectName, branchName) {
+	return new CliError({
+		code: "DATABASE_NOT_FOUND",
+		domain: "database",
+		summary: "Database not found",
+		why: `No database matched "${databaseRef}"${projectName ? ` in project "${projectName}"${branchName ? ` on branch "${branchName}"` : ""}` : ""}.`,
+		fix: "Pass a database id or name from prisma-cli database list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database list"]
+	});
+}
+function databaseAmbiguousError(databaseRef, matches, branchName) {
+	return new CliError({
+		code: "DATABASE_AMBIGUOUS",
+		domain: "database",
+		summary: "Database resolution is ambiguous",
+		why: branchName ? `Multiple databases matched "${databaseRef}" on branch "${branchName}".` : `Multiple databases matched "${databaseRef}".`,
+		fix: "Pass the database id, or pass --branch <git-name> to narrow the match.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database list"],
+		meta: { matches: matches.map((database) => ({
+			id: database.id,
+			name: database.name,
+			branchName: database.branchName
+		})) }
+	});
+}
+function connectionNotFoundError(connectionId) {
+	return new CliError({
+		code: "DATABASE_CONNECTION_NOT_FOUND",
+		domain: "database",
+		summary: "Database connection not found",
+		why: `No database connection matched "${connectionId}".`,
+		fix: "Pass a connection id from prisma-cli database connection list <database>.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database connection list <database>"]
+	});
+}
+//#endregion
+export { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow };

package/dist/controllers/project.js

@@ -713,4 +713,4 @@ function repoConnectionFixForStatus(status) {
 	return "Re-run with --trace for the underlying API response details.";
 }
 //#endregion
-export { listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };
+export { listFixtureWorkspaceProjects, listRealWorkspaceProjects, runGitConnect, runGitDisconnect, runProjectCreate, runProjectLink, runProjectList, runProjectShow };

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

package/dist/shell/command-meta.js

@@ -72,6 +72,16 @@ const DESCRIPTORS = [
 		description: "View your Platform branches",
 		examples: ["prisma-cli branch list"]
 	},
+	{
+		id: "database",
+		path: ["prisma", "database"],
+		description: "Manage Prisma Postgres databases for a project",
+		examples: [
+			"prisma-cli database list",
+			"prisma-cli database create my-db",
+			"prisma-cli database connection create db_123"
+		]
+	},
 	{
 		id: "git",
 		path: ["prisma", "git"],
@@ -156,6 +166,97 @@ const DESCRIPTORS = [
 		description: "List Platform branches for the resolved project",
 		examples: ["prisma-cli branch list", "prisma-cli branch list --json"]
 	},
+	{
+		id: "database.list",
+		path: [
+			"prisma",
+			"database",
+			"list"
+		],
+		description: "List Prisma Postgres databases for the resolved project",
+		examples: [
+			"prisma-cli database list",
+			"prisma-cli database list --branch feature/foo",
+			"prisma-cli database list --json"
+		]
+	},
+	{
+		id: "database.show",
+		path: [
+			"prisma",
+			"database",
+			"show"
+		],
+		description: "Show database metadata without secret values",
+		examples: ["prisma-cli database show db_123", "prisma-cli database show acme-preview --branch preview --json"]
+	},
+	{
+		id: "database.create",
+		path: [
+			"prisma",
+			"database",
+			"create"
+		],
+		description: "Create a Prisma Postgres database and print its one-time connection URL",
+		examples: ["prisma-cli database create my-db", "prisma-cli database create my-db --branch feature/foo --region eu-central-1"]
+	},
+	{
+		id: "database.remove",
+		path: [
+			"prisma",
+			"database",
+			"remove"
+		],
+		description: "Remove a database after exact id confirmation",
+		examples: ["prisma-cli database remove db_123 --confirm db_123"]
+	},
+	{
+		id: "database.connection",
+		path: [
+			"prisma",
+			"database",
+			"connection"
+		],
+		description: "Manage one-time-view database connection strings",
+		examples: [
+			"prisma-cli database connection list db_123",
+			"prisma-cli database connection create db_123",
+			"prisma-cli database connection remove conn_123 --confirm conn_123"
+		]
+	},
+	{
+		id: "database.connection.list",
+		path: [
+			"prisma",
+			"database",
+			"connection",
+			"list"
+		],
+		description: "List database connection metadata without secret values",
+		examples: ["prisma-cli database connection list db_123", "prisma-cli database connection list acme-preview --branch preview --json"]
+	},
+	{
+		id: "database.connection.create",
+		path: [
+			"prisma",
+			"database",
+			"connection",
+			"create"
+		],
+		description: "Create a database connection and print its one-time connection URL",
+		examples: ["prisma-cli database connection create db_123", "prisma-cli database connection create db_123 --name readonly"]
+	},
+	{
+		id: "database.connection.remove",
+		path: [
+			"prisma",
+			"database",
+			"connection",
+			"remove"
+		],
+		description: "Remove a database connection after exact id confirmation",
+		examples: ["prisma-cli database connection remove conn_123 --confirm conn_123"]
+	},
 	{
 		id: "app.build",
 		path: [

package/dist/shell/command-runner.js

@@ -31,13 +31,20 @@ async function runCommand(runtime, commandName, options, handler, presenter) {
 			});
 			return;
 		}
-		if (flags.quiet) return;
+		const stdout = presenter.renderStdout?.(context, descriptor, success.result) ?? [];
+		if (flags.quiet) {
+			if (stdout.length > 0) context.output.stdout.write(`${stdout.join("\n")}\n`);
+			return;
+		}
 		const rendered = presenter.renderHuman(context, descriptor, success.result);
 		const diagnostics = await renderBestEffortCommandDiagnostics(context, {
 			enabled: flags.verbose && rendered.length > 0,
 			durationMs: Date.now() - startedAt
 		});
-		writeHumanLines(context.output, [...rendered, ...diagnostics]);
+		const humanLines = [...rendered, ...diagnostics];
+		if (stdout.length > 0 && humanLines.length > 0) humanLines.push("");
+		writeHumanLines(context.output, humanLines);
+		if (stdout.length > 0) context.output.stdout.write(`${stdout.join("\n")}\n`);
 	} catch (error) {
 		const cliError = toCliError(error, runtime);
 		if (cliError) {

package/package.json

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