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

package/dist/controllers/app-env.js

@@ -0,0 +1,223 @@
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { resolveProjectTarget } from "../lib/project/resolution.js";
+import { createSelectPromptPort } from "./select-prompt-port.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listRealWorkspaceProjects } from "./project.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", context.runtime.env);
+	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, flags.projectRef);
+	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", context.runtime.env);
+	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, flags.projectRef);
+	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, flags.projectRef);
+	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, flags.projectRef);
+	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, explicitProject) {
+	const authState = await requireAuthenticatedAuthState(context);
+	const client = await requireComputeAuth(context.runtime.env);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	if (!authState.workspace) throw workspaceRequiredError();
+	return {
+		client,
+		projectId: (await resolveProjectTarget({
+			context,
+			workspace: authState.workspace,
+			explicitProject,
+			listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
+			prompt: createSelectPromptPort(context),
+			remember: true
+		})).project.id
+	};
+}
+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 };