@prisma/cli 3.0.0-dev.110.1 → 3.0.0-dev.114.1

package/dist/adapters/mock-api.js

@@ -131,6 +131,69 @@ var MockApi = class MockApi {
 		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
 		return connection;
 	}
+	getDatabaseUsage(databaseId, period) {
+		const defaults = (this.data.databaseUsage ?? []).find((record) => record.databaseId === databaseId) ?? {
+			databaseId,
+			period: {
+				start: "2026-06-01T00:00:00.000Z",
+				end: "2026-06-30T23:59:59.999Z"
+			},
+			metrics: {
+				operations: {
+					used: 0,
+					unit: "ops"
+				},
+				storage: {
+					used: 0,
+					unit: "GiB"
+				}
+			},
+			generatedAt: "2026-07-01T00:00:00.000Z"
+		};
+		return {
+			period: {
+				start: period?.from ?? defaults.period.start,
+				end: period?.to ?? defaults.period.end
+			},
+			metrics: defaults.metrics,
+			generatedAt: defaults.generatedAt
+		};
+	}
+	listDatabaseBackups(databaseId, limit) {
+		const backups = (this.data.databaseBackups ?? []).filter((backup) => backup.databaseId === databaseId);
+		const limited = limit === void 0 ? backups : backups.slice(0, limit);
+		return {
+			backups: limited.map((backup) => ({
+				id: backup.id,
+				backupType: backup.backupType,
+				status: backup.status,
+				size: backup.size ?? null,
+				createdAt: backup.createdAt
+			})),
+			retentionDays: this.data.databaseBackupRetentionDays ?? null,
+			hasMore: limited.length < backups.length
+		};
+	}
+	restoreDatabase(input) {
+		const target = this.getDatabase(input.targetDatabaseId);
+		if (!target) return { outcome: "target-not-found" };
+		if (!(this.data.databaseBackups ?? []).find((candidate) => candidate.id === input.backupId && candidate.databaseId === input.sourceDatabaseId)) return { outcome: "backup-not-found" };
+		target.status = "recovering";
+		return {
+			outcome: "restored",
+			database: target
+		};
+	}
+	rotateDatabaseConnection(connectionId) {
+		const connection = this.getDatabaseConnection(connectionId);
+		if (!connection) return;
+		const connectionString = `postgresql://rotated-${connection.databaseId}-${connection.id}.example.prisma.io/postgres`;
+		connection.connectionString = connectionString;
+		return {
+			connection,
+			connectionString
+		};
+	}
 };
 //#endregion
 export { MockApi };

package/dist/commands/database/index.js

@@ -2,8 +2,8 @@ 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 { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage } from "../../controllers/database.js";
+import { renderDatabaseBackupList, renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseConnectionRotate, renderDatabaseConnectionRotateStdout, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseRestore, renderDatabaseShow, renderDatabaseUsage, serializeDatabaseBackupList, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseConnectionRotate, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseRestore, serializeDatabaseShow, serializeDatabaseUsage } from "../../presenters/database.js";
 import { Command, Option } from "commander";
 //#region src/commands/database/index.ts
 function createDatabaseCommand(runtime) {
@@ -12,7 +12,10 @@ function createDatabaseCommand(runtime) {
 	database.addCommand(createDatabaseListCommand(runtime));
 	database.addCommand(createDatabaseShowCommand(runtime));
 	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseUsageCommand(runtime));
+	database.addCommand(createDatabaseRestoreCommand(runtime));
 	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseBackupCommand(runtime));
 	database.addCommand(createDatabaseConnectionCommand(runtime));
 	return database;
 }
@@ -75,6 +78,78 @@ function createDatabaseCreateCommand(runtime) {
 	});
 	return command;
 }
+function createDatabaseUsageCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("usage"), runtime), "database.usage");
+	command.argument("<database>", "Database id or name").addOption(new Option("--from <iso-date>", "Start of the usage period")).addOption(new Option("--to <iso-date>", "End of the usage period"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const from = options.from;
+		const to = options.to;
+		await runCommand(runtime, "database.usage", options, (context) => runDatabaseUsage(context, databaseRef, {
+			projectRef,
+			branchName,
+			from,
+			to
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseUsage(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseUsage(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRestoreCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("restore"), runtime), "database.restore");
+	command.argument("<database>", "Target database id or name").addOption(new Option("--backup <backup-id>", "Backup to restore from")).addOption(new Option("--source-database <database>", "Database the backup belongs to (defaults to the target)")).addOption(new Option("--confirm <database-id>", "Exact target database id required to restore"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const backupId = options.backup;
+		const sourceDatabaseRef = options.sourceDatabase;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.restore", options, (context) => runDatabaseRestore(context, databaseRef, {
+			projectRef,
+			branchName,
+			backupId,
+			sourceDatabaseRef,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRestore(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRestore(result)
+		});
+	});
+	return command;
+}
+function createDatabaseBackupCommand(runtime) {
+	const backup = attachCommandDescriptor(configureRuntimeCommand(new Command("backup"), runtime), "database.backup");
+	addCompactGlobalFlags(backup);
+	backup.addCommand(createDatabaseBackupListCommand(runtime));
+	return backup;
+}
+function createDatabaseBackupListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.backup.list");
+	command.argument("<database>", "Database id or name").addOption(new Option("--limit <n>", "Maximum number of backups to return"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const limit = options.limit;
+		await runCommand(runtime, "database.backup.list", options, (context) => runDatabaseBackupList(context, databaseRef, {
+			projectRef,
+			branchName,
+			limit
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseBackupList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseBackupList(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"));
@@ -100,9 +175,24 @@ function createDatabaseConnectionCommand(runtime) {
 	addCompactGlobalFlags(connection);
 	connection.addCommand(createDatabaseConnectionListCommand(runtime));
 	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRotateCommand(runtime));
 	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
 	return connection;
 }
+function createDatabaseConnectionRotateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rotate"), runtime), "database.connection.rotate");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to rotate"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.rotate", options, (context) => runDatabaseConnectionRotate(context, connectionRef, { confirm }), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionRotateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRotate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRotate(result)
+		});
+	});
+	return command;
+}
 function createDatabaseConnectionListCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
 	command.argument("<database>", "Database id or name");

package/dist/controllers/app-env-api.js

@@ -5,7 +5,8 @@ async function findVariableByNaturalKey(client, projectId, key, resolved, signal
 		params: { query: {
 			projectId,
 			class: resolved.apiTarget.class,
-			key
+			key,
+			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {}
 		} },
 		signal
 	});

package/dist/controllers/database.js

@@ -1,3 +1,4 @@
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
 import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
@@ -149,6 +150,197 @@ async function runDatabaseConnectionRemove(context, connectionRef, flags) {
 		nextSteps: []
 	};
 }
+async function runDatabaseUsage(context, databaseRef, flags) {
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const from = parseUsageDate(flags.from, "--from", "start", formatCommand);
+	const to = parseUsageDate(flags.to, "--to", "end", formatCommand);
+	if (from && to && Date.parse(from) > Date.parse(to)) throw usageError("Invalid usage period", "--from must not be later than --to.", "Pass a --from date that is on or before the --to date.", [formatCommand([
+		"database",
+		"usage",
+		"<database>",
+		"--from",
+		"2026-06-01",
+		"--to",
+		"2026-06-30"
+	])], "database");
+	const { provider, target } = await requireDatabaseContext(context, flags, "database usage");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const usage = await provider.getUsage(database.id, {
+		from,
+		to,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.usage",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			period: usage.period,
+			metrics: usage.metrics,
+			generatedAt: usage.generatedAt
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseBackupList(context, databaseRef, flags) {
+	const limit = parseBackupLimit(flags.limit, resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd));
+	const { provider, target } = await requireDatabaseContext(context, flags, "database backup list");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const backups = await provider.listBackups(database.id, {
+		limit,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.backup.list",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			backups: backups.backups,
+			retentionDays: backups.retentionDays,
+			hasMore: backups.hasMore
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseRestore(context, databaseRef, flags) {
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const backupId = flags.backupId?.trim();
+	if (!backupId) throw usageError("Backup id required", "Database restore needs the backup to restore from.", `Pass --backup <backup-id> from ${formatCommand([
+		"database",
+		"backup",
+		"list",
+		"<database>"
+	])}.`, [formatCommand([
+		"database",
+		"backup",
+		"list",
+		"<database>"
+	])], "database");
+	const { provider, target } = await requireDatabaseContext(context, flags, "database restore");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const sourceDatabase = flags.sourceDatabaseRef ? await resolveDatabase(provider, target, flags.sourceDatabaseRef, flags.branchName, context.runtime.signal) : database;
+	const sourceDatabaseArg = sourceDatabase.id === database.id ? "" : ` --source-database ${sourceDatabase.id}`;
+	requireExactConfirmation({
+		resourceName: "database",
+		commandName: "database restore",
+		id: database.id,
+		confirm: flags.confirm,
+		summary: "Confirm database restore",
+		why: "Restoring immediately and irreversibly overwrites all data in the target database, so it requires the exact target database id.",
+		nextStep: `${formatCommand([
+			"database",
+			"restore",
+			database.id,
+			"--backup",
+			backupId
+		])}${sourceDatabaseArg} --confirm ${database.id}`
+	});
+	const restored = await provider.restoreDatabase({
+		targetDatabaseId: database.id,
+		sourceDatabaseId: sourceDatabase.id,
+		backupId,
+		projectId: target.project.id,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.restore",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database: ensureProjectId(restored, target.project.id),
+			source: {
+				databaseId: sourceDatabase.id,
+				backupId
+			}
+		},
+		warnings: [],
+		nextSteps: [formatCommand([
+			"database",
+			"show",
+			database.id
+		])]
+	};
+}
+async function runDatabaseConnectionRotate(context, connectionRef, flags) {
+	const formatCommand = resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd);
+	const connectionId = connectionRef.trim();
+	if (!connectionId) throw usageError("Connection id required", "Database connection rotation needs a connection id.", "Pass the connection id to rotate.", [formatCommand([
+		"database",
+		"connection",
+		"rotate",
+		"<connection-id>",
+		"--confirm",
+		"<connection-id>"
+	])], "database");
+	requireExactConfirmation({
+		resourceName: "database connection",
+		commandName: "database connection rotate",
+		id: connectionId,
+		confirm: flags.confirm,
+		summary: "Confirm database connection rotation",
+		why: "Rotating revokes the previous credentials and breaks clients still using them, so it requires the exact connection id.",
+		nextStep: formatCommand([
+			"database",
+			"connection",
+			"rotate",
+			connectionId,
+			"--confirm",
+			connectionId
+		])
+	});
+	const rotated = await (await requireDatabaseProviderOnly(context)).rotateConnection(connectionId, { signal: context.runtime.signal });
+	return {
+		command: "database.connection.rotate",
+		result: {
+			connection: rotated.connection,
+			database: rotated.database,
+			connectionString: rotated.connectionString
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+const USAGE_DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const USAGE_DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T/;
+function parseUsageDate(value, flagName, dayBoundary, formatCommand) {
+	if (value === void 0) return;
+	const trimmed = value.trim();
+	if (USAGE_DATE_ONLY_PATTERN.test(trimmed) && isValidCalendarDate(trimmed)) return dayBoundary === "start" ? `${trimmed}T00:00:00.000Z` : `${trimmed}T23:59:59.999Z`;
+	if (USAGE_DATETIME_PATTERN.test(trimmed) && !Number.isNaN(Date.parse(trimmed)) && isValidCalendarDate(trimmed.slice(0, 10))) return trimmed;
+	throw usageError("Invalid usage period", `${flagName} must be an ISO date such as 2026-06-01 or an ISO datetime such as 2026-06-01T12:00:00Z.`, `Pass an ISO date or datetime to ${flagName}.`, [formatCommand([
+		"database",
+		"usage",
+		"<database>",
+		"--from",
+		"2026-06-01",
+		"--to",
+		"2026-06-30"
+	])], "database");
+}
+function isValidCalendarDate(datePart) {
+	const timestamp = Date.parse(`${datePart}T00:00:00.000Z`);
+	return !Number.isNaN(timestamp) && new Date(timestamp).toISOString().startsWith(datePart);
+}
+function parseBackupLimit(value, formatCommand) {
+	if (value === void 0) return;
+	const limit = Number(value.trim());
+	if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw usageError("Invalid backup limit", "--limit must be an integer between 1 and 100.", "Pass a --limit between 1 and 100.", [formatCommand([
+		"database",
+		"backup",
+		"list",
+		"<database>",
+		"--limit",
+		"50"
+	])], "database");
+	return limit;
+}
 async function requireDatabaseContext(context, flags, commandName) {
 	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
 	if (!workspace) throw workspaceRequiredError();
@@ -164,7 +356,7 @@ async function requireDatabaseContext(context, flags, commandName) {
 		});
 		if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
 		return {
-			provider: createManagementDatabaseProvider(client),
+			provider: createManagementDatabaseProvider(client, { formatCommand: resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd) }),
 			target: targetResult.value
 		};
 	}
@@ -186,7 +378,7 @@ async function requireDatabaseProviderOnly(context) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
-		return createManagementDatabaseProvider(client);
+		return createManagementDatabaseProvider(client, { formatCommand: resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd) });
 	}
 	return createFixtureDatabaseProvider(context);
 }
@@ -224,6 +416,40 @@ function createFixtureDatabaseProvider(context) {
 		},
 		async removeConnection(connectionId) {
 			if (!context.api.removeDatabaseConnection(connectionId)) throw connectionNotFoundError(connectionId);
+		},
+		async getUsage(databaseId, options) {
+			if (!context.api.getDatabase(databaseId)) throw databaseNotFoundError(databaseId);
+			return context.api.getDatabaseUsage(databaseId, {
+				from: options?.from,
+				to: options?.to
+			});
+		},
+		async listBackups(databaseId, options) {
+			if (!context.api.getDatabase(databaseId)) throw databaseNotFoundError(databaseId);
+			return context.api.listDatabaseBackups(databaseId, options?.limit);
+		},
+		async restoreDatabase(options) {
+			const restored = context.api.restoreDatabase({
+				targetDatabaseId: options.targetDatabaseId,
+				sourceDatabaseId: options.sourceDatabaseId,
+				backupId: options.backupId
+			});
+			if (restored.outcome === "target-not-found") throw databaseNotFoundError(options.targetDatabaseId);
+			if (restored.outcome === "backup-not-found") throw backupNotFoundError(options.backupId, options.sourceDatabaseId, resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd));
+			return normalizeDatabase(restored.database, options.projectId);
+		},
+		async rotateConnection(connectionId) {
+			const rotated = context.api.rotateDatabaseConnection(connectionId);
+			if (!rotated) throw connectionNotFoundError(connectionId);
+			const database = context.api.getDatabase(rotated.connection.databaseId);
+			return {
+				connection: normalizeConnection(rotated.connection, rotated.connection.databaseId),
+				database: database ? {
+					id: database.id,
+					name: database.name
+				} : null,
+				connectionString: rotated.connectionString
+			};
 		}
 	};
 }
@@ -262,11 +488,11 @@ function requireExactConfirmation(options) {
 	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.`,
+		summary: options.summary ?? `Confirm ${options.resourceName} removal`,
+		why: options.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}`],
+		nextSteps: [options.nextStep ?? `prisma-cli ${options.commandName} ${options.id} --confirm ${options.id}`],
 		meta: {
 			expectedConfirm: options.id,
 			receivedConfirm: options.confirm ?? null
@@ -303,6 +529,23 @@ function databaseAmbiguousError(databaseRef, matches, branchName) {
 		})) }
 	});
 }
+function backupNotFoundError(backupId, sourceDatabaseId, formatCommand) {
+	const listCommand = formatCommand([
+		"database",
+		"backup",
+		"list",
+		sourceDatabaseId
+	]);
+	return new CliError({
+		code: "DATABASE_BACKUP_NOT_FOUND",
+		domain: "database",
+		summary: "Database backup not found",
+		why: `No backup matched "${backupId}" for database "${sourceDatabaseId}".`,
+		fix: `Pass a backup id from ${listCommand}.`,
+		exitCode: 1,
+		nextSteps: [listCommand]
+	});
+}
 function connectionNotFoundError(connectionId) {
 	return new CliError({
 		code: "DATABASE_CONNECTION_NOT_FOUND",
@@ -315,4 +558,4 @@ function connectionNotFoundError(connectionId) {
 	});
 }
 //#endregion
-export { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow };
+export { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage };

package/dist/lib/database/provider.js

@@ -1,6 +1,8 @@
+import { formatPrismaCliCommand } from "../../shell/cli-command.js";
 import { CliError } from "../../shell/errors.js";
 //#region src/lib/database/provider.ts
-function createManagementDatabaseProvider(client) {
+function createManagementDatabaseProvider(client, options) {
+	const formatCommand = options?.formatCommand ?? ((args) => formatPrismaCliCommand(args));
 	return {
 		async listDatabases(options) {
 			const databases = [];
@@ -75,6 +77,55 @@ function createManagementDatabaseProvider(client) {
 				signal: options?.signal
 			});
 			if (result.error) throw databaseApiError("Failed to remove database connection", result.response, result.error);
+		},
+		async getUsage(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/usage", {
+				params: {
+					path: { databaseId },
+					query: {
+						...options?.from ? { startDate: options.from } : {},
+						...options?.to ? { endDate: options.to } : {}
+					}
+				},
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to fetch database usage", result.response, result.error);
+			return normalizeUsage(result.data);
+		},
+		async listBackups(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/backups", {
+				params: {
+					path: { databaseId },
+					query: { ...options?.limit !== void 0 ? { limit: options.limit } : {} }
+				},
+				signal: options?.signal
+			});
+			if (result.response?.status === 422) throw backupsUnsupportedError(databaseId, result.error);
+			if (result.error || !result.data) throw databaseApiError("Failed to list database backups", result.response, result.error);
+			return normalizeBackupList(result.data);
+		},
+		async restoreDatabase(options) {
+			const result = await client.POST("/v1/databases/{targetDatabaseId}/restore", {
+				params: { path: { targetDatabaseId: options.targetDatabaseId } },
+				body: { source: {
+					type: "backup",
+					databaseId: options.sourceDatabaseId,
+					backupId: options.backupId
+				} },
+				signal: options.signal
+			});
+			if (result.response?.status === 409) throw restoreConflictError(options.targetDatabaseId, result.error, formatCommand);
+			if (result.response?.status === 404) throw restoreBackupNotFoundError(options, result.error, formatCommand);
+			if (result.error || !result.data) throw databaseApiError("Failed to restore database", result.response, result.error);
+			return normalizeDatabase(result.data.data, options.projectId);
+		},
+		async rotateConnection(connectionId, options) {
+			const result = await client.POST("/v1/connections/{id}/rotate", {
+				params: { path: { id: connectionId } },
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw databaseApiError("Failed to rotate database connection", result.response, result.error);
+			return normalizeRotatedConnection(result.data.data);
 		}
 	};
 }
@@ -151,6 +202,102 @@ function requireDatabaseProjectId(database, fallbackProjectId) {
 function extractConnectionString(connection) {
 	return connection.endpoints?.pooled?.connectionString ?? connection.connectionString ?? connection.endpoints?.direct?.connectionString ?? connection.endpoints?.accelerate?.connectionString ?? null;
 }
+function normalizeUsage(usage) {
+	return {
+		period: {
+			start: usage.period?.start ?? "",
+			end: usage.period?.end ?? ""
+		},
+		metrics: {
+			operations: {
+				used: usage.metrics?.operations?.used ?? 0,
+				unit: usage.metrics?.operations?.unit ?? "ops"
+			},
+			storage: {
+				used: usage.metrics?.storage?.used ?? 0,
+				unit: usage.metrics?.storage?.unit ?? "GiB"
+			}
+		},
+		generatedAt: usage.generatedAt ?? ""
+	};
+}
+function normalizeBackupList(body) {
+	return {
+		backups: (body.data ?? []).map((backup) => ({
+			id: backup.id,
+			backupType: backup.backupType ?? "unknown",
+			status: backup.status ?? "unknown",
+			size: backup.size ?? null,
+			createdAt: backup.createdAt ?? ""
+		})),
+		retentionDays: body.meta?.backupRetentionDays ?? null,
+		hasMore: body.pagination?.hasMore ?? false
+	};
+}
+function normalizeRotatedConnection(connection) {
+	const connectionString = extractConnectionString(connection);
+	if (!connectionString) throw new CliError({
+		code: "DATABASE_CONNECTION_STRING_MISSING",
+		domain: "database",
+		summary: "Rotated connection did not return a connection string",
+		why: "Rotated connection strings are one-time-view secrets, but the Management API did not include one in this rotate response.",
+		fix: "Re-run the rotation, or create a replacement connection and store the returned URL immediately.",
+		exitCode: 1,
+		nextSteps: []
+	});
+	const database = connection.database?.id && connection.database?.name ? {
+		id: connection.database.id,
+		name: connection.database.name
+	} : null;
+	return {
+		connection: normalizeConnection(connection, connection.database?.id ?? connection.databaseId ?? ""),
+		database,
+		connectionString
+	};
+}
+function backupsUnsupportedError(databaseId, error) {
+	return new CliError({
+		code: "DATABASE_BACKUPS_UNSUPPORTED",
+		domain: "database",
+		summary: "Backups are not available for this database",
+		why: error?.error?.message ?? `The platform does not manage backups for database "${databaseId}", for example because it is a remote/BYO database.`,
+		fix: "Use your own backup tooling for externally managed databases.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function restoreBackupNotFoundError(options, error, formatCommand) {
+	const listCommand = formatCommand([
+		"database",
+		"backup",
+		"list",
+		options.sourceDatabaseId
+	]);
+	return new CliError({
+		code: "DATABASE_BACKUP_NOT_FOUND",
+		domain: "database",
+		summary: "Database backup not found",
+		why: error?.error?.message ?? `No backup matched "${options.backupId}" for database "${options.sourceDatabaseId}".`,
+		fix: `Pass a backup id from ${listCommand}.`,
+		exitCode: 1,
+		nextSteps: [listCommand]
+	});
+}
+function restoreConflictError(targetDatabaseId, error, formatCommand) {
+	return new CliError({
+		code: "DATABASE_RESTORE_CONFLICT",
+		domain: "database",
+		summary: "Database cannot be restored right now",
+		why: error?.error?.message ?? `Database "${targetDatabaseId}" is provisioning or already recovering.`,
+		fix: "Wait for the database to become ready, then retry the restore.",
+		exitCode: 1,
+		nextSteps: [formatCommand([
+			"database",
+			"show",
+			targetDatabaseId
+		])]
+	});
+}
 function databaseApiError(summary, response, error) {
 	const status = response?.status ?? 0;
 	return new CliError({

package/dist/presenters/database.js

@@ -236,6 +236,180 @@ function renderDatabaseConnectionRemove(context, descriptor, result) {
 function serializeDatabaseConnectionRemove(result) {
 	return { connection: result.connection };
 }
+function renderDatabaseUsage(context, descriptor, result) {
+	const lines = renderShow({
+		title: "Showing database usage metrics.",
+		descriptor,
+		fields: [
+			{
+				key: "project",
+				value: result.projectName
+			},
+			{
+				key: "database",
+				value: result.database.name
+			},
+			{
+				key: "id",
+				value: result.database.id,
+				tone: "dim"
+			},
+			{
+				key: "period",
+				value: `${formatUsageTimestamp(result.period.start)} to ${formatUsageTimestamp(result.period.end)}`
+			},
+			{
+				key: "operations",
+				value: `${result.metrics.operations.used} ${result.metrics.operations.unit}`
+			},
+			{
+				key: "storage",
+				value: `${result.metrics.storage.used} ${result.metrics.storage.unit}`
+			},
+			{
+				key: "generated",
+				value: formatUsageTimestamp(result.generatedAt),
+				tone: "dim"
+			}
+		]
+	}, context.ui);
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseUsage(result) {
+	return stripVerboseContext(result);
+}
+function renderDatabaseBackupList(context, descriptor, result) {
+	const ui = context.ui;
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing platform-created database backups.")}`, ""];
+	const rail = ui.dim("│");
+	lines.push(`${rail}  ${ui.accent("database:")}  ${result.database.name}`);
+	if (result.retentionDays !== null) lines.push(`${rail}  ${ui.accent("retention:")} ${result.retentionDays} days`);
+	lines.push(rail);
+	if (result.backups.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No backups found.")}`);
+		lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+		return lines;
+	}
+	const rows = result.backups.map((backup) => [
+		backup.id,
+		backup.backupType,
+		backup.status,
+		formatBackupSize(backup.size),
+		backup.createdAt
+	]);
+	const widths = [
+		Math.max(2, ...rows.map((row) => row[0].length)),
+		Math.max(4, ...rows.map((row) => row[1].length)),
+		Math.max(6, ...rows.map((row) => row[2].length)),
+		Math.max(4, ...rows.map((row) => row[3].length)),
+		Math.max(7, ...rows.map((row) => row[4].length))
+	];
+	lines.push(`${rail}  ${ui.accent(formatColumns([
+		"Id",
+		"Type",
+		"Status",
+		"Size",
+		"Created"
+	], widths))}`);
+	for (const row of rows) lines.push(`${rail}  ${formatColumns(row, widths)}`);
+	if (result.hasMore) {
+		lines.push(rail);
+		lines.push(`${rail}  ${ui.dim("More backups exist; raise --limit to see them.")}`);
+	}
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseBackupList(result) {
+	return {
+		...serializeList({
+			context: {
+				project: result.projectName,
+				database: result.database.name
+			},
+			items: result.backups.map((backup) => ({
+				noun: "backup",
+				label: backup.id,
+				id: backup.id,
+				status: null
+			}))
+		}),
+		projectId: result.projectId,
+		database: result.database,
+		backups: result.backups,
+		retentionDays: result.retentionDays,
+		hasMore: result.hasMore
+	};
+}
+function renderDatabaseRestore(context, descriptor, result) {
+	const lines = renderMutate({
+		title: "Restoring database from backup.",
+		descriptor,
+		context: [
+			{
+				key: "project",
+				value: result.projectName
+			},
+			{
+				key: "database",
+				value: result.database.name
+			},
+			{
+				key: "id",
+				value: result.database.id,
+				tone: "dim"
+			},
+			{
+				key: "backup",
+				value: result.source.backupId
+			},
+			...result.source.databaseId !== result.database.id ? [{
+				key: "source",
+				value: result.source.databaseId
+			}] : []
+		],
+		operationDescription: "Restoring database",
+		operationCount: 1,
+		details: [`The restore is running; the database status is "${result.database.status ?? "recovering"}" until it completes.`, "Connections and credentials are preserved."]
+	}, context.ui);
+	lines.push(...renderResolvedProjectContextBlock(context.ui, result.verboseContext));
+	return lines;
+}
+function serializeDatabaseRestore(result) {
+	return stripVerboseContext(result);
+}
+function renderDatabaseConnectionRotateStdout(_context, _descriptor, result) {
+	return [result.connectionString];
+}
+function renderDatabaseConnectionRotate(context, _descriptor, result) {
+	const ui = context.ui;
+	const lines = [
+		"Rotating connection...",
+		renderSummaryLine(ui, "success", `Rotated credentials for ${result.database ? `"${result.database.name}"` : `connection ${result.connection.id}`}. The previous credentials no longer work.`),
+		"  The connection URL below is shown once, so save it now."
+	];
+	if (ui.verbose) {
+		lines.push("");
+		lines.push(...renderDatabaseConnectionRotateVerboseRows(context, result));
+	}
+	return lines;
+}
+function serializeDatabaseConnectionRotate(result) {
+	return result;
+}
+function renderDatabaseConnectionRotateVerboseRows(context, result) {
+	return renderMetadataRows([...result.database ? [["database", formatResourceWithId(context, result.database.name, result.database.id)]] : [], ["connection", formatResourceWithId(context, result.connection.name, result.connection.id)]]);
+}
+function formatBackupSize(size) {
+	if (size === null) return "unknown";
+	if (size < 1024) return `${size} B`;
+	if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)} KiB`;
+	if (size < 1024 * 1024 * 1024) return `${(size / (1024 * 1024)).toFixed(1)} MiB`;
+	return `${(size / (1024 * 1024 * 1024)).toFixed(1)} GiB`;
+}
+function formatUsageTimestamp(value) {
+	return value || "unknown";
+}
 function formatStatus(database) {
 	return database.status ?? (database.isDefault ? "default" : "unknown");
 }
@@ -271,4 +445,4 @@ function renderMetadataRows(rows) {
 	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 };
+export { renderDatabaseBackupList, renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseConnectionRotate, renderDatabaseConnectionRotateStdout, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseRestore, renderDatabaseShow, renderDatabaseUsage, serializeDatabaseBackupList, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseConnectionRotate, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseRestore, serializeDatabaseShow, serializeDatabaseUsage };

package/dist/shell/command-meta.js

@@ -339,6 +339,26 @@ const DESCRIPTORS = [
 		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.usage",
+		path: [
+			"prisma",
+			"database",
+			"usage"
+		],
+		description: "Show usage metrics for a database",
+		examples: ["prisma-cli database usage db_123", "prisma-cli database usage acme-production --from 2026-06-01 --to 2026-06-30"]
+	},
+	{
+		id: "database.restore",
+		path: [
+			"prisma",
+			"database",
+			"restore"
+		],
+		description: "Restore a database from a backup after exact id confirmation",
+		examples: ["prisma-cli database restore db_123 --backup bkp_456 --confirm db_123"]
+	},
 	{
 		id: "database.remove",
 		path: [
@@ -349,6 +369,27 @@ const DESCRIPTORS = [
 		description: "Remove a database after exact id confirmation",
 		examples: ["prisma-cli database remove db_123 --confirm db_123"]
 	},
+	{
+		id: "database.backup",
+		path: [
+			"prisma",
+			"database",
+			"backup"
+		],
+		description: "Inspect platform-created database backups",
+		examples: ["prisma-cli database backup list db_123"]
+	},
+	{
+		id: "database.backup.list",
+		path: [
+			"prisma",
+			"database",
+			"backup",
+			"list"
+		],
+		description: "List backups for a database",
+		examples: ["prisma-cli database backup list db_123", "prisma-cli database backup list acme-production --limit 50"]
+	},
 	{
 		id: "database.connection",
 		path: [
@@ -385,6 +426,17 @@ const DESCRIPTORS = [
 		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.rotate",
+		path: [
+			"prisma",
+			"database",
+			"connection",
+			"rotate"
+		],
+		description: "Rotate connection credentials and print the new one-time connection URL",
+		examples: ["prisma-cli database connection rotate conn_123 --confirm conn_123"]
+	},
 	{
 		id: "database.connection.remove",
 		path: [

package/package.json

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