@prisma/cli 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/commands/database/index.js

@@ -0,0 +1,159 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow } from "../../controllers/database.js";
+import { renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseShow, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseShow } from "../../presenters/database.js";
+import { Command, Option } from "commander";
+//#region src/commands/database/index.ts
+function createDatabaseCommand(runtime) {
+	const database = attachCommandDescriptor(configureRuntimeCommand(new Command("database"), runtime), "database");
+	addCompactGlobalFlags(database);
+	database.addCommand(createDatabaseListCommand(runtime));
+	database.addCommand(createDatabaseShowCommand(runtime));
+	database.addCommand(createDatabaseCreateCommand(runtime));
+	database.addCommand(createDatabaseRemoveCommand(runtime));
+	database.addCommand(createDatabaseConnectionCommand(runtime));
+	return database;
+}
+function addProjectAndBranchOptions(command) {
+	return command.addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <git-name>", "Branch git name"));
+}
+function createDatabaseListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.list");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.list", options, (context) => runDatabaseList(context, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "database.show");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.show", options, (context) => runDatabaseShow(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseShow(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseShow(result)
+		});
+	});
+	return command;
+}
+function createDatabaseCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.create");
+	command.argument("<name>", "Database name").addOption(new Option("--region <region>", "Prisma Postgres region id"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (name, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const region = options.region;
+		await runCommand(runtime, "database.create", options, (context) => runDatabaseCreate(context, name, {
+			projectRef,
+			branchName,
+			region
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.remove");
+	command.argument("<database>", "Database id or name").addOption(new Option("--confirm <database-id>", "Exact database id required to remove"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.remove", options, (context) => runDatabaseRemove(context, databaseRef, {
+			projectRef,
+			branchName,
+			confirm
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseRemove(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCommand(runtime) {
+	const connection = attachCommandDescriptor(configureRuntimeCommand(new Command("connection"), runtime), "database.connection");
+	addCompactGlobalFlags(connection);
+	connection.addCommand(createDatabaseConnectionListCommand(runtime));
+	connection.addCommand(createDatabaseConnectionCreateCommand(runtime));
+	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
+	return connection;
+}
+function createDatabaseConnectionListCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.connection.list");
+	command.argument("<database>", "Database id or name");
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		await runCommand(runtime, "database.connection.list", options, (context) => runDatabaseConnectionList(context, databaseRef, {
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionList(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionList(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionCreateCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "database.connection.create");
+	command.argument("<database>", "Database id or name").addOption(new Option("--name <name>", "Connection name"));
+	addProjectAndBranchOptions(command);
+	addGlobalFlags(command);
+	command.action(async (databaseRef, options) => {
+		const projectRef = options.project;
+		const branchName = options.branch;
+		const name = options.name;
+		await runCommand(runtime, "database.connection.create", options, (context) => runDatabaseConnectionCreate(context, databaseRef, {
+			projectRef,
+			branchName,
+			name
+		}), {
+			renderStdout: (context, descriptor, result) => renderDatabaseConnectionCreateStdout(context, descriptor, result),
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionCreate(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionCreate(result)
+		});
+	});
+	return command;
+}
+function createDatabaseConnectionRemoveCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "database.connection.remove");
+	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to remove"));
+	addGlobalFlags(command);
+	command.action(async (connectionRef, options) => {
+		const confirm = options.confirm;
+		await runCommand(runtime, "database.connection.remove", options, (context) => runDatabaseConnectionRemove(context, connectionRef, { confirm }), {
+			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRemove(context, descriptor, result),
+			renderJson: (result) => serializeDatabaseConnectionRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createDatabaseCommand };

package/dist/commands/env.js

@@ -17,16 +17,18 @@ function createEnvCommand(runtime) {
 }
 function createEnvAddCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "project.env.add");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
 			renderJson: (result) => serializeEnvAdd(result)
@@ -36,16 +38,18 @@ function createEnvAddCommand(runtime) {
 }
 function createEnvUpdateCommand(runtime) {
 	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update"), runtime), "project.env.update");
-	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("[assignment]", "Variable assignment as KEY=VALUE or KEY from the current environment").addOption(new Option("--file <path>", "Read KEY=VALUE assignments from a dotenv file")).addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--branch <git-name>", "Preview branch override scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (assignment, options) => {
 		const roleName = options.role;
 		const branchName = options.branch;
 		const projectRef = options.project;
+		const filePath = options.file;
 		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, {
 			roleName,
 			branchName,
-			projectRef
+			projectRef,
+			filePath
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
 			renderJson: (result) => serializeEnvUpdate(result)

package/dist/controllers/app-env-api.js

@@ -0,0 +1,54 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+//#region src/controllers/app-env-api.ts
+async function findVariableByNaturalKey(client, projectId, key, resolved, signal) {
+	const { data, error, response } = await client.GET("/v1/environment-variables", {
+		params: { query: {
+			projectId,
+			class: resolved.apiTarget.class,
+			key
+		} },
+		signal
+	});
+	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
+	return data.data.filter((row) => rowMatchesExactScope(row, resolved))[0] ?? null;
+}
+function toMetadata(row, requestedScope) {
+	const rowScope = row.branchId === null ? {
+		kind: "role",
+		role: row.class
+	} : requestedScope;
+	return {
+		id: row.id,
+		key: row.key,
+		scope: rowScope,
+		source: formatDescriptorLabel(rowScope),
+		isManagedBySystem: row.isManagedBySystem,
+		updatedAt: row.updatedAt
+	};
+}
+function rowMatchesExactScope(row, resolved) {
+	return row.class === resolved.apiTarget.class && row.branchId === resolved.apiTarget.branchId;
+}
+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: []
+	});
+}
+function formatDescriptorLabel(scope) {
+	if (scope.kind === "role") return scope.role ?? "unknown";
+	if (scope.kind === "overview") return "overview";
+	return `branch:${scope.branchName ?? scope.branchId ?? "unknown"}`;
+}
+//#endregion
+export { apiCallError, findVariableByNaturalKey, toMetadata };

package/dist/controllers/app-env-file.js

@@ -0,0 +1,181 @@
+import { CliError } from "../shell/errors.js";
+import { formatScopeLabel } from "../lib/app/env-config.js";
+import { apiCallError, findVariableByNaturalKey, toMetadata } from "./app-env-api.js";
+//#region src/controllers/app-env-file.ts
+async function runEnvAddFile(context, client, projectId, resolved, filePath, assignments, verboseContext) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const existingKeys = assignments.map((assignment) => assignment.key).filter((key) => existing.has(key));
+	if (existingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_ALREADY_EXISTS",
+		domain: "app",
+		summary: `${existingKeys.length} environment variable(s) already exist in ${formatScopeLabel(resolved.scope)}`,
+		why: `Existing keys: ${formatKeyList(existingKeys)}.`,
+		fix: "Split the input file by key state: update existing keys and add new keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			existingKeys,
+			first: "update-existing"
+		}),
+		meta: { keys: existingKeys }
+	});
+	const warnings = await missingPreviewDefaultWarnings(client, projectId, resolved.scope, assignments.map((assignment) => assignment.key), context.runtime.signal);
+	const variables = [];
+	for (const assignment of assignments) try {
+		const { data, error, response } = await client.POST("/v1/environment-variables", {
+			body: {
+				projectId,
+				class: resolved.apiTarget.class,
+				...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {},
+				key: assignment.key,
+				value: assignment.value
+			},
+			signal: context.runtime.signal
+		});
+		if (error || !data) throw apiCallError(`Failed to add ${assignment.key}`, response, error);
+		variables.push(toMetadata(data.data, resolved.descriptor));
+	} catch (error) {
+		throw envFileApplyFailedError("add", filePath, resolved.scope, assignment.key, variables, error);
+	}
+	return {
+		command: "project.env.add",
+		result: {
+			projectId,
+			verboseContext,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings,
+		nextSteps: []
+	};
+}
+async function runEnvUpdateFile(context, client, projectId, resolved, filePath, assignments, verboseContext) {
+	const existing = await findVariablesByNaturalKey(client, projectId, assignments.map((assignment) => assignment.key), resolved, context.runtime.signal);
+	const missingKeys = assignments.map((assignment) => assignment.key).filter((key) => !existing.has(key));
+	if (missingKeys.length > 0) throw new CliError({
+		code: "ENV_VARIABLE_NOT_FOUND",
+		domain: "app",
+		summary: `${missingKeys.length} environment variable(s) not found in ${formatScopeLabel(resolved.scope)}`,
+		why: `Missing keys: ${formatKeyList(missingKeys)}.`,
+		fix: "Split the input file by key state: add missing keys and update existing keys separately.",
+		exitCode: 1,
+		nextSteps: splitFileNextSteps(filePath, resolved.scope, {
+			missingKeys,
+			first: "add-missing"
+		}),
+		meta: { keys: missingKeys }
+	});
+	const variables = [];
+	for (const assignment of assignments) {
+		const existingVariable = existing.get(assignment.key);
+		if (!existingVariable) continue;
+		try {
+			const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
+				params: { path: { envVarId: existingVariable.id } },
+				body: { value: assignment.value },
+				signal: context.runtime.signal
+			});
+			if (error || !data) throw apiCallError(`Failed to update value for ${assignment.key}`, response, error);
+			variables.push(toMetadata(data.data, resolved.descriptor));
+		} catch (error) {
+			throw envFileApplyFailedError("update", filePath, resolved.scope, assignment.key, variables, error);
+		}
+	}
+	return {
+		command: "project.env.update",
+		result: {
+			projectId,
+			verboseContext,
+			scope: resolved.descriptor,
+			variables,
+			file: {
+				path: filePath,
+				count: variables.length
+			}
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function findVariablesByNaturalKey(client, projectId, keys, resolved, signal) {
+	const found = /* @__PURE__ */ new Map();
+	for (const key of keys) {
+		const row = await findVariableByNaturalKey(client, projectId, key, resolved, signal);
+		if (row) found.set(key, row);
+	}
+	return found;
+}
+async function missingPreviewDefaultWarnings(client, projectId, scope, keys, signal) {
+	if (scope.kind !== "branch") return [];
+	const previewScope = {
+		scope: {
+			kind: "role",
+			role: "preview"
+		},
+		descriptor: {
+			kind: "role",
+			role: "preview"
+		},
+		apiTarget: {
+			class: "preview",
+			branchId: null
+		}
+	};
+	const missing = [];
+	for (const key of keys) if (!await findVariableByNaturalKey(client, projectId, key, previewScope, signal)) missing.push(key);
+	if (missing.length === 0) return [];
+	if (missing.length === 1) return [`Variable "${missing[0]}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`];
+	return [`Variables ${formatKeyList(missing)} do not exist in preview. They will only exist on ${formatScopeLabel(scope)}.`];
+}
+function envFileApplyFailedError(command, filePath, scope, failedKey, writtenVariables, error) {
+	const writtenKeys = writtenVariables.map((variable) => variable.key);
+	const cause = error instanceof CliError ? error.summary : error instanceof Error ? error.message : "Unknown error.";
+	return new CliError({
+		code: "ENV_FILE_APPLY_FAILED",
+		domain: "app",
+		summary: `Failed to ${command} "${failedKey}" from "${filePath}"`,
+		why: writtenKeys.length === 0 ? `No variables were written before ${failedKey} failed. Cause: ${cause}` : `Written keys before failure: ${formatKeyList(writtenKeys)}. Cause: ${cause}`,
+		fix: "Inspect the target scope, then retry the remaining keys once the API issue is resolved.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli project env list ${formatScopeFlag(scope)}`, retryStepForApplyFailure(command, filePath, scope, writtenKeys)],
+		meta: {
+			file: filePath,
+			failedKey,
+			writtenKeys
+		}
+	});
+}
+function retryStepForApplyFailure(command, filePath, scope, writtenKeys) {
+	if (command === "update") return `prisma-cli project env update --file ${filePath} ${formatScopeFlag(scope)}`;
+	if (writtenKeys.length === 0) return `prisma-cli project env add --file ${filePath} ${formatScopeFlag(scope)}`;
+	return `prisma-cli project env add --file <remaining.env> ${formatScopeFlag(scope)}`;
+}
+function splitFileNextSteps(filePath, scope, options) {
+	const scopeFlag = formatScopeFlag(scope);
+	const existingFile = `${filePath}.existing`;
+	const newFile = `${filePath}.new`;
+	if (options.first === "update-existing") return [
+		`# existing keys: ${formatKeyList(options.existingKeys)}`,
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`,
+		"# new keys only",
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`
+	];
+	return [
+		`# missing keys: ${formatKeyList(options.missingKeys)}`,
+		`prisma-cli project env add --file ${newFile} ${scopeFlag}`,
+		"# existing keys only",
+		`prisma-cli project env update --file ${existingFile} ${scopeFlag}`
+	];
+}
+function formatKeyList(keys) {
+	return keys.map((key) => `"${key}"`).join(", ");
+}
+function formatScopeFlag(scope) {
+	if (scope.kind === "role") return `--role ${scope.role}`;
+	return `--branch ${scope.branchName}`;
+}
+//#endregion
+export { runEnvAddFile, runEnvUpdateFile };