@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.10

package/dist/controllers/database.js

@@ -1,463 +0,0 @@
-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 { requireAuthenticatedAuthState } from "./auth.js";
-import { listRealWorkspaceProjects } from "./project.js";
-import { createManagementDatabaseProvider } from "../lib/database/provider.js";
-import { randomBytes } from "node:crypto";
-//#region src/controllers/database.ts
-async function runDatabaseList(context, flags) {
-	const { provider, target } = await requireDatabaseContext(context, flags, "database list");
-	const databases = sortDatabases(await provider.listDatabases({
-		projectId: target.project.id,
-		branchName: flags.branchName,
-		signal: context.runtime.signal
-	}));
-	return {
-		command: "database.list",
-		result: {
-			projectId: target.project.id,
-			projectName: target.project.name,
-			branchName: flags.branchName ?? null,
-			verboseContext: target,
-			databases
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runDatabaseShow(context, databaseRef, flags) {
-	const { provider, target } = await requireDatabaseContext(context, flags, "database show");
-	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
-	const connections = await provider.listConnections(database.id, { signal: context.runtime.signal });
-	return {
-		command: "database.show",
-		result: {
-			projectId: target.project.id,
-			projectName: target.project.name,
-			verboseContext: target,
-			database,
-			connections
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runDatabaseCreate(context, name, flags) {
-	const databaseName = name.trim();
-	if (!databaseName) throw usageError("Database name required", "Database create needs a non-empty name.", "Pass a database name.", ["prisma-cli database create <name>"], "database");
-	const { provider, target } = await requireDatabaseContext(context, flags, "database create");
-	const created = await provider.createDatabase({
-		projectId: target.project.id,
-		name: databaseName,
-		branchName: flags.branchName,
-		region: flags.region,
-		signal: context.runtime.signal
-	});
-	return {
-		command: "database.create",
-		result: {
-			projectId: target.project.id,
-			projectName: target.project.name,
-			verboseContext: target,
-			database: ensureProjectId(created.database, target.project.id),
-			connection: created.connection,
-			connectionString: created.connectionString
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runDatabaseRemove(context, databaseRef, flags) {
-	const { provider, target } = await requireDatabaseContext(context, flags, "database remove");
-	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
-	requireExactConfirmation({
-		resourceName: "database",
-		commandName: "database remove",
-		id: database.id,
-		confirm: flags.confirm
-	});
-	await provider.removeDatabase(database.id, { signal: context.runtime.signal });
-	return {
-		command: "database.remove",
-		result: {
-			projectId: target.project.id,
-			projectName: target.project.name,
-			verboseContext: target,
-			database
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runDatabaseConnectionList(context, databaseRef, flags) {
-	const { provider, target } = await requireDatabaseContext(context, flags, "database connection list");
-	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
-	const connections = await provider.listConnections(database.id, { signal: context.runtime.signal });
-	return {
-		command: "database.connection.list",
-		result: {
-			projectId: target.project.id,
-			projectName: target.project.name,
-			verboseContext: target,
-			database,
-			connections
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runDatabaseConnectionCreate(context, databaseRef, flags) {
-	const { provider, target } = await requireDatabaseContext(context, flags, "database connection create");
-	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
-	const created = await provider.createConnection({
-		databaseId: database.id,
-		name: flags.name?.trim() || defaultConnectionName(),
-		signal: context.runtime.signal
-	});
-	return {
-		command: "database.connection.create",
-		result: {
-			projectId: target.project.id,
-			projectName: target.project.name,
-			verboseContext: target,
-			database,
-			connection: created.connection,
-			connectionString: created.connectionString
-		},
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function runDatabaseConnectionRemove(context, connectionRef, flags) {
-	const connectionId = connectionRef.trim();
-	if (!connectionId) throw usageError("Connection id required", "Database connection removal needs a connection id.", "Pass the connection id to remove.", ["prisma-cli database connection remove <connection-id> --confirm <connection-id>"], "database");
-	requireExactConfirmation({
-		resourceName: "database connection",
-		commandName: "database connection remove",
-		id: connectionId,
-		confirm: flags.confirm
-	});
-	await (await requireDatabaseProviderOnly(context)).removeConnection(connectionId, { signal: context.runtime.signal });
-	return {
-		command: "database.connection.remove",
-		result: { connection: { id: connectionId } },
-		warnings: [],
-		nextSteps: []
-	};
-}
-async function 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();
-	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, context.runtime.signal),
-			commandName
-		});
-		if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
-		return {
-			provider: createManagementDatabaseProvider(client, {
-				formatCommand: resolvePrismaCliPackageCommandFormatterSync(context.runtime.cwd),
-				workspaceId: workspace.id
-			}),
-			target: targetResult.value
-		};
-	}
-}
-async function requireDatabaseProviderOnly(context) {
-	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();
-	if (!ref) throw usageError("Database id or name required", "This command needs a database id or name.", "Pass a database id or name.", ["prisma-cli database list"], "database");
-	const matches = (await provider.listDatabases({
-		projectId: target.project.id,
-		branchName,
-		signal
-	})).filter((database) => database.id === ref || database.name === ref);
-	if (matches.length === 0) throw databaseNotFoundError(ref, target.project.name, branchName);
-	if (matches.length > 1) throw databaseAmbiguousError(ref, matches, branchName);
-	const selected = matches[0];
-	const shown = await provider.showDatabase(selected.id, {
-		projectId: target.project.id,
-		signal
-	});
-	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 : {
-		...database,
-		projectId
-	};
-}
-function sortDatabases(databases) {
-	return databases.slice().sort((left, right) => {
-		const branchOrder = (left.branchName ?? "").localeCompare(right.branchName ?? "");
-		if (branchOrder !== 0) return branchOrder;
-		const nameOrder = left.name.localeCompare(right.name);
-		return nameOrder !== 0 ? nameOrder : left.id.localeCompare(right.id);
-	});
-}
-function requireExactConfirmation(options) {
-	if (options.confirm === options.id) return;
-	throw new CliError({
-		code: "CONFIRMATION_REQUIRED",
-		domain: "database",
-		summary: 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: [options.nextStep ?? `prisma-cli ${options.commandName} ${options.id} --confirm ${options.id}`],
-		meta: {
-			expectedConfirm: options.id,
-			receivedConfirm: options.confirm ?? null
-		}
-	});
-}
-function defaultConnectionName() {
-	return `cli-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 17)}-${randomBytes(2).toString("hex")}`;
-}
-function databaseNotFoundError(databaseRef, projectName, branchName) {
-	return new CliError({
-		code: "DATABASE_NOT_FOUND",
-		domain: "database",
-		summary: "Database not found",
-		why: `No database matched "${databaseRef}"${projectName ? ` in project "${projectName}"${branchName ? ` on branch "${branchName}"` : ""}` : ""}.`,
-		fix: "Pass a database id or name from prisma-cli database list.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli database list"]
-	});
-}
-function databaseAmbiguousError(databaseRef, matches, branchName) {
-	return new CliError({
-		code: "DATABASE_AMBIGUOUS",
-		domain: "database",
-		summary: "Database resolution is ambiguous",
-		why: branchName ? `Multiple databases matched "${databaseRef}" on branch "${branchName}".` : `Multiple databases matched "${databaseRef}".`,
-		fix: "Pass the database id, or pass --branch <git-name> to narrow the match.",
-		exitCode: 1,
-		nextSteps: ["prisma-cli database list"],
-		meta: { matches: matches.map((database) => ({
-			id: database.id,
-			name: database.name,
-			branchName: database.branchName
-		})) }
-	});
-}
-//#endregion
-export { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage };

package/dist/controllers/feedback.js

@@ -1,90 +0,0 @@
-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 };