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

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

@@ -0,0 +1,184 @@
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region src/lib/app/branch-database.ts
+const SKIPPED_DIRECTORIES = new Set([
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".prisma",
+	".turbo",
+	".vercel",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out"
+]);
+const DATABASE_URL_SCAN_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".env",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".prisma",
+	".ts",
+	".tsx"
+]);
+const MAX_SCAN_DEPTH = 6;
+const MAX_SCAN_FILES = 1e3;
+const MAX_DATABASE_URL_REFERENCE_FILES = 10;
+const MAX_TEXT_FILE_BYTES = 1024 * 1024;
+async function inspectBranchDatabaseSignal(cwd, signal) {
+	const state = {
+		filesVisited: 0,
+		schemaCandidates: [],
+		databaseUrlReferences: []
+	};
+	await scanDirectory(cwd, cwd, 0, state, signal);
+	const schemaPath = selectSchemaPath(cwd, state.schemaCandidates);
+	const hasMigrations = schemaPath ? await hasMigrationsDirectory(path.dirname(schemaPath), signal) : false;
+	return {
+		schema: schemaPath ? {
+			path: schemaPath,
+			hasMigrations,
+			command: hasMigrations ? "migrate-deploy" : "db-push"
+		} : null,
+		databaseUrlReferences: state.databaseUrlReferences
+	};
+}
+function hasBranchDatabaseSignal(signal) {
+	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({
+		context: options.context,
+		args,
+		env: {
+			DATABASE_URL: options.databaseUrl,
+			...options.directUrl ? { DIRECT_URL: options.directUrl } : {}
+		}
+	});
+	return {
+		command: options.schema.command,
+		schemaPath
+	};
+}
+async function scanDirectory(cwd, directory, depth, state, signal) {
+	signal.throwIfAborted();
+	if (depth > MAX_SCAN_DEPTH || state.filesVisited >= MAX_SCAN_FILES) return;
+	let entries;
+	try {
+		entries = await readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	entries.sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		signal.throwIfAborted();
+		if (state.filesVisited >= MAX_SCAN_FILES) return;
+		const entryPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) {
+			if (!SKIPPED_DIRECTORIES.has(entry.name)) await scanDirectory(cwd, entryPath, depth + 1, state, signal);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		state.filesVisited += 1;
+		if (entry.name === "schema.prisma") state.schemaCandidates.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) {
+	return candidates.map((candidate) => ({
+		absolute: candidate,
+		relative: path.relative(cwd, candidate) || "schema.prisma"
+	})).sort((left, right) => {
+		if (left.relative === "schema.prisma") return -1;
+		if (right.relative === "schema.prisma") return 1;
+		return left.relative.length - right.relative.length || left.relative.localeCompare(right.relative);
+	})[0]?.absolute ?? null;
+}
+async function hasMigrationsDirectory(schemaDirectory, signal) {
+	signal.throwIfAborted();
+	const migrationsPath = path.join(schemaDirectory, "migrations");
+	try {
+		await access(migrationsPath);
+		return (await readdir(migrationsPath)).length > 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function shouldScanForDatabaseUrl(fileName) {
+	if (fileName === ".env" || fileName.startsWith(".env.")) return true;
+	return DATABASE_URL_SCAN_EXTENSIONS.has(path.extname(fileName));
+}
+async function fileContainsDatabaseUrl(filePath, signal) {
+	signal.throwIfAborted();
+	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return false;
+	return (await 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
+	];
+}
+async function runPrismaCommand(options) {
+	const shouldPipeOutput = !options.context.flags.json && !options.context.flags.quiet;
+	const child = spawn("npx", options.args, {
+		cwd: options.context.runtime.cwd,
+		env: {
+			...options.context.runtime.env,
+			...options.env
+		},
+		signal: options.context.runtime.signal,
+		stdio: shouldPipeOutput ? [
+			"ignore",
+			"pipe",
+			"pipe"
+		] : [
+			"ignore",
+			"ignore",
+			"ignore"
+		]
+	});
+	if (shouldPipeOutput) {
+		child.stdout?.pipe(options.context.output.stderr, { end: false });
+		child.stderr?.pipe(options.context.output.stderr, { end: false });
+	}
+	const exit = await new Promise((resolve, reject) => {
+		child.once("error", reject);
+		child.once("close", (code, signal) => resolve({
+			code,
+			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}.`);
+}
+//#endregion
+export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup };

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

@@ -0,0 +1,102 @@
+//#region src/lib/app/preview-branch-database.ts
+async function createBranchDatabase(client, options) {
+	const result = await client.POST("/v1/databases", {
+		body: {
+			projectId: options.projectId,
+			branchId: options.branchId,
+			name: options.branchName,
+			source: { type: "empty" }
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to create database for branch "${options.branchName}"`, result.response, result.error);
+	return normalizeBranchDatabaseRecord(result.data.data);
+}
+async function listEnvironmentVariables(client, options) {
+	const variables = [];
+	let cursor;
+	while (true) {
+		const result = await client.GET("/v1/environment-variables", {
+			params: { query: {
+				projectId: options.projectId,
+				class: options.className,
+				key: options.key,
+				branchId: options.branchId,
+				cursor
+			} },
+			signal: options.signal
+		});
+		if (result.error || !result.data) throw apiCallError("Failed to list environment variables", result.response, result.error);
+		variables.push(...result.data.data);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return variables.map((variable) => normalizeEnvironmentVariable(variable));
+}
+async function createEnvironmentVariable(client, options) {
+	const result = await client.POST("/v1/environment-variables", {
+		body: {
+			projectId: options.projectId,
+			class: options.className,
+			key: options.key,
+			value: options.value,
+			...options.branchId ? { branchId: options.branchId } : {}
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to add ${options.key}`, result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteBranchDatabase(client, options) {
+	const result = await client.DELETE("/v1/databases/{databaseId}", {
+		params: { path: { databaseId: options.databaseId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete branch database", result.response, result.error);
+}
+async function updateEnvironmentVariable(client, options) {
+	const result = await client.PATCH("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		body: { value: options.value },
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError("Failed to update environment variable", result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteEnvironmentVariable(client, options) {
+	const result = await client.DELETE("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete environment variable", result.response, result.error);
+}
+function normalizeEnvironmentVariable(variable) {
+	return {
+		id: variable.id,
+		key: variable.key,
+		branchId: variable.branchId,
+		className: variable.class,
+		isManagedBySystem: variable.isManagedBySystem
+	};
+}
+function normalizeBranchDatabaseRecord(database) {
+	const connection = database.connections?.[0];
+	const databaseUrl = connection?.endpoints?.pooled?.connectionString;
+	const directUrl = connection?.endpoints?.direct?.connectionString ?? null;
+	if (!databaseUrl) throw new Error("Created database did not return a pooled connection string.");
+	return {
+		id: database.id,
+		name: database.name,
+		branchId: database.branchId,
+		databaseUrl,
+		directUrl
+	};
+}
+function apiCallError(summary, response, error) {
+	if (response.status === 404) return /* @__PURE__ */ new Error("Resource Not Found");
+	const message = error.error?.message ?? `Management API returned HTTP ${response.status}.`;
+	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
+	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
+}
+//#endregion
+export { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable };

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

@@ -1,5 +1,6 @@
 import { envVarNames } from "./env-vars.js";
 import { PreviewBuildStrategy } from "./preview-build.js";
+import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./preview-branch-database.js";
 import path from "node:path";
 import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
@@ -48,6 +49,24 @@ function createPreviewAppProvider(client, options) {
 				role: branch.role
 			};
 		},
+		async createBranchDatabase(options) {
+			return createBranchDatabase(client, options);
+		},
+		async deleteBranchDatabase(options) {
+			return deleteBranchDatabase(client, options);
+		},
+		async listEnvironmentVariables(options) {
+			return listEnvironmentVariables(client, options);
+		},
+		async createEnvironmentVariable(options) {
+			return createEnvironmentVariable(client, options);
+		},
+		async updateEnvironmentVariable(options) {
+			return updateEnvironmentVariable(client, options);
+		},
+		async deleteEnvironmentVariable(options) {
+			return deleteEnvironmentVariable(client, options);
+		},
 		async removeApp(appId, options) {
 			const appResult = await sdk.showService({
 				serviceId: appId,

package/dist/presenters/app.js

@@ -30,6 +30,7 @@ function renderAppDeploy(context, descriptor, result) {
 	return [
 		`Live in ${formatDuration(result.durationMs)}`,
 		...result.deployment.url ? [context.ui.link(result.deployment.url)] : [],
+		...renderBranchDatabaseDeploySummary(context, result),
 		"",
 		...renderDeployOutputRows(context.ui, [{
 			label: "Logs",
@@ -41,6 +42,23 @@ function serializeAppDeploy(result) {
 	const { localPin: _localPin, ...serialized } = result;
 	return serialized;
 }
+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: result.branchDatabase.schema.command === "migrate-deploy" ? "prisma migrate deploy" : "prisma db push"
+		}] : []
+	])];
+}
 function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
 	return `${(durationMs / 1e3).toFixed(1)}s`;

package/dist/presenters/branch.js

@@ -1,111 +1,39 @@
-import { renderList, renderMutate, renderShow, serializeList } from "../output/patterns.js";
+import { formatColumns } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
 //#region src/presenters/branch.ts
 function renderBranchList(context, descriptor, result) {
-	return renderList({
-		title: "Listing branches for the resolved project.",
-		descriptor,
-		parentContext: {
-			key: "project",
-			value: result.projectName ?? "not resolved"
-		},
-		items: result.branches.map((branch) => ({
-			noun: "branch",
-			label: branch.name,
-			id: branch.id,
-			status: branch.active ? "active" : null
-		})),
-		emptyMessage: "No branches found."
-	}, context.ui);
+	const ui = context.ui;
+	const lines = [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("Listing branches for the resolved project.")}`, ""];
+	const rail = ui.dim("│");
+	lines.push(`${rail}  ${ui.accent("project:")}  ${result.projectName}`);
+	lines.push(rail);
+	if (result.branches.length === 0) {
+		lines.push(`${rail}  ${ui.dim("No branches found.")}`);
+		return lines;
+	}
+	const widths = [
+		Math.max(4, ...result.branches.map((branch) => branch.name.length)),
+		Math.max(4, ...result.branches.map((branch) => branch.role.length)),
+		Math.max(7, ...result.branches.map((branch) => branch.envMap.length))
+	];
+	lines.push(`${rail}  ${ui.accent(formatColumns([
+		"Name",
+		"Role",
+		"Env map"
+	], widths))}`);
+	for (const branch of result.branches) lines.push(`${rail}  ${formatColumns([
+		branch.name,
+		branch.role,
+		branch.envMap
+	], widths)}`);
+	return lines;
 }
 function serializeBranchList(result) {
-	return serializeList({
-		context: { project: result.projectName ?? "not resolved" },
-		items: result.branches.map((branch) => ({
-			noun: "branch",
-			label: branch.name,
-			id: branch.id,
-			status: branch.active ? "active" : null
-		}))
-	});
-}
-function serializeBranchShow(result) {
 	return {
 		projectId: result.projectId,
 		projectName: result.projectName,
-		branch: {
-			name: result.branch.name,
-			kind: result.branch.kind,
-			active: result.branch.active,
-			remoteState: result.branch.remoteState,
-			liveDeployment: result.branch.liveDeployment
-		}
+		branches: result.branches
 	};
 }
-function renderBranchShow(context, descriptor, result) {
-	const fields = [
-		{
-			key: "project",
-			value: result.projectName ?? "not resolved",
-			tone: result.projectName ? "default" : "dim"
-		},
-		{
-			key: "branch",
-			value: result.branch.name,
-			tone: result.branch.active ? "success" : "default"
-		},
-		{
-			key: "kind",
-			value: result.branch.kind
-		}
-	];
-	if (result.branch.liveDeployment) {
-		fields.push({
-			key: "status",
-			value: result.branch.liveDeployment.status,
-			tone: toneForDeploymentStatus(result.branch.liveDeployment.status)
-		});
-		if (result.branch.liveDeployment.url) fields.push({
-			key: "url",
-			value: result.branch.liveDeployment.url,
-			tone: "link"
-		});
-	} else if (!result.branch.remoteState) fields.push({
-		key: "remote state",
-		value: "not created yet",
-		tone: "dim"
-	});
-	return renderShow({
-		title: "Showing the current active branch context.",
-		descriptor,
-		fields
-	}, context.ui);
-}
-function toneForDeploymentStatus(status) {
-	if (status === "ready" || status === "active" || status === "healthy") return "success";
-	if (status === "pending" || status === "building" || status === "starting") return "warning";
-	if (status === "failed" || status === "error") return "error";
-	return "default";
-}
-function renderBranchUse(context, descriptor, result) {
-	return renderMutate({
-		title: "Changing the local default branch context.",
-		descriptor,
-		context: [{
-			key: "project",
-			value: result.projectName ?? "not resolved",
-			tone: result.projectName ? "default" : "dim"
-		}, {
-			key: "branch",
-			value: result.branch.name
-		}],
-		operationDescription: "Applying active branch change",
-		operationCount: 1,
-		details: ["Active branch updated in local CLI state for this repo."],
-		alerts: result.branch.kind === "production" ? [{
-			tone: "warning",
-			text: "Production is protected and durable. Use with care"
-		}] : void 0
-	}, context.ui);
-}
 //#endregion
-export { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow };
+export { renderBranchList, serializeBranchList };

package/dist/shell/command-meta.js

@@ -69,8 +69,8 @@ const DESCRIPTORS = [
 	{
 		id: "branch",
 		path: ["prisma", "branch"],
-		description: "View your active Platform branches",
-		examples: ["prisma-cli branch list", "prisma-cli branch show"]
+		description: "View your Platform branches",
+		examples: ["prisma-cli branch list"]
 	},
 	{
 		id: "git",
@@ -153,29 +153,9 @@ const DESCRIPTORS = [
 			"branch",
 			"list"
 		],
-		description: "List active Platform branches for the resolved project",
+		description: "List Platform branches for the resolved project",
 		examples: ["prisma-cli branch list", "prisma-cli branch list --json"]
 	},
-	{
-		id: "branch.show",
-		path: [
-			"prisma",
-			"branch",
-			"show"
-		],
-		description: "Show the Platform branch matching your current Git branch",
-		examples: ["prisma-cli branch show", "prisma-cli branch show --json"]
-	},
-	{
-		id: "branch.use",
-		path: [
-			"prisma",
-			"branch",
-			"use"
-		],
-		description: "Change the local default branch context.",
-		examples: ["prisma-cli branch use", "prisma-cli branch use production"]
-	},
 	{
 		id: "app.build",
 		path: [
@@ -214,6 +194,8 @@ const DESCRIPTORS = [
 			"prisma-cli app deploy --project proj_123",
 			"prisma-cli app deploy --create-project my-app --yes",
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
+			"prisma-cli app deploy --db",
+			"prisma-cli app deploy --db --yes",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
 			"prisma-cli app deploy --branch feat-login --framework hono",
 			"prisma-cli app deploy --prod --yes",

package/dist/shell/ui.js

@@ -48,6 +48,9 @@ function renderNextSteps(steps) {
 		...steps.map((step) => `- ${step}`)
 	];
 }
+function formatColumns(columns, widths) {
+	return columns.map((value, index) => padDisplay(value, widths[index])).join("   ").trimEnd();
+}
 function wrapText(text, width, indent = "") {
 	return wrapAnsi(text, width, {
 		hard: false,
@@ -74,4 +77,4 @@ function formatHeaderValue(ui, row) {
 	return value;
 }
 //#endregion
-export { createShellUi, maskValue, padDisplay, renderCommandHeader, renderNextSteps, renderSummaryLine, wrapText };
+export { createShellUi, formatColumns, maskValue, padDisplay, renderCommandHeader, renderNextSteps, renderSummaryLine, wrapText };

package/dist/use-cases/branch.js

@@ -1,34 +1,19 @@
 //#region src/use-cases/branch.ts
 function createBranchUseCases(dependencies) {
-	return {
-		list: async () => {
-			const [projectId, activeBranch] = await Promise.all([dependencies.projectStateGateway.readRememberedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
-			const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				activeBranch,
-				branches: buildBranchSummaries(activeBranch, remoteBranches)
-			};
-		},
-		show: async () => {
-			const [projectId, activeBranch] = await Promise.all([dependencies.projectStateGateway.readRememberedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				branch: buildBranchDetail(dependencies.branchGateway, projectId, activeBranch)
-			};
-		},
-		use: async (branchName) => {
-			await dependencies.branchStateGateway.writeActiveBranch(branchName);
-			const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
-			return {
-				projectId,
-				projectName: resolveProjectName(dependencies.projectGateway, projectId),
-				branch: buildBranchDetail(dependencies.branchGateway, projectId, branchName)
-			};
-		}
-	};
+	return { list: async () => {
+		const projectId = await dependencies.projectStateGateway.readRememberedProjectId();
+		if (!projectId) return {
+			projectId: "",
+			projectName: "not resolved",
+			branches: []
+		};
+		const remoteBranches = await listRemoteBranches(dependencies.branchGateway, projectId);
+		return {
+			projectId,
+			projectName: resolveProjectName(dependencies.projectGateway, projectId) ?? "not resolved",
+			branches: buildBranchSummaries(remoteBranches)
+		};
+	} };
 }
 function resolveProjectName(projectGateway, projectId) {
 	if (!projectId) return null;
@@ -38,38 +23,13 @@ async function listRemoteBranches(branchGateway, projectId) {
 	if (!projectId) return [];
 	return branchGateway.listBranchesForProject(projectId);
 }
-function buildBranchSummaries(activeBranch, remoteBranches) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const branch of remoteBranches) byName.set(branch.name, {
+function buildBranchSummaries(remoteBranches) {
+	return sortBranches(remoteBranches.map((branch) => ({
 		id: branch.id,
 		name: branch.name,
-		kind: branch.kind,
-		active: activeBranch === branch.name,
-		remoteState: true
-	});
-	if (!byName.has(activeBranch)) byName.set(activeBranch, {
-		id: activeBranch,
-		name: activeBranch,
-		kind: toBranchKind(activeBranch),
-		active: true,
-		remoteState: false
-	});
-	return sortBranches([...byName.values()]);
-}
-function buildBranchDetail(branchGateway, projectId, branchName) {
-	const kind = toBranchKind(branchName);
-	const remoteBranch = projectId ? branchGateway.getBranchForProject(projectId, branchName) : void 0;
-	return {
-		name: branchName,
-		kind,
-		active: true,
-		remoteState: Boolean(remoteBranch),
-		liveDeployment: remoteBranch && remoteBranch.currentDeploymentId ? toLiveDeployment(branchGateway.getDeployment(remoteBranch.currentDeploymentId)) : null
-	};
-}
-function toBranchKind(name) {
-	if (name === "production") return "production";
-	return "preview";
+		role: branch.role,
+		envMap: branch.role
+	})));
 }
 function sortBranches(branches) {
 	return branches.slice().sort((left, right) => {
@@ -80,16 +40,8 @@ function sortBranches(branches) {
 	});
 }
 function branchOrder(branch) {
-	if (branch.name === "production") return 0;
+	if (branch.role === "production") return 0;
 	return 1;
 }
-function toLiveDeployment(deployment) {
-	if (!deployment) return null;
-	return {
-		id: deployment.id,
-		status: deployment.status,
-		url: deployment.url
-	};
-}
 //#endregion
 export { createBranchUseCases };