@prisma/cli 3.0.0-beta.21 → 3.0.0-beta.23

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