@prisma/cli 3.0.0-dev.99.1 → 8.0.0-rc.2

package/dist/commands/env.js

@@ -1,99 +0,0 @@
-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, runEnvRemove, 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 active project");
-	env.addCommand(createEnvAddCommand(runtime));
-	env.addCommand(createEnvUpdateCommand(runtime));
-	env.addCommand(createEnvListCommand(runtime));
-	env.addCommand(createEnvRemoveCommand(runtime));
-	return env;
-}
-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("--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,
-			filePath
-		}), {
-			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 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,
-			filePath
-		}), {
-			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"])).addOption(new Option("--branch <git-name>", "Preview branch resolved scope")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const roleName = options.role;
-		const branchName = options.branch;
-		const projectRef = options.project;
-		await runCommand(runtime, "project.env.list", options, (context) => runEnvList(context, {
-			roleName,
-			branchName,
-			projectRef
-		}), {
-			renderHuman: (context, descriptor, result) => renderEnvList(context, descriptor, result),
-			renderJson: (result) => serializeEnvList(result)
-		});
-	});
-	return command;
-}
-function createEnvRemoveCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "project.env.remove");
-	command.alias("rm").argument("<key>", "Variable key to remove").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 (key, options) => {
-		const roleName = options.role;
-		const branchName = options.branch;
-		const projectRef = options.project;
-		await runCommand(runtime, "project.env.remove", options, (context) => runEnvRemove(context, key, {
-			roleName,
-			branchName,
-			projectRef
-		}), {
-			renderHuman: (context, descriptor, result) => renderEnvRm(context, descriptor, result),
-			renderJson: (result) => serializeEnvRm(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createEnvCommand };

package/dist/commands/git/index.js

@@ -1,36 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runGitConnect, runGitDisconnect } from "../../controllers/project.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { renderGitConnect, renderGitDisconnect } from "../../presenters/project.js";
-import { Command } from "commander";
-//#region src/commands/git/index.ts
-function createGitCommand(runtime) {
-	const git = attachCommandDescriptor(configureRuntimeCommand(new Command("git"), runtime), "git");
-	addCompactGlobalFlags(git);
-	git.addCommand(createGitConnectCommand(runtime));
-	git.addCommand(createGitDisconnectCommand(runtime));
-	return git;
-}
-function createGitConnectCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("connect"), runtime), "git.connect");
-	command.argument("[git-url]", "GitHub repository URL");
-	command.option("--project <id-or-name>", "Project id or name");
-	addGlobalFlags(command);
-	command.action(async (gitUrl, options) => {
-		await runCommand(runtime, "git.connect", options, (context) => runGitConnect(context, gitUrl, { project: typeof options.project === "string" ? options.project : void 0 }), { renderHuman: (context, descriptor, result) => renderGitConnect(context, descriptor, result) });
-	});
-	return command;
-}
-function createGitDisconnectCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("disconnect"), runtime), "git.disconnect");
-	command.option("--project <id-or-name>", "Project id or name");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "git.disconnect", options, (context) => runGitDisconnect(context, { project: typeof options.project === "string" ? options.project : void 0 }), { renderHuman: (context, descriptor, result) => renderGitDisconnect(context, descriptor, result) });
-	});
-	return command;
-}
-//#endregion
-export { createGitCommand };

package/dist/commands/project/index.js

@@ -1,69 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runProjectCreate, runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow } 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(createProjectCreateCommand(runtime));
-	project.addCommand(createProjectLinkCommand(runtime));
-	project.addCommand(createEnvCommand(runtime));
-	return project;
-}
-function createProjectCreateCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "project.create");
-	command.argument("<name>", "Project name");
-	addGlobalFlags(command);
-	command.action(async (name, options) => {
-		await runCommand(runtime, "project.create", options, (context) => runProjectCreate(context, String(name)), {
-			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
-			renderJson: (result) => serializeProjectSetup(result)
-		});
-	});
-	return command;
-}
-function createProjectLinkCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("link"), runtime), "project.link");
-	command.argument("[id-or-name]", "Project id or name");
-	addGlobalFlags(command);
-	command.action(async (projectRef, options) => {
-		await runCommand(runtime, "project.link", options, (context) => runProjectLink(context, typeof projectRef === "string" ? projectRef : void 0), {
-			renderHuman: (context, descriptor, result) => renderProjectSetup(context, descriptor, result),
-			renderJson: (result) => serializeProjectSetup(result)
-		});
-	});
-	return command;
-}
-function createProjectListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "project.list");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "project.list", options, (context) => runProjectList(context), {
-			renderHuman: (context, descriptor, result) => renderProjectList(context, descriptor, result),
-			renderJson: (result) => serializeProjectList(result)
-		});
-	});
-	return command;
-}
-function createProjectShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "project.show");
-	command.option("--project <id-or-name>", "Project id or name");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const projectRef = options.project;
-		await runCommand(runtime, "project.show", options, (context) => runProjectShow(context, projectRef), {
-			renderHuman: (context, descriptor, result) => renderProjectShow(context, descriptor, result),
-			renderJson: (result) => serializeProjectShow(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createProjectCommand };

package/dist/commands/version/index.js

@@ -1,18 +0,0 @@
-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 { runVersion } from "../../controllers/version.js";
-import { renderVersionSuccess } from "../../presenters/version.js";
-import { Command } from "commander";
-//#region src/commands/version/index.ts
-function createVersionCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("version"), runtime), "version");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "version", options, (context) => runVersion(context), { renderHuman: (context, descriptor, result) => renderVersionSuccess(context, descriptor, result) });
-	});
-	return command;
-}
-//#endregion
-export { createVersionCommand };

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

@@ -1,54 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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 };