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

package/dist/controllers/auth.js

@@ -11,32 +11,32 @@ function isRealMode(context) {
 async function runAuthLogin(context, options) {
 	let result;
 	if (isRealMode(context)) {
-		await performLogin(context.runtime.env);
-		result = await readAuthState(context.runtime.env);
+		await performLogin(context.runtime.env, context.runtime.signal);
+		result = await readAuthState(context.runtime.env, context.runtime.signal);
 	} else result = await loginWithSelectionFlow(context, createAuthUseCases(createCliUseCaseGateways(context)), options);
 	return createAuthSuccess("auth.login", result, ["prisma-cli auth whoami", "prisma-cli project list"]);
 }
 async function runAuthLogout(context) {
 	let result;
 	if (isRealMode(context)) {
-		await performLogout(context.runtime.env);
-		result = await readAuthState(context.runtime.env);
+		await performLogout(context.runtime.env, context.runtime.signal);
+		result = await readAuthState(context.runtime.env, context.runtime.signal);
 	} else result = await createAuthUseCases(createCliUseCaseGateways(context)).logout();
 	return createAuthSuccess("auth.logout", result, ["prisma-cli auth login"]);
 }
 async function runAuthWhoAmI(context) {
 	let result;
-	if (isRealMode(context)) result = await readAuthState(context.runtime.env);
+	if (isRealMode(context)) result = await readAuthState(context.runtime.env, context.runtime.signal);
 	else result = await createAuthUseCases(createCliUseCaseGateways(context)).whoami();
 	return createAuthSuccess("auth.whoami", result, result.authenticated ? [] : ["prisma-cli auth login"]);
 }
 async function requireAuthenticatedAuthState(context) {
 	if (isRealMode(context)) {
-		const current = await readAuthState(context.runtime.env);
+		const current = await readAuthState(context.runtime.env, context.runtime.signal);
 		if (current.authenticated) return current;
 		if (!canPrompt(context)) throw authRequiredError();
-		await performLogin(context.runtime.env);
-		return readAuthState(context.runtime.env);
+		await performLogin(context.runtime.env, context.runtime.signal);
+		return readAuthState(context.runtime.env, context.runtime.signal);
 	}
 	const useCases = createAuthUseCases(createCliUseCaseGateways(context));
 	const current = await useCases.whoami();

package/dist/controllers/branch.js

@@ -1,73 +1,103 @@
-import { featureUnavailableError, usageError } from "../shell/errors.js";
-import { canPrompt } from "../shell/runtime.js";
+import { CliError, authRequiredError, workspaceRequiredError } from "../shell/errors.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
-import { createSelectPromptPort } from "./select-prompt-port.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listRealWorkspaceProjects } from "./project.js";
 import { createBranchUseCases } from "../use-cases/branch.js";
 //#region src/controllers/branch.ts
-const PREVIEW_BRANCH_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function isRealMode(context) {
 	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
 }
 async function runBranchList(context) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	return {
+	if (isRealMode(context)) return {
 		command: "branch.list",
-		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
+		result: await listRealBranches(context),
 		warnings: [],
 		nextSteps: []
 	};
-}
-async function runBranchShow(context) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	const result = await createBranchUseCases(createCliUseCaseGateways(context)).show();
 	return {
-		command: "branch.show",
-		result,
+		command: "branch.list",
+		result: await createBranchUseCases(createCliUseCaseGateways(context)).list(),
 		warnings: [],
-		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma-cli app deploy"] : []
+		nextSteps: []
 	};
 }
-async function runBranchUse(context, branchName) {
-	if (isRealMode(context)) throw branchCommandsUnavailableError();
-	const useCases = createBranchUseCases(createCliUseCaseGateways(context));
-	const resolvedBranchName = await resolveBranchNameForUse(context, useCases, branchName);
-	validateBranchName(resolvedBranchName);
-	const result = await useCases.use(resolvedBranchName);
+async function listRealBranches(context) {
+	const authState = await requireAuthenticatedAuthState(context);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	const workspace = authState.workspace;
+	if (!workspace) throw workspaceRequiredError();
+	const targetResult = await resolveProjectTarget({
+		context,
+		workspace,
+		listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal)
+	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	const target = targetResult.value;
+	const branches = await listBranches(client, target.project.id, context.runtime.signal);
 	return {
-		command: "branch.use",
-		result,
-		warnings: result.branch.kind === "production" ? ["Production is protected and durable. Use with care."] : [],
-		nextSteps: result.branch.kind === "preview" && !result.branch.remoteState ? ["prisma-cli branch show", "prisma-cli app deploy"] : ["prisma-cli branch show"]
+		projectId: target.project.id,
+		projectName: target.project.name,
+		verboseContext: {
+			workspace,
+			project: target.project,
+			resolution: target.resolution
+		},
+		branches: sortBranches(branches.map(toBranchSummary))
 	};
 }
-async function resolveBranchNameForUse(context, useCases, branchName) {
-	if (branchName) return branchName;
-	if (!canPrompt(context)) throw branchSelectionRequiredError();
-	const result = await useCases.list();
-	return createSelectPromptPort(context).select({
-		message: "Select a branch",
-		choices: result.branches.map((branch) => ({
-			label: renderBranchChoiceLabel(branch),
-			value: branch.name
-		}))
+function sortBranches(branches) {
+	return branches.slice().sort((left, right) => {
+		const leftRank = branchOrder(left);
+		const rightRank = branchOrder(right);
+		if (leftRank !== rightRank) return leftRank - rightRank;
+		return left.name.localeCompare(right.name);
 	});
 }
-function renderBranchChoiceLabel(branch) {
-	const markers = [];
-	if (branch.active) markers.push("active");
-	if (!branch.remoteState) markers.push("not created yet");
-	return markers.length > 0 ? `${branch.name} (${markers.join(", ")})` : branch.name;
+function branchOrder(branch) {
+	return branch.role === "production" ? 0 : 1;
 }
-function validateBranchName(branchName) {
-	if (branchName === "production") return;
-	if (PREVIEW_BRANCH_PATTERN.test(branchName)) return;
-	throw usageError("Branch name must use the documented form", "Branch names must be production or a lowercase preview slug such as preview or feat-auth.", "Use production or a lowercase preview branch name with letters, numbers, and hyphens.", ["prisma-cli branch list"], "branch");
+async function listBranches(client, projectId, signal) {
+	const collected = [];
+	let cursor;
+	while (true) {
+		const query = {};
+		if (cursor !== void 0) query.cursor = cursor;
+		const { data, error, response } = await client.GET("/v1/projects/{projectId}/branches", {
+			params: {
+				path: { projectId },
+				query
+			},
+			signal
+		});
+		if (error || !data) throw branchApiError("Failed to list branches", response, error);
+		collected.push(...data.data);
+		if (!data.pagination.hasMore || !data.pagination.nextCursor) break;
+		cursor = data.pagination.nextCursor;
+	}
+	return collected;
 }
-function branchSelectionRequiredError() {
-	return usageError("Branch use requires a target in non-interactive mode", "This command cannot prompt for branch selection in the current mode.", "Re-run prisma-cli branch use in a TTY, or pass a branch name explicitly.", ["prisma-cli branch list"], "branch");
+function toBranchSummary(branch) {
+	return {
+		id: branch.id,
+		name: branch.gitName,
+		role: branch.role,
+		envMap: branch.role
+	};
 }
-function branchCommandsUnavailableError() {
-	return featureUnavailableError("Branch commands are not available in this preview", "The current preview cannot resolve or change remote branch context yet.", "Use prisma-cli app deploy for preview app deployment workflows.", ["prisma-cli app deploy --app <name>"], "branch");
+function branchApiError(summary, response, error) {
+	const status = response?.status ?? 0;
+	return new CliError({
+		code: error?.error?.code ?? "BRANCH_API_ERROR",
+		domain: "branch",
+		summary,
+		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
+		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
+		exitCode: 1,
+		nextSteps: []
+	});
 }
 //#endregion
-export { runBranchList, runBranchShow, runBranchUse };
+export { runBranchList };

package/dist/controllers/database.js

@@ -0,0 +1,318 @@
+import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listFixtureWorkspaceProjects, listRealWorkspaceProjects } from "./project.js";
+import { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase } from "../lib/database/provider.js";
+import { randomBytes } from "node:crypto";
+//#region src/controllers/database.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runDatabaseList(context, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database list");
+	const databases = sortDatabases(await provider.listDatabases({
+		projectId: target.project.id,
+		branchName: flags.branchName,
+		signal: context.runtime.signal
+	}));
+	return {
+		command: "database.list",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			branchName: flags.branchName ?? null,
+			verboseContext: target,
+			databases
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseShow(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database show");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const connections = await provider.listConnections(database.id, { signal: context.runtime.signal });
+	return {
+		command: "database.show",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			connections
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseCreate(context, name, flags) {
+	const databaseName = name.trim();
+	if (!databaseName) throw usageError("Database name required", "Database create needs a non-empty name.", "Pass a database name.", ["prisma-cli database create <name>"], "database");
+	const { provider, target } = await requireDatabaseContext(context, flags, "database create");
+	const created = await provider.createDatabase({
+		projectId: target.project.id,
+		name: databaseName,
+		branchName: flags.branchName,
+		region: flags.region,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.create",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database: ensureProjectId(created.database, target.project.id),
+			connection: created.connection,
+			connectionString: created.connectionString
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseRemove(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database remove");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	requireExactConfirmation({
+		resourceName: "database",
+		commandName: "database remove",
+		id: database.id,
+		confirm: flags.confirm
+	});
+	await provider.removeDatabase(database.id, { signal: context.runtime.signal });
+	return {
+		command: "database.remove",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseConnectionList(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database connection list");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const connections = await provider.listConnections(database.id, { signal: context.runtime.signal });
+	return {
+		command: "database.connection.list",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			connections
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseConnectionCreate(context, databaseRef, flags) {
+	const { provider, target } = await requireDatabaseContext(context, flags, "database connection create");
+	const database = await resolveDatabase(provider, target, databaseRef, flags.branchName, context.runtime.signal);
+	const created = await provider.createConnection({
+		databaseId: database.id,
+		name: flags.name?.trim() || defaultConnectionName(),
+		signal: context.runtime.signal
+	});
+	return {
+		command: "database.connection.create",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			database,
+			connection: created.connection,
+			connectionString: created.connectionString
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runDatabaseConnectionRemove(context, connectionRef, flags) {
+	const connectionId = connectionRef.trim();
+	if (!connectionId) throw usageError("Connection id required", "Database connection removal needs a connection id.", "Pass the connection id to remove.", ["prisma-cli database connection remove <connection-id> --confirm <connection-id>"], "database");
+	requireExactConfirmation({
+		resourceName: "database connection",
+		commandName: "database connection remove",
+		id: connectionId,
+		confirm: flags.confirm
+	});
+	await (await requireDatabaseProviderOnly(context)).removeConnection(connectionId, { signal: context.runtime.signal });
+	return {
+		command: "database.connection.remove",
+		result: { connection: { id: connectionId } },
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function requireDatabaseContext(context, flags, commandName) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+		if (!client) throw authRequiredError();
+		const targetResult = await resolveProjectTarget({
+			context,
+			workspace,
+			explicitProject: flags.projectRef,
+			listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+			commandName
+		});
+		if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+		return {
+			provider: createManagementDatabaseProvider(client),
+			target: targetResult.value
+		};
+	}
+	const targetResult = await resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject: flags.projectRef,
+		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
+		commandName
+	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	return {
+		provider: createFixtureDatabaseProvider(context),
+		target: targetResult.value
+	};
+}
+async function requireDatabaseProviderOnly(context) {
+	await requireAuthenticatedAuthState(context);
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+		if (!client) throw authRequiredError();
+		return createManagementDatabaseProvider(client);
+	}
+	return createFixtureDatabaseProvider(context);
+}
+function createFixtureDatabaseProvider(context) {
+	return {
+		async listDatabases(options) {
+			return context.api.listDatabasesForProject(options.projectId, options.branchName).map((database) => normalizeDatabase(database, database.projectId));
+		},
+		async showDatabase(databaseId) {
+			const database = context.api.getDatabase(databaseId);
+			return database ? normalizeDatabase(database, database.projectId) : null;
+		},
+		async createDatabase(options) {
+			const created = context.api.createDatabase(options);
+			return {
+				database: normalizeDatabase(created.database, created.database.projectId),
+				connection: normalizeConnection(created.connection, created.connection.databaseId),
+				connectionString: created.connectionString
+			};
+		},
+		async removeDatabase(databaseId) {
+			if (!context.api.removeDatabase(databaseId)) throw databaseNotFoundError(databaseId);
+		},
+		async listConnections(databaseId) {
+			if (!context.api.getDatabase(databaseId)) throw databaseNotFoundError(databaseId);
+			return context.api.listDatabaseConnections(databaseId).map((connection) => normalizeConnection(connection, connection.databaseId));
+		},
+		async createConnection(options) {
+			const created = context.api.createDatabaseConnection(options);
+			if (!created) throw databaseNotFoundError(options.databaseId);
+			return {
+				connection: normalizeConnection(created.connection, created.connection.databaseId),
+				connectionString: created.connectionString
+			};
+		},
+		async removeConnection(connectionId) {
+			if (!context.api.removeDatabaseConnection(connectionId)) throw connectionNotFoundError(connectionId);
+		}
+	};
+}
+async function resolveDatabase(provider, target, databaseRef, branchName, signal) {
+	const ref = databaseRef.trim();
+	if (!ref) throw usageError("Database id or name required", "This command needs a database id or name.", "Pass a database id or name.", ["prisma-cli database list"], "database");
+	const matches = (await provider.listDatabases({
+		projectId: target.project.id,
+		branchName,
+		signal
+	})).filter((database) => database.id === ref || database.name === ref);
+	if (matches.length === 0) throw databaseNotFoundError(ref, target.project.name, branchName);
+	if (matches.length > 1) throw databaseAmbiguousError(ref, matches, branchName);
+	const selected = matches[0];
+	return ensureProjectId(await provider.showDatabase(selected.id, {
+		projectId: target.project.id,
+		signal
+	}) ?? selected, target.project.id);
+}
+function ensureProjectId(database, projectId) {
+	return database.projectId ? database : {
+		...database,
+		projectId
+	};
+}
+function sortDatabases(databases) {
+	return databases.slice().sort((left, right) => {
+		const branchOrder = (left.branchName ?? "").localeCompare(right.branchName ?? "");
+		if (branchOrder !== 0) return branchOrder;
+		const nameOrder = left.name.localeCompare(right.name);
+		return nameOrder !== 0 ? nameOrder : left.id.localeCompare(right.id);
+	});
+}
+function requireExactConfirmation(options) {
+	if (options.confirm === options.id) return;
+	throw new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "database",
+		summary: `Confirm ${options.resourceName} removal`,
+		why: `Removing this ${options.resourceName} is destructive and requires the exact id.`,
+		fix: `Rerun with --confirm ${options.id}.`,
+		exitCode: 2,
+		nextSteps: [`prisma-cli ${options.commandName} ${options.id} --confirm ${options.id}`],
+		meta: {
+			expectedConfirm: options.id,
+			receivedConfirm: options.confirm ?? null
+		}
+	});
+}
+function defaultConnectionName() {
+	return `cli-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 17)}-${randomBytes(2).toString("hex")}`;
+}
+function databaseNotFoundError(databaseRef, projectName, branchName) {
+	return new CliError({
+		code: "DATABASE_NOT_FOUND",
+		domain: "database",
+		summary: "Database not found",
+		why: `No database matched "${databaseRef}"${projectName ? ` in project "${projectName}"${branchName ? ` on branch "${branchName}"` : ""}` : ""}.`,
+		fix: "Pass a database id or name from prisma-cli database list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database list"]
+	});
+}
+function databaseAmbiguousError(databaseRef, matches, branchName) {
+	return new CliError({
+		code: "DATABASE_AMBIGUOUS",
+		domain: "database",
+		summary: "Database resolution is ambiguous",
+		why: branchName ? `Multiple databases matched "${databaseRef}" on branch "${branchName}".` : `Multiple databases matched "${databaseRef}".`,
+		fix: "Pass the database id, or pass --branch <git-name> to narrow the match.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database list"],
+		meta: { matches: matches.map((database) => ({
+			id: database.id,
+			name: database.name,
+			branchName: database.branchName
+		})) }
+	});
+}
+function connectionNotFoundError(connectionId) {
+	return new CliError({
+		code: "DATABASE_CONNECTION_NOT_FOUND",
+		domain: "database",
+		summary: "Database connection not found",
+		why: `No database connection matched "${connectionId}".`,
+		fix: "Pass a connection id from prisma-cli database connection list <database>.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli database connection list <database>"]
+	});
+}
+//#endregion
+export { runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseShow };