@prisma/cli 3.0.0-beta.8 → 3.0.0-dev.101.1

package/dist/lib/project/resolution.js

@@ -1,46 +1,100 @@
 import { CliError } from "../../shell/errors.js";
-import { formatCommandArgument } from "../../shell/command-arguments.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
+import { formatCommandArgument } from "../../shell/command-arguments.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { Result, TaggedError, matchError } from "better-result";
 //#region src/lib/project/resolution.ts
+var ProjectNotFoundError = class extends TaggedError("ProjectNotFoundError")() {
+	constructor(projectRef, workspace) {
+		super({
+			message: `Project "${projectRef}" was not found in workspace "${workspace.name}".`,
+			projectRef,
+			workspace
+		});
+	}
+};
+var ProjectAmbiguousError = class extends TaggedError("ProjectAmbiguousError")() {
+	constructor(projectRef, matches) {
+		super({
+			message: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
+			projectRef,
+			matches
+		});
+	}
+};
+var LocalStateStaleError = class extends TaggedError("LocalStateStaleError")() {
+	constructor() {
+		super({
+			message: `The target recorded in ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} is no longer available in the selected workspace.`,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalProjectWorkspaceMismatchError = class extends TaggedError("LocalProjectWorkspaceMismatchError")() {
+	constructor(options) {
+		super({
+			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} links this directory to project ${options.pinnedProjectId} in workspace ${options.pinnedWorkspaceId}, but the active workspace is "${options.activeWorkspace.name}" (${options.activeWorkspace.id}).`,
+			pinnedWorkspaceId: options.pinnedWorkspaceId,
+			pinnedProjectId: options.pinnedProjectId,
+			activeWorkspace: options.activeWorkspace
+		});
+	}
+};
+var ProjectSetupRequiredError = class extends TaggedError("ProjectSetupRequiredError")() {
+	constructor(options) {
+		const commandLabel = options.commandName ? `prisma-cli ${options.commandName}` : "this command";
+		super({
+			message: `This directory is not linked to a Prisma Project, and ${commandLabel} will not choose one from package or directory names.`,
+			commandName: options.commandName,
+			suggestion: options.suggestion
+		});
+	}
+};
 async function resolveProjectTarget(options) {
-	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: true });
-	const projects = await options.listProjects();
-	const target = await resolveBoundProjectTarget(options, projects, {
-		allowEnvProjectId: true,
-		localPin
-	});
-	if (target) return target;
-	throw await projectSetupRequiredError({
-		cwd: options.context.runtime.cwd,
-		projects,
-		commandName: options.commandName,
-		signal: options.context.runtime.signal
+	return Result.gen(async function* () {
+		const localPin = yield* Result.await(readImplicitLocalPin(options, { allowEnvProjectId: true }));
+		const projects = await options.listProjects();
+		const target = yield* Result.await(resolveBoundProjectTarget(options, projects, {
+			allowEnvProjectId: true,
+			localPin
+		}));
+		if (target) return Result.ok(target);
+		return Result.err(await projectSetupRequiredError({
+			cwd: options.context.runtime.cwd,
+			projects,
+			commandName: options.commandName,
+			signal: options.context.runtime.signal
+		}));
 	});
 }
 async function inspectProjectBinding(options) {
-	const localPin = await readImplicitLocalPin(options, { allowEnvProjectId: false });
-	const projects = await options.listProjects();
-	const target = await resolveBoundProjectTarget(options, projects, {
-		allowEnvProjectId: false,
-		localPin
+	return Result.gen(async function* () {
+		const localPin = yield* Result.await(readImplicitLocalPin(options, { allowEnvProjectId: false }));
+		const projects = await options.listProjects();
+		const target = yield* Result.await(resolveBoundProjectTarget(options, projects, {
+			allowEnvProjectId: false,
+			localPin
+		}));
+		if (target) return Result.ok(target);
+		return Result.ok({
+			workspace: options.workspace,
+			project: null,
+			localBinding: { status: "not-linked" },
+			resolution: { projectSource: "unbound" },
+			...await buildProjectSetupSuggestion({
+				cwd: options.context.runtime.cwd,
+				projects,
+				commandName: options.commandName ?? "project show",
+				signal: options.context.runtime.signal
+			})
+		});
 	});
-	if (target) return target;
-	return {
-		workspace: options.workspace,
-		project: null,
-		localBinding: { status: "not-linked" },
-		resolution: { projectSource: "unbound" },
-		...await buildProjectSetupSuggestion({
-			cwd: options.context.runtime.cwd,
-			projects,
-			commandName: options.commandName ?? "project show",
-			signal: options.context.runtime.signal
-		})
-	};
 }
 function projectNotFoundError(projectRef, workspace) {
+	return projectResolutionErrorToCliError(new ProjectNotFoundError(projectRef, workspace));
+}
+function projectNotFoundCliError(projectRef, workspace) {
 	return new CliError({
 		code: "PROJECT_NOT_FOUND",
 		domain: "project",
@@ -52,6 +106,9 @@ function projectNotFoundError(projectRef, workspace) {
 	});
 }
 function projectAmbiguousError(projectRef, matches) {
+	return projectResolutionErrorToCliError(new ProjectAmbiguousError(projectRef, matches));
+}
+function projectAmbiguousCliError(projectRef, matches) {
 	const firstMatch = matches[0];
 	const nextSteps = ["prisma-cli project list"];
 	if (firstMatch) nextSteps.push(`prisma-cli app deploy --project ${firstMatch.id}`);
@@ -69,7 +126,7 @@ function projectAmbiguousError(projectRef, matches) {
 		nextSteps
 	});
 }
-function localStateStaleError() {
+function localStateStaleCliError() {
 	return new CliError({
 		code: "LOCAL_STATE_STALE",
 		domain: "project",
@@ -82,12 +139,15 @@ function localStateStaleError() {
 	});
 }
 function localProjectWorkspaceMismatchError(options) {
+	return projectResolutionErrorToCliError(new LocalProjectWorkspaceMismatchError(options));
+}
+function localProjectWorkspaceMismatchCliError(options) {
 	return new CliError({
 		code: "LOCAL_PROJECT_WORKSPACE_MISMATCH",
 		domain: "project",
 		summary: "Project link uses another workspace",
 		why: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} links this directory to project ${options.pinnedProjectId} in workspace ${options.pinnedWorkspaceId}, but your current CLI session is workspace "${options.activeWorkspace.name}" (${options.activeWorkspace.id}).`,
-		fix: "Sign in to the linked workspace, or relink this directory to a project in the current workspace.",
+		fix: "Switch to the linked workspace, or relink this directory to a project in the current workspace.",
 		meta: {
 			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
 			pinnedWorkspaceId: options.pinnedWorkspaceId,
@@ -97,12 +157,37 @@ function localProjectWorkspaceMismatchError(options) {
 		},
 		exitCode: 1,
 		nextSteps: [
-			"prisma-cli auth login",
+			`prisma-cli auth workspace use ${options.pinnedWorkspaceId}`,
 			"prisma-cli project list",
 			"prisma-cli project link <id-or-name>"
 		]
 	});
 }
+/**
+* Converts expected project-resolution variants to command-boundary CliErrors.
+* `LocalResolutionPinReadAbortedError` and `UnhandledException` intentionally
+* propagate as exceptions; callers such as `resolveProjectShowInRealMode`
+* throw this helper's result, so passthrough variants should keep bubbling.
+*/
+function projectResolutionErrorToCliError(error) {
+	return matchError(error, {
+		ProjectNotFoundError: (error) => projectNotFoundCliError(error.projectRef, error.workspace),
+		ProjectAmbiguousError: (error) => projectAmbiguousCliError(error.projectRef, error.matches),
+		ProjectSetupRequiredError: (error) => projectSetupRequiredCliError(error),
+		LocalStateStaleError: () => localStateStaleCliError(),
+		LocalProjectWorkspaceMismatchError: (error) => localProjectWorkspaceMismatchCliError({
+			pinnedWorkspaceId: error.pinnedWorkspaceId,
+			pinnedProjectId: error.pinnedProjectId,
+			activeWorkspace: error.activeWorkspace
+		}),
+		LocalResolutionPinReadAbortedError: (error) => {
+			throw error;
+		},
+		UnhandledException: (error) => {
+			throw error;
+		}
+	});
+}
 async function buildProjectSetupSuggestion(options) {
 	const suggestedName = await inferTargetName(options.cwd, options.signal);
 	const candidates = sortProjects(options.projects.filter((project) => projectMatchesSuggestedName(project, suggestedName.name))).map(toProjectSummary);
@@ -115,17 +200,24 @@ async function buildProjectSetupSuggestion(options) {
 }
 async function projectSetupRequiredError(options) {
 	const suggestion = await buildProjectSetupSuggestion(options);
+	return new ProjectSetupRequiredError({
+		commandName: options.commandName,
+		suggestion
+	});
+}
+function projectSetupRequiredCliError(error) {
+	const suggestion = error.suggestion;
 	return new CliError({
 		code: "PROJECT_SETUP_REQUIRED",
 		domain: "project",
 		summary: "Choose a Project before running this command",
-		why: `This directory is not linked to a Prisma Project, and ${options.commandName ? `prisma-cli ${options.commandName}` : "this command"} will not choose one from package or directory names.`,
+		why: error.message,
 		fix: "Link the directory to an existing Project, or pass --project <id-or-name> for this command.",
 		meta: { ...suggestion },
 		exitCode: 1,
 		nextSteps: ["prisma-cli project list", ...suggestion.recoveryCommands],
 		nextActions: buildProjectSetupNextActions({
-			commandName: options.commandName,
+			commandName: error.commandName,
 			suggestedProjectName: suggestion.suggestedProjectName
 		})
 	});
@@ -199,9 +291,9 @@ function sortProjects(projects) {
 }
 function resolveExplicitProject(projectRef, projects, workspace) {
 	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
-	if (matches.length === 1) return matches[0];
-	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
-	throw projectNotFoundError(projectRef, workspace);
+	if (matches.length === 1) return Result.ok(matches[0]);
+	if (matches.length > 1) return Result.err(new ProjectAmbiguousError(projectRef, matches));
+	return Result.err(new ProjectNotFoundError(projectRef, workspace));
 }
 function projectMatchesSuggestedName(project, suggestedName) {
 	return project.id === suggestedName || project.name === suggestedName || project.slug === suggestedName;
@@ -210,50 +302,63 @@ async function resolveDurablePlatformMapping() {
 	return null;
 }
 async function resolveBoundProjectTarget(options, projects, settings) {
-	if (options.explicitProject) return resolvedTarget(options.workspace, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
-		targetName: options.explicitProject,
-		targetNameSource: "explicit"
-	});
+	if (options.explicitProject) {
+		const projectResult = resolveExplicitProject(options.explicitProject, projects, options.workspace);
+		if (projectResult.isErr()) return Result.err(projectResult.error);
+		return Result.ok(resolvedTarget(options.workspace, projectResult.value, "explicit", {
+			targetName: options.explicitProject,
+			targetNameSource: "explicit"
+		}));
+	}
 	if (settings.allowEnvProjectId && options.envProjectId) {
 		const project = projects.find((candidate) => candidate.id === options.envProjectId);
-		if (!project) throw projectNotFoundError(options.envProjectId, options.workspace);
-		return resolvedTarget(options.workspace, project, "env", {
+		if (!project) return Result.err(new ProjectNotFoundError(options.envProjectId, options.workspace));
+		return Result.ok(resolvedTarget(options.workspace, project, "env", {
 			targetName: options.envProjectId,
 			targetNameSource: "env"
-		});
+		}));
 	}
 	const localPin = settings.localPin;
-	if (!localPin) return null;
-	if (localPin.kind === "invalid") throw localStateStaleError();
+	if (!localPin) return Result.ok(null);
 	if (localPin.kind === "present") {
-		if (localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
+		if (localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
 			pinnedWorkspaceId: localPin.pin.workspaceId,
 			pinnedProjectId: localPin.pin.projectId,
 			activeWorkspace: options.workspace
-		});
+		}));
 		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
-		if (!project) throw localStateStaleError();
-		return resolvedTarget(options.workspace, project, "local-pin", {
+		if (!project) return Result.err(new LocalStateStaleError());
+		return Result.ok(resolvedTarget(options.workspace, project, "local-pin", {
 			targetName: project.name,
 			targetNameSource: "local-pin"
-		});
+		}));
 	}
 	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
+	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return Result.ok(resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
 		targetName: platformMapping.name,
 		targetNameSource: "platform-mapping"
-	});
-	return null;
+	}));
+	return Result.ok(null);
 }
 async function readImplicitLocalPin(options, settings) {
-	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return null;
-	const localPin = await readLocalResolutionPin(options.context.runtime.cwd, options.context.runtime.signal);
-	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) throw localProjectWorkspaceMismatchError({
+	if (options.explicitProject || settings.allowEnvProjectId && options.envProjectId) return Result.ok(null);
+	const localPinResult = await readLocalResolutionPin(options.projectDir ?? options.context.runtime.cwd, options.context.runtime.signal);
+	if (localPinResult.isErr()) return Result.err(localPinReadErrorToProjectError(localPinResult.error));
+	const localPin = localPinResult.value;
+	if (localPin.kind === "present" && localPin.pin.workspaceId !== options.workspace.id) return Result.err(new LocalProjectWorkspaceMismatchError({
 		pinnedWorkspaceId: localPin.pin.workspaceId,
 		pinnedProjectId: localPin.pin.projectId,
 		activeWorkspace: options.workspace
+	}));
+	return Result.ok(localPin);
+}
+function localPinReadErrorToProjectError(error) {
+	return matchError(error, {
+		LocalResolutionPinInvalidJsonError: () => new LocalStateStaleError(),
+		LocalResolutionPinInvalidShapeError: () => new LocalStateStaleError(),
+		LocalResolutionPinReadAbortedError: (error) => error,
+		UnhandledException: (error) => error
 	});
-	return localPin;
 }
 function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
 	return {
@@ -278,4 +383,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectAmbiguousError, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };
+export { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, localProjectWorkspaceMismatchError, projectAmbiguousError, projectNotFoundError, projectResolutionErrorToCliError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };

package/dist/lib/project/setup.js

@@ -1,7 +1,10 @@
 import { CliError, usageError } from "../../shell/errors.js";
-import "../../shell/command-arguments.js";
+import { shortenHomePath } from "../fs/home-path.js";
 import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
+import "../../shell/command-arguments.js";
 import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
+import path from "node:path";
+import { Result, matchError } from "better-result";
 //#region src/lib/project/setup.ts
 function isValidProjectSetupName(projectName) {
 	return projectName.trim().length > 0;
@@ -16,22 +19,64 @@ function resolveProjectForSetup(projectRef, projects, workspace) {
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
 	throw projectNotFoundError(projectRef, workspace);
 }
-async function bindProjectToDirectory(context, workspace, project, action) {
-	await writeLocalResolutionPin(context.runtime.cwd, {
-		workspaceId: workspace.id,
-		projectId: project.id
-	}, context.runtime.signal);
-	await ensureLocalResolutionPinGitignore(context.runtime.cwd, context.runtime.signal);
-	return {
-		workspace,
-		project,
-		directory: formatSetupDirectory(context.runtime.cwd),
-		localPin: {
-			path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
-			written: true
+async function bindProjectToDirectory(context, workspace, project, action, directory = context.runtime.cwd) {
+	return Result.gen(async function* () {
+		yield* Result.await(writeLocalResolutionPin(directory, {
+			workspaceId: workspace.id,
+			projectId: project.id
+		}, context.runtime.signal));
+		yield* Result.await(ensureLocalResolutionPinGitignore(directory, context.runtime.signal));
+		return Result.ok({
+			workspace,
+			project,
+			directory: formatSetupDirectory(directory, context),
+			localPin: {
+				path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
+				written: true
+			},
+			action
+		});
+	});
+}
+function projectDirectoryBindingErrorToCliError(error) {
+	return matchError(error, {
+		LocalResolutionPinSerializationError: (error) => {
+			throw error;
 		},
-		action
-	};
+		LocalResolutionPinWriteAbortedError: (error) => {
+			throw error;
+		},
+		LocalResolutionPinWriteFailedError: (error) => localStateWriteFailedError(error, {
+			why: `The CLI could not write ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			meta: {
+				pinPath: error.pinPath,
+				operation: error.operation
+			}
+		}),
+		LocalResolutionPinGitignoreUpdateAbortedError: (error) => {
+			throw error;
+		},
+		LocalResolutionPinGitignoreUpdateFailedError: (error) => localStateWriteFailedError(error, {
+			why: "The CLI could not update .gitignore to keep local Project binding state out of git.",
+			meta: {
+				gitignorePath: error.gitignorePath,
+				operation: error.operation
+			}
+		})
+	});
+}
+function localStateWriteFailedError(error, options) {
+	return new CliError({
+		code: "LOCAL_STATE_WRITE_FAILED",
+		domain: "project",
+		summary: "Could not save local Project binding",
+		why: options.why,
+		fix: "Check that this directory is writable and that .prisma/local.json and .gitignore are not blocked by directories or permissions, then retry.",
+		debug: formatDebugDetails(error.cause),
+		meta: options.meta,
+		exitCode: 1,
+		nextSteps: ["prisma-cli project link <id-or-name>", "prisma-cli app deploy --project <id-or-name>"]
+	});
 }
 function toProjectSummary(project) {
 	return {
@@ -66,8 +111,9 @@ function projectCreateFailedError(error, projectName, workspace, options) {
 		nextSteps: options.nextSteps
 	});
 }
-function formatSetupDirectory(cwd) {
-	const basename = cwd.split(/[\\/]/).filter(Boolean).pop();
+function formatSetupDirectory(directory, context) {
+	if (path.resolve(directory) !== path.resolve(context.runtime.cwd)) return shortenHomePath(directory, context.runtime.env);
+	const basename = directory.split(/[\\/]/).filter(Boolean).pop();
 	return basename ? `./${basename}` : ".";
 }
 function extractHttpStatus(error) {
@@ -86,4 +132,4 @@ function formatDebugDetails(error) {
 	return typeof error === "string" ? error : null;
 }
 //#endregion
-export { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary, validateProjectSetupNameText };
+export { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary, validateProjectSetupNameText };

package/dist/output/patterns.js

@@ -1,5 +1,5 @@
-import { maskValue, padDisplay, renderSummaryLine } from "../shell/ui.js";
 import { formatDescriptorLabel } from "../shell/command-meta.js";
+import { maskValue, padDisplay, renderSummaryLine } from "../shell/ui.js";
 import stringWidth from "string-width";
 //#region src/output/patterns.ts
 function renderList(input, ui) {

package/dist/presenters/app.js

@@ -28,7 +28,8 @@ function renderAppBuild(context, descriptor, result) {
 function serializeAppBuild(result) {
 	return result;
 }
-function renderAppDeploy(context, descriptor, 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)] : [],
@@ -36,12 +37,37 @@ function renderAppDeploy(context, descriptor, result) {
 		"",
 		...renderDeployOutputRows(context.ui, [{
 			label: "Logs",
-			value: "prisma-cli app logs"
+			value: logsCommand
 		}]),
 		...renderDeployResolvedContextBlock(context, result),
 		...renderDeploySettingsBlock(context, result)
 	];
 }
+function isAppDeployAllResult(result) {
+	return "deployments" in result;
+}
+function renderAppDeployAll(context, descriptor, result) {
+	const lines = [];
+	for (const deployment of result.deployments) {
+		lines.push(deployment.target);
+		lines.push(...renderAppDeploy(context, descriptor, deployment.result, { logsTarget: deployment.target }).map((line) => line ? `  ${line}` : line));
+		lines.push("");
+	}
+	lines.push(...renderDeployOutputRows(context.ui, result.deployments.map((deployment) => ({
+		label: deployment.target,
+		value: deployment.result.deployment.url ?? deployment.result.deployment.id
+	}))));
+	return lines;
+}
+function serializeAppDeployAll(result) {
+	return {
+		count: result.deployments.length,
+		deployments: result.deployments.map((deployment) => ({
+			target: deployment.target,
+			...serializeAppDeploy(deployment.result)
+		}))
+	};
+}
 function serializeAppDeploy(result) {
 	const { deploySettings, localPin: _localPin, ...serialized } = result;
 	const { id: _branchId, ...branch } = serialized.branch;
@@ -57,27 +83,13 @@ function serializeAppDeploy(result) {
 }
 function renderBranchDatabaseDeploySummary(context, result) {
 	if (!result.branchDatabase || result.branchDatabase.status !== "created") return [];
-	return ["", ...renderDeployOutputRows(context.ui, [
-		{
-			label: "Database",
-			value: result.branchDatabase.database?.name ?? "created"
-		},
-		{
-			label: "Env",
-			value: result.branchDatabase.envVars.join(", ")
-		},
-		...result.branchDatabase.schema ? [{
-			label: "Schema",
-			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";
-	}
+	return ["", ...renderDeployOutputRows(context.ui, [{
+		label: "Database",
+		value: result.branchDatabase.database?.name ?? "created"
+	}, {
+		label: "Env",
+		value: result.branchDatabase.envVars.join(", ")
+	}])];
 }
 function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
@@ -163,21 +175,14 @@ function branchDatabaseRows(branchDatabase) {
 		value: "not configured",
 		tone: "dim"
 	}];
-	return [
-		{
-			key: "branch db",
-			value: branchDatabase.status === "created" ? `created${branchDatabase.database ? ` (${branchDatabase.database.name})` : ""}` : `skipped${branchDatabase.reason ? ` (${branchDatabase.reason})` : ""}`,
-			tone: branchDatabase.status === "created" ? "success" : "dim"
-		},
-		...branchDatabase.envVars.length > 0 ? [{
-			key: "branch db env",
-			value: branchDatabase.envVars.join(", ")
-		}] : [],
-		...branchDatabase.schema ? [{
-			key: "branch db schema",
-			value: `${formatBranchDatabaseSchemaCommand(branchDatabase.schema.command)} (${branchDatabase.schema.source}, ${branchDatabase.schema.path})`
-		}] : []
-	];
+	return [{
+		key: "branch db",
+		value: branchDatabase.status === "created" ? `created${branchDatabase.database ? ` (${branchDatabase.database.name})` : ""}` : `skipped${branchDatabase.reason ? ` (${branchDatabase.reason})` : ""}`,
+		tone: branchDatabase.status === "created" ? "success" : "dim"
+	}, ...branchDatabase.envVars.length > 0 ? [{
+		key: "branch db env",
+		value: branchDatabase.envVars.join(", ")
+	}] : []];
 }
 function formatEnvVarNames(envVars) {
 	return envVars.length > 0 ? envVars.join(", ") : "none";
@@ -638,4 +643,4 @@ function formatRecentDeployments(deployments) {
 	return deployments.map((deployment) => `${deployment.id}${deployment.live ? " (live)" : ""}`).join(", ");
 }
 //#endregion
-export { renderAppBuild, renderAppDeploy, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppDomainAdd, serializeAppDomainRemove, serializeAppDomainRetry, serializeAppDomainShow, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy };
+export { isAppDeployAllResult, renderAppBuild, renderAppDeploy, renderAppDeployAll, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppDeployAll, serializeAppDomainAdd, serializeAppDomainRemove, serializeAppDomainRetry, serializeAppDomainShow, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy };