@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/controllers/database.js

@@ -1,14 +1,12 @@
-import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { resolvePrismaCliPackageCommandFormatterSync } from "../lib/agent/cli-command.js";
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../errors.js";
+import { authenticatedManagementApiClient } from "../auth/guard.js";
 import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
-import { requireComputeAuth } from "../lib/auth/guard.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
-import { listFixtureWorkspaceProjects, listRealWorkspaceProjects } from "./project.js";
-import { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase } from "../lib/database/provider.js";
+import { listRealWorkspaceProjects } from "./project.js";
+import { createManagementDatabaseProvider } 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({
@@ -149,83 +147,228 @@ 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();
-	if (isRealMode(context)) {
-		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
-		if (!client) throw authRequiredError();
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	{
 		const targetResult = await resolveProjectTarget({
 			context,
 			workspace,
 			explicitProject: flags.projectRef,
-			listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+			listProjects: () => listRealWorkspaceProjects(client, context.runtime.signal),
 			commandName
 		});
 		if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
 		return {
-			provider: createManagementDatabaseProvider(client),
+			provider: createManagementDatabaseProvider(client, {
+				formatCommand: resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd),
+				workspaceId: workspace.id
+			}),
 			target: targetResult.value
 		};
 	}
-	const targetResult = await resolveProjectTarget({
-		context,
-		workspace,
-		explicitProject: flags.projectRef,
-		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
-		commandName
-	});
-	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
-	return {
-		provider: createFixtureDatabaseProvider(context),
-		target: targetResult.value
-	};
 }
 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);
-		}
-	};
+	const authState = await requireAuthenticatedAuthState(context);
+	const client = await authenticatedManagementApiClient(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError();
+	return createManagementDatabaseProvider(client, {
+		formatCommand: resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd),
+		workspaceId: authState.workspace?.id
+	});
 }
 async function resolveDatabase(provider, target, databaseRef, branchName, signal) {
 	const ref = databaseRef.trim();
@@ -238,10 +381,23 @@ async function resolveDatabase(provider, target, databaseRef, branchName, signal
 	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, {
+	const shown = await provider.showDatabase(selected.id, {
 		projectId: target.project.id,
 		signal
-	}) ?? selected, target.project.id);
+	});
+	if (shown === null) throw databaseRemovedDuringResolutionError(selected, target.project.name);
+	return ensureProjectId(shown, target.project.id);
+}
+function databaseRemovedDuringResolutionError(database, projectName) {
+	return new CliError({
+		code: "DATABASE_NOT_FOUND",
+		domain: "database",
+		summary: "Database not found",
+		why: `"${database.name}" (${database.id}) was listed for project "${projectName}", but reading it returned 404. It was most likely removed while this command was running.`,
+		fix: "Re-run the command, or list the project's databases to see what is there now.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database list"]
+	});
 }
 function ensureProjectId(database, projectId) {
 	return database.projectId ? database : {
@@ -262,11 +418,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,16 +459,5 @@ function databaseAmbiguousError(databaseRef, matches, 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 };
+export { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage };

package/dist/controllers/feedback.js

@@ -0,0 +1,90 @@
+import { CliError, usageError } from "../errors.js";
+import { FEEDBACK_TIMEOUT_MS, unreachableDetail, unreadableBodyDetail } from "../lib/feedback.js";
+import { getCliVersion } from "../lib/version.js";
+//#region src/controllers/feedback.ts
+const DEFAULT_FEEDBACK_ENDPOINT = "https://hiieirp2pwqnjvq9axzyg6d0.fra.prisma.build/feedback";
+const MAX_MESSAGE_LENGTH = 4e3;
+const MAX_EMAIL_LENGTH = 320;
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+async function runFeedback(context, messageArg, flags) {
+	const message = messageArg.trim();
+	if (!message) throw usageError("Feedback message required", "The message argument is empty.", "Pass a non-empty message.", ["prisma-cli feedback \"the deploy flow is great\""]);
+	if (message.length > MAX_MESSAGE_LENGTH) throw usageError("Feedback message too long", `The message is ${message.length} characters; the limit is ${MAX_MESSAGE_LENGTH}.`, "Shorten the message.");
+	const email = flags.email?.trim();
+	if (email !== void 0 && (email.length > MAX_EMAIL_LENGTH || !EMAIL_PATTERN.test(email))) throw usageError("Invalid email", `"${flags.email}" is not a valid email address of at most ${MAX_EMAIL_LENGTH} characters.`, "Pass a valid address with --email, or drop the flag to stay anonymous.", ["prisma-cli feedback \"please add X\" --email you@example.com"]);
+	const feedbackContext = {
+		cliVersion: getCliVersion(),
+		nodeVersion: process.version,
+		platform: process.platform,
+		arch: process.arch
+	};
+	return {
+		command: "feedback",
+		result: {
+			id: await postFeedback(context, context.runtime.env.PRISMA_CLI_FEEDBACK_URL || DEFAULT_FEEDBACK_ENDPOINT, {
+				message,
+				...email ? { email } : {},
+				meta: { ...feedbackContext }
+			}),
+			email: email ?? null,
+			context: feedbackContext
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function postFeedback(context, endpoint, body) {
+	const response = await sendFeedback(context, endpoint, body);
+	if (!response.ok) throw feedbackSendFailed(`The feedback service responded with HTTP ${response.status}${await readServiceError(context, response)}.`);
+	return readSubmissionId(context, response);
+}
+async function sendFeedback(context, endpoint, body) {
+	try {
+		return await fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				"user-agent": `prisma-cli/${getCliVersion()}`
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.any([context.runtime.signal, AbortSignal.timeout(FEEDBACK_TIMEOUT_MS)])
+		});
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		throw feedbackSendFailed(unreachableDetail(error));
+	}
+}
+async function readSubmissionId(context, response) {
+	let payload;
+	try {
+		payload = await response.json();
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		if (!(error instanceof SyntaxError)) throw feedbackSendFailed(unreadableBodyDetail(error));
+		payload = null;
+	}
+	return typeof payload?.id === "string" ? payload.id : null;
+}
+async function readServiceError(context, response) {
+	let payload;
+	try {
+		payload = await response.json();
+	} catch (error) {
+		if (context.runtime.signal.aborted) throw error;
+		return "";
+	}
+	return typeof payload?.error?.message === "string" ? ` (${payload.error.message})` : "";
+}
+function feedbackSendFailed(detail) {
+	return new CliError({
+		code: "FEEDBACK_SEND_FAILED",
+		domain: "cli",
+		summary: "Feedback could not be delivered",
+		why: detail,
+		fix: "Check your network and rerun the command.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+//#endregion
+export { runFeedback };