@prisma/cli 3.0.0-beta.20 → 3.0.0-beta.22

package/dist/adapters/mock-api.js

@@ -32,6 +32,9 @@ var MockApi = class MockApi {
 		const workspaceIds = this.data.memberships.filter((membership) => membership.userId === userId).map((membership) => membership.workspaceId);
 		return this.data.workspaces.filter((workspace) => workspaceIds.includes(workspace.id));
 	}
+	listWorkspaces() {
+		return this.data.workspaces;
+	}
 	getWorkspace(workspaceId) {
 		return this.data.workspaces.find((workspace) => workspace.id === workspaceId);
 	}
@@ -47,6 +50,36 @@ var MockApi = class MockApi {
 	getProjectForWorkspace(workspaceId, projectId) {
 		return this.listProjectsForWorkspace(workspaceId).find((project) => project.id === projectId);
 	}
+	renameProject(projectId, name) {
+		const project = this.getProject(projectId);
+		if (!project) return;
+		project.name = name;
+		return project;
+	}
+	removeProject(projectId) {
+		const project = this.getProject(projectId);
+		if (!project) return { outcome: "not-found" };
+		if (this.data.deployments.some((deployment) => deployment.projectId === projectId)) return { outcome: "blocked" };
+		const removedDatabaseIds = new Set((this.data.databases ?? []).filter((database) => database.projectId === projectId).map((database) => database.id));
+		this.data.projects = this.data.projects.filter((candidate) => candidate.id !== projectId);
+		this.data.branches = this.data.branches.filter((branch) => branch.projectId !== projectId);
+		this.data.databases = (this.data.databases ?? []).filter((database) => database.projectId !== projectId);
+		this.data.databaseConnections = (this.data.databaseConnections ?? []).filter((connection) => !removedDatabaseIds.has(connection.databaseId));
+		return {
+			outcome: "removed",
+			project
+		};
+	}
+	transferProject(projectId, targetWorkspaceId) {
+		const project = this.getProject(projectId);
+		if (!project) return { outcome: "not-found" };
+		if (!this.getWorkspace(targetWorkspaceId)) return { outcome: "workspace-not-found" };
+		project.workspaceId = targetWorkspaceId;
+		return {
+			outcome: "transferred",
+			project
+		};
+	}
 	listBranchesForProject(projectId) {
 		return this.data.branches.filter((branch) => branch.projectId === projectId);
 	}
@@ -131,6 +164,69 @@ var MockApi = class MockApi {
 		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
 		return connection;
 	}
+	getDatabaseUsage(databaseId, period) {
+		const defaults = (this.data.databaseUsage ?? []).find((record) => record.databaseId === databaseId) ?? {
+			databaseId,
+			period: {
+				start: "2026-06-01T00:00:00.000Z",
+				end: "2026-06-30T23:59:59.999Z"
+			},
+			metrics: {
+				operations: {
+					used: 0,
+					unit: "ops"
+				},
+				storage: {
+					used: 0,
+					unit: "GiB"
+				}
+			},
+			generatedAt: "2026-07-01T00:00:00.000Z"
+		};
+		return {
+			period: {
+				start: period?.from ?? defaults.period.start,
+				end: period?.to ?? defaults.period.end
+			},
+			metrics: defaults.metrics,
+			generatedAt: defaults.generatedAt
+		};
+	}
+	listDatabaseBackups(databaseId, limit) {
+		const backups = (this.data.databaseBackups ?? []).filter((backup) => backup.databaseId === databaseId);
+		const limited = limit === void 0 ? backups : backups.slice(0, limit);
+		return {
+			backups: limited.map((backup) => ({
+				id: backup.id,
+				backupType: backup.backupType,
+				status: backup.status,
+				size: backup.size ?? null,
+				createdAt: backup.createdAt
+			})),
+			retentionDays: this.data.databaseBackupRetentionDays ?? null,
+			hasMore: limited.length < backups.length
+		};
+	}
+	restoreDatabase(input) {
+		const target = this.getDatabase(input.targetDatabaseId);
+		if (!target) return { outcome: "target-not-found" };
+		if (!(this.data.databaseBackups ?? []).find((candidate) => candidate.id === input.backupId && candidate.databaseId === input.sourceDatabaseId)) return { outcome: "backup-not-found" };
+		target.status = "recovering";
+		return {
+			outcome: "restored",
+			database: target
+		};
+	}
+	rotateDatabaseConnection(connectionId) {
+		const connection = this.getDatabaseConnection(connectionId);
+		if (!connection) return;
+		const connectionString = `postgresql://rotated-${connection.databaseId}-${connection.id}.example.prisma.io/postgres`;
+		connection.connectionString = connectionString;
+		return {
+			connection,
+			connectionString
+		};
+	}
 };
 //#endregion
 export { MockApi };

package/dist/adapters/token-storage.js

@@ -77,6 +77,7 @@ var FileTokenStorage = class {
 		this.signal?.throwIfAborted();
 		try {
 			const credentials = await this.readCredentialsFromDisk();
+			if (this.options.pinnedWorkspaceId) return findTokensForWorkspace(credentials, this.options.pinnedWorkspaceId);
 			const context = await this.readAuthContext();
 			if (context.state.activeWorkspaceId) return findTokensForWorkspace(credentials, context.state.activeWorkspaceId);
 			const latest = findLatestValidTokens(credentials);
@@ -138,6 +139,9 @@ var FileTokenStorage = class {
 		this.signal?.throwIfAborted();
 		const credentials = await this.readCredentialsFromDisk();
 		const context = await this.ensureMigratedAuthContext(credentials);
+		return this.workspacesFromState(credentials, context);
+	}
+	workspacesFromState(credentials, context) {
 		return credentials.map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null).map((tokens) => {
 			const cached = context.state.workspaces[tokens.workspaceId];
 			const id = typeof cached?.id === "string" && cached.id.trim().length > 0 ? cached.id.trim() : tokens.workspaceId;
@@ -159,6 +163,24 @@ var FileTokenStorage = class {
 	async useWorkspace(workspaceRef) {
 		return this.withRefreshLock(() => this.useWorkspaceUnlocked(workspaceRef));
 	}
+	/**
+	* Resolve a workspace ref (id, credential workspace id, or cached name)
+	* against the locally stored sessions without changing the active
+	* workspace. Read-only counterpart of useWorkspace: it reads the auth
+	* context as-is and never runs the legacy-state migration, so it writes
+	* nothing.
+	*/
+	async resolveWorkspace(workspaceRef) {
+		const ref = workspaceRef.trim();
+		if (!ref) throw new WorkspaceSelectionError("missing");
+		this.signal?.throwIfAborted();
+		const credentials = await this.readCredentialsFromDisk();
+		const context = await this.readAuthContext();
+		const matches = this.workspacesFromState(credentials, context).filter((workspace) => workspaceMatchesRef(workspace, ref));
+		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
+		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
+		return matches[0];
+	}
 	async useWorkspaceUnlocked(workspaceRef) {
 		const ref = workspaceRef.trim();
 		if (!ref) throw new WorkspaceSelectionError("missing");
@@ -327,6 +349,7 @@ var FileTokenStorage = class {
 		await this.writeAuthContext(context.state);
 	}
 	async maybeActivateWorkspaceId(workspaceId) {
+		if (this.options.pinnedWorkspaceId) return;
 		const context = await this.readAuthContext();
 		if (this.options.activateOnSetTokens === false && context.exists && context.state.activeWorkspaceId && context.state.activeWorkspaceId !== workspaceId) return;
 		context.state.activeWorkspaceId = workspaceId;

package/dist/cli2.js

@@ -12,6 +12,7 @@ import { createBranchCommand } from "./commands/branch/index.js";
 import { createBuildCommand } from "./commands/build/index.js";
 import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
+import { createInitCommand } from "./commands/init/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
 import { runVersion } from "./controllers/version.js";
@@ -48,6 +49,7 @@ function createProgram(runtime) {
 	program.addOption(new Option("--version", "Print the CLI version and exit."));
 	program.name("prisma").showSuggestionAfterError();
 	program.addCommand(createVersionCommand(runtime));
+	program.addCommand(createInitCommand(runtime));
 	program.addCommand(createAgentCommand(runtime));
 	program.addCommand(createAuthCommand(runtime));
 	program.addCommand(createProjectCommand(runtime));

package/dist/commands/database/index.js

@@ -2,8 +2,8 @@ import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow } from "../../controllers/database.js";
-import { renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseShow, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseShow } from "../../presenters/database.js";
+import { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage } from "../../controllers/database.js";
+import { renderDatabaseBackupList, renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseConnectionRotate, renderDatabaseConnectionRotateStdout, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseRestore, renderDatabaseShow, renderDatabaseUsage, serializeDatabaseBackupList, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseConnectionRotate, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseRestore, serializeDatabaseShow, serializeDatabaseUsage } from "../../presenters/database.js";
 import { Command, Option } from "commander";
 //#region src/commands/database/index.ts
 function createDatabaseCommand(runtime) {
@@ -12,7 +12,10 @@ function createDatabaseCommand(runtime) {
 	database.addCommand(createDatabaseListCommand(runtime));
 	database.addCommand(createDatabaseShowCommand(runtime));
 	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseUsageCommand(runtime));
+	database.addCommand(createDatabaseRestoreCommand(runtime));
 	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseBackupCommand(runtime));
 	database.addCommand(createDatabaseConnectionCommand(runtime));
 	return database;
 }
@@ -75,6 +78,78 @@ function createDatabaseCreateCommand(runtime) {
 	});
 	return command;
 }
+function createDatabaseUsageCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("usage"), runtime), "database.usage");
+	command.argument("<database>", "Database id or name").addOption(new Option("--from <iso-date>", "Start of the usage period")).addOption(new Option("--to <iso-date>", "End of the usage period"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const from = options.from;
+		const to = options.to;
+		await runCommand(runtime, "database.usage", options, (context) => runDatabaseUsage(context, databaseRef, {
+			projectRef,
+			branchName,
+			from,
+			to
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseUsage(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseUsage(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRestoreCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("restore"), runtime), "database.restore");
+	command.argument("<database>", "Target database id or name").addOption(new Option("--backup <backup-id>", "Backup to restore from")).addOption(new Option("--source-database <database>", "Database the backup belongs to (defaults to the target)")).addOption(new Option("--confirm <database-id>", "Exact target database id required to restore"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const backupId = options.backup;
+		const sourceDatabaseRef = options.sourceDatabase;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.restore", options, (context) => runDatabaseRestore(context, databaseRef, {
+			projectRef,
+			branchName,
+			backupId,
+			sourceDatabaseRef,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRestore(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRestore(result)
+		});
+	});
+	return command;
+}
+function createDatabaseBackupCommand(runtime) {
+	const backup = attachCommandDescriptor(configureRuntimeCommand(new Command("backup"), runtime), "database.backup");
+	addCompactGlobalFlags(backup);
+	backup.addCommand(createDatabaseBackupListCommand(runtime));
+	return backup;
+}
+function createDatabaseBackupListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.backup.list");
+	command.argument("<database>", "Database id or name").addOption(new Option("--limit <n>", "Maximum number of backups to return"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const limit = options.limit;
+		await runCommand(runtime, "database.backup.list", options, (context) => runDatabaseBackupList(context, databaseRef, {
+			projectRef,
+			branchName,
+			limit
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseBackupList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseBackupList(result)
+		});
+	});
+	return command;
+}
 function createDatabaseRemoveCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.remove");
 	command.argument("<database>", "Database id or name").addOption(new Option("--confirm <database-id>", "Exact database id required to remove"));
@@ -100,9 +175,24 @@ function createDatabaseConnectionCommand(runtime) {
 	addCompactGlobalFlags(connection);
 	connection.addCommand(createDatabaseConnectionListCommand(runtime));
 	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRotateCommand(runtime));
 	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
 	return connection;
 }
+function createDatabaseConnectionRotateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rotate"), runtime), "database.connection.rotate");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to rotate"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.rotate", options, (context) => runDatabaseConnectionRotate(context, connectionRef, { confirm }), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionRotateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRotate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRotate(result)
+		});
+	});
+	return command;
+}
 function createDatabaseConnectionListCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
 	command.argument("<database>", "Database id or name");

package/dist/commands/init/index.js

@@ -0,0 +1,32 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { runInit } from "../../controllers/init.js";
+import { renderInit, serializeInit } from "../../presenters/init.js";
+import { Command, Option } from "commander";
+//#region src/commands/init/index.ts
+function createInitCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("init"), runtime), "init");
+	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const flags = options;
+		await runCommand(runtime, "init", options, (context) => runInit(context, {
+			framework: flags.framework,
+			entry: flags.entry,
+			httpPort: flags.httpPort,
+			region: flags.region,
+			name: flags.name,
+			link: flags.link,
+			project: flags.project,
+			install: flags.install
+		}), {
+			renderHuman: (context, descriptor, result) => renderInit(context, descriptor, result),
+			renderJson: (result) => serializeInit(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createInitCommand };

package/dist/commands/project/index.js

@@ -2,10 +2,10 @@ import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
-import { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
-import { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } from "../../presenters/project.js";
+import { runProjectCreate, runProjectLink, runProjectList, runProjectRemove, runProjectRename, runProjectShow, runProjectTransfer } from "../../controllers/project.js";
+import { renderProjectList, renderProjectRemove, renderProjectRename, renderProjectSetup, renderProjectShow, renderProjectTransfer, serializeProjectList, serializeProjectRemove, serializeProjectRename, serializeProjectSetup, serializeProjectShow, serializeProjectTransfer } from "../../presenters/project.js";
 import { createEnvCommand } from "../env.js";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 //#region src/commands/project/index.ts
 function createProjectCommand(runtime) {
 	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
@@ -14,9 +14,57 @@ function createProjectCommand(runtime) {
 	project.addCommand(createProjectShowCommand(runtime));
 	project.addCommand(createProjectCreateCommand(runtime));
 	project.addCommand(createProjectLinkCommand(runtime));
+	project.addCommand(createProjectRenameCommand(runtime));
+	project.addCommand(createProjectRemoveCommand(runtime));
+	project.addCommand(createProjectTransferCommand(runtime));
 	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
+function createProjectRenameCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rename"), runtime), "project.rename");
+	command.argument("<name>", "New project name").addOption(new Option("--project <id-or-name>", "Project id or name"));
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		await runCommand(runtime, "project.rename", options, (context) => runProjectRename(context, name, { project: projectRef }), {
+			renderHuman: (context, descriptor, result) => renderProjectRename(context, descriptor, result),
+			renderJson: (result) => serializeProjectRename(result)
+		});
+	});
+	return command;
+}
+function createProjectRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "project.remove");
+	command.argument("<project>", "Project id or name").addOption(new Option("--confirm <project-id>", "Exact project id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "project.remove", options, (context) => runProjectRemove(context, projectRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderProjectRemove(context, descriptor, result),
+			renderJson: (result) => serializeProjectRemove(result)
+		});
+	});
+	return command;
+}
+function createProjectTransferCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("transfer"), runtime), "project.transfer");
+	command.argument("<project>", "Project id or name").addOption(new Option("--to-workspace <id-or-name>", "Locally authenticated workspace to receive the project")).addOption(new Option("--recipient-token <token>", "Access token for the receiving workspace")).addOption(new Option("--confirm <project-id>", "Exact project id required to transfer"));
+	addGlobalFlags(command);
+	command.action(async (projectRef, options) => {
+		const toWorkspace = options.toWorkspace;
+		const recipientToken = options.recipientToken;
+		const confirm = options.confirm;
+		await runCommand(runtime, "project.transfer", options, (context) => runProjectTransfer(context, projectRef, {
+			toWorkspace,
+			recipientToken,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderProjectTransfer(context, descriptor, result),
+			renderJson: (result) => serializeProjectTransfer(result)
+		});
+	});
+	return command;
+}
 function createProjectCreateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "project.create");
 	command.argument("<name>", "Project name");

package/dist/controllers/app-env-api.js

@@ -5,7 +5,8 @@ async function findVariableByNaturalKey(client, projectId, key, resolved, signal
 		params: { query: {
 			projectId,
 			class: resolved.apiTarget.class,
-			key
+			key,
+			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {}
 		} },
 		signal
 	});

package/dist/controllers/app.js

@@ -2528,4 +2528,4 @@ function toOptionalEnvVars(envVars) {
 	return Object.keys(envVars).length > 0 ? envVars : void 0;
 }
 //#endregion
-export { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };
+export { detectDeployFramework, runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy };