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

package/dist/controllers/database.js

@@ -1,318 +0,0 @@
-import { CliError, authRequiredError, usageError, workspaceRequiredError } from "../shell/errors.js";
-import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
-import { requireComputeAuth } from "../lib/auth/guard.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 };