@prisma/cli 3.0.0-dev.107.1 → 3.0.0-dev.110.1

package/dist/cli2.js

@@ -9,6 +9,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 { createBuildCommand } from "./commands/build/index.js";
 import { createDatabaseCommand } from "./commands/database/index.js";
 import { createGitCommand } from "./commands/git/index.js";
 import { createProjectCommand } from "./commands/project/index.js";
@@ -52,6 +53,7 @@ function createProgram(runtime) {
 	program.addCommand(createProjectCommand(runtime));
 	program.addCommand(createGitCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createBuildCommand(runtime));
 	program.addCommand(createDatabaseCommand(runtime));
 	program.addCommand(createAppCommand(runtime));
 	return program;

package/dist/commands/app/index.js

@@ -66,7 +66,7 @@ function createRunCommand(runtime) {
 }
 function createDeployCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([...FRAMEWORK_KEYS])).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("--region <region>", "Region for a newly created app; existing apps keep their region")).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"));
+	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([...FRAMEWORK_KEYS])).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("--region <region>", "Region for a newly created app; existing apps keep their region")).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")).addOption(new Option("--no-promote", "Build the new deployment without promoting it to live (promote later with app promote <id>)"));
 	addGlobalFlags(command);
 	command.action(async (configTarget, options) => {
 		const appName = options.app;
@@ -79,6 +79,7 @@ function createDeployCommand(runtime) {
 		const projectRef = options.project;
 		const createProjectName = options.createProject;
 		const prod = options.prod;
+		const noPromote = options.promote === false;
 		const db = options.db;
 		const hasDbConflict = hasFlag(runtime.argv, "--db") && hasFlag(runtime.argv, "--no-db");
 		await runCommand(runtime, "app.deploy", options, (context) => {
@@ -93,6 +94,7 @@ function createDeployCommand(runtime) {
 				region,
 				envAssignments,
 				prod: prod === true,
+				noPromote,
 				db,
 				configTarget
 			});

package/dist/commands/build/index.js

@@ -0,0 +1,29 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runStreamingCommand } from "../../shell/command-runner.js";
+import { runBuildLogs } from "../../controllers/build.js";
+import { Command, Option } from "commander";
+//#region src/commands/build/index.ts
+function createBuildCommand(runtime) {
+	const build = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "build");
+	addCompactGlobalFlags(build);
+	build.addCommand(createLogsCommand(runtime));
+	return build;
+}
+function createLogsCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "build.logs");
+	command.argument("<buildId>", "Build id from a git-push or Console deploy").addOption(new Option("--follow", "Keep the connection open and stream new logs as the build runs")).addOption(new Option("--cursor <cursor>", "Resume from a prior terminal cursor"));
+	addGlobalFlags(command);
+	command.action(async (buildId, options) => {
+		const follow = options.follow;
+		const cursor = options.cursor;
+		await runStreamingCommand(runtime, "build.logs", options, (context) => runBuildLogs(context, buildId, {
+			follow,
+			cursor
+		}), { emitJsonSuccessEvent: false });
+	});
+	return command;
+}
+//#endregion
+export { createBuildCommand };

package/dist/controllers/app.js

@@ -329,7 +329,8 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 	});
 	framework = customized.framework;
 	runtime = customized.runtime;
-	const productionDeployGate = await enforceProductionDeployGate(context, provider, {
+	const noPromote = options?.noPromote === true;
+	const productionDeployGate = noPromote ? { firstProductionDeploy: false } : await enforceProductionDeployGate(context, provider, {
 		appId: selectedApp.appId,
 		appName: selectedApp.displayName,
 		branchKind: target.branch.kind,
@@ -367,6 +368,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		buildSettings: buildSettingsResolution.settings,
 		portMapping,
 		envVars,
+		skipPromote: noPromote,
 		interaction: void 0,
 		signal: context.runtime.signal,
 		progress: createDeployProgress(context.output.stderr, context.ui, !context.flags.json && !context.flags.quiet, progressState)
@@ -378,7 +380,8 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 		id: deployResult.app.id,
 		name: deployResult.app.name
 	});
-	await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, deployResult.deployment.id);
+	const knownLiveDeploymentId = deployResult.promoted ? deployResult.deployment.id : deployResult.app.liveDeploymentId;
+	if (knownLiveDeploymentId) await context.stateStore.setKnownLiveDeployment(projectId, deployResult.app.id, knownLiveDeploymentId);
 	return {
 		command: "app.deploy",
 		result: {
@@ -392,6 +395,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 				name: deployResult.app.name
 			},
 			deployment: deployResult.deployment,
+			promoted: deployResult.promoted,
 			deploySettings: {
 				config: {
 					path: buildSettingsResolution.relativeConfigPath,
@@ -424,7 +428,7 @@ async function runSingleAppDeploy(context, appName, options, preloadedConfig) {
 			...legacyWarnings,
 			...branchDatabaseSetup.warnings
 		],
-		nextSteps: ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`]
+		nextSteps: deployResult.promoted ? ["prisma-cli app list-deploys", `prisma-cli app show-deploy ${deployResult.deployment.id}`] : [`prisma-cli app promote ${deployResult.deployment.id}`, `prisma-cli app show-deploy ${deployResult.deployment.id}`]
 	};
 }
 async function resolveDeployBuildSettings(options) {

package/dist/controllers/build.js

@@ -0,0 +1,88 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+import { writeJsonEvent } from "../shell/output.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+//#region src/controllers/build.ts
+async function runBuildLogs(context, buildId, options = {}) {
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	if (!context.flags.json && !context.flags.quiet) context.output.stderr.write(`build logs → Streaming logs for build ${buildId}\n\n`);
+	const { data, response } = await client.GET("/v1/builds/{buildId}/logs", {
+		params: {
+			path: { buildId },
+			query: {
+				...options.follow ? { follow: "true" } : {},
+				...options.cursor ? { cursor: options.cursor } : {}
+			}
+		},
+		parseAs: "stream",
+		signal: context.runtime.signal
+	});
+	const body = data;
+	if (!response.ok || !body) throw buildLogsRequestError(buildId, response.status);
+	let sawError = false;
+	await forEachNdjsonRecord(body, (record) => {
+		if (record.type === "terminal" && record.kind === "error") sawError = true;
+		writeBuildLogRecord(context, record);
+	});
+	if (sawError) process.exitCode = 1;
+}
+function writeBuildLogRecord(context, record) {
+	if (context.flags.json) {
+		writeJsonEvent(context.output, {
+			type: record.type,
+			command: "build.logs",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			data: record
+		});
+		return;
+	}
+	if (record.type === "log") {
+		const stream = record.source === "stderr" || record.level === "error" ? context.output.stderr : context.output.stdout;
+		stream.write(record.text);
+		if (!record.text.endsWith("\n")) stream.write("\n");
+		return;
+	}
+	if (record.code !== "end") context.output.stderr.write(`${record.message}\n`);
+}
+/** Reads a newline-delimited JSON body line by line, parsing each into a record. */
+async function forEachNdjsonRecord(body, onRecord) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (value) buffer += decoder.decode(value, { stream: true });
+		let newlineIndex = buffer.indexOf("\n");
+		while (newlineIndex !== -1) {
+			const line = buffer.slice(0, newlineIndex).trim();
+			buffer = buffer.slice(newlineIndex + 1);
+			if (line) onRecord(JSON.parse(line));
+			newlineIndex = buffer.indexOf("\n");
+		}
+		if (done) {
+			const tail = buffer.trim();
+			if (tail) onRecord(JSON.parse(tail));
+			return;
+		}
+	}
+}
+function buildLogsRequestError(buildId, status) {
+	if (status === 404) return new CliError({
+		code: "BUILD_NOT_FOUND",
+		domain: "app",
+		summary: `Build ${buildId} was not found`,
+		why: "The build does not exist, or your workspace does not have access to it.",
+		fix: "Check the build id, or run prisma-cli auth login to switch to the workspace that owns it.",
+		exitCode: 1
+	});
+	return new CliError({
+		code: "BUILD_LOGS_FAILED",
+		domain: "app",
+		summary: `Failed to read logs for build ${buildId}`,
+		why: `The Management API returned HTTP ${status}.`,
+		fix: "Retry the command, or rerun with --trace for more detail.",
+		exitCode: 1
+	});
+}
+//#endregion
+export { runBuildLogs };

package/dist/lib/app/app-provider.js

@@ -174,6 +174,7 @@ function createAppProvider(client, options) {
 				region: resolvedApp.region,
 				portMapping: options.portMapping,
 				envVars: options.envVars,
+				skipPromote: options.skipPromote,
 				timeoutSeconds: 120,
 				pollIntervalMs: 2e3,
 				interaction: options.interaction,
@@ -188,14 +189,16 @@ function createAppProvider(client, options) {
 					id: deployed.appId,
 					name: deployed.appName,
 					region: deployed.region ?? null,
-					liveDeploymentId: deployed.deploymentId,
+					liveDeploymentId: deployed.promoted ? deployed.deploymentId : deployed.previousDeploymentId,
 					liveUrl: toAbsoluteUrl(deployed.appEndpointDomain ?? null)
 				},
 				deployment: {
 					id: deployed.deploymentId,
 					status: "running",
-					url: toAbsoluteUrl(deployed.appEndpointDomain ?? deployed.deploymentEndpointDomain ?? null)
-				}
+					url: toAbsoluteUrl(deployed.appEndpointDomain ?? deployed.deploymentEndpointDomain ?? null),
+					live: deployed.promoted
+				},
+				promoted: deployed.promoted
 			};
 		},
 		async updateAppEnv(options) {

package/dist/presenters/app.js

@@ -31,11 +31,17 @@ function serializeAppBuild(result) {
 function renderAppDeploy(context, descriptor, result, options) {
 	const logsCommand = options?.logsTarget ? `prisma-cli app logs ${options.logsTarget}` : "prisma-cli app logs";
 	return [
-		`Live in ${formatDuration(result.durationMs)}`,
-		...result.deployment.url ? [context.ui.link(result.deployment.url)] : [],
+		...result.promoted ? [`Live in ${formatDuration(result.durationMs)}`, ...result.deployment.url ? [context.ui.link(result.deployment.url)] : []] : [
+			`Built ${result.deployment.id} in ${formatDuration(result.durationMs)} (not promoted)`,
+			...result.deployment.url ? [context.ui.link(result.deployment.url)] : [],
+			context.ui.dim("The live deployment is unchanged.")
+		],
 		...renderBranchDatabaseDeploySummary(context, result),
 		"",
-		...renderDeployOutputRows(context.ui, [{
+		...renderDeployOutputRows(context.ui, [...result.promoted ? [] : [{
+			label: "Promote",
+			value: `prisma-cli app promote ${result.deployment.id}`
+		}], {
 			label: "Logs",
 			value: logsCommand
 		}]),

package/dist/shell/command-meta.js

@@ -195,6 +195,22 @@ const DESCRIPTORS = [
 		description: "View your Platform branches",
 		examples: ["prisma-cli branch list"]
 	},
+	{
+		id: "build",
+		path: ["prisma", "build"],
+		description: "Inspect builds",
+		examples: ["prisma-cli build logs <build_id>"]
+	},
+	{
+		id: "build.logs",
+		path: [
+			"prisma",
+			"build",
+			"logs"
+		],
+		description: "Stream the logs for a build",
+		examples: ["prisma-cli build logs <build_id>", "prisma-cli build logs <build_id> --follow"]
+	},
 	{
 		id: "database",
 		path: ["prisma", "database"],

package/dist/shell/command-runner.js

@@ -75,12 +75,12 @@ async function renderBestEffortCommandDiagnostics(context, options) {
 		return [];
 	}
 }
-async function runStreamingCommand(runtime, commandName, options, handler) {
+async function runStreamingCommand(runtime, commandName, options, handler, streamOptions) {
 	const flags = resolveGlobalFlags(runtime.argv, options);
 	const context = await createCommandContext(runtime, flags);
 	try {
 		await handler(context);
-		if (flags.json) writeJsonEvent(context.output, {
+		if (flags.json && (streamOptions?.emitJsonSuccessEvent ?? true)) writeJsonEvent(context.output, {
 			type: "success",
 			command: commandName,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.107.1",
+  "version": "3.0.0-dev.110.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {