@prisma/cli 3.0.0-beta.7 → 3.0.0-beta.9

package/dist/adapters/mock-api.js

@@ -56,6 +56,81 @@ var MockApi = class MockApi {
 	getDeployment(deploymentId) {
 		return this.data.deployments.find((deployment) => deployment.id === deploymentId);
 	}
+	listDatabasesForProject(projectId, branchName) {
+		return (this.data.databases ?? []).filter((database) => database.projectId === projectId && (!branchName || database.branchName === branchName));
+	}
+	getDatabase(databaseId) {
+		return (this.data.databases ?? []).find((database) => database.id === databaseId);
+	}
+	createDatabase(input) {
+		this.data.databases ??= [];
+		this.data.databaseConnections ??= [];
+		const database = {
+			id: `db_${this.data.databases.length + 1e3}`,
+			projectId: input.projectId,
+			branchId: input.branchName ? this.getBranchForProject(input.projectId, input.branchName)?.id ?? null : null,
+			branchName: input.branchName ?? null,
+			name: input.name,
+			region: input.region ?? null,
+			status: "ready",
+			isDefault: false,
+			createdAt: "2026-06-09T00:00:00.000Z"
+		};
+		const connectionString = `postgresql://${database.id}.example.prisma.io/postgres`;
+		const connection = {
+			id: `conn_${this.data.databaseConnections.length + 1e3}`,
+			databaseId: database.id,
+			name: "primary",
+			createdAt: "2026-06-09T00:00:00.000Z",
+			connectionString
+		};
+		this.data.databases.push(database);
+		this.data.databaseConnections.push(connection);
+		return {
+			database,
+			connection,
+			connectionString
+		};
+	}
+	removeDatabase(databaseId) {
+		this.data.databases ??= [];
+		this.data.databaseConnections ??= [];
+		const database = this.getDatabase(databaseId);
+		if (!database) return;
+		this.data.databases = this.data.databases.filter((candidate) => candidate.id !== databaseId);
+		this.data.databaseConnections = this.data.databaseConnections.filter((connection) => connection.databaseId !== databaseId);
+		return database;
+	}
+	listDatabaseConnections(databaseId) {
+		return (this.data.databaseConnections ?? []).filter((connection) => connection.databaseId === databaseId);
+	}
+	getDatabaseConnection(connectionId) {
+		return (this.data.databaseConnections ?? []).find((connection) => connection.id === connectionId);
+	}
+	createDatabaseConnection(input) {
+		if (!this.getDatabase(input.databaseId)) return;
+		this.data.databaseConnections ??= [];
+		const connectionString = `postgresql://${input.databaseId}-${this.data.databaseConnections.length + 1}.example.prisma.io/postgres`;
+		const connection = {
+			id: `conn_${this.data.databaseConnections.length + 1e3}`,
+			databaseId: input.databaseId,
+			name: input.name,
+			createdAt: "2026-06-09T00:00:00.000Z",
+			connectionString
+		};
+		this.data.databaseConnections.push(connection);
+		return {
+			connection,
+			connectionString
+		};
+	}
+	removeDatabaseConnection(connectionId) {
+		this.data.databaseConnections ??= [];
+		const connection = this.getDatabaseConnection(connectionId);
+		if (!connection) return;
+		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
+		return connection;
+	}
 };
 //#endregion
 export { MockApi };

package/dist/cli2.js

@@ -8,6 +8,7 @@ import "./shell/prompt.js";
 import { createAppCommand } from "./commands/app/index.js";
 import { createAuthCommand } from "./commands/auth/index.js";
 import { createBranchCommand } from "./commands/branch/index.js";
+import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
 import { getCliName, getCliVersion } from "./lib/version.js";
@@ -49,6 +50,7 @@ function createProgram(runtime) {
 	program.addCommand(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createDatabaseCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;
 }

package/dist/commands/app/index.js

@@ -65,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("--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"));
+	])).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|file>", "Environment variable assignment or dotenv file").argParser(collectRepeatableValues)).addOption(new Option("--db", "Create and wire a Prisma Postgres database for this deploy target")).addOption(new Option("--no-db", "Skip database setup")).addOption(new Option("--prod", "Confirm intent to deploy to production"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
@@ -80,7 +80,7 @@ function createDeployCommand(runtime) {
 		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");
+			if (hasDbConflict) throw usageError("app deploy accepts either --db or --no-db", "--db requests 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,

package/dist/commands/database/index.js

@@ -0,0 +1,159 @@
+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 { Command, Option } from "commander";
+//#region src/commands/database/index.ts
+function createDatabaseCommand(runtime) {
+	const database = attachCommandDescriptor(configureRuntimeCommand(new Command("database"), runtime), "database");
+	addCompactGlobalFlags(database);
+	database.addCommand(createDatabaseListCommand(runtime));
+	database.addCommand(createDatabaseShowCommand(runtime));
+	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseConnectionCommand(runtime));
+	return database;
+}
+function addProjectAndBranchOptions(command) {
+	return command.addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <git-name>", "Branch git name"));
+}
+function createDatabaseListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.list");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.list", options, (context) => runDatabaseList(context, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "database.show");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.show", options, (context) => runDatabaseShow(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseShow(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseShow(result)
+		});
+	});
+	return command;
+}
+function createDatabaseCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.create");
+	command.argument("<name>", "Database name").addOption(new Option("--region <region>", "Prisma Postgres region id"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const region = options.region;
+		await runCommand(runtime, "database.create", options, (context) => runDatabaseCreate(context, name, {
+			projectRef,
+			branchName,
+			region
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseCreate(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"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.remove", options, (context) => runDatabaseRemove(context, databaseRef, {
+			projectRef,
+			branchName,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRemove(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCommand(runtime) {
+	const connection = attachCommandDescriptor(configureRuntimeCommand(new Command("connection"), runtime), "database.connection");
+	addCompactGlobalFlags(connection);
+	connection.addCommand(createDatabaseConnectionListCommand(runtime));
+	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
+	return connection;
+}
+function createDatabaseConnectionListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.connection.list", options, (context) => runDatabaseConnectionList(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.connection.create");
+	command.argument("<database>", "Database id or name").addOption(new Option("--name <name>", "Connection name"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const name = options.name;
+		await runCommand(runtime, "database.connection.create", options, (context) => runDatabaseConnectionCreate(context, databaseRef, {
+			projectRef,
+			branchName,
+			name
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.connection.remove");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.remove", options, (context) => runDatabaseConnectionRemove(context, connectionRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createDatabaseCommand };

package/dist/controllers/app-env.js

@@ -1,11 +1,11 @@
 import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
+import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
+import { readEnvFileAssignments } from "../lib/app/env-file.js";
 import { resolveProjectTarget } from "../lib/project/resolution.js";
 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

package/dist/controllers/app.js

@@ -7,7 +7,7 @@ import { canPrompt } from "../shell/runtime.js";
 import { confirmPrompt, selectPrompt, textPrompt } from "../shell/prompt.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { readAuthState } from "../lib/auth/auth-ops.js";
-import { envVarNames, parseEnvAssignments } from "../lib/app/env-vars.js";
+import { envVarNames, parseEnvInputs } from "../lib/app/env-vars.js";
 import { renderDeployOutputRows, renderDeploySettingsPreview } from "../lib/app/deploy-output.js";
 import { readBunPackageEntrypoint, readBunPackageJson } from "../lib/app/bun-project.js";
 import { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp } from "../lib/app/local-dev.js";
@@ -17,6 +17,7 @@ import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, re
 import { bindProjectToDirectory, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
+import { resolveOrCreatePreviewBuildSettings } from "../lib/app/preview-build-settings.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
 import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
@@ -30,6 +31,7 @@ import { listRealWorkspaceProjects } from "./project.js";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import open from "open";
+import { Result, matchError } from "better-result";
 //#region src/controllers/app.ts
 const DEPLOY_FRAMEWORKS = [
 	"nextjs",
@@ -111,9 +113,9 @@ async function runAppDeploy(context, appName, options) {
 		createProjectName: options?.createProjectName,
 		envProjectId
 	});
-	const skipLocalPin = Boolean(envProjectId || options?.projectRef || options?.createProjectName);
-	const localPin = skipLocalPin ? { kind: "missing" } : await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
-	if (!skipLocalPin && localPin.kind === "invalid") throw localResolutionPinStaleError();
+	const localPinReadResult = Boolean(envProjectId || options?.projectRef || options?.createProjectName) ? Result.ok({ kind: "missing" }) : await readLocalResolutionPin(context.runtime.cwd, context.runtime.signal);
+	if (localPinReadResult.isErr()) throw localPinReadErrorToDeployError(localPinReadResult.error);
+	const localPin = localPinReadResult.value;
 	const branch = await resolveDeployBranch(context, options?.branchName);
 	if (options?.httpPort) parseDeployHttpPort(options.httpPort);
 	assertSupportedEntrypointForRequestedDeployShape({
@@ -138,7 +140,7 @@ async function runAppDeploy(context, appName, options) {
 	});
 	let runtime = resolveDeployRuntime(options?.httpPort, framework);
 	assertSupportedEntrypoint(framework.buildType, options?.entrypoint, "deploy");
-	const envVars = toOptionalEnvVars(parseEnvAssignments(options?.envAssignments, { commandName: "deploy" }));
+	const envVars = toOptionalEnvVars(await parseEnvInputs(context.runtime.cwd, options?.envAssignments, { commandName: "deploy" }));
 	const selectedApp = await resolveDeployAppSelection(context, projectId, await listApps(context, provider, projectId, target.branch.name), {
 		explicitAppName: appName,
 		explicitAppId: envAppId,
@@ -161,7 +163,7 @@ async function runAppDeploy(context, appName, options) {
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
-	await enforceProductionDeployGate(context, provider, {
+	const productionDeployGate = await enforceProductionDeployGate(context, provider, {
 		appId: selectedApp.appId,
 		appName: selectedApp.displayName,
 		branchKind: target.branch.kind,
@@ -170,10 +172,17 @@ async function runAppDeploy(context, appName, options) {
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
 	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint, context.runtime.signal);
+	const buildSettingsResolution = await resolveOrCreatePreviewBuildSettings({
+		appPath: context.runtime.cwd,
+		buildType,
+		signal: context.runtime.signal
+	});
+	maybeRenderDeployBuildSettings(context, buildSettingsResolution);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
 	const branchDatabaseSetup = await maybeSetupBranchDatabase(context, provider, projectId, toBranchDatabaseDeployBranch(target.branch), {
 		db: options?.db,
-		inlineEnvVars: envVars
+		providedEnvVars: envVars,
+		firstProductionDeploy: productionDeployGate.firstProductionDeploy
 	});
 	const progressState = createPreviewDeployProgressState();
 	const deployStartedAt = Date.now();
@@ -186,6 +195,7 @@ async function runAppDeploy(context, appName, options) {
 		region: selectedApp.region,
 		entrypoint,
 		buildType,
+		buildSettings: buildSettingsResolution.settings,
 		portMapping,
 		envVars,
 		interaction: void 0,
@@ -214,6 +224,18 @@ async function runAppDeploy(context, appName, options) {
 			},
 			deployment: deployResult.deployment,
 			deploySettings: {
+				config: {
+					path: buildSettingsResolution.relativeConfigPath,
+					status: buildSettingsResolution.status
+				},
+				buildCommand: {
+					value: buildSettingsResolution.settings.buildCommand,
+					source: buildSettingsResolution.settings.buildCommandSource
+				},
+				outputDirectory: {
+					value: buildSettingsResolution.settings.outputDirectory,
+					source: buildSettingsResolution.settings.outputDirectorySource
+				},
 				framework: {
 					key: framework.key,
 					buildType,
@@ -1603,7 +1625,6 @@ async function detectNextConfig(cwd, signal) {
 	for (const candidate of [
 		"next.config.js",
 		"next.config.mjs",
-		"next.config.cjs",
 		"next.config.ts",
 		"next.config.mts"
 	]) {
@@ -1696,6 +1717,20 @@ async function maybeRenderDeploySetupBlock(context, details) {
 	const prefix = details.includeDirectory ? `Deploying ${directory} to` : "Deploying to";
 	context.output.stderr.write(`${prefix} ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
 }
+function maybeRenderDeployBuildSettings(context, resolution) {
+	if (context.flags.json || context.flags.quiet) return;
+	const settings = resolution.settings;
+	const title = resolution.status === "created" ? `Created ${resolution.relativeConfigPath}` : `Using ${resolution.relativeConfigPath}`;
+	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [{
+		label: "Build Command",
+		value: settings.buildCommand ?? "none",
+		origin: settings.buildCommandSource ?? void 0
+	}, {
+		label: "Output Directory",
+		value: settings.outputDirectory,
+		origin: settings.outputDirectorySource ?? void 0
+	}]).join("\n")}\n\n`);
+}
 function maybeRenderProjectLinked(context, directory, projectName, localPinPath) {
 	if (context.flags.json || context.flags.quiet) return;
 	context.output.stderr.write(`${context.ui.success("✔")} Linked "${directory}" to Project "${projectName}"\nSaved ${localPinPath}\n\n`);
@@ -1942,6 +1977,18 @@ function localResolutionPinStaleError() {
 		]
 	});
 }
+function localPinReadErrorToDeployError(error) {
+	return matchError(error, {
+		LocalResolutionPinInvalidJsonError: () => localResolutionPinStaleError(),
+		LocalResolutionPinInvalidShapeError: () => localResolutionPinStaleError(),
+		LocalResolutionPinReadAbortedError: (error) => {
+			throw error;
+		},
+		UnhandledException: (error) => {
+			throw error;
+		}
+	});
+}
 function readDeployEnvOverride(context, name) {
 	const value = context.runtime.env[name]?.trim();
 	return value ? value : void 0;