@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/lib/database/provider.js

@@ -0,0 +1,378 @@
+import { formatPrismaCliCommand } from "../../shell/cli-command.js";
+import { CliError } from "../../shell/errors.js";
+//#region src/lib/database/provider.ts
+const SUBSCRIPTION_LOOKUP_TIMEOUT_MS = 3e3;
+function createManagementDatabaseProvider(client, options) {
+	const formatCommand = options?.formatCommand ?? ((args) => formatPrismaCliCommand(args));
+	const toDatabaseApiError = (summary, response, error, signal) => databaseApiError({
+		client,
+		workspaceId: options?.workspaceId,
+		summary,
+		response,
+		error,
+		signal
+	});
+	return {
+		async listDatabases(options) {
+			const databases = [];
+			let cursor;
+			while (true) {
+				const result = await client.GET("/v1/databases", {
+					params: { query: {
+						projectId: options.projectId,
+						branchGitName: options.branchName,
+						cursor
+					} },
+					signal: options.signal
+				});
+				if (result.error || !result.data) throw await toDatabaseApiError("Failed to list databases", result.response, result.error, options.signal);
+				databases.push(...result.data.data);
+				if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+				cursor = result.data.pagination.nextCursor;
+			}
+			return databases.map((database) => normalizeDatabase(database, options.projectId));
+		},
+		async showDatabase(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.response?.status === 404 && !isPlanLimitApiError(result.error)) return null;
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to show database", result.response, result.error, options?.signal);
+			const database = result.data.data;
+			return normalizeDatabase(database, requireDatabaseProjectId(database, options?.projectId));
+		},
+		async createDatabase(options) {
+			const result = await client.POST("/v1/databases", {
+				body: {
+					projectId: options.projectId,
+					name: options.name,
+					source: { type: "empty" },
+					...options.branchName ? { branchGitName: options.branchName } : {},
+					...options.region ? { region: options.region } : {}
+				},
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to create database", result.response, result.error, options.signal);
+			return normalizeCreatedDatabase(result.data.data, options.projectId);
+		},
+		async removeDatabase(databaseId, options) {
+			const result = await client.DELETE("/v1/databases/{databaseId}", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.error) throw await toDatabaseApiError("Failed to remove database", result.response, result.error, options?.signal);
+		},
+		async listConnections(databaseId, options) {
+			const result = await client.GET("/v1/databases/{databaseId}/connections", {
+				params: { path: { databaseId } },
+				signal: options?.signal
+			});
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to list database connections", result.response, result.error, options?.signal);
+			return result.data.data.map((connection) => normalizeConnection(connection, databaseId));
+		},
+		async createConnection(options) {
+			const result = await client.POST("/v1/databases/{databaseId}/connections", {
+				params: { path: { databaseId: options.databaseId } },
+				body: { name: options.name },
+				signal: options.signal
+			});
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to create database connection", result.response, result.error, options.signal);
+			return normalizeCreatedConnection(result.data.data, options.databaseId);
+		},
+		async removeConnection(connectionId, options) {
+			const result = await client.DELETE("/v1/connections/{id}", {
+				params: { path: { id: connectionId } },
+				signal: options?.signal
+			});
+			if (result.error) throw await toDatabaseApiError("Failed to remove database connection", result.response, result.error, options?.signal);
+		},
+		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 await toDatabaseApiError("Failed to fetch database usage", result.response, result.error, options?.signal);
+			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 && !isPlanLimitApiError(result.error)) throw backupsUnsupportedError(databaseId, result.error);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to list database backups", result.response, result.error, options?.signal);
+			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 && !isPlanLimitApiError(result.error)) throw restoreConflictError(options.targetDatabaseId, result.error, formatCommand);
+			if (result.response?.status === 404 && !isPlanLimitApiError(result.error)) throw restoreBackupNotFoundError(options, result.error, formatCommand);
+			if (result.error || !result.data) throw await toDatabaseApiError("Failed to restore database", result.response, result.error, options.signal);
+			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 await toDatabaseApiError("Failed to rotate database connection", result.response, result.error, options?.signal);
+			return normalizeRotatedConnection(result.data.data);
+		}
+	};
+}
+function normalizeDatabase(database, fallbackProjectId) {
+	return {
+		id: database.id,
+		name: database.name,
+		projectId: database.projectId ?? fallbackProjectId,
+		branchId: database.branchId ?? database.branch?.id ?? null,
+		branchName: database.branchGitName ?? database.branchName ?? database.branch?.gitName ?? database.branch?.name ?? null,
+		region: normalizeRegion(database),
+		status: database.status ?? null,
+		isDefault: database.isDefault ?? null,
+		createdAt: database.createdAt ?? null
+	};
+}
+function normalizeConnection(connection, fallbackDatabaseId) {
+	return {
+		id: connection.id,
+		name: connection.name ?? connection.id,
+		databaseId: connection.databaseId ?? fallbackDatabaseId,
+		createdAt: connection.createdAt ?? null
+	};
+}
+function normalizeCreatedDatabase(database, fallbackProjectId) {
+	const rawConnection = database.connections?.[0];
+	if (!rawConnection) throw new CliError({
+		code: "DATABASE_CONNECTION_MISSING",
+		domain: "database",
+		summary: "Created database did not return a connection string",
+		why: "The Management API created the database but did not include the one-time connection payload.",
+		fix: "Create a connection explicitly with prisma-cli database connection create <database>.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli database connection create ${database.id}`]
+	});
+	return {
+		database: normalizeDatabase(database, fallbackProjectId),
+		...normalizeCreatedConnection(rawConnection, database.id)
+	};
+}
+function normalizeCreatedConnection(connection, fallbackDatabaseId) {
+	const connectionString = extractConnectionString(connection);
+	if (!connectionString) throw new CliError({
+		code: "DATABASE_CONNECTION_STRING_MISSING",
+		domain: "database",
+		summary: "Created connection did not return a connection string",
+		why: "Database connection strings are one-time-view secrets, but the Management API did not include one in this create response.",
+		fix: "Create another database connection and store the returned URL immediately.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli database connection create ${fallbackDatabaseId}`]
+	});
+	return {
+		connection: normalizeConnection(connection, fallbackDatabaseId),
+		connectionString
+	};
+}
+function normalizeRegion(database) {
+	if (typeof database.region === "string") return database.region;
+	return database.region?.id ?? database.regionId ?? null;
+}
+function requireDatabaseProjectId(database, fallbackProjectId) {
+	const projectId = database.projectId ?? fallbackProjectId;
+	if (projectId) return projectId;
+	throw new CliError({
+		code: "DATABASE_API_ERROR",
+		domain: "database",
+		summary: "Database response did not include a project id",
+		why: "The Management API returned database metadata without project context.",
+		fix: "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+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
+		])]
+	});
+}
+async function databaseApiError(options) {
+	if (isPlanLimitApiError(options.error)) {
+		const subscription = options.workspaceId ? await readWorkspaceSubscription(options.client, options.workspaceId, options.signal) : null;
+		const workspaceLine = options.workspaceId ? `Workspace: ${options.workspaceId}` : "Workspace: unavailable";
+		const planName = subscription?.planName || null;
+		const usageBlocked = subscription?.usageBlocked ?? null;
+		const upgradeUrl = subscription?.upgradeUrl || null;
+		const recoveryLines = [...planName ? [`Current plan: ${planName}`] : [], upgradeUrl ? `Upgrade: ${upgradeUrl}` : "Upgrade: Open Prisma Console and upgrade the affected workspace plan."];
+		return new CliError({
+			code: "PLAN_LIMIT_REACHED",
+			domain: "database",
+			summary: "Workspace plan limit reached",
+			why: "Database operations are blocked because this workspace has used the operations included in its plan. This is a workspace plan limit, not a Prisma outage.",
+			fix: upgradeUrl ? `Upgrade the workspace plan at ${upgradeUrl}.` : "Open Prisma Console and upgrade the affected workspace plan.",
+			meta: {
+				workspaceId: options.workspaceId ?? null,
+				blockedFeature: null,
+				planName,
+				usageBlocked,
+				upgradeUrl
+			},
+			exitCode: 1,
+			nextSteps: [],
+			humanLines: [
+				"Workspace plan limit reached [PLAN_LIMIT_REACHED]",
+				"",
+				"Database operations are blocked because this workspace has used the operations included in its plan. This is a workspace plan limit, not a Prisma outage.",
+				"",
+				workspaceLine,
+				...recoveryLines
+			]
+		});
+	}
+	const status = options.response?.status ?? 0;
+	return new CliError({
+		code: options.error?.error?.code ?? "DATABASE_API_ERROR",
+		domain: "database",
+		summary: options.summary,
+		why: options.error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: options.error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function isPlanLimitApiError(error) {
+	return error?.error?.code === "planLimitReached";
+}
+async function readWorkspaceSubscription(client, workspaceId, signal) {
+	signal?.throwIfAborted();
+	const timeoutController = new AbortController();
+	const timeout = setTimeout(() => timeoutController.abort(), SUBSCRIPTION_LOOKUP_TIMEOUT_MS);
+	const requestSignal = signal ? AbortSignal.any([signal, timeoutController.signal]) : timeoutController.signal;
+	try {
+		const result = await client.GET("/v1/workspaces/{id}/subscription", {
+			params: { path: { id: workspaceId } },
+			signal: requestSignal
+		});
+		signal?.throwIfAborted();
+		if (result.error) return null;
+		return result.data?.data ?? null;
+	} catch {
+		signal?.throwIfAborted();
+		return null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+export { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase };

package/dist/lib/diagnostics.js

@@ -0,0 +1,15 @@
+import { resolveLocalStateFilePath } from "../adapters/local-state.js";
+import { resolveStateDir } from "../shell/runtime.js";
+import { readLocalGitState } from "./git/local-status.js";
+//#region src/lib/diagnostics.ts
+async function collectCommandDiagnostics(context, options = {}) {
+	const stateDir = await resolveStateDir(context.runtime);
+	return {
+		cwd: context.runtime.cwd,
+		stateFilePath: resolveLocalStateFilePath(stateDir),
+		git: await readLocalGitState(context.runtime.cwd, context.runtime.signal),
+		durationMs: options.durationMs
+	};
+}
+//#endregion
+export { collectCommandDiagnostics };

package/dist/lib/fs/home-path.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+//#region src/lib/fs/home-path.ts
+/**
+* Shortens a path under the user's home directory to `~/...` for display,
+* posix-style on every platform. Falls back to the Windows home variables
+* when `HOME` is unset (native cmd/PowerShell sessions).
+*/
+function shortenHomePath(value, env) {
+	const resolved = path.resolve(value);
+	const home = resolveHomeDirectory(env);
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved).split(path.sep).join("/");
+		return relative ? `~/${relative}` : "~";
+	}
+	return resolved;
+}
+function resolveHomeDirectory(env) {
+	if (env.HOME) return path.resolve(env.HOME);
+	if (env.USERPROFILE) return path.resolve(env.USERPROFILE);
+	if (env.HOMEDRIVE && env.HOMEPATH) return path.resolve(`${env.HOMEDRIVE}${env.HOMEPATH}`);
+	return null;
+}
+//#endregion
+export { shortenHomePath };

package/dist/lib/git/local-branch.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { access, readFile } from "node:fs/promises";
+//#region src/lib/git/local-branch.ts
+/**
+* Resolves the checked-out branch the way git does: the nearest `.git`
+* (directory or worktree file) from `cwd` upward owns the answer, so
+* monorepo commands run from inside a package see the repository branch.
+* Returns null for detached HEAD or when no repository contains `cwd`.
+*/
+async function readLocalGitBranch(cwd, signal) {
+	for (let directory = path.resolve(cwd);;) {
+		const headPath = await resolveGitHeadPath(path.join(directory, ".git"), signal);
+		if (headPath) return readBranchFromHead(headPath, signal);
+		const parent = path.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+async function readBranchFromHead(headPath, signal) {
+	try {
+		const head = (await readFile(headPath, {
+			encoding: "utf8",
+			signal
+		})).trim();
+		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	return null;
+}
+async function resolveGitHeadPath(gitPath, signal) {
+	signal.throwIfAborted();
+	try {
+		const raw = await readFile(gitPath, {
+			encoding: "utf8",
+			signal
+		});
+		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	signal.throwIfAborted();
+	try {
+		await access(path.join(gitPath, "HEAD"));
+		signal.throwIfAborted();
+		return path.join(gitPath, "HEAD");
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return null;
+	}
+}
+//#endregion
+export { readLocalGitBranch };

package/dist/lib/git/local-status.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+//#region src/lib/git/local-status.ts
+async function readLocalGitState(cwd, signal) {
+	signal.throwIfAborted();
+	if ((await runGit(cwd, ["rev-parse", "--is-inside-work-tree"], signal))?.trim() !== "true") return null;
+	const [ref, sha, status] = await Promise.all([
+		runGit(cwd, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"HEAD"
+		], signal),
+		runGit(cwd, [
+			"rev-parse",
+			"--short",
+			"HEAD"
+		], signal),
+		runGit(cwd, ["status", "--porcelain"], signal)
+	]);
+	return {
+		ref: cleanGitValue(ref),
+		sha: cleanGitValue(sha),
+		dirty: status === null ? null : status.trim().length > 0
+	};
+}
+function runGit(cwd, args, signal) {
+	return new Promise((resolve, reject) => {
+		signal.throwIfAborted();
+		execFile("git", args, {
+			cwd,
+			signal,
+			timeout: 2e3
+		}, (error, stdout) => {
+			if (signal.aborted) {
+				reject(error);
+				return;
+			}
+			if (error) {
+				resolve(null);
+				return;
+			}
+			resolve(stdout);
+		}).on("error", (error) => {
+			if (signal.aborted) {
+				reject(error);
+				return;
+			}
+			resolve(null);
+		});
+	});
+}
+function cleanGitValue(value) {
+	const cleaned = value?.trim();
+	return cleaned ? cleaned : null;
+}
+//#endregion
+export { readLocalGitState };

package/dist/lib/project/interactive-setup.js

@@ -12,6 +12,10 @@ async function promptForProjectSetupChoice(options) {
 		output: options.context.runtime.stderr,
 		message: "Which Project should this directory use?",
 		choices: [
+			{
+				label: "+ Create a new Project",
+				value: { kind: "create" }
+			},
 			...sortedProjects.map((project) => ({
 				label: duplicateNames.has(project.name) ? `${project.name} (${project.id})` : project.name,
 				value: {
@@ -19,10 +23,6 @@ async function promptForProjectSetupChoice(options) {
 					project
 				}
 			})),
-			{
-				label: "Create a new Project",
-				value: { kind: "create" }
-			},
 			{
 				label: "Cancel",
 				value: { kind: "cancel" }
@@ -40,6 +40,7 @@ async function promptForProjectSetupChoice(options) {
 	const rawName = await textPrompt({
 		input: options.context.runtime.stdin,
 		output: options.context.runtime.stderr,
+		signal: options.context.runtime.signal,
 		message: "Project name",
 		placeholder: suggestedName.name,
 		validate: (value) => validateProjectSetupNameText(value, suggestedName.name)