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

package/README.md

@@ -57,6 +57,8 @@ Useful next commands:
 npx prisma-cli app logs
 npx prisma-cli app open
 npx prisma-cli project env add DATABASE_URL=postgresql://example --role preview
+npx prisma-cli project env add --file .env --role preview
+npx prisma-cli project env list
 npx prisma-cli project env list --role preview
 ```
 
@@ -73,7 +75,7 @@ The beta package exposes `prisma-cli` so it can coexist with the existing
 | `auth` | Log in, log out, and inspect the active Prisma account. |
 | `project` | List projects, show the resolved project, and manage project environment variables. |
 | `git` | Connect or disconnect a project from a GitHub repository. |
-| `branch` | Inspect the Prisma branch that maps to the current work context. |
+| `branch` | List Prisma branches for the resolved project. |
 | `app` | Build, run, deploy, inspect, open, stream logs, promote, roll back, and remove apps. |
 
 Common examples:
@@ -82,7 +84,7 @@ Common examples:
 npx prisma-cli version
 npx prisma-cli auth whoami
 npx prisma-cli project show
-npx prisma-cli branch show
+npx prisma-cli branch list
 npx prisma-cli app deploy --branch feat-login --framework nextjs
 npx prisma-cli app promote <deployment-id>
 ```

package/dist/commands/app/index.js

@@ -1,3 +1,4 @@
+import { usageError } from "../../shell/errors.js";
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
@@ -64,7 +65,7 @@ function createDeployCommand(runtime) {
 		"hono",
 		"tanstack-start",
 		"bun"
-	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues)).addOption(new Option("--db", "Create and wire an isolated database for the preview Branch")).addOption(new Option("--no-db", "Skip branch database setup")).addOption(new Option("--prod", "Confirm intent to deploy to production"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
@@ -75,21 +76,32 @@ function createDeployCommand(runtime) {
 		const envAssignments = options.env;
 		const projectRef = options.project;
 		const createProjectName = options.createProject;
-		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
-			projectRef,
-			createProjectName,
-			branchName,
-			entrypoint: entry,
-			framework,
-			httpPort,
-			envAssignments
-		}), {
+		const prod = options.prod;
+		const db = options.db;
+		const hasDbConflict = hasFlag(runtime.argv, "--db") && hasFlag(runtime.argv, "--no-db");
+		await runCommand(runtime, "app.deploy", options, (context) => {
+			if (hasDbConflict) throw usageError("app deploy accepts either --db or --no-db", "--db requests branch database setup, while --no-db disables it.", "Pass exactly one database setup flag.", ["prisma-cli app deploy --db", "prisma-cli app deploy --no-db"], "app");
+			return runAppDeploy(context, appName, {
+				projectRef,
+				createProjectName,
+				branchName,
+				entrypoint: entry,
+				framework,
+				httpPort,
+				envAssignments,
+				prod: prod === true,
+				db
+			});
+		}, {
 			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
 			renderJson: (result) => serializeAppDeploy(result)
 		});
 	});
 	return command;
 }
+function hasFlag(argv, flag) {
+	return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
 function createShowCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
 	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));

package/dist/commands/branch/index.js

@@ -2,16 +2,14 @@ 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 { runBranchList, runBranchShow, runBranchUse } from "../../controllers/branch.js";
-import { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow } from "../../presenters/branch.js";
+import { runBranchList } from "../../controllers/branch.js";
+import { renderBranchList, serializeBranchList } from "../../presenters/branch.js";
 import { Command } from "commander";
 //#region src/commands/branch/index.ts
 function createBranchCommand(runtime) {
 	const branch = attachCommandDescriptor(configureRuntimeCommand(new Command("branch"), runtime), "branch");
 	addCompactGlobalFlags(branch);
 	branch.addCommand(createBranchListCommand(runtime));
-	branch.addCommand(createBranchShowCommand(runtime));
-	branch.addCommand(createBranchUseCommand(runtime));
 	return branch;
 }
 function createBranchListCommand(runtime) {
@@ -25,28 +23,5 @@ function createBranchListCommand(runtime) {
 	});
 	return command;
 }
-function createBranchShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "branch.show");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "branch.show", options, (context) => runBranchShow(context), {
-			renderHuman: (context, descriptor, result) => renderBranchShow(context, descriptor, result),
-			renderJson: (result) => serializeBranchShow(result)
-		});
-	});
-	return command;
-}
-function createBranchUseCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "branch.use");
-	command.argument("[name]", "Branch name");
-	addGlobalFlags(command);
-	command.action(async (branchName, options) => {
-		await runCommand(runtime, "branch.use", options, (context) => runBranchUse(context, branchName), {
-			renderHuman: (context, descriptor, result) => renderBranchUse(context, descriptor, result),
-			renderJson: (result) => serializeBranchShow(result)
-		});
-	});
-	return command;
-}
 //#endregion
 export { createBranchCommand };

package/dist/commands/env.js

@@ -17,16 +17,18 @@ function createEnvCommand(runtime) {
 }
 function createEnvAddCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "project.env.add");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
 			renderJson: (result) => serializeEnvAdd(result)
@@ -36,16 +38,18 @@ function createEnvAddCommand(runtime) {
 }
 function createEnvUpdateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "project.env.update");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
 			renderJson: (result) => serializeEnvUpdate(result)

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

@@ -0,0 +1,54 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+//#region src/controllers/app-env-api.ts
+async function findVariableByNaturalKey(client, projectId, key, resolved, signal) {
+	const { data, error, response } = await client.GET("/v1/environment-variables", {
+		params: { query: {
+			projectId,
+			class: resolved.apiTarget.class,
+			key
+		} },
+		signal
+	});
+	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
+	return data.data.filter((row) => rowMatchesExactScope(row, resolved))[0] ?? null;
+}
+function toMetadata(row, requestedScope) {
+	const rowScope = row.branchId === null ? {
+		kind: "role",
+		role: row.class
+	} : requestedScope;
+	return {
+		id: row.id,
+		key: row.key,
+		scope: rowScope,
+		source: formatDescriptorLabel(rowScope),
+		isManagedBySystem: row.isManagedBySystem,
+		updatedAt: row.updatedAt
+	};
+}
+function rowMatchesExactScope(row, resolved) {
+	return row.class === resolved.apiTarget.class && row.branchId === resolved.apiTarget.branchId;
+}
+function apiCallError(summary, response, error) {
+	const status = response?.status ?? 0;
+	const apiCode = error?.error?.code;
+	const apiMessage = error?.error?.message;
+	const apiHint = error?.error?.hint;
+	if (status === 401 || status === 403) return authRequiredError(["prisma auth login"]);
+	return new CliError({
+		code: apiCode ?? "ENV_API_ERROR",
+		domain: "app",
+		summary,
+		why: apiMessage ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: apiHint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+function formatDescriptorLabel(scope) {
+	if (scope.kind === "role") return scope.role ?? "unknown";
+	if (scope.kind === "overview") return "overview";
+	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
+}
+//#endregion
+export { apiCallError, findVariableByNaturalKey, toMetadata };

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

@@ -0,0 +1,179 @@
+import { CliError } from "../shell/errors.js";
+import { formatScopeLabel } from "../lib/app/env-config.js";
+import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
+//#region src/controllers/app-env-file.ts
+async function runEnvAddFile(context, client, projectId, resolved, filePath, assignments) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const existingKeys = assignments.map((assignment) => assignment.key).filter((key) => existing.has(key));
+	if (existingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_ALREADY_EXISTS",
+		domain: "app",
+		summary: `${existingKeys.length} environment variable(s) already exist in ${formatScopeLabel(resolved.scope)}`,
+		why: `Existing keys: ${formatKeyList(existingKeys)}.`,
+		fix: "Split the input file by key state: update existing keys and add new keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			existingKeys,
+			first: "update-existing"
+		}),
+		meta: { keys: existingKeys }
+	});
+	const warnings = await missingPreviewDefaultWarnings(client, projectId, resolved.scope, assignments.map((assignment) => assignment.key), context.runtime.signal);
+	const variables = [];
+	for (const assignment of assignments) try {
+		const { data, error, response } = await client.POST("/v1/environment-variables", {
+			body: {
+				projectId,
+				class: resolved.apiTarget.class,
+				...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {},
+				key: assignment.key,
+				value: assignment.value
+			},
+			signal: context.runtime.signal
+		});
+		if (error || !data) throw apiCallError(`Failed to add ${assignment.key}`, response, error);
+		variables.push(toMetadata(data.data, resolved.descriptor));
+	} catch (error) {
+		throw envFileApplyFailedError("add", filePath, resolved.scope, assignment.key, variables, error);
+	}
+	return {
+		command: "project.env.add",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings,
+		nextSteps: []
+	};
+}
+async function runEnvUpdateFile(context, client, projectId, resolved, filePath, assignments) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const missingKeys = assignments.map((assignment) => assignment.key).filter((key) => !existing.has(key));
+	if (missingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_NOT_FOUND",
+		domain: "app",
+		summary: `${missingKeys.length} environment variable(s) not found in ${formatScopeLabel(resolved.scope)}`,
+		why: `Missing keys: ${formatKeyList(missingKeys)}.`,
+		fix: "Split the input file by key state: add missing keys and update existing keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			missingKeys,
+			first: "add-missing"
+		}),
+		meta: { keys: missingKeys }
+	});
+	const variables = [];
+	for (const assignment of assignments) {
+		const existingVariable = existing.get(assignment.key);
+		if (!existingVariable) continue;
+		try {
+			const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
+				params: { path: { envVarId: existingVariable.id } },
+				body: { value: assignment.value },
+				signal: context.runtime.signal
+			});
+			if (error || !data) throw apiCallError(`Failed to update value for ${assignment.key}`, response, error);
+			variables.push(toMetadata(data.data, resolved.descriptor));
+		} catch (error) {
+			throw envFileApplyFailedError("update", filePath, resolved.scope, assignment.key, variables, error);
+		}
+	}
+	return {
+		command: "project.env.update",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function findVariablesByNaturalKey(client, projectId, keys, resolved, signal) {
+	const found = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const row = await findVariableByNaturalKey(client, projectId, key, resolved, signal);
+		if (row) found.set(key, row);
+	}
+	return found;
+}
+async function missingPreviewDefaultWarnings(client, projectId, scope, keys, signal) {
+	if (scope.kind !== "branch") return [];
+	const previewScope = {
+		scope: {
+			kind: "role",
+			role: "preview"
+		},
+		descriptor: {
+			kind: "role",
+			role: "preview"
+		},
+		apiTarget: {
+			class: "preview",
+			branchId: null
+		}
+	};
+	const missing = [];
+	for (const key of keys) if (!await findVariableByNaturalKey(client, projectId, key, previewScope, signal)) missing.push(key);
+	if (missing.length === 0) return [];
+	if (missing.length === 1) return [`Variable "${missing[0]}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`];
+	return [`Variables ${formatKeyList(missing)} do not exist in preview. They will only exist on ${formatScopeLabel(scope)}.`];
+}
+function envFileApplyFailedError(command, filePath, scope, failedKey, writtenVariables, error) {
+	const writtenKeys = writtenVariables.map((variable) => variable.key);
+	const cause = error instanceof CliError ? error.summary : error instanceof Error ? error.message : "Unknown error.";
+	return new CliError({
+		code: "ENV_FILE_APPLY_FAILED",
+		domain: "app",
+		summary: `Failed to ${command} "${failedKey}" from "${filePath}"`,
+		why: writtenKeys.length === 0 ? `No variables were written before ${failedKey} failed. Cause: ${cause}` : `Written keys before failure: ${formatKeyList(writtenKeys)}. Cause: ${cause}`,
+		fix: "Inspect the target scope, then retry the remaining keys once the API issue is resolved.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env list ${formatScopeFlag(scope)}`, retryStepForApplyFailure(command, filePath, scope, writtenKeys)],
+		meta: {
+			file: filePath,
+			failedKey,
+			writtenKeys
+		}
+	});
+}
+function retryStepForApplyFailure(command, filePath, scope, writtenKeys) {
+	if (command === "update") return `prisma-cli project env update --file ${filePath} ${formatScopeFlag(scope)}`;
+	if (writtenKeys.length === 0) return `prisma-cli project env add --file ${filePath} ${formatScopeFlag(scope)}`;
+	return `prisma-cli project env add --file <remaining.env> ${formatScopeFlag(scope)}`;
+}
+function splitFileNextSteps(filePath, scope, options) {
+	const scopeFlag = formatScopeFlag(scope);
+	const existingFile = `${filePath}.existing`;
+	const newFile = `${filePath}.new`;
+	if (options.first === "update-existing") return [
+		`# existing keys: ${formatKeyList(options.existingKeys)}`,
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`,
+		"# new keys only",
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`
+	];
+	return [
+		`# missing keys: ${formatKeyList(options.missingKeys)}`,
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`,
+		"# existing keys only",
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`
+	];
+}
+function formatKeyList(keys) {
+	return keys.map((key) => `"${key}"`).join(", ");
+}
+function formatScopeFlag(scope) {
+	if (scope.kind === "role") return `--role ${scope.role}`;
+	return `--branch ${scope.branchName}`;
+}
+//#endregion
+export { runEnvAddFile, runEnvUpdateFile };