@prisma/cli 3.0.0-alpha.0 → 3.0.0-alpha.10

package/dist/lib/project/resolution.js

@@ -0,0 +1,201 @@
+import { CliError } from "../../shell/errors.js";
+import { canPrompt } from "../../shell/runtime.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/project/resolution.ts
+async function resolveProjectTarget(options) {
+	const projects = await options.listProjects();
+	const inferredName = await inferTargetName(options.context.runtime.cwd);
+	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
+		targetName: options.explicitProject,
+		targetNameSource: "explicit"
+	});
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
+	let staleRemembered = false;
+	if (!options.allowCreate) {
+		const rememberedResult = await resolveRememberedProject(options, projects);
+		if (rememberedResult.target) return rememberedResult.target;
+		staleRemembered = rememberedResult.stale;
+	}
+	const packageName = inferredName.source === "package-name" ? inferredName.name : null;
+	if (packageName) {
+		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
+		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name", {
+			targetName: packageName,
+			targetNameSource: "package-name"
+		});
+		if (matches.length > 1) return resolveAmbiguousProject(options, matches, packageName, "package-name");
+	}
+	if (options.allowCreate && options.createProject) {
+		if (inferredName.name) {
+			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName.name));
+			if (existing.length === 1) return rememberIfRequested(options, existing[0], inferredName.source, {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
+			if (existing.length > 1) return resolveAmbiguousProject(options, existing, inferredName.name, inferredName.source);
+			return rememberIfRequested(options, await options.createProject(inferredName.name), "created", {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
+		}
+	}
+	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
+		message: "Select a project",
+		choices: sortProjects(projects).map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	}), "prompt");
+	if (staleRemembered && projects.length > 1) throw localStateStaleError();
+	throw projectUnresolvedError();
+}
+async function resolveRememberedProject(options, projects) {
+	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
+	if (!remembered) return {
+		target: null,
+		stale: false
+	};
+	const matched = projects.find((project) => project.id === remembered.id);
+	if (!matched) return {
+		target: null,
+		stale: true
+	};
+	return {
+		target: await rememberIfRequested(options, matched, "remembered-local", {
+			targetName: remembered.name,
+			targetNameSource: "remembered-local"
+		}),
+		stale: false
+	};
+}
+function projectNotFoundError(projectRef, workspace) {
+	return new CliError({
+		code: "PROJECT_NOT_FOUND",
+		domain: "project",
+		summary: "Project not found",
+		why: `The project "${projectRef}" does not exist in workspace "${workspace.name}" or is not accessible.`,
+		fix: "Pass a project id or name from prisma-cli project list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list"]
+	});
+}
+function projectAmbiguousError(projectRef, matches) {
+	const firstMatch = matches[0];
+	const nextSteps = ["prisma-cli project list"];
+	if (firstMatch) nextSteps.push(`prisma-cli app deploy --project ${firstMatch.id}`);
+	return new CliError({
+		code: "PROJECT_AMBIGUOUS",
+		domain: "project",
+		summary: "Project resolution is ambiguous",
+		why: projectRef ? `Multiple projects matched "${projectRef}".` : "Multiple projects matched the current directory context.",
+		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		meta: { matches: matches.map((project) => ({
+			id: project.id,
+			name: project.name
+		})) },
+		exitCode: 1,
+		nextSteps
+	});
+}
+function projectUnresolvedError() {
+	return new CliError({
+		code: "PROJECT_UNRESOLVED",
+		domain: "project",
+		summary: "No project is resolved for this directory",
+		why: "No project could be resolved from explicit input, platform mappings, remembered local context, or package metadata.",
+		fix: "Pass --project <id-or-name> on the command that needs a project, or add a package.json name that matches an accessible project.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list", "prisma-cli project show --project <id-or-name>"]
+	});
+}
+function localStateStaleError() {
+	return new CliError({
+		code: "LOCAL_STATE_STALE",
+		domain: "project",
+		summary: "Remembered project context is stale",
+		why: "The remembered project is no longer available in the selected workspace, and automatic resolution would be ambiguous.",
+		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli project list"]
+	});
+}
+async function readPackageName(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, "package.json"), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object") return null;
+		const packageName = "name" in parsed ? parsed.name : null;
+		return typeof packageName === "string" && packageName.trim().length > 0 ? packageName.trim() : null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		if (error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+async function inferTargetName(cwd) {
+	const packageName = await readPackageName(cwd);
+	if (packageName && isValidInferredTargetName(packageName)) return {
+		name: packageName,
+		source: "package-name"
+	};
+	return {
+		name: path.basename(cwd),
+		source: "directory-name"
+	};
+}
+function isValidInferredTargetName(value) {
+	return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
+}
+function sortProjects(projects) {
+	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+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);
+}
+function resolveAmbiguousProject(options, matches, projectRef, targetNameSource) {
+	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
+		message: "Select a project",
+		choices: sortProjects(matches).map((project) => ({
+			label: `${project.name} (${project.id})`,
+			value: project
+		}))
+	}).then((selected) => rememberIfRequested(options, selected, "prompt", {
+		targetName: projectRef,
+		targetNameSource
+	}));
+	throw projectAmbiguousError(projectRef, matches);
+}
+function projectMatchesPackageName(project, packageName) {
+	return project.id === packageName || project.name === packageName || project.slug === packageName;
+}
+async function resolveDurablePlatformMapping() {
+	return null;
+}
+async function rememberIfRequested(options, project, projectSource, resolutionDetails) {
+	if (options.remember) await options.context.stateStore.setRememberedProject({
+		id: project.id,
+		name: project.name,
+		workspaceId: options.workspace.id
+	});
+	return {
+		workspace: options.workspace,
+		project: toProjectSummary(project),
+		resolution: {
+			projectSource,
+			...resolutionDetails
+		}
+	};
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+//#endregion
+export { inferTargetName, projectNotFoundError, resolveProjectTarget, sortProjects };

package/dist/lib/version.js

@@ -0,0 +1,55 @@
+import { CliError } from "../shell/errors.js";
+import { createRequire } from "node:module";
+import process from "node:process";
+//#region src/lib/version.ts
+const requireFromHere = createRequire(import.meta.url);
+function readPackageMetadata() {
+	try {
+		return requireFromHere("../../package.json");
+	} catch {
+		return {};
+	}
+}
+function getCliVersion() {
+	const pkg = readPackageMetadata();
+	if (!pkg.version) throw new CliError({
+		code: "VERSION_UNAVAILABLE",
+		domain: "cli",
+		summary: "CLI version metadata is missing from the installed package",
+		why: "The bundled package.json could not be read or did not contain a version field.",
+		fix: "Reinstall the CLI from the npm registry, or check your install path is intact.",
+		exitCode: 1
+	});
+	return pkg.version;
+}
+function getCliName() {
+	return "prisma-cli";
+}
+function detectInvocation(env, argv) {
+	if (env.npm_config_user_agent?.startsWith("bun")) return "bunx";
+	const normalizedExecPath = env.npm_execpath?.replace(/\\/g, "/").toLowerCase();
+	const normalizedUserAgent = env.npm_config_user_agent?.toLowerCase();
+	if (env.npm_lifecycle_event === "npx" || normalizedExecPath?.includes("/_npx/") || normalizedUserAgent?.includes("npx")) return "npx";
+	const entry = (argv[1] ?? "").replace(/\\/g, "/").toLowerCase();
+	if (entry.endsWith(".ts") || entry.includes("/tsx/")) return "dev";
+	if (entry.includes("/_npx/")) return "npx";
+	if (entry.includes("/.bun/")) return "bunx";
+	if (entry.includes("/node_modules/.bin/") || /\/prisma-cli(\.cmd|\.exe)?$/.test(entry)) return "global";
+	return "unknown";
+}
+function buildVersionResult(env, argv) {
+	return {
+		cli: {
+			name: getCliName(),
+			version: getCliVersion()
+		},
+		node: { version: process.version },
+		os: {
+			platform: process.platform,
+			arch: process.arch
+		},
+		invocation: detectInvocation(env, argv)
+	};
+}
+//#endregion
+export { buildVersionResult, getCliName, getCliVersion };

package/dist/output/patterns.js

@@ -1,15 +1,14 @@
-import { formatDescriptorLabel } from "../shell/command-meta.js";
 import { maskValue, padDisplay, renderSummaryLine } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
 import stringWidth from "string-width";
 //#region src/output/patterns.ts
 function renderList(input, ui) {
-	const keyWidth = Math.max(stringWidth(`${input.parentContext.key}:`), ...input.items.map((item) => stringWidth(`⚬ ${item.noun}:`)), stringWidth("Read more"));
+	const keyWidth = Math.max(stringWidth(`${input.parentContext.key}:`), ...input.items.map((item) => stringWidth(`⚬ ${item.noun}:`)), ...readMoreWidth(input.descriptor));
 	const lines = renderCardTitle(input.descriptor, input.title, ui);
 	lines.push(renderCardRow(ui, keyWidth, input.parentContext.key, input.parentContext.value));
 	if (input.items.length === 0) lines.push(renderPlainCardLine(ui, ui.dim(input.emptyMessage)));
 	else for (const item of input.items) lines.push(renderCardRow(ui, keyWidth, `⚬ ${item.noun}`, formatListItemValue(ui, item)));
-	lines.push(renderCardDivider(ui));
-	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	pushReadMore(lines, ui, keyWidth, input.descriptor);
 	return lines;
 }
 function serializeList(input) {
@@ -24,24 +23,18 @@ function serializeList(input) {
 	};
 }
 function renderShow(input, ui) {
-	const keyWidth = Math.max(...input.fields.map((field) => stringWidth(`${field.key}:`)), stringWidth("Read more"));
+	const keyWidth = Math.max(0, ...input.fields.map((field) => stringWidth(`${field.key}:`)), ...readMoreWidth(input.descriptor));
 	const lines = renderCardTitle(input.descriptor, input.title, ui);
 	for (const field of input.fields) lines.push(renderCardRow(ui, keyWidth, field.key, formatValue(ui, field.value, field.tone, field.sensitive)));
-	lines.push(renderCardDivider(ui));
-	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	pushReadMore(lines, ui, keyWidth, input.descriptor);
 	return lines;
 }
 function renderMutate(input, ui) {
-	const rows = [...input.context, {
-		key: "mode",
-		value: "apply",
-		tone: "dim"
-	}];
-	const keyWidth = Math.max(...rows.map((row) => stringWidth(`${row.key}:`)), stringWidth("Read more"));
+	const rows = input.context;
+	const keyWidth = Math.max(0, ...rows.map((row) => stringWidth(`${row.key}:`)), ...readMoreWidth(input.descriptor));
 	const lines = renderCardTitle(input.descriptor, input.title, ui);
 	for (const row of rows) lines.push(renderCardRow(ui, keyWidth, row.key, formatValue(ui, row.value, row.tone, row.sensitive)));
-	lines.push(renderCardDivider(ui));
-	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	pushReadMore(lines, ui, keyWidth, input.descriptor);
 	lines.push("");
 	lines.push(`${ui.warning("◇")} ${input.operationDescription}...`);
 	lines.push(renderSummaryLine(ui, "success", `Applied ${input.operationCount} operation(s)`));
@@ -64,8 +57,13 @@ function renderPlainCardLine(ui, text) {
 function renderCardDivider(ui) {
 	return renderCardRail(ui);
 }
-function renderReadMore(ui, keyWidth, descriptor) {
-	return `${renderCardRail(ui)}  ${ui.accent(padDisplay("Read more", keyWidth))}  ${ui.link(descriptor.docsPath ?? "")}`;
+function readMoreWidth(descriptor) {
+	return descriptor.docsPath ? [stringWidth("Read more")] : [];
+}
+function pushReadMore(lines, ui, keyWidth, descriptor) {
+	if (!descriptor.docsPath) return;
+	lines.push(renderCardDivider(ui));
+	lines.push(`${renderCardRail(ui)}  ${ui.accent(padDisplay("Read more", keyWidth))}  ${ui.link(descriptor.docsPath)}`);
 }
 function renderCardRail(ui) {
 	return ui.dim("│");
@@ -76,7 +74,6 @@ function formatListItemValue(ui, item) {
 }
 function renderAnnotation(ui, status) {
 	if (status === "active") return ui.success("(active)");
-	if (status === "linked") return ui.accent("(linked)");
 	if (status === "default") return ui.dim("(default)");
 	return "";
 }

package/dist/presenters/app-env.js

@@ -0,0 +1,129 @@
+import { renderList, renderShow, serializeList } from "../output/patterns.js";
+//#region src/presenters/app-env.ts
+function scopeLabel(scope) {
+	return scope.role;
+}
+function renderEnvAdd(context, descriptor, result) {
+	return renderShow({
+		title: "Setting a new environment variable.",
+		descriptor,
+		fields: [
+			{
+				key: "project",
+				value: result.projectId
+			},
+			{
+				key: "scope",
+				value: scopeLabel(result.scope)
+			},
+			{
+				key: "key",
+				value: result.variable.key
+			},
+			{
+				key: "id",
+				value: result.variable.id,
+				tone: "dim"
+			},
+			{
+				key: "last updated",
+				value: result.variable.updatedAt,
+				tone: "dim"
+			}
+		]
+	}, context.ui);
+}
+function serializeEnvAdd(result) {
+	return result;
+}
+function renderEnvUpdate(context, descriptor, result) {
+	return renderShow({
+		title: "Replacing the environment variable's value.",
+		descriptor,
+		fields: [
+			{
+				key: "project",
+				value: result.projectId
+			},
+			{
+				key: "scope",
+				value: scopeLabel(result.scope)
+			},
+			{
+				key: "key",
+				value: result.variable.key
+			},
+			{
+				key: "id",
+				value: result.variable.id,
+				tone: "dim"
+			},
+			{
+				key: "last updated",
+				value: result.variable.updatedAt,
+				tone: "dim"
+			}
+		]
+	}, context.ui);
+}
+function serializeEnvUpdate(result) {
+	return result;
+}
+function renderEnvList(context, descriptor, result) {
+	return renderList({
+		title: "Listing environment variables for the selected scope.",
+		descriptor,
+		parentContext: {
+			key: "scope",
+			value: scopeLabel(result.scope)
+		},
+		items: result.variables.map((variable) => ({
+			noun: "variable",
+			label: variable.key,
+			id: variable.id,
+			status: variable.isManagedBySystem ? "default" : null
+		})),
+		emptyMessage: "No environment variables defined in this scope."
+	}, context.ui);
+}
+function serializeEnvList(result) {
+	return {
+		projectId: result.projectId,
+		scope: result.scope,
+		...serializeList({
+			context: { scope: scopeLabel(result.scope) },
+			items: result.variables.map((variable) => ({
+				noun: "variable",
+				label: variable.key,
+				id: variable.id,
+				status: variable.isManagedBySystem ? "default" : null
+			}))
+		}),
+		variables: result.variables
+	};
+}
+function renderEnvRm(context, descriptor, result) {
+	return renderShow({
+		title: "Removing the environment variable from the scope.",
+		descriptor,
+		fields: [
+			{
+				key: "project",
+				value: result.projectId
+			},
+			{
+				key: "scope",
+				value: scopeLabel(result.scope)
+			},
+			{
+				key: "key",
+				value: result.key
+			}
+		]
+	}, context.ui);
+}
+function serializeEnvRm(result) {
+	return result;
+}
+//#endregion
+export { renderEnvAdd, renderEnvList, renderEnvRm, renderEnvUpdate, serializeEnvAdd, serializeEnvList, serializeEnvRm, serializeEnvUpdate };

package/dist/presenters/app.js

@@ -1,3 +1,4 @@
+import { renderDeployOutputRows } from "../lib/app/deploy-output.js";
 import { renderList, renderShow, serializeList } from "../output/patterns.js";
 //#region src/presenters/app.ts
 function renderAppBuild(context, descriptor, result) {
@@ -25,37 +26,23 @@ function serializeAppBuild(result) {
 	return result;
 }
 function renderAppDeploy(context, descriptor, result) {
-	return renderShow({
-		title: "Deploying the selected app.",
-		descriptor,
-		fields: [
-			{
-				key: "project",
-				value: result.projectId
-			},
-			{
-				key: "app",
-				value: result.app.name
-			},
-			{
-				key: "deployment",
-				value: result.deployment.id
-			},
-			{
-				key: "status",
-				value: result.deployment.status,
-				tone: toneForStatus(result.deployment.status)
-			},
-			...result.deployment.url ? [{
-				key: "url",
-				value: result.deployment.url,
-				tone: "link"
-			}] : []
-		]
-	}, context.ui);
+	return [
+		`Live in ${formatDuration(result.durationMs)}`,
+		...result.deployment.url ? [context.ui.link(result.deployment.url)] : [],
+		"",
+		...renderDeployOutputRows(context.ui, [{
+			label: "Logs",
+			value: "prisma-cli app logs"
+		}])
+	];
 }
 function serializeAppDeploy(result) {
-	return result;
+	const { localPin: _localPin, ...serialized } = result;
+	return serialized;
+}
+function formatDuration(durationMs) {
+	if (durationMs < 1e3) return `${durationMs}ms`;
+	return `${(durationMs / 1e3).toFixed(1)}s`;
 }
 function renderAppUpdateEnv(context, descriptor, result) {
 	return renderShow({

package/dist/presenters/auth.js

@@ -9,7 +9,7 @@ function renderAuthSuccess(context, descriptor, command, result) {
 		});
 		if (result.user) rows.push({
 			key: "user",
-			value: `${result.user.name} <${result.user.email}>`
+			value: result.user.email
 		});
 		if (result.workspace?.name) rows.push({
 			key: "workspace",
@@ -47,7 +47,7 @@ function renderAuthSuccess(context, descriptor, command, result) {
 			},
 			...result.user ? [{
 				key: "user",
-				value: `${result.user.name} <${result.user.email}>`
+				value: result.user.email
 			}] : [],
 			...result.provider ? [{
 				key: "provider",

package/dist/presenters/branch.js

@@ -2,11 +2,11 @@ import { renderList, renderMutate, renderShow, serializeList } from "../output/p
 //#region src/presenters/branch.ts
 function renderBranchList(context, descriptor, result) {
 	return renderList({
-		title: "Listing branches for the linked project.",
+		title: "Listing branches for the resolved project.",
 		descriptor,
 		parentContext: {
 			key: "project",
-			value: result.projectName ?? "not linked"
+			value: result.projectName ?? "not resolved"
 		},
 		items: result.branches.map((branch) => ({
 			noun: "branch",
@@ -19,7 +19,7 @@ function renderBranchList(context, descriptor, result) {
 }
 function serializeBranchList(result) {
 	return serializeList({
-		context: { project: result.projectName ?? "not linked" },
+		context: { project: result.projectName ?? "not resolved" },
 		items: result.branches.map((branch) => ({
 			noun: "branch",
 			label: branch.name,
@@ -30,7 +30,7 @@ function serializeBranchList(result) {
 }
 function serializeBranchShow(result) {
 	return {
-		linkedProjectId: result.linkedProjectId,
+		projectId: result.projectId,
 		projectName: result.projectName,
 		branch: {
 			name: result.branch.name,
@@ -45,7 +45,7 @@ function renderBranchShow(context, descriptor, result) {
 	const fields = [
 		{
 			key: "project",
-			value: result.projectName ?? "not linked",
+			value: result.projectName ?? "not resolved",
 			tone: result.projectName ? "default" : "dim"
 		},
 		{
@@ -92,7 +92,7 @@ function renderBranchUse(context, descriptor, result) {
 		descriptor,
 		context: [{
 			key: "project",
-			value: result.projectName ?? "not linked",
+			value: result.projectName ?? "not resolved",
 			tone: result.projectName ? "default" : "dim"
 		}, {
 			key: "branch",