@prisma/cli 2.20.0 → 3.0.0-alpha.0

package/dist/commands/app/index.js

@@ -0,0 +1,223 @@
+import { attachCommandDescriptor } from "../../shell/command-meta.js";
+import { addGlobalFlags } from "../../shell/global-flags.js";
+import { configureRuntimeCommand } from "../../shell/runtime.js";
+import { runAppBuild, runAppDeploy, runAppListDeploys, runAppListEnv, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy, runAppUpdateEnv } from "../../controllers/app.js";
+import { renderAppBuild, renderAppDeploy, renderAppListDeploys, renderAppListEnv, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, renderAppUpdateEnv, serializeAppBuild, serializeAppDeploy, serializeAppListDeploys, serializeAppListEnv, serializeAppOpen, serializeAppPromote, serializeAppRemove, serializeAppRollback, serializeAppRun, serializeAppShow, serializeAppShowDeploy, serializeAppUpdateEnv } from "../../presenters/app.js";
+import { runCommand } from "../../shell/command-runner.js";
+import { Command, Option } from "commander";
+//#region src/commands/app/index.ts
+function createAppCommand(runtime) {
+	const app = attachCommandDescriptor(configureRuntimeCommand(new Command("app"), runtime), "app");
+	app.addCommand(createBuildCommand(runtime));
+	app.addCommand(createRunCommand(runtime));
+	app.addCommand(createDeployCommand(runtime));
+	app.addCommand(createUpdateEnvCommand(runtime));
+	app.addCommand(createListEnvCommand(runtime));
+	app.addCommand(createShowCommand(runtime));
+	app.addCommand(createOpenCommand(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.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto builds")).addOption(new Option("--build-type <type>", "Local build type").choices([
+		"auto",
+		"bun",
+		"nextjs"
+	]).default("auto"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const entry = options.entry;
+		const buildType = options.buildType;
+		await runCommand(runtime, "app.build", options, (context) => runAppBuild(context, entry, buildType), {
+			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.addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto runs")).addOption(new Option("--build-type <type>", "Local framework type").choices([
+		"auto",
+		"bun",
+		"nextjs"
+	]).default("auto")).addOption(new Option("--port <port>", "Local port"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const entry = options.entry;
+		const buildType = options.buildType;
+		const port = options.port;
+		await runCommand(runtime, "app.run", options, (context) => runAppRun(context, entry, buildType, port), {
+			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.addOption(new Option("--app <name>", "App name")).addOption(new Option("--entry <path>", "Entrypoint path for Bun or auto deploys")).addOption(new Option("--build-type <type>", "Deploy build type").choices([
+		"auto",
+		"bun",
+		"nextjs"
+	]).default("auto")).addOption(new Option("--http-port <port>", "HTTP port override for the deployed app")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		const entry = options.entry;
+		const buildType = options.buildType;
+		const httpPort = options.httpPort;
+		const envAssignments = options.env;
+		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
+			entrypoint: entry,
+			buildType,
+			httpPort,
+			envAssignments
+		}), {
+			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
+			renderJson: (result) => serializeAppDeploy(result)
+		});
+	});
+	return command;
+}
+function createUpdateEnvCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("update-env"), runtime), "app.update-env");
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		const envAssignments = options.env;
+		await runCommand(runtime, "app.update-env", options, (context) => runAppUpdateEnv(context, appName, envAssignments), {
+			renderHuman: (context, descriptor, result) => renderAppUpdateEnv(context, descriptor, result),
+			renderJson: (result) => serializeAppUpdateEnv(result)
+		});
+	});
+	return command;
+}
+function createListEnvCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-env"), runtime), "app.list-env");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.list-env", options, (context) => runAppListEnv(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppListEnv(context, descriptor, result),
+			renderJson: (result) => serializeAppListEnv(result)
+		});
+	});
+	return command;
+}
+function createShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
+	command.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName), {
+			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.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
+			renderJson: (result) => serializeAppOpen(result)
+		});
+	});
+	return command;
+}
+function createLogsCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "app.logs");
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--deployment <id>", "Deployment id"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		const deploymentId = options.deployment;
+		await runCommand(runtime, "app.logs", options, (context) => runAppLogs(context, appName, deploymentId), { renderHuman: () => [] });
+	});
+	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.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.list-deploys", options, (context) => runAppListDeploys(context, appName), {
+			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.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (deploymentId, options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.promote", options, (context) => runAppPromote(context, deploymentId, appName), {
+			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.addOption(new Option("--app <name>", "App name")).addOption(new Option("--to <deployment>", "Deployment id"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		const deploymentId = options.to;
+		await runCommand(runtime, "app.rollback", options, (context) => runAppRollback(context, appName, deploymentId), {
+			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.addOption(new Option("--app <name>", "App name"));
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		const appName = options.app;
+		await runCommand(runtime, "app.remove", options, (context) => runAppRemove(context, appName), {
+			renderHuman: (context, descriptor, result) => renderAppRemove(context, descriptor, result),
+			renderJson: (result) => serializeAppRemove(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createAppCommand };

package/dist/commands/auth/index.js

@@ -0,0 +1,42 @@
+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 { runAuthLogin, runAuthLogout, runAuthWhoAmI } from "../../controllers/auth.js";
+import { renderAuthSuccess } 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");
+	auth.addCommand(createAuthLoginCommand(runtime));
+	auth.addCommand(createAuthLogoutCommand(runtime));
+	auth.addCommand(createAuthWhoAmICommand(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");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		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;
+}
+//#endregion
+export { createAuthCommand };

package/dist/commands/branch/index.js

@@ -0,0 +1,51 @@
+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 { runBranchList, runBranchShow, runBranchUse } from "../../controllers/branch.js";
+import { renderBranchList, renderBranchShow, renderBranchUse, serializeBranchList, serializeBranchShow } 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");
+	branch.addCommand(createBranchListCommand(runtime));
+	branch.addCommand(createBranchShowCommand(runtime));
+	branch.addCommand(createBranchUseCommand(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;
+}
+function createBranchShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "branch.show");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "branch.show", options, (context) => runBranchShow(context), {
+			renderHuman: (context, descriptor, result) => renderBranchShow(context, descriptor, result),
+			renderJson: (result) => serializeBranchShow(result)
+		});
+	});
+	return command;
+}
+function createBranchUseCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("use"), runtime), "branch.use");
+	command.argument("[name]", "Branch name");
+	addGlobalFlags(command);
+	command.action(async (branchName, options) => {
+		await runCommand(runtime, "branch.use", options, (context) => runBranchUse(context, branchName), {
+			renderHuman: (context, descriptor, result) => renderBranchUse(context, descriptor, result),
+			renderJson: (result) => serializeBranchShow(result)
+		});
+	});
+	return command;
+}
+//#endregion
+export { createBranchCommand };

package/dist/commands/project/index.js

@@ -0,0 +1,45 @@
+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 { runProjectLink, runProjectList, runProjectShow } from "../../controllers/project.js";
+import { renderProjectLink, renderProjectList, renderProjectShow, serializeProjectList } from "../../presenters/project.js";
+import { Command } from "commander";
+//#region src/commands/project/index.ts
+function createProjectCommand(runtime) {
+	const project = attachCommandDescriptor(configureRuntimeCommand(new Command("project"), runtime), "project");
+	project.addCommand(createProjectListCommand(runtime));
+	project.addCommand(createProjectShowCommand(runtime));
+	project.addCommand(createProjectLinkCommand(runtime));
+	return project;
+}
+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");
+	addGlobalFlags(command);
+	command.action(async (options) => {
+		await runCommand(runtime, "project.show", options, (context) => runProjectShow(context), { renderHuman: (context, descriptor, result) => renderProjectShow(context, descriptor, result) });
+	});
+	return command;
+}
+function createProjectLinkCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("link"), runtime), "project.link");
+	command.argument("[project]", "Project id");
+	addGlobalFlags(command);
+	command.action(async (projectId, options) => {
+		await runCommand(runtime, "project.link", options, (context) => runProjectLink(context, projectId), { renderHuman: (context, descriptor, result) => renderProjectLink(context, descriptor, result) });
+	});
+	return command;
+}
+//#endregion
+export { createProjectCommand };