@prisma/cli 2.20.1 → 3.0.0-alpha.1

package/dist/shell/help.js

@@ -0,0 +1,78 @@
+import { formatDescriptorLabel, getDescriptorForCommand } from "./command-meta.js";
+import { resolveGlobalFlags } from "./global-flags.js";
+import { createShellUi, padDisplay, wrapText } from "./ui.js";
+//#region src/shell/help.ts
+function renderHelp(command, runtime) {
+	const descriptor = getDescriptorForCommand(command);
+	const ui = createShellUi(runtime, resolveGlobalFlags(runtime.argv, {}));
+	const rail = ui.isTTY ? ui.dim("│") : "│";
+	const lines = [`${formatDescriptorLabel(descriptor)} ${ui.dim("→")} ${ui.dim(descriptor.description)}`, ""];
+	const visibleCommands = command.commands.filter((candidate) => candidate.name() !== "help" && !candidate.hidden);
+	const visibleOptions = command.options.filter((candidate) => !candidate.hidden);
+	if (visibleCommands.length > 0) lines.push(...renderCommandRows(rail, ui, visibleCommands));
+	if (visibleOptions.length > 0) {
+		if (visibleCommands.length > 0) lines.push(`${rail}`);
+		lines.push(...renderOptionRows(rail, ui, visibleOptions));
+	}
+	if (descriptor.examples && descriptor.examples.length > 0) {
+		lines.push(`${rail}`);
+		lines.push(`${rail}  Examples:`);
+		for (const example of descriptor.examples) lines.push(`${rail}    $ ${example}`);
+	}
+	if (descriptor.longDescription) {
+		lines.push(`${rail}`);
+		const wrapped = wrapText(descriptor.longDescription, Math.max(ui.width - 3, 40));
+		for (const line of wrapped) lines.push(`${rail}  ${line}`);
+	}
+	if (descriptor.docsPath) {
+		lines.push(`${rail}`);
+		lines.push(`${rail}  ${ui.accent(padDisplay("Read more", 16))}  ${ui.link(descriptor.docsPath)}`);
+	}
+	lines.push("");
+	return `${lines.join("\n")}`;
+}
+function renderCommandRows(rail, ui, commands) {
+	return renderAlignedRows(rail, ui, commands.map((command) => {
+		const descriptor = getDescriptorForCommand(command);
+		return {
+			term: renderCommandTerm(command),
+			description: descriptor.description
+		};
+	}));
+}
+function renderOptionRows(rail, ui, options) {
+	return renderAlignedRows(rail, ui, options.map((option) => ({
+		term: option.flags,
+		description: option.description || "",
+		defaultValue: option.defaultValueDescription ?? formatDefaultValue(option.defaultValue)
+	})));
+}
+function renderAlignedRows(rail, ui, rows) {
+	const termWidth = rows.reduce((width, row) => Math.max(width, row.term.length), 0);
+	const descriptionWidth = Math.max(ui.width - 3 - termWidth - 4, 30);
+	const lines = [];
+	for (const row of rows) {
+		const [firstLine, ...rest] = wrapText(row.description, descriptionWidth, " ".repeat(termWidth + 2));
+		lines.push(`${rail}  ${ui.accent(padDisplay(row.term, termWidth))}  ${firstLine}`);
+		for (const line of rest) lines.push(`${rail}  ${" ".repeat(termWidth)}  ${line.trimStart()}`);
+		if (row.defaultValue) lines.push(`${rail}  ${" ".repeat(termWidth)}  ${ui.dim(`default: ${row.defaultValue}`)}`);
+	}
+	return lines;
+}
+function renderCommandTerm(command) {
+	const argumentsList = command.registeredArguments.map(renderArgumentLabel).join(" ");
+	return `${command.name()}${argumentsList ? ` ${argumentsList}` : ""}`;
+}
+function renderArgumentLabel(argument) {
+	const name = argument.name();
+	return argument.required ? `<${name}>` : `[${name}]`;
+}
+function formatDefaultValue(value) {
+	if (value === void 0) return null;
+	if (Array.isArray(value)) return value.join(", ");
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	if (typeof value === "string" && value.length > 0) return value;
+	return null;
+}
+//#endregion
+export { renderHelp };

package/dist/shell/output.js

@@ -0,0 +1,54 @@
+import { renderNextSteps, renderSummaryLine } from "./ui.js";
+//#region src/shell/output.ts
+function writeJsonSuccess(output, success) {
+	output.stdout.write(`${JSON.stringify({
+		ok: true,
+		...success
+	}, null, 2)}\n`);
+}
+function writeJsonError(output, command, error) {
+	output.stdout.write(`${JSON.stringify({
+		ok: false,
+		command,
+		error: {
+			code: error.code,
+			domain: error.domain,
+			severity: error.severity,
+			summary: error.summary,
+			why: error.why,
+			fix: error.fix,
+			where: error.where,
+			meta: error.meta,
+			docsUrl: error.docsUrl
+		},
+		warnings: [],
+		nextSteps: error.nextSteps
+	}, null, 2)}\n`);
+}
+function writeHumanLines(output, lines) {
+	if (lines.length === 0) return;
+	output.stderr.write(`${lines.join("\n")}\n`);
+}
+function writeHumanError(output, ui, error, options) {
+	const lines = [renderSummaryLine(ui, "error", `${error.summary} [${error.code}]`)];
+	if (error.where) lines.push(...["", `Where: ${error.where}`]);
+	if (error.why) {
+		if (!error.where) lines.push("");
+		lines.push(`Why: ${error.why}`);
+	}
+	if (error.fix) lines.push(`Fix: ${error.fix}`);
+	if (options.trace) {
+		if (error.debug) {
+			lines.push("");
+			lines.push("Trace:");
+			lines.push(...error.debug.trimEnd().split("\n"));
+		}
+	} else {
+		lines.push("");
+		lines.push("More: Re-run with --trace for deeper diagnostics");
+	}
+	lines.push(...renderNextSteps(error.nextSteps));
+	writeHumanLines(output, lines);
+}
+//#endregion
+export { writeHumanError, writeHumanLines, writeJsonError, writeJsonSuccess };

package/dist/shell/prompt.js

@@ -0,0 +1,31 @@
+import { usageError } from "./errors.js";
+import { isCancel, select, text } from "@clack/prompts";
+//#region src/shell/prompt.ts
+async function selectPrompt(options) {
+	const promptOptions = options.choices.map((choice) => ({
+		label: choice.label,
+		value: choice.value
+	}));
+	const response = await select({
+		input: options.input,
+		output: options.output,
+		message: options.message,
+		options: promptOptions
+	});
+	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a selection was made.", "Re-run the command and choose an option to continue.");
+	return response;
+}
+async function textPrompt(options) {
+	const response = await text({
+		input: options.input,
+		output: options.output,
+		message: options.message,
+		placeholder: options.placeholder,
+		validate: options.validate
+	});
+	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a value was entered.", "Re-run the command and provide a value to continue.");
+	return response;
+}
+function disposePromptState(_input) {}
+//#endregion
+export { disposePromptState, selectPrompt, textPrompt };

package/dist/shell/runtime.js

@@ -0,0 +1,51 @@
+import { LocalStateStore } from "../adapters/local-state.js";
+import { MockApi } from "../adapters/mock-api.js";
+import { createShellUi } from "./ui.js";
+import { renderHelp } from "./help.js";
+import path from "node:path";
+//#region src/shell/runtime.ts
+const DEFAULT_STATE_DIR_NAME = path.join(".prisma", "cli");
+function configureRuntimeCommand(command, runtime) {
+	return command.helpCommand(false).configureHelp({ formatHelp: (configuredCommand) => renderHelp(configuredCommand, runtime) }).configureOutput({
+		writeOut: (text) => {
+			runtime.stderr.write(text);
+		},
+		writeErr: (text) => {
+			runtime.stderr.write(text);
+		},
+		outputError: (text, write) => {
+			write(text);
+		}
+	}).exitOverride();
+}
+async function createCommandContext(runtime, flags) {
+	const fixturePath = runtime.fixturePath ?? runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+	const stateDir = resolveStateDir(runtime);
+	let loadedApi;
+	if (fixturePath) loadedApi = await MockApi.load(fixturePath);
+	return {
+		get api() {
+			if (!loadedApi) throw new Error("context.api accessed in real mode. Set runtime.fixturePath or PRISMA_CLI_MOCK_FIXTURE_PATH to use fixture mode.");
+			return loadedApi;
+		},
+		stateStore: new LocalStateStore(stateDir),
+		output: {
+			stdout: runtime.stdout,
+			stderr: runtime.stderr
+		},
+		flags,
+		runtime,
+		ui: createShellUi(runtime, flags)
+	};
+}
+function resolveStateDir(runtime) {
+	return runtime.stateDir ?? runtime.env.PRISMA_CLI_STATE_DIR ?? path.join(runtime.cwd, DEFAULT_STATE_DIR_NAME);
+}
+function canPrompt(context) {
+	if (context.flags.json) return false;
+	if (context.flags.interactive === false) return false;
+	if (context.runtime.env.CI && context.flags.interactive !== true) return false;
+	return Boolean(context.runtime.stdin.isTTY && context.runtime.stderr.isTTY);
+}
+//#endregion
+export { canPrompt, configureRuntimeCommand, createCommandContext };

package/dist/shell/ui.js

@@ -0,0 +1,59 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+import { createColors } from "colorette";
+//#region src/shell/ui.ts
+const DEFAULT_WIDTH = 80;
+function createShellUi(runtime, flags) {
+	const isTTY = Boolean(runtime.stderr.isTTY);
+	const colorEnabled = resolveColorEnabled(runtime, flags, isTTY);
+	const colors = createColors({ useColor: colorEnabled });
+	return {
+		isTTY,
+		colorEnabled,
+		width: runtime.stderr.columns && runtime.stderr.columns > 0 ? runtime.stderr.columns : DEFAULT_WIDTH,
+		quiet: flags.quiet,
+		verbose: flags.verbose,
+		trace: flags.trace,
+		accent: (text) => colors.cyan(text),
+		success: (text) => colors.greenBright(text),
+		error: (text) => colors.redBright(text),
+		warning: (text) => colors.yellow(text),
+		info: (text) => colors.blue(text),
+		link: (text) => colors.blue(text),
+		dim: (text) => colors.dim(text),
+		strong: (text) => colors.bold(text)
+	};
+}
+function renderSummaryLine(ui, status, text) {
+	return `${status === "success" ? ui.success("✔") : status === "error" ? ui.error("✘") : status === "warning" ? ui.warning("⚠") : ui.info("ℹ")} ${text}`;
+}
+function renderNextSteps(steps) {
+	if (steps.length === 0) return [];
+	return [
+		"",
+		steps.length === 1 ? "Next step:" : "Next steps:",
+		...steps.map((step) => `- ${step}`)
+	];
+}
+function wrapText(text, width, indent = "") {
+	return wrapAnsi(text, width, {
+		hard: false,
+		trim: false
+	}).split("\n").map((line, index) => index === 0 ? line : `${indent}${line}`);
+}
+function padDisplay(text, width) {
+	const padding = Math.max(width - stringWidth(stripAnsi(text)), 0);
+	return `${text}${" ".repeat(padding)}`;
+}
+function maskValue(value) {
+	return value.replace(/([A-Za-z0-9._%+-]{1,})(?=@)/g, "****").replace(/:\/\/[^:@/\s]+:[^@/\s]+@/g, "://****:****@");
+}
+function resolveColorEnabled(runtime, flags, isTTY) {
+	if (flags.color === true) return true;
+	if (flags.color === false) return false;
+	if (runtime.env.NO_COLOR !== void 0) return false;
+	return isTTY;
+}
+//#endregion
+export { createShellUi, maskValue, padDisplay, renderNextSteps, renderSummaryLine, wrapText };

package/dist/use-cases/auth.js

@@ -0,0 +1,70 @@
+import { usageError } from "../shell/errors.js";
+//#region src/use-cases/auth.ts
+function createAuthUseCases(dependencies) {
+	return {
+		whoami: () => resolveCurrentAuthState(dependencies),
+		login: async (selection) => {
+			await dependencies.sessionGateway.writeAuthSession({
+				provider: selection.provider,
+				userId: selection.userId,
+				workspaceId: selection.workspaceId
+			});
+			return resolveCurrentAuthState(dependencies);
+		},
+		logout: async () => {
+			await dependencies.sessionGateway.clearAuthSession();
+			return resolveCurrentAuthState(dependencies);
+		},
+		listProviders: async () => dependencies.identityGateway.listProviders(),
+		resolveProvider: async (providerId) => {
+			const provider = dependencies.identityGateway.getProvider(providerId);
+			if (!provider) throw usageError("Login requires a valid mock provider", `The mock provider "${providerId}" does not exist.`, "Use --provider github or --provider google.", ["prisma auth login"], "auth");
+			return provider;
+		},
+		listUsersForProvider: async (providerId) => {
+			const users = dependencies.identityGateway.listUsersForProvider(providerId);
+			if (users.length === 0) throw usageError("Login requires a valid mock user", `No mock users support provider "${providerId}".`, "Update the fixture data or choose a different provider.", ["prisma auth login"], "auth");
+			return users;
+		},
+		resolveUserForProvider: async (providerId, userId) => {
+			const user = dependencies.identityGateway.getUserForProvider(providerId, userId);
+			if (!user) throw usageError("Login requires a valid mock user", `The mock user "${userId}" is not available for provider "${providerId}".`, "Choose a user that supports the selected provider.", ["prisma auth login"], "auth");
+			return user;
+		},
+		listWorkspacesForUser: async (userId) => dependencies.identityGateway.listUserWorkspaces(userId),
+		resolveWorkspaceForUser: async (userId, workspaceId) => {
+			const workspace = dependencies.identityGateway.getUserWorkspace(userId, workspaceId);
+			if (!workspace) throw usageError("Login requires a valid mock workspace", `The mock workspace "${workspaceId}" is not available for the selected user.`, "Choose a workspace that the selected user can access.", ["prisma auth login"], "auth");
+			return workspace;
+		}
+	};
+}
+async function resolveCurrentAuthState(dependencies) {
+	const [session, linkedProjectId] = await Promise.all([dependencies.sessionGateway.readAuthSession(), dependencies.projectConfigGateway.readLinkedProjectId()]);
+	if (!session) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId
+	};
+	const provider = dependencies.identityGateway.getProvider(session.provider);
+	const user = dependencies.identityGateway.getUser(session.userId);
+	const workspace = dependencies.identityGateway.getWorkspace(session.workspaceId);
+	if (!provider || !user || !workspace) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId
+	};
+	return {
+		authenticated: true,
+		provider: provider.id,
+		user,
+		workspace,
+		linkedProjectId
+	};
+}
+//#endregion
+export { createAuthUseCases };

package/dist/use-cases/branch.js

@@ -0,0 +1,95 @@
+//#region src/use-cases/branch.ts
+function createBranchUseCases(dependencies) {
+	return {
+		list: async () => {
+			const [linkedProjectId, activeBranch] = await Promise.all([dependencies.projectConfigGateway.readLinkedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
+			const remoteBranches = await listRemoteBranches(dependencies.branchGateway, linkedProjectId);
+			return {
+				linkedProjectId,
+				projectName: resolveProjectName(dependencies.projectGateway, linkedProjectId),
+				activeBranch,
+				branches: buildBranchSummaries(activeBranch, remoteBranches)
+			};
+		},
+		show: async () => {
+			const [linkedProjectId, activeBranch] = await Promise.all([dependencies.projectConfigGateway.readLinkedProjectId(), dependencies.branchStateGateway.readActiveBranch()]);
+			return {
+				linkedProjectId,
+				projectName: resolveProjectName(dependencies.projectGateway, linkedProjectId),
+				branch: buildBranchDetail(dependencies.branchGateway, linkedProjectId, activeBranch)
+			};
+		},
+		use: async (branchName) => {
+			await dependencies.branchStateGateway.writeActiveBranch(branchName);
+			const linkedProjectId = await dependencies.projectConfigGateway.readLinkedProjectId();
+			return {
+				linkedProjectId,
+				projectName: resolveProjectName(dependencies.projectGateway, linkedProjectId),
+				branch: buildBranchDetail(dependencies.branchGateway, linkedProjectId, branchName)
+			};
+		}
+	};
+}
+function resolveProjectName(projectGateway, linkedProjectId) {
+	if (!linkedProjectId) return null;
+	return projectGateway.getProject(linkedProjectId)?.name ?? null;
+}
+async function listRemoteBranches(branchGateway, linkedProjectId) {
+	if (!linkedProjectId) return [];
+	return branchGateway.listBranchesForProject(linkedProjectId);
+}
+function buildBranchSummaries(activeBranch, remoteBranches) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const branch of remoteBranches) byName.set(branch.name, {
+		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, linkedProjectId, branchName) {
+	const kind = toBranchKind(branchName);
+	const remoteBranch = linkedProjectId ? branchGateway.getBranchForProject(linkedProjectId, 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";
+}
+function sortBranches(branches) {
+	return branches.slice().sort((left, right) => {
+		const leftRank = branchOrder(left);
+		const rightRank = branchOrder(right);
+		if (leftRank !== rightRank) return leftRank - rightRank;
+		return left.name.localeCompare(right.name);
+	});
+}
+function branchOrder(branch) {
+	if (branch.name === "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 };

package/dist/use-cases/create-cli-gateways.js

@@ -0,0 +1,93 @@
+import { UnsafeConfigWriteError, readLinkedProjectId, writeLinkedProjectId } from "../adapters/config.js";
+import { usageError } from "../shell/errors.js";
+//#region src/use-cases/create-cli-gateways.ts
+function createCliUseCaseGateways(context) {
+	return {
+		identityGateway: {
+			listProviders: () => context.api.listProviders(),
+			getProvider: (providerId) => context.api.getProvider(providerId),
+			listUsersForProvider: (providerId) => context.api.listUsersForProvider(providerId).map(toAuthUser),
+			getUser: (userId) => {
+				const user = context.api.getUser(userId);
+				return user ? toAuthUser(user) : void 0;
+			},
+			getUserForProvider: (providerId, userId) => {
+				const user = context.api.getUserForProvider(providerId, userId);
+				return user ? toAuthUser(user) : void 0;
+			},
+			listUserWorkspaces: (userId) => context.api.listUserWorkspaces(userId).map(toAuthWorkspace),
+			getWorkspace: (workspaceId) => {
+				const workspace = context.api.getWorkspace(workspaceId);
+				return workspace ? toAuthWorkspace(workspace) : void 0;
+			},
+			getUserWorkspace: (userId, workspaceId) => {
+				const workspace = context.api.getUserWorkspace(userId, workspaceId);
+				return workspace ? toAuthWorkspace(workspace) : void 0;
+			}
+		},
+		projectGateway: {
+			listProjectsForWorkspace: (workspaceId) => context.api.listProjectsForWorkspace(workspaceId),
+			getProject: (projectId) => context.api.getProject(projectId),
+			getProjectForWorkspace: (workspaceId, projectId) => context.api.getProjectForWorkspace(workspaceId, projectId)
+		},
+		branchGateway: {
+			listBranchesForProject: (projectId) => context.api.listBranchesForProject(projectId).map((branch) => ({
+				...branch,
+				kind: branch.name === "production" ? "production" : "preview"
+			})),
+			getBranchForProject: (projectId, name) => {
+				const branch = context.api.getBranchForProject(projectId, name);
+				return branch ? {
+					...branch,
+					kind: branch.name === "production" ? "production" : "preview"
+				} : void 0;
+			},
+			getDeployment: (deploymentId) => context.api.getDeployment(deploymentId)
+		},
+		projectConfigGateway: {
+			readLinkedProjectId: () => readLinkedProjectId(context.runtime.cwd),
+			writeLinkedProjectId: async (projectId) => {
+				try {
+					await writeLinkedProjectId(context.runtime.cwd, projectId);
+				} catch (error) {
+					if (error instanceof UnsafeConfigWriteError) throw usageError("Project link requires a writable Prisma config", error.message, "Update prisma.config.ts to use a recognizable project field, or remove it and rerun prisma project link.", ["prisma project link proj_123"], "project");
+					throw error;
+				}
+			}
+		},
+		sessionGateway: {
+			readAuthSession: async () => {
+				return (await context.stateStore.read()).auth;
+			},
+			writeAuthSession: async (session) => {
+				await context.stateStore.setAuthSession(session);
+			},
+			clearAuthSession: async () => {
+				await context.stateStore.clearAuthSession();
+			}
+		},
+		branchStateGateway: {
+			readActiveBranch: async () => {
+				return (await context.stateStore.read()).branch.active;
+			},
+			writeActiveBranch: async (branchName) => {
+				await context.stateStore.setActiveBranch(branchName);
+			}
+		}
+	};
+}
+function toAuthUser(user) {
+	return {
+		id: user.id,
+		name: user.name,
+		email: user.email
+	};
+}
+function toAuthWorkspace(workspace) {
+	return {
+		id: workspace.id,
+		name: workspace.name
+	};
+}
+//#endregion
+export { createCliUseCaseGateways };

package/dist/use-cases/project.js

@@ -0,0 +1,75 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+//#region src/use-cases/project.ts
+function createProjectUseCases(dependencies) {
+	return {
+		list: async (authState) => {
+			const workspace = requireWorkspace(authState);
+			return {
+				workspace,
+				linkedProjectId: authState.linkedProjectId,
+				projects: listSortedWorkspaceProjects(dependencies.projectGateway, workspace.id).map(toProjectSummary)
+			};
+		},
+		show: async (authState) => {
+			if (!authState.linkedProjectId) return {
+				linkedProjectId: null,
+				workspace: null,
+				project: null
+			};
+			if (!authState.authenticated || !authState.workspace) return {
+				linkedProjectId: authState.linkedProjectId,
+				workspace: null,
+				project: null
+			};
+			const project = dependencies.projectGateway.getProjectForWorkspace(authState.workspace.id, authState.linkedProjectId);
+			if (!project) return {
+				linkedProjectId: authState.linkedProjectId,
+				workspace: null,
+				project: null
+			};
+			return {
+				linkedProjectId: authState.linkedProjectId,
+				workspace: authState.workspace,
+				project: toProjectSummary(project)
+			};
+		},
+		link: async (authState, projectId) => {
+			const workspace = requireWorkspace(authState);
+			const project = dependencies.projectGateway.getProjectForWorkspace(workspace.id, projectId);
+			if (!project) throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma project list and choose a project id from the active workspace.");
+			await dependencies.projectConfigGateway.writeLinkedProjectId(project.id);
+			return {
+				linkedProjectId: project.id,
+				workspace,
+				project: toProjectSummary(project)
+			};
+		},
+		listProjectsForWorkspace: async (workspaceId) => listSortedWorkspaceProjects(dependencies.projectGateway, workspaceId).map(toProjectSummary)
+	};
+}
+function requireWorkspace(authState) {
+	if (!authState.authenticated || !authState.workspace) throw authRequiredError();
+	return authState.workspace;
+}
+function listSortedWorkspaceProjects(projectGateway, workspaceId) {
+	return projectGateway.listProjectsForWorkspace(workspaceId).slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+function projectNotFoundError(why, fix, nextSteps = ["prisma project list"]) {
+	return new CliError({
+		code: "PROJECT_NOT_FOUND",
+		domain: "project",
+		summary: "Project not found",
+		why,
+		fix,
+		exitCode: 1,
+		nextSteps
+	});
+}
+//#endregion
+export { createProjectUseCases, projectNotFoundError };