@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.2-dev.49

package/dist/lib/database/provider.js

@@ -1,385 +0,0 @@
-import { formatPrismaCliCommand } from "../../cli-command.js";
-import { CliError } from "../../errors.js";
-import "../../shell/cli-command.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;
-}
-/** Absence is carried, not filled in. A `0` here reached the card, the
-*  stdout lane and the json record as though the API had measured it, and
-*  "you used nothing" is the answer a user acts on. The unit is the same
-*  problem an order of magnitude worse: `GiB` was a guess, and a value the
-*  API denominates in bytes would print against it unchanged. */
-function normalizeUsageMetric(metric) {
-	return {
-		used: metric?.used ?? null,
-		unit: metric?.unit ?? null
-	};
-}
-function normalizeUsage(usage) {
-	return {
-		period: {
-			start: usage.period?.start ?? null,
-			end: usage.period?.end ?? null
-		},
-		metrics: {
-			operations: normalizeUsageMetric(usage.metrics?.operations),
-			storage: normalizeUsageMetric(usage.metrics?.storage)
-		},
-		generatedAt: usage.generatedAt ?? null
-	};
-}
-function normalizeBackupList(body) {
-	return {
-		backups: (body.data ?? []).map((backup) => ({
-			id: backup.id,
-			backupType: backup.backupType ?? "",
-			status: backup.status ?? "",
-			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)) return planLimitReachedError(options);
-	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: []
-	});
-}
-async function planLimitReachedError(options) {
-	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
-		]
-	});
-}
-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 };

package/dist/lib/diagnostics.js

@@ -1,16 +0,0 @@
-import { resolveLocalStateFilePath } from "../adapters/local-state.js";
-import { resolveStateDir } from "../state-dir.js";
-import "../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/feedback.js

@@ -1,15 +0,0 @@
-//#region src/lib/feedback.ts
-const FEEDBACK_TIMEOUT_MS = 3e3;
-const TIMEOUT_DETAIL = `The feedback service did not answer within ${FEEDBACK_TIMEOUT_MS / 1e3} seconds.`;
-function isTimeout(error) {
-	return error instanceof Error && error.name === "TimeoutError";
-}
-function unreachableDetail(error) {
-	if (isTimeout(error)) return TIMEOUT_DETAIL;
-	return `The feedback service could not be reached${error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : ""}.`;
-}
-function unreadableBodyDetail(error) {
-	return isTimeout(error) ? TIMEOUT_DETAIL : "The feedback service response could not be read.";
-}
-//#endregion
-export { FEEDBACK_TIMEOUT_MS, unreachableDetail, unreadableBodyDetail };

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

@@ -1,24 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,57 +0,0 @@
-import { usageError } from "../../errors.js";
-import { selectPrompt, textPrompt } from "../../shell/prompt.js";
-import { inferTargetName, sortProjects } from "./resolution.js";
-import { toProjectSummary, validateProjectSetupNameText } from "./setup.js";
-//#region src/lib/project/interactive-setup.ts
-async function promptForProjectSetupChoice(options) {
-	const sortedProjects = sortProjects(options.projects);
-	const projectNames = sortedProjects.map((project) => project.name);
-	const duplicateNames = new Set(projectNames.filter((name, index) => projectNames.indexOf(name) !== index));
-	const choice = await selectPrompt({
-		input: options.context.runtime.stdin,
-		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: {
-					kind: "project",
-					project
-				}
-			})),
-			{
-				label: "Cancel",
-				value: { kind: "cancel" }
-			}
-		]
-	});
-	if (choice.kind === "cancel") throw usageError("Project setup canceled", options.cancel.why, options.cancel.fix, options.cancel.nextSteps, "project");
-	if (choice.kind === "project") return {
-		project: toProjectSummary(choice.project),
-		action: "linked",
-		targetName: choice.project.name,
-		targetNameSource: "prompt"
-	};
-	const suggestedName = await inferTargetName(options.context.runtime.cwd, options.context.runtime.signal);
-	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)
-	});
-	const projectName = rawName.trim() || suggestedName.name;
-	return {
-		project: toProjectSummary(await options.createProject(projectName)),
-		action: "created",
-		targetName: projectName,
-		targetNameSource: rawName.trim() ? "prompt" : suggestedName.source
-	};
-}
-//#endregion
-export { promptForProjectSetupChoice };