@prisma/cli 3.0.0-alpha.2 → 3.0.0-alpha.4

package/dist/lib/app/env-config.js

@@ -0,0 +1,57 @@
+import { usageError } from "../../shell/errors.js";
+//#region src/lib/app/env-config.ts
+const VALID_ROLES = new Set(["production", "preview"]);
+function positionalHint(command) {
+	if (command === "add" || command === "update") return "KEY=value ";
+	if (command === "rm") return "KEY ";
+	return "";
+}
+function resolveEnvScope(flags, options) {
+	if (flags.roleName) {
+		if (!VALID_ROLES.has(flags.roleName)) throw usageError(`Unknown role "${flags.roleName}"`, "--role accepts production or preview.", "Pass --role production or --role preview.", [`prisma-cli project env ${options.command} --role production`, `prisma-cli project env ${options.command} --role preview`], "app");
+		return {
+			kind: "role",
+			role: flags.roleName
+		};
+	}
+	if (options.requireExplicit) {
+		const positional = positionalHint(options.command);
+		throw usageError(`prisma-cli project env ${options.command} requires --role`, "Writing without an explicit scope is rejected so the command never silently targets production.", "Pass --role production or --role preview.", [`prisma-cli project env ${options.command} ${positional}--role production`, `prisma-cli project env ${options.command} ${positional}--role preview`], "app");
+	}
+	return null;
+}
+function parseKeyValuePositional(raw, command, env = process.env) {
+	if (!raw) throw usageError(`prisma-cli project env ${command} requires KEY=VALUE`, "No KEY=VALUE positional argument was supplied.", "Pass the variable as KEY=VALUE, e.g. STRIPE_KEY=sk_test_xxx.", [`prisma-cli project env ${command} STRIPE_KEY=sk_test_xxx --role production`], "app");
+	const separatorIndex = raw.indexOf("=");
+	if (separatorIndex === -1) {
+		if (KEY_SHAPE.test(raw)) {
+			validateKey(raw, command);
+			const value = env[raw];
+			if (typeof value === "string" && value.length > 0) return {
+				key: raw,
+				value
+			};
+			throw usageError(`Value for "${raw}" was not provided`, `No KEY=VALUE assignment was supplied, and ${raw} is not set in the current environment.`, "Pass KEY=VALUE or export the variable before running the command.", [`prisma-cli project env ${command} ${raw}=value --role production`, `${raw}=value prisma-cli project env ${command} ${raw} --role production`], "app");
+		}
+		throw usageError(`KEY=VALUE argument is missing the = separator`, `"${raw}" does not contain an = character.`, "Pass the variable as KEY=VALUE, e.g. STRIPE_KEY=sk_test_xxx.", [`prisma-cli project env ${command} STRIPE_KEY=sk_test_xxx --role production`], "app");
+	}
+	const key = raw.slice(0, separatorIndex);
+	const value = raw.slice(separatorIndex + 1);
+	validateKey(key, command);
+	if (value.length === 0) throw usageError(`KEY=VALUE argument has an empty value`, `"${raw}" has an empty value after the = separator.`, `Pass a non-empty value, or use prisma-cli project env rm to remove a variable.`, [`prisma-cli project env ${command} ${key}=value --role production`], "app");
+	return {
+		key,
+		value
+	};
+}
+const KEY_SHAPE = /^[A-Z_][A-Z0-9_]*$/;
+function validateKey(key, command) {
+	if (key.length === 0) throw usageError(`Variable key cannot be empty`, "An empty key was passed.", "Pass an env-var key, e.g. STRIPE_KEY.", [`prisma-cli project env ${command} STRIPE_KEY${command === "rm" ? "" : "=value"} --role production`], "app");
+	if (key.length > 256) throw usageError(`Variable key "${key}" exceeds the 256-character limit`, "Env-var keys are capped at 256 characters by the platform.", "Use a shorter key.", [], "app");
+	if (!KEY_SHAPE.test(key)) throw usageError(`Variable key "${key}" must match the POSIX env-var shape`, "Keys must start with an uppercase letter or underscore and contain only uppercase letters, digits, and underscores.", "Rename the key to match [A-Z_][A-Z0-9_]*.", [`prisma-cli project env ${command} STRIPE_KEY${command === "rm" ? "" : "=value"} --role production`], "app");
+}
+function formatScopeLabel(scope) {
+	return scope.role;
+}
+//#endregion
+export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope };

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

@@ -1,9 +1,9 @@
 import { envVarNames } from "./env-vars.js";
 import { PreviewBuildStrategy } from "./preview-build.js";
 import path from "node:path";
-import { ApiError, ComputeClient } from "@prisma/compute-sdk";
+import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
-function createPreviewAppProvider(client) {
+function createPreviewAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
 		async createProject(options) {
@@ -197,6 +197,19 @@ function createPreviewAppProvider(client) {
 					live: null
 				}
 			};
+		},
+		async streamDeploymentLogs(streamOptions) {
+			if (!options?.baseUrl || !options.getToken) throw new Error("Log streaming requires an authenticated API base URL and token.");
+			const result = await streamLogs({
+				baseUrl: options.baseUrl,
+				token: await options.getToken(),
+				versionId: streamOptions.deploymentId,
+				signal: streamOptions.signal
+			}, streamOptions.onRecord);
+			if (result.isErr()) {
+				if (CancelledError.is(result.error)) return;
+				throw result.error;
+			}
 		}
 	};
 }

package/dist/lib/auth/auth-ops.js

@@ -11,6 +11,10 @@ function decodeJwtPayload(token) {
 		return {};
 	}
 }
+function emailFromClaims(claims) {
+	const email = claims.email;
+	return typeof email === "string" && email.trim().length > 0 ? email.trim() : null;
+}
 async function performLogin(env) {
 	await login({
 		tokenStorage: new FileTokenStorage(env),
@@ -23,10 +27,9 @@ async function readAuthState(env) {
 		authenticated: false,
 		provider: null,
 		user: null,
-		workspace: null,
-		linkedProjectId: null
+		workspace: null
 	};
-	const claims = decodeJwtPayload(tokens.accessToken);
+	const email = emailFromClaims(decodeJwtPayload(tokens.accessToken));
 	const client = await requireComputeAuth(env);
 	let workspaceId = tokens.workspaceId;
 	let workspaceName = tokens.workspaceId;
@@ -38,16 +41,11 @@ async function readAuthState(env) {
 	return {
 		authenticated: true,
 		provider: null,
-		user: {
-			id: claims.sub ?? "",
-			name: claims.name ?? "",
-			email: claims.email ?? ""
-		},
+		user: email ? { email } : null,
 		workspace: {
 			id: workspaceId,
 			name: workspaceName
-		},
-		linkedProjectId: null
+		}
 	};
 }
 async function performLogout(env) {

package/dist/lib/auth/client.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import os from "node:os";
+import path from "node:path";
 //#region src/lib/auth/client.ts
 const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
 const SERVICE_TOKEN_ENV_VAR = "PRISMA_API_TOKEN";

package/dist/lib/project/resolution.js

@@ -0,0 +1,148 @@
+import { CliError } from "../../shell/errors.js";
+import { canPrompt } from "../../shell/runtime.js";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/lib/project/resolution.ts
+async function resolveProjectTarget(options) {
+	const projects = await options.listProjects();
+	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit");
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
+	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
+	let staleRemembered = false;
+	if (remembered) {
+		const matched = projects.find((project) => project.id === remembered.id);
+		if (matched) return rememberIfRequested(options, matched, "remembered-local");
+		staleRemembered = true;
+	}
+	const packageName = await readPackageName(options.context.runtime.cwd);
+	if (packageName) {
+		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
+		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name");
+		if (matches.length > 1) return resolveAmbiguousProject(options, matches, "package-name");
+	}
+	if (options.allowCreate && options.createProject) {
+		const inferredName = packageName ?? path.basename(options.context.runtime.cwd);
+		if (inferredName) {
+			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName));
+			if (existing.length === 1) return rememberIfRequested(options, existing[0], "package-name");
+			if (existing.length > 1) return resolveAmbiguousProject(options, existing, "package-name");
+			return rememberIfRequested(options, await options.createProject(inferredName), "created");
+		}
+	}
+	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();
+}
+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) {
+	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: ["prisma-cli project list"]
+	});
+}
+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;
+	}
+}
+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) {
+	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"));
+	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) {
+	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 }
+	};
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+//#endregion
+export { resolveProjectTarget, sortProjects };

package/dist/output/patterns.js

@@ -1,5 +1,5 @@
-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) {
@@ -74,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

@@ -29,9 +29,17 @@ function renderAppDeploy(context, descriptor, result) {
 		title: "Deploying the selected app.",
 		descriptor,
 		fields: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
 			{
 				key: "project",
-				value: result.projectId
+				value: result.project.name
+			},
+			{
+				key: "branch",
+				value: result.branch.name
 			},
 			{
 				key: "app",

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",

package/dist/presenters/project.js

@@ -12,7 +12,7 @@ function renderProjectList(context, descriptor, result) {
 			noun: "project",
 			label: project.name,
 			id: project.id,
-			status: result.linkedProjectId === project.id ? "linked" : null
+			status: null
 		})),
 		emptyMessage: "No projects found."
 	}, context.ui);
@@ -24,61 +24,101 @@ function serializeProjectList(result) {
 			noun: "project",
 			label: project.name,
 			id: project.id,
-			status: result.linkedProjectId === project.id ? "linked" : null
+			status: null
 		}))
 	});
 }
 function renderProjectShow(context, descriptor, result) {
-	if (!result.linkedProjectId) return renderShow({
-		title: "Showing the linked project for the current repo.",
-		descriptor,
-		fields: [{
-			key: "project",
-			value: "not linked",
-			tone: "dim"
-		}]
-	}, context.ui);
-	if (!result.project || !result.workspace) return renderShow({
-		title: "Showing the linked project for the current repo.",
+	return renderShow({
+		title: "Showing the project Prisma resolves for this directory.",
 		descriptor,
-		fields: [{
-			key: "project",
-			value: "linked",
-			tone: "success"
-		}, {
-			key: "remote details",
-			value: "unavailable until you sign in",
-			tone: "dim"
-		}]
+		fields: [
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "resolution",
+				value: formatProjectSource(result.resolution.projectSource)
+			}
+		]
 	}, context.ui);
-	return renderShow({
-		title: "Showing the linked project for the current repo.",
+}
+function serializeProjectShow(result) {
+	return result;
+}
+function renderGitConnect(context, descriptor, result) {
+	const connection = result.repositoryConnection;
+	return renderMutate({
+		title: "Connecting Git to the resolved project.",
 		descriptor,
-		fields: [{
-			key: "project",
-			value: result.project.name
-		}, {
-			key: "workspace",
-			value: result.workspace.name
-		}]
+		context: [
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "repository",
+				value: connection.repository.fullName
+			},
+			{
+				key: "status",
+				value: connection.status
+			}
+		],
+		operationDescription: "Applying repository connection",
+		operationCount: 1,
+		details: [formatGitConnectionDetail(connection.status)]
 	}, context.ui);
 }
-function renderProjectLink(context, descriptor, result) {
-	if (!result.project || !result.workspace) throw new Error("Linked project result must be enriched for human output.");
+function renderGitDisconnect(context, descriptor, result) {
 	return renderMutate({
-		title: "Linking the current repo to an existing project.",
+		title: "Disconnecting Git from the resolved project.",
 		descriptor,
-		context: [{
-			key: "project",
-			value: result.project.name
-		}, {
-			key: "workspace",
-			value: result.workspace.name
-		}],
-		operationDescription: "Applying local project link",
+		context: [
+			{
+				key: "project",
+				value: result.project.name
+			},
+			{
+				key: "workspace",
+				value: result.workspace.name
+			},
+			{
+				key: "repository",
+				value: result.repositoryConnection.repository.fullName
+			}
+		],
+		operationDescription: "Applying repository disconnection",
 		operationCount: 1,
-		details: ["Project link written to local repo config."]
+		details: ["GitHub branch automation is no longer active for this project."]
 	}, context.ui);
 }
+function formatProjectSource(source) {
+	switch (source) {
+		case "explicit": return "explicit";
+		case "platform-mapping": return "platform mapping";
+		case "remembered-local": return "remembered local context";
+		case "package-name": return "package name";
+		case "created": return "created";
+		case "prompt": return "prompt";
+	}
+}
+function formatGitConnectionDetail(status) {
+	switch (status) {
+		case "active": return "GitHub branch automation is active for this project.";
+		case "pending": return "GitHub branch automation is pending GitHub App installation.";
+		case "archived": return "GitHub branch automation has been archived for this project.";
+		default: return "GitHub repository is connected, but branch automation is not active.";
+	}
+}
 //#endregion
-export { renderProjectLink, renderProjectList, renderProjectShow, serializeProjectList };
+export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectShow, serializeProjectList, serializeProjectShow };