@prisma/cli 3.0.0-alpha.1 → 3.0.0-alpha.3

package/README.md

@@ -18,22 +18,7 @@ pnpm prisma-cli app list-env
 ```
 
 The package exposes `prisma-cli` so it can coexist with the existing `prisma`
-executable. If you want local project scripts that use the future command shape,
-add:
-
-```json
-{
-  "scripts": {
-    "prisma": "prisma-cli"
-  }
-}
-```
-
-Then run:
-
-```bash
-pnpm prisma app deploy
-```
+executable.
 
 Notes:
 

package/dist/cli2.js

@@ -1,4 +1,5 @@
 import { attachCommandDescriptor } from "./shell/command-meta.js";
+import { addCompactGlobalFlags } from "./shell/global-flags.js";
 import { configureRuntimeCommand } from "./shell/runtime.js";
 import "./shell/prompt.js";
 import { createAppCommand } from "./commands/app/index.js";
@@ -31,6 +32,7 @@ async function runCli(options = {}) {
 }
 function createProgram(runtime) {
 	const program = attachCommandDescriptor(configureRuntimeCommand(new Command(), runtime), "root");
+	addCompactGlobalFlags(program);
 	program.name("prisma").showSuggestionAfterError();
 	program.addCommand(createAuthCommand(runtime));
 	program.addCommand(createBranchCommand(runtime));

package/dist/commands/app/index.js

@@ -1,14 +1,15 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { PREVIEW_BUILD_TYPES } from "../../lib/app/preview-build.js";
 import { runAppBuild, runAppDeploy, runAppListDeploys, runAppListEnv, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy, runAppUpdateEnv } from "../../controllers/app.js";
 import { renderAppBuild, renderAppDeploy, renderAppListDeploys, renderAppListEnv, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, renderAppUpdateEnv, serializeAppBuild, serializeAppDeploy, serializeAppListDeploys, serializeAppListEnv, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy, serializeAppUpdateEnv } from "../../presenters/app.js";
-import { runCommand } from "../../shell/command-runner.js";
+import { runCommand, runStreamingCommand } from "../../shell/command-runner.js";
 import { Command, Option } from "commander";
 //#region src/commands/app/index.ts
 function createAppCommand(runtime) {
 	const app = attachCommandDescriptor(configureRuntimeCommand(new Command("app"), runtime), "app");
+	addCompactGlobalFlags(app);
 	app.addCommand(createBuildCommand(runtime));
 	app.addCommand(createRunCommand(runtime));
 	app.addCommand(createDeployCommand(runtime));
@@ -139,7 +140,7 @@ function createLogsCommand(runtime) {
 	command.action(async (options) => {
 		const appName = options.app;
 		const deploymentId = options.deployment;
-		await runCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId), { renderHuman: () => [] });
+		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId));
 	});
 	return command;
 }

package/dist/commands/auth/index.js

@@ -1,5 +1,5 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
 import { runAuthLogin, runAuthLogout, runAuthWhoAmI } from "../../controllers/auth.js";
@@ -8,6 +8,7 @@ import { Command, Option } from "commander";
 //#region src/commands/auth/index.ts
 function createAuthCommand(runtime) {
 	const auth = attachCommandDescriptor(configureRuntimeCommand(new Command("auth"), runtime), "auth");
+	addCompactGlobalFlags(auth);
 	auth.addCommand(createAuthLoginCommand(runtime));
 	auth.addCommand(createAuthLogoutCommand(runtime));
 	auth.addCommand(createAuthWhoAmICommand(runtime));

package/dist/commands/branch/index.js

@@ -1,5 +1,5 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
 import { runBranchList, runBranchShow, runBranchUse } from "../../controllers/branch.js";
@@ -8,6 +8,7 @@ import { Command } from "commander";
 //#region src/commands/branch/index.ts
 function createBranchCommand(runtime) {
 	const branch = attachCommandDescriptor(configureRuntimeCommand(new Command("branch"), runtime), "branch");
+	addCompactGlobalFlags(branch);
 	branch.addCommand(createBranchListCommand(runtime));
 	branch.addCommand(createBranchShowCommand(runtime));
 	branch.addCommand(createBranchUseCommand(runtime));

package/dist/commands/env.js

@@ -0,0 +1,71 @@
+import { attachCommandDescriptor } from "../shell/command-meta.js";
+import { addGlobalFlags } from "../shell/global-flags.js";
+import { configureRuntimeCommand } from "../shell/runtime.js";
+import { runCommand } from "../shell/command-runner.js";
+import { runEnvAdd, runEnvList, runEnvRm, runEnvUpdate } from "../controllers/app-env.js";
+import { renderEnvAdd, renderEnvList, renderEnvRm, renderEnvUpdate, serializeEnvAdd, serializeEnvList, serializeEnvRm, serializeEnvUpdate } from "../presenters/app-env.js";
+import { Command, Option } from "commander";
+//#region src/commands/env.ts
+function createEnvCommand(runtime) {
+	const env = attachCommandDescriptor(configureRuntimeCommand(new Command("env"), runtime), "project.env");
+	env.description("Manage environment variables for the linked project.");
+	env.addCommand(createEnvAddCommand(runtime));
+	env.addCommand(createEnvUpdateCommand(runtime));
+	env.addCommand(createEnvListCommand(runtime));
+	env.addCommand(createEnvRmCommand(runtime));
+	return env;
+}
+function createEnvAddCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "project.env.add");
+	command.argument("<assignment>", "Variable assignment in KEY=VALUE form").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"]));
+	addGlobalFlags(command);
+	command.action(async (assignment, options) => {
+		const roleName = options.role;
+		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, { roleName }), {
+			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
+			renderJson: (result) => serializeEnvAdd(result)
+		});
+	});
+	return command;
+}
+function createEnvUpdateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "project.env.update");
+	command.argument("<assignment>", "Variable assignment in KEY=VALUE form").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"]));
+	addGlobalFlags(command);
+	command.action(async (assignment, options) => {
+		const roleName = options.role;
+		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, { roleName }), {
+			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
+			renderJson: (result) => serializeEnvUpdate(result)
+		});
+	});
+	return command;
+}
+function createEnvListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "project.env.list");
+	command.addOption(new Option("--role <role>", "Project template scope").choices(["production", "preview"]));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const roleName = options.role;
+		await runCommand(runtime, "project.env.list", options, (context) => runEnvList(context, { roleName }), {
+			renderHuman: (context, descriptor, result) => renderEnvList(context, descriptor, result),
+			renderJson: (result) => serializeEnvList(result)
+		});
+	});
+	return command;
+}
+function createEnvRmCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rm"), runtime), "project.env.rm");
+	command.argument("<key>", "Variable key to remove").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"]));
+	addGlobalFlags(command);
+	command.action(async (key, options) => {
+		const roleName = options.role;
+		await runCommand(runtime, "project.env.rm", options, (context) => runEnvRm(context, key, { roleName }), {
+			renderHuman: (context, descriptor, result) => renderEnvRm(context, descriptor, result),
+			renderJson: (result) => serializeEnvRm(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createEnvCommand };

package/dist/commands/project/index.js

@@ -1,16 +1,19 @@
 import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addGlobalFlags } from "../../shell/global-flags.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { runCommand } from "../../shell/command-runner.js";
 import { runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
 import { renderProjectLink, renderProjectList, renderProjectShow, serializeProjectList } from "../../presenters/project.js";
+import { createEnvCommand } from "../env.js";
 import { Command } from "commander";
 //#region src/commands/project/index.ts
 function createProjectCommand(runtime) {
 	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
+	addCompactGlobalFlags(project);
 	project.addCommand(createProjectListCommand(runtime));
 	project.addCommand(createProjectShowCommand(runtime));
 	project.addCommand(createProjectLinkCommand(runtime));
+	project.addCommand(createEnvCommand(runtime));
 	return project;
 }
 function createProjectListCommand(runtime) {

package/dist/controllers/app-env.js

@@ -0,0 +1,221 @@
+import { readLinkedProjectId } from "../adapters/config.js";
+import { CliError, authRequiredError, usageError } from "../shell/errors.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { formatScopeLabel, parseKeyValuePositional, resolveEnvScope } from "../lib/app/env-config.js";
+//#region src/controllers/app-env.ts
+function defaultRoleScope() {
+	return {
+		kind: "role",
+		role: "production"
+	};
+}
+async function runEnvAdd(context, rawAssignment, flags) {
+	const { key, value } = parseKeyValuePositional(rawAssignment, "add");
+	const scope = resolveEnvScope(flags, {
+		requireExplicit: true,
+		command: "add"
+	});
+	if (!scope) throw usageError(`prisma-cli project env add requires --role`, "Writing without an explicit scope is rejected.", "Pass --role production or --role preview.", [`prisma-cli project env add ${key}=${value} --role production`], "app");
+	const { client, projectId } = await requireClientAndProject(context);
+	const resolved = resolveScopeToApi(scope);
+	if (await findVariableByNaturalKey(client, projectId, key, resolved)) throw new CliError({
+		code: "ENV_VARIABLE_ALREADY_EXISTS",
+		domain: "app",
+		summary: `Variable "${key}" already exists in ${formatScopeLabel(scope)}`,
+		why: "A variable with this key already exists in the targeted scope.",
+		fix: "Use `prisma-cli project env update` to change an existing variable's value.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env update ${key}=<new-value> --role ${scope.role}`]
+	});
+	const { data, error, response } = await client.POST("/v1/environment-variables", { body: {
+		projectId,
+		class: resolved.apiTarget.class,
+		key,
+		value
+	} });
+	if (error || !data) throw apiCallError(`Failed to add ${key}`, response, error);
+	return {
+		command: "project.env.add",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variable: toMetadata(data.data, resolved.descriptor)
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runEnvUpdate(context, rawAssignment, flags) {
+	const { key, value } = parseKeyValuePositional(rawAssignment, "update");
+	const scope = resolveEnvScope(flags, {
+		requireExplicit: true,
+		command: "update"
+	});
+	if (!scope) throw usageError(`prisma-cli project env update requires --role`, "Writing without an explicit scope is rejected.", "Pass --role production or --role preview.", [`prisma-cli project env update ${key}=${value} --role production`], "app");
+	const { client, projectId } = await requireClientAndProject(context);
+	const resolved = resolveScopeToApi(scope);
+	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
+	if (!existing) throw new CliError({
+		code: "ENV_VARIABLE_NOT_FOUND",
+		domain: "app",
+		summary: `Variable "${key}" not found in ${formatScopeLabel(scope)}`,
+		why: "No variable with this key exists in the targeted scope.",
+		fix: "Use `prisma-cli project env add` to create a new variable.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env add ${key}=<value> --role ${scope.role}`]
+	});
+	const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: existing.id } },
+		body: { value }
+	});
+	if (error || !data) throw apiCallError(`Failed to update value for ${key}`, response, error);
+	return {
+		command: "project.env.update",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variable: toMetadata(data.data, resolved.descriptor)
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runEnvList(context, flags) {
+	const scope = resolveEnvScope(flags, {
+		requireExplicit: false,
+		command: "list"
+	}) ?? defaultRoleScope();
+	const { client, projectId } = await requireClientAndProject(context);
+	const resolved = resolveScopeToApi(scope);
+	const variables = await listVariables(client, projectId, resolved);
+	return {
+		command: "project.env.list",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			variables: variables.map((row) => toMetadata(row, resolved.descriptor))
+		},
+		warnings: [],
+		nextSteps: variables.length === 0 ? [`prisma-cli project env add KEY=value --role ${scope.role}`] : []
+	};
+}
+async function runEnvRm(context, key, flags) {
+	if (!key) throw usageError("prisma-cli project env rm requires KEY", "No KEY positional argument was supplied.", "Pass the variable name to remove, e.g. STRIPE_KEY.", ["prisma-cli project env rm STRIPE_KEY --role production"], "app");
+	const scope = resolveEnvScope(flags, {
+		requireExplicit: true,
+		command: "rm"
+	});
+	if (!scope) throw usageError("prisma-cli project env rm requires --role", "Writing without an explicit scope is rejected.", "Pass --role production or --role preview.", [`prisma-cli project env rm ${key} --role production`], "app");
+	const { client, projectId } = await requireClientAndProject(context);
+	const resolved = resolveScopeToApi(scope);
+	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
+	if (!existing) throw new CliError({
+		code: "ENV_VARIABLE_NOT_FOUND",
+		domain: "app",
+		summary: `Variable "${key}" not found in ${formatScopeLabel(scope)}`,
+		why: "No variable with this key exists in the targeted scope, so there is nothing to remove.",
+		fix: "Run prisma-cli project env list with the same scope to see the available variables.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env list --role ${scope.role}`]
+	});
+	const { error, response } = await client.DELETE("/v1/environment-variables/{envVarId}", { params: { path: { envVarId: existing.id } } });
+	if (error) throw apiCallError(`Failed to remove ${key}`, response, error);
+	return {
+		command: "project.env.rm",
+		result: {
+			projectId,
+			scope: resolved.descriptor,
+			key
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function requireClientAndProject(context) {
+	const projectId = await readLinkedProjectId(context.runtime.cwd);
+	if (!projectId) throw new CliError({
+		code: "PROJECT_NOT_LINKED",
+		domain: "project",
+		summary: "Project link required",
+		why: "prisma-cli project env needs a linked project for the current repo.",
+		fix: "Run prisma project link before managing environment variables.",
+		exitCode: 1,
+		nextSteps: ["prisma project link"]
+	});
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError(["prisma auth login"]);
+	return {
+		client,
+		projectId
+	};
+}
+function resolveScopeToApi(scope) {
+	return {
+		scope,
+		descriptor: {
+			kind: "role",
+			role: scope.role
+		},
+		apiTarget: {
+			class: scope.role,
+			branchId: null
+		}
+	};
+}
+async function findVariableByNaturalKey(client, projectId, key, resolved) {
+	const { data, error, response } = await client.GET("/v1/environment-variables", { params: { query: {
+		projectId,
+		class: resolved.apiTarget.class,
+		key
+	} } });
+	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
+	return data.data.filter((row) => rowMatchesScope(row, resolved))[0] ?? null;
+}
+async function listVariables(client, projectId, resolved) {
+	const collected = [];
+	let cursor;
+	while (true) {
+		const query = {
+			projectId,
+			class: resolved.apiTarget.class
+		};
+		if (cursor !== void 0) query.cursor = cursor;
+		const result = await client.GET("/v1/environment-variables", { params: { query } });
+		if (result.error || !result.data) throw apiCallError(`Failed to list environment variables`, result.response, result.error);
+		const page = result.data.data.filter((row) => rowMatchesScope(row, resolved));
+		collected.push(...page);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return collected;
+}
+function rowMatchesScope(row, resolved) {
+	return row.branchId === null && row.class === resolved.apiTarget.class;
+}
+function toMetadata(row, scope) {
+	return {
+		id: row.id,
+		key: row.key,
+		scope,
+		isManagedBySystem: row.isManagedBySystem,
+		updatedAt: row.updatedAt
+	};
+}
+function apiCallError(summary, response, error) {
+	const status = response?.status ?? 0;
+	const apiCode = error?.error?.code;
+	const apiMessage = error?.error?.message;
+	const apiHint = error?.error?.hint;
+	if (status === 401 || status === 403) return authRequiredError(["prisma auth login"]);
+	return new CliError({
+		code: apiCode ?? "ENV_API_ERROR",
+		domain: "app",
+		summary,
+		why: apiMessage ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: apiHint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
+}
+//#endregion
+export { runEnvAdd, runEnvList, runEnvRm, runEnvUpdate };