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

package/dist/commands/app/index.js

@@ -1,345 +0,0 @@
-import { usageError } from "../../shell/errors.js";
-import { APP_BUILD_TYPES } from "../../lib/app/build.js";
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy } from "../../controllers/app.js";
-import { isAppDeployAllResult, renderAppBuild, renderAppDeploy, renderAppDeployAll, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, serializeAppDeployAll, serializeAppDomainAdd, serializeAppDomainRemove, serializeAppDomainRetry, serializeAppDomainShow, serializeAppListDeploys, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy } from "../../presenters/app.js";
-import { runCommand, runStreamingCommand } from "../../shell/command-runner.js";
-import { Command, Option } from "commander";
-import { FRAMEWORK_KEYS, LOCAL_DEV_BUILD_TYPES } from "@prisma/compute-sdk/config";
-//#region src/commands/app/index.ts
-function createAppCommand(runtime) {
-	const app = attachCommandDescriptor(configureRuntimeCommand(new Command("app"), runtime), "app");
-	addCompactGlobalFlags(app);
-	app.addCommand(createBuildCommand(runtime));
-	app.addCommand(createRunCommand(runtime));
-	app.addCommand(createDeployCommand(runtime));
-	app.addCommand(createShowCommand(runtime));
-	app.addCommand(createOpenCommand(runtime));
-	app.addCommand(createDomainCommand(runtime));
-	app.addCommand(createLogsCommand(runtime));
-	app.addCommand(createListDeploysCommand(runtime));
-	app.addCommand(createShowDeployCommand(runtime));
-	app.addCommand(createPromoteCommand(runtime));
-	app.addCommand(createRollbackCommand(runtime));
-	app.addCommand(createRemoveCommand(runtime));
-	return app;
-}
-function createBuildCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "app.build");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto builds")).addOption(new Option("--build-type <type>", "Local build type").choices([...APP_BUILD_TYPES]).default("auto"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const entry = options.entry;
-		const buildType = options.buildType;
-		await runCommand(runtime, "app.build", options, (context) => runAppBuild(context, {
-			entrypoint: entry,
-			buildType,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppBuild(context, descriptor, result),
-			renderJson: (result) => serializeAppBuild(result)
-		});
-	});
-	return command;
-}
-function createRunCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("run"), runtime), "app.run");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto runs")).addOption(new Option("--build-type <type>", "Local framework type").choices(["auto", ...LOCAL_DEV_BUILD_TYPES]).default("auto")).addOption(new Option("--port <port>", "Local port"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const entry = options.entry;
-		const buildType = options.buildType;
-		const port = options.port;
-		await runCommand(runtime, "app.run", options, (context) => runAppRun(context, {
-			entrypoint: entry,
-			buildType,
-			port,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppRun(context, descriptor, result),
-			renderJson: (result) => serializeAppRun(result)
-		});
-	});
-	return command;
-}
-function createDeployCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("deploy"), runtime), "app.deploy");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--create-project <name>", "Create and link a new Project before deploying")).addOption(new Option("--branch <name>", "Branch name")).addOption(new Option("--framework <name>", "Framework to deploy").choices([...FRAMEWORK_KEYS])).addOption(new Option("--entry <path>", "Entrypoint path for Bun deploys")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value|file>", "Environment variable assignment or dotenv file").argParser(collectRepeatableValues)).addOption(new Option("--db", "Create and wire a Prisma Postgres database for this deploy target")).addOption(new Option("--no-db", "Skip database setup")).addOption(new Option("--prod", "Confirm intent to deploy to production"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const entry = options.entry;
-		const branchName = options.branch;
-		const framework = options.framework;
-		const httpPort = options.httpPort;
-		const envAssignments = options.env;
-		const projectRef = options.project;
-		const createProjectName = options.createProject;
-		const prod = options.prod;
-		const db = options.db;
-		const hasDbConflict = hasFlag(runtime.argv, "--db") && hasFlag(runtime.argv, "--no-db");
-		await runCommand(runtime, "app.deploy", options, (context) => {
-			if (hasDbConflict) throw usageError("app deploy accepts either --db or --no-db", "--db requests database setup, while --no-db disables it.", "Pass exactly one database setup flag.", ["prisma-cli app deploy --db", "prisma-cli app deploy --no-db"], "app");
-			return runAppDeploy(context, appName, {
-				projectRef,
-				createProjectName,
-				branchName,
-				entrypoint: entry,
-				framework,
-				httpPort,
-				envAssignments,
-				prod: prod === true,
-				db,
-				configTarget
-			});
-		}, {
-			renderHuman: (context, descriptor, result) => isAppDeployAllResult(result) ? renderAppDeployAll(context, descriptor, result) : renderAppDeploy(context, descriptor, result),
-			renderJson: (result) => isAppDeployAllResult(result) ? serializeAppDeployAll(result) : serializeAppDeploy(result)
-		});
-	});
-	return command;
-}
-function hasFlag(argv, flag) {
-	return argv.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
-}
-function createShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
-			renderJson: (result) => serializeAppShow(result)
-		});
-	});
-	return command;
-}
-function createOpenCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("open"), runtime), "app.open");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
-			renderJson: (result) => serializeAppOpen(result)
-		});
-	});
-	return command;
-}
-function createDomainCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("domain"), runtime), "app.domain");
-	addCompactGlobalFlags(command);
-	command.addCommand(createDomainAddCommand(runtime));
-	command.addCommand(createDomainShowCommand(runtime));
-	command.addCommand(createDomainRemoveCommand(runtime));
-	command.addCommand(createDomainRetryCommand(runtime));
-	command.addCommand(createDomainWaitCommand(runtime));
-	return command;
-}
-function addDomainTargetOptions(command) {
-	return command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--branch <name>", "Branch name"));
-}
-function createDomainAddCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("add"), runtime), "app.domain.add");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.add", options, (context) => runAppDomainAdd(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainAdd(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainAdd(result)
-		});
-	});
-	return command;
-}
-function createDomainShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.domain.show");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.show", options, (context) => runAppDomainShow(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainShow(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainShow(result)
-		});
-	});
-	return command;
-}
-function createDomainRemoveCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "app.domain.remove");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.remove", options, (context) => runAppDomainRemove(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainRemove(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainRemove(result)
-		});
-	});
-	return command;
-}
-function createDomainRetryCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("retry"), runtime), "app.domain.retry");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "app.domain.retry", options, (context) => runAppDomainRetry(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			configTarget
-		}), {
-			renderHuman: (context, descriptor, result) => renderAppDomainRetry(context, descriptor, result),
-			renderJson: (result) => serializeAppDomainRetry(result)
-		});
-	});
-	return command;
-}
-function createDomainWaitCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("wait"), runtime), "app.domain.wait");
-	command.argument("<hostname>", "Custom domain hostname");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	addDomainTargetOptions(command);
-	command.addOption(new Option("--timeout <duration>", "Maximum time to wait").default("15m"));
-	addGlobalFlags(command);
-	command.action(async (hostname, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		const branchName = options.branch;
-		const timeout = options.timeout;
-		await runStreamingCommand(runtime, "app.domain.wait", options, (context) => runAppDomainWait(context, hostname, {
-			appName,
-			projectRef,
-			branchName,
-			timeout,
-			configTarget
-		}));
-	});
-	return command;
-}
-function createLogsCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "app.logs");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--deployment <id>", "Deployment id"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const deploymentId = options.deployment;
-		const projectRef = options.project;
-		await runStreamingCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId, projectRef, configTarget));
-	});
-	return command;
-}
-function collectRepeatableValues(value, previous) {
-	return [...previous ?? [], value];
-}
-function createListDeploysCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-deploys"), runtime), "app.list-deploys");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.list-deploys", options, (context) => runAppListDeploys(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppListDeploys(context, descriptor, result),
-			renderJson: (result) => serializeAppListDeploys(result)
-		});
-	});
-	return command;
-}
-function createShowDeployCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show-deploy"), runtime), "app.show-deploy");
-	command.argument("<deployment>", "Deployment id");
-	addGlobalFlags(command);
-	command.action(async (deploymentId, options) => {
-		await runCommand(runtime, "app.show-deploy", options, (context) => runAppShowDeploy(context, deploymentId), {
-			renderHuman: (context, descriptor, result) => renderAppShowDeploy(context, descriptor, result),
-			renderJson: (result) => serializeAppShowDeploy(result)
-		});
-	});
-	return command;
-}
-function createPromoteCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("promote"), runtime), "app.promote");
-	command.argument("<deployment>", "Deployment id");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (deploymentId, configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.promote", options, (context) => runAppPromote(context, deploymentId, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppPromote(context, descriptor, result),
-			renderJson: (result) => serializeAppPromote(result)
-		});
-	});
-	return command;
-}
-function createRollbackCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rollback"), runtime), "app.rollback");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name")).addOption(new Option("--to <deployment>", "Deployment id"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const deploymentId = options.to;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.rollback", options, (context) => runAppRollback(context, appName, deploymentId, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppRollback(context, descriptor, result),
-			renderJson: (result) => serializeAppRollback(result)
-		});
-	});
-	return command;
-}
-function createRemoveCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("remove"), runtime), "app.remove");
-	command.argument("[app]", "App target from prisma.compute.ts when the config defines multiple apps").addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
-	addGlobalFlags(command);
-	command.action(async (configTarget, options) => {
-		const appName = options.app;
-		const projectRef = options.project;
-		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName, projectRef, configTarget), {
-			renderHuman: (context, descriptor, result) => renderAppRemove(context, descriptor, result),
-			renderJson: (result) => serializeAppRemove(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createAppCommand };

package/dist/commands/auth/index.js

@@ -1,96 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runAuthLogin, runAuthLogout, runAuthWhoAmI, runAuthWorkspaceList, runAuthWorkspaceLogout, runAuthWorkspaceUse } from "../../controllers/auth.js";
-import { runCommand } from "../../shell/command-runner.js";
-import { renderAuthSuccess, renderAuthWorkspaceList, renderAuthWorkspaceLogout, renderAuthWorkspaceUse, serializeAuthWorkspaceList, serializeAuthWorkspaceLogout, serializeAuthWorkspaceUse } from "../../presenters/auth.js";
-import { Command, Option } from "commander";
-//#region src/commands/auth/index.ts
-function createAuthCommand(runtime) {
-	const auth = attachCommandDescriptor(configureRuntimeCommand(new Command("auth"), runtime), "auth");
-	addCompactGlobalFlags(auth);
-	auth.addCommand(createAuthLoginCommand(runtime));
-	auth.addCommand(createAuthLogoutCommand(runtime));
-	auth.addCommand(createAuthWhoAmICommand(runtime));
-	auth.addCommand(createAuthWorkspaceCommand(runtime));
-	return auth;
-}
-function createAuthLoginCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("login"), runtime), "auth.login");
-	command.addOption(new Option("--provider <provider>").hideHelp()).addOption(new Option("--user <id>").hideHelp()).addOption(new Option("--workspace <id>").hideHelp());
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "auth.login", options, (context) => runAuthLogin(context, options), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.login", result) });
-	});
-	return command;
-}
-function createAuthLogoutCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logout"), runtime), "auth.logout");
-	command.addOption(new Option("--workspace <id-or-name>", "Remove one stored OAuth workspace session"));
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const logoutOptions = options;
-		if (logoutOptions.workspace?.trim()) {
-			await runCommand(runtime, "auth.workspace.logout", options, (context) => runAuthWorkspaceLogout(context, logoutOptions.workspace), {
-				renderHuman: (context, descriptor, result) => renderAuthWorkspaceLogout(context, descriptor, result),
-				renderJson: (result) => serializeAuthWorkspaceLogout(result)
-			});
-			return;
-		}
-		await runCommand(runtime, "auth.logout", options, (context) => runAuthLogout(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.logout", result) });
-	});
-	return command;
-}
-function createAuthWhoAmICommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("whoami"), runtime), "auth.whoami");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "auth.whoami", options, (context) => runAuthWhoAmI(context), { renderHuman: (context, descriptor, result) => renderAuthSuccess(context, descriptor, "auth.whoami", result) });
-	});
-	return command;
-}
-function createAuthWorkspaceCommand(runtime) {
-	const workspace = attachCommandDescriptor(configureRuntimeCommand(new Command("workspace"), runtime), "auth.workspace");
-	addCompactGlobalFlags(workspace);
-	workspace.addCommand(createAuthWorkspaceListCommand(runtime));
-	workspace.addCommand(createAuthWorkspaceUseCommand(runtime));
-	workspace.addCommand(createAuthWorkspaceLogoutCommand(runtime));
-	return workspace;
-}
-function createAuthWorkspaceListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "auth.workspace.list");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "auth.workspace.list", options, (context) => runAuthWorkspaceList(context), {
-			renderHuman: (context, descriptor, result) => renderAuthWorkspaceList(context, descriptor, result),
-			renderJson: (result) => serializeAuthWorkspaceList(result)
-		});
-	});
-	return command;
-}
-function createAuthWorkspaceLogoutCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logout"), runtime), "auth.workspace.logout");
-	command.argument("<id-or-name>", "Workspace id or exact name");
-	addGlobalFlags(command);
-	command.action(async (workspaceRef, options) => {
-		await runCommand(runtime, "auth.workspace.logout", options, (context) => runAuthWorkspaceLogout(context, typeof workspaceRef === "string" ? workspaceRef : void 0), {
-			renderHuman: (context, descriptor, result) => renderAuthWorkspaceLogout(context, descriptor, result),
-			renderJson: (result) => serializeAuthWorkspaceLogout(result)
-		});
-	});
-	return command;
-}
-function createAuthWorkspaceUseCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "auth.workspace.use");
-	command.argument("[id-or-name]", "Workspace id or exact name");
-	addGlobalFlags(command);
-	command.action(async (workspaceRef, options) => {
-		await runCommand(runtime, "auth.workspace.use", options, (context) => runAuthWorkspaceUse(context, typeof workspaceRef === "string" ? workspaceRef : void 0), {
-			renderHuman: (context, descriptor, result) => renderAuthWorkspaceUse(context, descriptor, result),
-			renderJson: (result) => serializeAuthWorkspaceUse(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createAuthCommand };

package/dist/commands/branch/index.js

@@ -1,27 +0,0 @@
-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 { runBranchList } from "../../controllers/branch.js";
-import { renderBranchList, serializeBranchList } from "../../presenters/branch.js";
-import { Command } from "commander";
-//#region src/commands/branch/index.ts
-function createBranchCommand(runtime) {
-	const branch = attachCommandDescriptor(configureRuntimeCommand(new Command("branch"), runtime), "branch");
-	addCompactGlobalFlags(branch);
-	branch.addCommand(createBranchListCommand(runtime));
-	return branch;
-}
-function createBranchListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "branch.list");
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		await runCommand(runtime, "branch.list", options, (context) => runBranchList(context), {
-			renderHuman: (context, descriptor, result) => renderBranchList(context, descriptor, result),
-			renderJson: (result) => serializeBranchList(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createBranchCommand };

package/dist/commands/database/index.js

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