@prisma/cli 3.0.0-dev.112.1 → 3.0.0-dev.115.1

package/dist/adapters/mock-api.js

@@ -32,6 +32,9 @@ var MockApi = class MockApi {
 		const workspaceIds = this.data.memberships.filter((membership) => membership.userId === userId).map((membership) => membership.workspaceId);
 		return this.data.workspaces.filter((workspace) => workspaceIds.includes(workspace.id));
 	}
+	listWorkspaces() {
+		return this.data.workspaces;
+	}
 	getWorkspace(workspaceId) {
 		return this.data.workspaces.find((workspace) => workspace.id === workspaceId);
 	}
@@ -47,6 +50,36 @@ var MockApi = class MockApi {
 	getProjectForWorkspace(workspaceId, projectId) {
 		return this.listProjectsForWorkspace(workspaceId).find((project) => project.id === projectId);
 	}
+	renameProject(projectId, name) {
+		const project = this.getProject(projectId);
+		if (!project) return;
+		project.name = name;
+		return project;
+	}
+	removeProject(projectId) {
+		const project = this.getProject(projectId);
+		if (!project) return { outcome: "not-found" };
+		if (this.data.deployments.some((deployment) => deployment.projectId === projectId)) return { outcome: "blocked" };
+		const removedDatabaseIds = new Set((this.data.databases ?? []).filter((database) => database.projectId === projectId).map((database) => database.id));
+		this.data.projects = this.data.projects.filter((candidate) => candidate.id !== projectId);
+		this.data.branches = this.data.branches.filter((branch) => branch.projectId !== projectId);
+		this.data.databases = (this.data.databases ?? []).filter((database) => database.projectId !== projectId);
+		this.data.databaseConnections = (this.data.databaseConnections ?? []).filter((connection) => !removedDatabaseIds.has(connection.databaseId));
+		return {
+			outcome: "removed",
+			project
+		};
+	}
+	transferProject(projectId, targetWorkspaceId) {
+		const project = this.getProject(projectId);
+		if (!project) return { outcome: "not-found" };
+		if (!this.getWorkspace(targetWorkspaceId)) return { outcome: "workspace-not-found" };
+		project.workspaceId = targetWorkspaceId;
+		return {
+			outcome: "transferred",
+			project
+		};
+	}
 	listBranchesForProject(projectId) {
 		return this.data.branches.filter((branch) => branch.projectId === projectId);
 	}
@@ -131,6 +164,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/adapters/token-storage.js

@@ -77,6 +77,7 @@ var FileTokenStorage = class {
 		this.signal?.throwIfAborted();
 		try {
 			const credentials = await this.readCredentialsFromDisk();
+			if (this.options.pinnedWorkspaceId) return findTokensForWorkspace(credentials, this.options.pinnedWorkspaceId);
 			const context = await this.readAuthContext();
 			if (context.state.activeWorkspaceId) return findTokensForWorkspace(credentials, context.state.activeWorkspaceId);
 			const latest = findLatestValidTokens(credentials);
@@ -138,6 +139,9 @@ var FileTokenStorage = class {
 		this.signal?.throwIfAborted();
 		const credentials = await this.readCredentialsFromDisk();
 		const context = await this.ensureMigratedAuthContext(credentials);
+		return this.workspacesFromState(credentials, context);
+	}
+	workspacesFromState(credentials, context) {
 		return credentials.map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null).map((tokens) => {
 			const cached = context.state.workspaces[tokens.workspaceId];
 			const id = typeof cached?.id === "string" && cached.id.trim().length > 0 ? cached.id.trim() : tokens.workspaceId;
@@ -159,6 +163,24 @@ var FileTokenStorage = class {
 	async useWorkspace(workspaceRef) {
 		return this.withRefreshLock(() => this.useWorkspaceUnlocked(workspaceRef));
 	}
+	/**
+	* Resolve a workspace ref (id, credential workspace id, or cached name)
+	* against the locally stored sessions without changing the active
+	* workspace. Read-only counterpart of useWorkspace: it reads the auth
+	* context as-is and never runs the legacy-state migration, so it writes
+	* nothing.
+	*/
+	async resolveWorkspace(workspaceRef) {
+		const ref = workspaceRef.trim();
+		if (!ref) throw new WorkspaceSelectionError("missing");
+		this.signal?.throwIfAborted();
+		const credentials = await this.readCredentialsFromDisk();
+		const context = await this.readAuthContext();
+		const matches = this.workspacesFromState(credentials, context).filter((workspace) => workspaceMatchesRef(workspace, ref));
+		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
+		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
+		return matches[0];
+	}
 	async useWorkspaceUnlocked(workspaceRef) {
 		const ref = workspaceRef.trim();
 		if (!ref) throw new WorkspaceSelectionError("missing");
@@ -327,6 +349,7 @@ var FileTokenStorage = class {
 		await this.writeAuthContext(context.state);
 	}
 	async maybeActivateWorkspaceId(workspaceId) {
+		if (this.options.pinnedWorkspaceId) return;
 		const context = await this.readAuthContext();
 		if (this.options.activateOnSetTokens === false && context.exists && context.state.activeWorkspaceId && context.state.activeWorkspaceId !== workspaceId) return;
 		context.state.activeWorkspaceId = workspaceId;

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/commands/project/index.js

@@ -2,10 +2,10 @@ 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 { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
-import { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } from "../../presenters/project.js";
+import { runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer } from "../../controllers/project.js";
+import { renderProjectList, renderProjectRemove, renderProjectRename, renderProjectSetup, renderProjectShow, renderProjectTransfer, serializeProjectList, serializeProjectRemove, serializeProjectRename, serializeProjectSetup, serializeProjectShow, serializeProjectTransfer } from "../../presenters/project.js";
 import { createEnvCommand } from "../env.js";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 //#region src/commands/project/index.ts
 function createProjectCommand(runtime) {
 	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
@@ -14,9 +14,57 @@ function createProjectCommand(runtime) {
 	project.addCommand(createProjectShowCommand(runtime));
 	project.addCommand(createProjectCreateCommand(runtime));
 	project.addCommand(createProjectLinkCommand(runtime));
+	project.addCommand(createProjectRenameCommand(runtime));
+	project.addCommand(createProjectRemoveCommand(runtime));
+	project.addCommand(createProjectTransferCommand(runtime));
 	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
+function createProjectRenameCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rename"), runtime), "project.rename");
+	command.argument("<name>", "New project name").addOption(new Option("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.rename", options, (context) => runProjectRename(context, name, { project: projectRef }), {
+			renderHuman: (context, descriptor, result) => renderProjectRename(context, descriptor, result),
+			renderJson: (result) => serializeProjectRename(result)
+		});
+	});
+	return command;
+}
+function createProjectRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "project.remove");
+	command.argument("<project>", "Project id or name").addOption(new Option("--confirm <project-id>", "Exact project id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "project.remove", options, (context) => runProjectRemove(context, projectRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderProjectRemove(context, descriptor, result),
+			renderJson: (result) => serializeProjectRemove(result)
+		});
+	});
+	return command;
+}
+function createProjectTransferCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("transfer"), runtime), "project.transfer");
+	command.argument("<project>", "Project id or name").addOption(new Option("--to-workspace <id-or-name>", "Locally authenticated workspace to receive the project")).addOption(new Option("--recipient-token <token>", "Access token for the receiving workspace")).addOption(new Option("--confirm <project-id>", "Exact project id required to transfer"));
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		const toWorkspace = options.toWorkspace;
+		const recipientToken = options.recipientToken;
+		const confirm = options.confirm;
+		await runCommand(runtime, "project.transfer", options, (context) => runProjectTransfer(context, projectRef, {
+			toWorkspace,
+			recipientToken,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderProjectTransfer(context, descriptor, result),
+			renderJson: (result) => serializeProjectTransfer(result)
+		});
+	});
+	return command;
+}
 function createProjectCreateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "project.create");
 	command.argument("<name>", "Project name");

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