@prisma/cli 3.0.0-dev.60.1 → 3.0.0-dev.62.1

package/README.md

@@ -57,6 +57,7 @@ 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
 ```

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 };

package/dist/controllers/app-env.js

@@ -5,29 +5,34 @@ import { readLocalGitBranch } from "../lib/git/local-branch.js";
 import { requireAuthenticatedAuthState } from "./auth.js";
 import { listRealWorkspaceProjects } from "./project.js";
 import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
+import { readEnvFileAssignments } from "../lib/app/env-file.js";
+import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
+import { runEnvAddFile, runEnvUpdateFile } from "./app-env-file.js";
 //#region src/controllers/app-env.ts
 async function runEnvAdd(context, rawAssignment, flags) {
-	const { key, value } = parseKeyValuePositional(rawAssignment, "add", context.runtime.env);
+	const source = resolveEnvWriteSource(rawAssignment, flags.filePath, "add");
 	const scope = resolveEnvScope(flags, {
 		requireExplicit: true,
 		command: "add"
 	});
-	if (!scope) throw usageError(`prisma-cli project env add requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env add ${key}=${value} --role production`], "app");
+	if (!scope) throw usageError(`prisma-cli project env add requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", ["prisma-cli project env add KEY=value --role production"], "app");
+	const input = await resolveEnvWriteInput(context, source, "add");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env add");
 	const resolved = await resolveScopeToApi(client, projectId, scope, {
 		createBranchIfMissing: true,
 		signal: context.runtime.signal
 	});
-	if (await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal)) throw new CliError({
+	if (input.kind === "file") return runEnvAddFile(context, client, projectId, resolved, input.filePath, input.assignments);
+	if (await findVariableByNaturalKey(client, projectId, input.key, resolved, context.runtime.signal)) throw new CliError({
 		code: "ENV_VARIABLE_ALREADY_EXISTS",
 		domain: "app",
-		summary: `Variable "${key}" already exists in ${formatScopeLabel(scope)}`,
+		summary: `Variable "${input.key}" already exists in ${formatScopeLabel(scope)}`,
 		why: "A variable with this key already exists in the targeted scope.",
 		fix: "Use `prisma-cli project env update` to change an existing variable's value.",
 		exitCode: 1,
-		nextSteps: [`prisma-cli project env update ${key}=<new-value> ${formatScopeFlag(scope)}`]
+		nextSteps: [`prisma-cli project env update ${input.key}=<new-value> ${formatScopeFlag(scope)}`]
 	});
-	const warnings = scope.kind === "branch" && !await findVariableByNaturalKey(client, projectId, key, {
+	const warnings = scope.kind === "branch" && !await findVariableByNaturalKey(client, projectId, input.key, {
 		scope: {
 			kind: "role",
 			role: "preview"
@@ -40,18 +45,18 @@ async function runEnvAdd(context, rawAssignment, flags) {
 			class: "preview",
 			branchId: null
 		}
-	}, context.runtime.signal) ? [`Variable "${key}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`] : [];
+	}, context.runtime.signal) ? [`Variable "${input.key}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`] : [];
 	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,
-			value
+			key: input.key,
+			value: input.value
 		},
 		signal: context.runtime.signal
 	});
-	if (error || !data) throw apiCallError(`Failed to add ${key}`, response, error);
+	if (error || !data) throw apiCallError(`Failed to add ${input.key}`, response, error);
 	return {
 		command: "project.env.add",
 		result: {
@@ -64,33 +69,35 @@ async function runEnvAdd(context, rawAssignment, flags) {
 	};
 }
 async function runEnvUpdate(context, rawAssignment, flags) {
-	const { key, value } = parseKeyValuePositional(rawAssignment, "update", context.runtime.env);
+	const source = resolveEnvWriteSource(rawAssignment, flags.filePath, "update");
 	const scope = resolveEnvScope(flags, {
 		requireExplicit: true,
 		command: "update"
 	});
-	if (!scope) throw usageError(`prisma-cli project env update requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env update ${key}=${value} --role production`], "app");
+	if (!scope) throw usageError(`prisma-cli project env update requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", ["prisma-cli project env update KEY=value --role production"], "app");
+	const input = await resolveEnvWriteInput(context, source, "update");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env update");
 	const resolved = await resolveScopeToApi(client, projectId, scope, {
 		createBranchIfMissing: false,
 		signal: context.runtime.signal
 	});
-	const existing = await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal);
+	if (input.kind === "file") return runEnvUpdateFile(context, client, projectId, resolved, input.filePath, input.assignments);
+	const existing = await findVariableByNaturalKey(client, projectId, input.key, resolved, context.runtime.signal);
 	if (!existing) throw new CliError({
 		code: "ENV_VARIABLE_NOT_FOUND",
 		domain: "app",
-		summary: `Variable "${key}" not found in ${formatScopeLabel(scope)}`,
+		summary: `Variable "${input.key}" not found in ${formatScopeLabel(scope)}`,
 		why: "No variable with this key exists in the targeted scope.",
 		fix: "Use `prisma-cli project env add` to create a new variable.",
 		exitCode: 1,
-		nextSteps: [`prisma-cli project env add ${key}=<value> ${formatScopeFlag(scope)}`]
+		nextSteps: [`prisma-cli project env add ${input.key}=<value> ${formatScopeFlag(scope)}`]
 	});
 	const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
 		params: { path: { envVarId: existing.id } },
-		body: { value },
+		body: { value: input.value },
 		signal: context.runtime.signal
 	});
-	if (error || !data) throw apiCallError(`Failed to update value for ${key}`, response, error);
+	if (error || !data) throw apiCallError(`Failed to update value for ${input.key}`, response, error);
 	return {
 		command: "project.env.update",
 		result: {
@@ -102,6 +109,32 @@ async function runEnvUpdate(context, rawAssignment, flags) {
 		nextSteps: []
 	};
 }
+function resolveEnvWriteSource(rawAssignment, filePath, command) {
+	if (filePath !== void 0 && rawAssignment !== void 0) throw usageError(`prisma-cli project env ${command} accepts either KEY=VALUE or --file`, "The command received both a positional assignment and a dotenv file path.", "Pass one input source.", [`prisma-cli project env ${command} KEY=value --role preview`, `prisma-cli project env ${command} --file .env --role preview`], "app");
+	if (filePath !== void 0) {
+		if (filePath.length === 0) throw usageError(`prisma-cli project env ${command} --file requires a path`, "The --file flag was passed without a file path.", "Pass a readable dotenv file path.", [`prisma-cli project env ${command} --file .env --role preview`], "app");
+		return {
+			kind: "file",
+			filePath
+		};
+	}
+	if (rawAssignment === void 0) throw usageError(`prisma-cli project env ${command} requires KEY=VALUE or --file`, "No environment variable input was supplied.", "Pass a single KEY=VALUE assignment or a dotenv file path.", [`prisma-cli project env ${command} KEY=value --role preview`, `prisma-cli project env ${command} --file .env --role preview`], "app");
+	return {
+		kind: "single",
+		rawAssignment
+	};
+}
+async function resolveEnvWriteInput(context, source, command) {
+	if (source.kind === "file") return {
+		kind: "file",
+		filePath: source.filePath,
+		assignments: await readEnvFileAssignments(context.runtime.cwd, source.filePath, command)
+	};
+	return {
+		kind: "single",
+		...parseKeyValuePositional(source.rawAssignment, command, context.runtime.env)
+	};
+}
 async function runEnvList(context, flags) {
 	const explicit = resolveEnvScope(flags, {
 		requireExplicit: false,
@@ -410,18 +443,6 @@ async function projectHasDefaultBranch(client, projectId, signal) {
 		cursor = result.data.pagination.nextCursor;
 	}
 }
-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;
-}
 async function listVariables(client, projectId, resolved, signal) {
 	return materializeEffectiveRows(await collectEnvironmentVariables(client, projectId, signal, {
 		className: resolved.apiTarget.class,
@@ -461,9 +482,6 @@ function rowMatchesScope(row, resolved) {
 	if (resolved.apiTarget.branchId === null) return row.branchId === null;
 	return row.branchId === null || row.branchId === resolved.apiTarget.branchId;
 }
-function rowMatchesExactScope(row, resolved) {
-	return row.class === resolved.apiTarget.class && row.branchId === resolved.apiTarget.branchId;
-}
 function materializeEffectiveRows(rows, resolved) {
 	if (resolved.apiTarget.branchId === null) return rows;
 	const byKey = /* @__PURE__ */ new Map();
@@ -471,40 +489,5 @@ function materializeEffectiveRows(rows, resolved) {
 	for (const row of rows) if (row.branchId === resolved.apiTarget.branchId) byKey.set(row.key, row);
 	return [...byKey.values()].sort((left, right) => left.key.localeCompare(right.key));
 }
-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 formatDescriptorLabel(scope) {
-	if (scope.kind === "role") return scope.role ?? "unknown";
-	if (scope.kind === "overview") return "overview";
-	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
-}
-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: []
-	});
-}
 //#endregion
 export { runEnvAdd, runEnvList, runEnvRemove, runEnvUpdate };

package/dist/lib/app/branch-database-deploy.js

@@ -32,6 +32,10 @@ async function maybeSetupBranchDatabase(context, provider, projectId, branch, op
 			warnings: warning ? [warning] : []
 		};
 	}
+	if (localSignal.unsupportedSchema) {
+		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch.name, context);
+		return emptyBranchDatabaseSetupOutcome();
+	}
 	const hasSignal = hasBranchDatabaseSignal(localSignal) || Boolean(envState.previewDatabaseUrl);
 	if (options.db !== true) {
 		if (!hasSignal) return emptyBranchDatabaseSetupOutcome();
@@ -76,10 +80,10 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 				databaseUrl: database.databaseUrl,
 				directUrl: database.directUrl
 			}).catch((error) => {
-				throw schemaSetupFailedError(error, signal.schema, branch.name);
+				throw schemaSetupFailedError(error, signal.schema, branch.name, context.runtime.cwd);
 			});
 			emitBranchDatabaseProgress(context, "success", "Applied database schema");
-		} else skippedSchemaWarning = "No schema.prisma file was found. Branch database env vars were created, but schema setup was skipped.";
+		} else skippedSchemaWarning = "No supported Prisma schema source was found. Branch database env vars were created, but schema setup was skipped.";
 		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
 		emitBranchDatabaseProgress(context, "success", `Added branch env override${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")}`);
 		if (skippedSchemaWarning) {
@@ -96,6 +100,7 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 				envVars,
 				schema: schemaSetup ? {
 					command: schemaSetup.command,
+					source: schemaSetup.source,
 					path: schemaSetup.schemaPath
 				} : null
 			},
@@ -185,7 +190,7 @@ function hasInlineDatabaseEnvVars(envVars) {
 function maybeRenderBranchDatabaseSignal(context, branchName, signal, envState) {
 	if (context.flags.json || context.flags.quiet) return;
 	const rows = [
-		signal.schema ? `  Schema  ${path.relative(context.runtime.cwd, signal.schema.path) || "schema.prisma"}` : null,
+		signal.schema ? `  Schema  ${path.relative(context.runtime.cwd, signal.schema.path) || defaultSchemaSourcePath(signal.schema)}` : null,
 		signal.databaseUrlReferences.length > 0 ? `  Code    ${signal.databaseUrlReferences.slice(0, 3).join(", ")}` : null,
 		envState.previewDatabaseUrl ? "  Env     preview DATABASE_URL is inherited by this branch" : null
 	].filter((row) => Boolean(row));
@@ -207,7 +212,11 @@ function emptyBranchDatabaseSetupOutcome() {
 	};
 }
 function formatSchemaSetupCommand(command) {
-	return command === "migrate-deploy" ? "prisma migrate deploy" : "prisma db push";
+	switch (command) {
+		case "migrate-deploy": return "prisma migrate deploy";
+		case "db-push": return "prisma db push";
+		case "prisma-next-db-init": return "prisma-next db init";
+	}
 }
 function branchDatabaseSetupFailedError(summary, error, branchName) {
 	return new CliError({
@@ -257,7 +266,7 @@ function branchDatabaseCleanupFailedError(setupError, cleanupError, database, br
 		nextSteps: []
 	});
 }
-function schemaSetupFailedError(error, schema, branchName) {
+function schemaSetupFailedError(error, schema, branchName, cwd) {
 	return new CliError({
 		code: "SCHEMA_SETUP_FAILED",
 		domain: "app",
@@ -268,12 +277,39 @@ function schemaSetupFailedError(error, schema, branchName) {
 		meta: {
 			branch: branchName,
 			schemaPath: schema.path,
+			source: schema.kind,
 			command: schema.command
 		},
 		exitCode: 1,
-		nextSteps: [schema.command === "migrate-deploy" ? "npx --no-install prisma migrate deploy" : "npx --no-install prisma db push --skip-generate", `prisma-cli app deploy --branch ${formatCommandArgument(branchName)} --db`]
+		nextSteps: [...formatSchemaSetupNextSteps(schema, cwd), `prisma-cli app deploy --branch ${formatCommandArgument(branchName)} --db`]
 	});
 }
+function unsupportedBranchDatabaseSchemaError(schema, branchName, context) {
+	return usageError("Branch database setup is not available for this Prisma schema", `${path.relative(context.runtime.cwd, schema.path) || defaultUnsupportedSchemaSourcePath(schema)} targets ${formatUnsupportedSchemaTarget(schema.target)}, but --db creates Prisma Postgres databases.`, "Use project env commands to provide a database URL for this branch, or switch the Prisma schema source to PostgreSQL before using --db.", [`prisma-cli project env add DATABASE_URL=<value> --branch ${formatCommandArgument(branchName)}`, `prisma-cli app deploy --branch ${formatCommandArgument(branchName)}`], "app");
+}
+function formatSchemaSetupNextSteps(schema, cwd) {
+	const sourcePath = path.relative(cwd, schema.path) || defaultSchemaSourcePath(schema);
+	switch (schema.command) {
+		case "migrate-deploy": return [`npx --no-install prisma migrate deploy --schema ${formatCommandArgument(sourcePath)}`];
+		case "db-push": return [`npx --no-install prisma db push --schema ${formatCommandArgument(sourcePath)}`];
+		case "prisma-next-db-init": return [`npx --no-install prisma-next contract emit --config ${formatCommandArgument(sourcePath)}`, `npx --no-install prisma-next db init --config ${formatCommandArgument(sourcePath)} --db <DATABASE_URL>`];
+	}
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+function defaultUnsupportedSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+function formatUnsupportedSchemaTarget(target) {
+	switch (target) {
+		case "cockroachdb": return "CockroachDB";
+		case "mongodb": return "MongoDB";
+		case "mysql": return "MySQL";
+		case "sqlite": return "SQLite";
+		case "sqlserver": return "SQL Server";
+	}
+}
 function formatDebugDetails(error) {
 	if (error instanceof Error) return error.stack ?? error.message;
 	return typeof error === "string" ? error : null;

package/dist/lib/app/branch-database.js

@@ -10,6 +10,7 @@ const SKIPPED_DIRECTORIES = new Set([
 	".prisma",
 	".turbo",
 	".vercel",
+	".wrangler",
 	"build",
 	"coverage",
 	"dist",
@@ -37,29 +38,41 @@ async function inspectBranchDatabaseSignal(cwd, signal) {
 	const state = {
 		filesVisited: 0,
 		schemaCandidates: [],
+		prismaNextConfigCandidates: [],
 		databaseUrlReferences: []
 	};
 	await scanDirectory(cwd, cwd, 0, state, signal);
-	const schemaPath = selectSchemaPath(cwd, state.schemaCandidates);
-	const hasMigrations = schemaPath ? await hasMigrationsDirectory(path.dirname(schemaPath), signal) : false;
+	const prismaNextConfigs = await Promise.all(state.prismaNextConfigCandidates.map((configPath) => classifyPrismaNextConfig(configPath, signal)));
+	const supportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "supported");
+	const unsupportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "unsupported");
+	const selectedPrismaOrmSchema = await selectPrismaOrmSchema(cwd, state.schemaCandidates, signal);
+	const schema = supportedPrismaNextConfig ? {
+		kind: "prisma-next",
+		path: supportedPrismaNextConfig.path,
+		hasMigrations: false,
+		command: "prisma-next-db-init",
+		target: supportedPrismaNextConfig.target
+	} : selectedPrismaOrmSchema.schema;
 	return {
-		schema: schemaPath ? {
-			path: schemaPath,
-			hasMigrations,
-			command: hasMigrations ? "migrate-deploy" : "db-push"
-		} : null,
+		schema,
+		unsupportedSchema: schema ? null : unsupportedPrismaNextConfig ? {
+			kind: "prisma-next",
+			path: unsupportedPrismaNextConfig.path,
+			target: unsupportedPrismaNextConfig.target
+		} : selectedPrismaOrmSchema.unsupportedSchema,
 		databaseUrlReferences: state.databaseUrlReferences
 	};
 }
 function hasBranchDatabaseSignal(signal) {
+	if (signal.unsupportedSchema) return false;
 	return Boolean(signal.schema || signal.databaseUrlReferences.length > 0);
 }
 async function runBranchDatabaseSchemaSetup(options) {
-	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || "schema.prisma";
-	const args = buildPrismaSchemaCommandArgs(options.schema.command, schemaPath);
-	await runPrismaCommand({
+	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || defaultSchemaSourcePath(options.schema);
+	const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl);
+	for (const command of commands) await runPrismaCommand({
 		context: options.context,
-		args,
+		...command,
 		env: {
 			DATABASE_URL: options.databaseUrl,
 			...options.directUrl ? { DIRECT_URL: options.directUrl } : {}
@@ -67,6 +80,7 @@ async function runBranchDatabaseSchemaSetup(options) {
 	});
 	return {
 		command: options.schema.command,
+		source: options.schema.kind,
 		schemaPath
 	};
 }
@@ -92,18 +106,57 @@ async function scanDirectory(cwd, directory, depth, state, signal) {
 		if (!entry.isFile()) continue;
 		state.filesVisited += 1;
 		if (entry.name === "schema.prisma") state.schemaCandidates.push(entryPath);
+		if (isPrismaNextConfigFile(entry.name)) state.prismaNextConfigCandidates.push(entryPath);
 		if (state.databaseUrlReferences.length < MAX_DATABASE_URL_REFERENCE_FILES && shouldScanForDatabaseUrl(entry.name) && await fileContainsDatabaseUrl(entryPath, signal)) state.databaseUrlReferences.push(path.relative(cwd, entryPath) || entry.name);
 	}
 }
-function selectSchemaPath(cwd, candidates) {
+async function selectPrismaOrmSchema(cwd, candidates, signal) {
+	const sorted = sortByPreferredRelativePath(cwd, candidates, "schema.prisma");
+	for (const schemaPath of sorted) {
+		const target = await classifyPrismaOrmSchemaTarget(schemaPath, signal);
+		if (target === "postgresql" || target === "unknown") {
+			const hasMigrations = await hasMigrationsDirectory(path.dirname(schemaPath), signal);
+			return {
+				schema: {
+					kind: "prisma-orm",
+					path: schemaPath,
+					hasMigrations,
+					command: hasMigrations ? "migrate-deploy" : "db-push",
+					target
+				},
+				unsupportedSchema: null
+			};
+		}
+		return {
+			schema: null,
+			unsupportedSchema: {
+				kind: "prisma-orm",
+				path: schemaPath,
+				target
+			}
+		};
+	}
+	return {
+		schema: null,
+		unsupportedSchema: null
+	};
+}
+function selectPrismaNextConfig(cwd, candidates, mode) {
+	const matches = candidates.filter((candidate) => {
+		const isSupported = candidate.target === "postgresql" || candidate.target === "unknown";
+		return mode === "supported" ? isSupported : !isSupported;
+	});
+	return sortByPreferredRelativePath(cwd, matches.map((candidate) => candidate.path), "prisma-next.config.ts").map((candidatePath) => matches.find((candidate) => candidate.path === candidatePath)).find((candidate) => Boolean(candidate)) ?? null;
+}
+function sortByPreferredRelativePath(cwd, candidates, preferredRootFile) {
 	return candidates.map((candidate) => ({
 		absolute: candidate,
-		relative: path.relative(cwd, candidate) || "schema.prisma"
+		relative: path.relative(cwd, candidate) || preferredRootFile
 	})).sort((left, right) => {
-		if (left.relative === "schema.prisma") return -1;
-		if (right.relative === "schema.prisma") return 1;
+		if (left.relative === preferredRootFile) return -1;
+		if (right.relative === preferredRootFile) return 1;
 		return left.relative.length - right.relative.length || left.relative.localeCompare(right.relative);
-	})[0]?.absolute ?? null;
+	}).map((candidate) => candidate.absolute);
 }
 async function hasMigrationsDirectory(schemaDirectory, signal) {
 	signal.throwIfAborted();
@@ -116,36 +169,115 @@ async function hasMigrationsDirectory(schemaDirectory, signal) {
 		throw error;
 	}
 }
+async function classifyPrismaNextConfig(configPath, signal) {
+	const content = await readTextFileIfSmall(configPath, signal);
+	if (!content) return {
+		path: configPath,
+		target: "unknown"
+	};
+	if (content.includes("@prisma-next/postgres/config")) return {
+		path: configPath,
+		target: "postgresql"
+	};
+	if (content.includes("@prisma-next/mongo/config")) return {
+		path: configPath,
+		target: "mongodb"
+	};
+	if (content.includes("@prisma-next/sqlite/config")) return {
+		path: configPath,
+		target: "sqlite"
+	};
+	return {
+		path: configPath,
+		target: "unknown"
+	};
+}
+async function classifyPrismaOrmSchemaTarget(schemaPath, signal) {
+	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(/\bprovider\s*=\s*"([^"]+)"/)?.[1] ?? null) {
+		case "postgresql": return "postgresql";
+		case "mongodb": return "mongodb";
+		case "mysql": return "mysql";
+		case "sqlite": return "sqlite";
+		case "sqlserver": return "sqlserver";
+		case "cockroachdb": return "cockroachdb";
+		default: return "unknown";
+	}
+}
 function shouldScanForDatabaseUrl(fileName) {
 	if (fileName === ".env" || fileName.startsWith(".env.")) return true;
 	return DATABASE_URL_SCAN_EXTENSIONS.has(path.extname(fileName));
 }
+function isPrismaNextConfigFile(fileName) {
+	if (!fileName.startsWith("prisma-next.config.")) return false;
+	return [
+		".cjs",
+		".cts",
+		".js",
+		".mjs",
+		".mts",
+		".ts"
+	].some((extension) => fileName.endsWith(extension));
+}
 async function fileContainsDatabaseUrl(filePath, signal) {
+	return (await readTextFileIfSmall(filePath, signal))?.includes("DATABASE_URL") ?? false;
+}
+async function readTextFileIfSmall(filePath, signal) {
 	signal.throwIfAborted();
-	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return false;
-	return (await readFile(filePath, {
+	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return null;
+	return readFile(filePath, {
 		encoding: "utf8",
 		signal
-	})).includes("DATABASE_URL");
-}
-function buildPrismaSchemaCommandArgs(command, schemaPath) {
-	if (command === "migrate-deploy") return [
-		"--no-install",
-		"prisma",
-		"migrate",
-		"deploy",
-		"--schema",
-		schemaPath
-	];
-	return [
-		"--no-install",
-		"prisma",
-		"db",
-		"push",
-		"--skip-generate",
-		"--schema",
-		schemaPath
-	];
+	});
+}
+function buildSchemaSetupCommands(schema, schemaPath, databaseUrl) {
+	if (schema.command === "migrate-deploy") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"migrate",
+			"deploy",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma migrate deploy"
+	}];
+	if (schema.command === "db-push") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"db",
+			"push",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma db push"
+	}];
+	return [{
+		args: [
+			"--no-install",
+			"prisma-next",
+			"contract",
+			"emit",
+			"--config",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma-next contract emit"
+	}, {
+		args: [
+			"--no-install",
+			"prisma-next",
+			"db",
+			"init",
+			"--config",
+			schemaPath,
+			"--db",
+			databaseUrl
+		],
+		displayCommand: "npx --no-install prisma-next db init"
+	}];
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
 }
 async function runPrismaCommand(options) {
 	const shouldPipeOutput = !options.context.flags.json && !options.context.flags.quiet;
@@ -177,8 +309,8 @@ async function runPrismaCommand(options) {
 			signal
 		}));
 	});
-	if (exit.signal) throw new Error(`npx prisma was terminated by ${exit.signal}.`);
-	if (exit.code !== 0) throw new Error(`npx prisma exited with code ${exit.code ?? 1}.`);
+	if (exit.signal) throw new Error(`${options.displayCommand} was terminated by ${exit.signal}.`);
+	if (exit.code !== 0) throw new Error(`${options.displayCommand} exited with code ${exit.code ?? 1}.`);
 }
 //#endregion
 export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup };

package/dist/lib/app/env-config.js

@@ -64,4 +64,4 @@ function formatScopeLabel(scope) {
 	return `branch:${scope.branchName}`;
 }
 //#endregion
-export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope };
+export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope, validateKey };

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

@@ -0,0 +1,82 @@
+import { usageError } from "../../shell/errors.js";
+import { validateKey } from "./env-config.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse } from "dotenv";
+//#region src/lib/app/env-file.ts
+const ASSIGNMENT_KEY_PATTERN = /^\s*(?:export\s+)?([^#=\s]+)\s*=/;
+async function readEnvFileAssignments(cwd, filePath, command) {
+	const resolvedPath = path.resolve(cwd, filePath);
+	let contents;
+	try {
+		contents = await readFile(resolvedPath, "utf8");
+	} catch (error) {
+		throw usageError(`Failed to read env file "${filePath}"`, error instanceof Error ? error.message : "The file could not be read.", "Pass a readable dotenv file path.", [`prisma-cli project env ${command} --file .env --role preview`], "app");
+	}
+	return parseEnvFileContents(contents, filePath, command);
+}
+function parseEnvFileContents(contents, filePath, command) {
+	const parsedKeys = extractParsedKeys(contents);
+	if (parsedKeys.length === 0) throw usageError(`No environment variables found in "${filePath}"`, "The file does not contain any KEY=VALUE assignments.", "Pass a dotenv file with at least one non-empty variable.", [], "app");
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of parsedKeys) {
+		validateEnvFileKey(entry.key, entry.line, filePath, command);
+		const firstLine = seen.get(entry.key);
+		if (firstLine !== void 0) throw usageError(`Duplicate environment variable "${entry.key}" in "${filePath}"`, `Lines ${firstLine} and ${entry.line} both define ${entry.key}.`, "Keep one assignment for each key before importing the file.", [], "app");
+		seen.set(entry.key, entry.line);
+	}
+	const parsedValues = parse(contents);
+	return parsedKeys.map(({ key }) => {
+		const value = parsedValues[key];
+		if (typeof value !== "string" || value.length === 0) {
+			const line = seen.get(key);
+			throw usageError(`Environment variable "${key}" in "${filePath}" has an empty value`, line === void 0 ? `${key} has an empty value.` : `Line ${line} defines ${key} with an empty value.`, "Pass a non-empty value, or omit the key from the file.", [], "app");
+		}
+		return {
+			key,
+			value
+		};
+	});
+}
+function extractParsedKeys(contents) {
+	const keys = [];
+	let multilineQuote = null;
+	const lines = contents.split(/\n/);
+	for (const [index, line] of lines.entries()) {
+		const lineNumber = index + 1;
+		if (multilineQuote !== null) {
+			if (hasClosingQuote(line, multilineQuote, 0)) multilineQuote = null;
+			continue;
+		}
+		const match = ASSIGNMENT_KEY_PATTERN.exec(line);
+		if (!match) continue;
+		const key = match[1];
+		keys.push({
+			key,
+			line: lineNumber
+		});
+		const valueStart = line.slice(match[0].length).trimStart();
+		const openingQuote = valueStart[0];
+		if ((openingQuote === "\"" || openingQuote === "'" || openingQuote === "`") && !hasClosingQuote(valueStart, openingQuote, 1)) multilineQuote = openingQuote;
+	}
+	return keys;
+}
+function validateEnvFileKey(key, line, filePath, command) {
+	try {
+		validateKey(key, command);
+	} catch (error) {
+		const reason = error instanceof Error && error.message.length > 0 ? error.message : "Invalid environment variable key.";
+		throw usageError(`Invalid environment variable "${key}" in "${filePath}"`, `Line ${line}: ${reason}`, "Use a valid env-var key and retry the import.", [], "app");
+	}
+}
+function hasClosingQuote(value, quote, startIndex) {
+	for (let index = startIndex; index < value.length; index += 1) if (value[index] === quote && !isEscaped(value, index)) return true;
+	return false;
+}
+function isEscaped(value, index) {
+	let backslashes = 0;
+	for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) backslashes += 1;
+	return backslashes % 2 === 1;
+}
+//#endregion
+export { readEnvFileAssignments };

package/dist/presenters/app-env.js

@@ -15,6 +15,21 @@ function listTargetLabel(result) {
 	return scopeLabel(result.scope);
 }
 function renderEnvAdd(context, descriptor, result) {
+	if (result.variables !== void 0) return renderList({
+		title: "Setting new environment variables from file.",
+		descriptor,
+		parentContext: {
+			key: "target",
+			value: `${scopeLabel(result.scope)} from ${result.file.path}`
+		},
+		items: result.variables.map((variable) => ({
+			noun: "variable",
+			label: `${variable.key} (${variable.source})`,
+			id: variable.id,
+			status: variable.isManagedBySystem ? "default" : null
+		})),
+		emptyMessage: "No environment variables imported."
+	}, context.ui);
 	return renderShow({
 		title: "Setting a new environment variable.",
 		descriptor,
@@ -48,6 +63,21 @@ function serializeEnvAdd(result) {
 	return result;
 }
 function renderEnvUpdate(context, descriptor, result) {
+	if (result.variables !== void 0) return renderList({
+		title: "Replacing environment variable values from file.",
+		descriptor,
+		parentContext: {
+			key: "target",
+			value: `${scopeLabel(result.scope)} from ${result.file.path}`
+		},
+		items: result.variables.map((variable) => ({
+			noun: "variable",
+			label: `${variable.key} (${variable.source})`,
+			id: variable.id,
+			status: variable.isManagedBySystem ? "default" : null
+		})),
+		emptyMessage: "No environment variables updated."
+	}, context.ui);
 	return renderShow({
 		title: "Replacing the environment variable's value.",
 		descriptor,

package/dist/presenters/app.js

@@ -55,10 +55,17 @@ function renderBranchDatabaseDeploySummary(context, result) {
 		},
 		...result.branchDatabase.schema ? [{
 			label: "Schema",
-			value: result.branchDatabase.schema.command === "migrate-deploy" ? "prisma migrate deploy" : "prisma db push"
+			value: formatBranchDatabaseSchemaCommand(result.branchDatabase.schema.command)
 		}] : []
 	])];
 }
+function formatBranchDatabaseSchemaCommand(command) {
+	switch (command) {
+		case "migrate-deploy": return "prisma migrate deploy";
+		case "db-push": return "prisma db push";
+		case "prisma-next-db-init": return "prisma-next db init";
+	}
+}
 function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
 	return `${(durationMs / 1e3).toFixed(1)}s`;

package/dist/shell/command-meta.js

@@ -363,6 +363,7 @@ const DESCRIPTORS = [
 		examples: [
 			"prisma-cli project env list",
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role production",
+			"prisma-cli project env add --file .env --role preview",
 			"prisma-cli project env add DATABASE_URL=postgresql://branch --branch feature/foo",
 			"prisma-cli project env remove STRIPE_KEY --role preview"
 		]
@@ -379,7 +380,9 @@ const DESCRIPTORS = [
 		examples: [
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role production",
 			"prisma-cli project env add STRIPE_KEY=sk_test_xxx --role preview",
+			"prisma-cli project env add --file .env --role preview",
 			"prisma-cli project env add DATABASE_URL=postgresql://branch --branch feature/foo",
+			"prisma-cli project env add --file .env.local --branch feature/foo",
 			"API_URL=https://api.example prisma-cli project env add API_URL --project proj_123 --role preview"
 		]
 	},
@@ -395,6 +398,7 @@ const DESCRIPTORS = [
 		examples: [
 			"prisma-cli project env update STRIPE_KEY=sk_new_xxx --role production",
 			"prisma-cli project env update STRIPE_KEY=sk_new_xxx --role preview",
+			"prisma-cli project env update --file .env --role production",
 			"prisma-cli project env update DATABASE_URL=postgresql://branch --branch feature/foo"
 		]
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.60.1",
+  "version": "3.0.0-dev.62.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -42,6 +42,7 @@
     "c12": "4.0.0-beta.5",
     "colorette": "^2.0.20",
     "commander": "^14.0.3",
+    "dotenv": "^17.4.2",
     "magicast": "^0.5.3",
     "open": "^11.0.0",
     "string-width": "^8.2.1",