@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.2

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/bucket/index.js

@@ -1,123 +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 { runBucketCreate, runBucketDelete, runBucketKeyCreate, runBucketKeyDelete, runBucketKeyList, runBucketList } from "../../controllers/bucket.js";
-import { renderBucketCreate, renderBucketDelete, renderBucketKeyCreate, renderBucketKeyCreateStdout, renderBucketKeyDelete, renderBucketKeyList, renderBucketList, serializeBucketCreate, serializeBucketDelete, serializeBucketKeyCreate, serializeBucketKeyDelete, serializeBucketKeyList, serializeBucketList } from "../../presenters/bucket.js";
-import { Command, Option } from "commander";
-//#region src/commands/bucket/index.ts
-function createBucketCommand(runtime) {
-	const bucket = attachCommandDescriptor(configureRuntimeCommand(new Command("bucket"), runtime), "bucket");
-	addCompactGlobalFlags(bucket);
-	bucket.addCommand(createBucketListCommand(runtime));
-	bucket.addCommand(createBucketCreateCommand(runtime));
-	bucket.addCommand(createBucketDeleteCommand(runtime));
-	bucket.addCommand(createBucketKeyCommand(runtime));
-	return bucket;
-}
-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 createBucketListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "bucket.list");
-	addProjectAndBranchOptions(command);
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const projectRef = options.project;
-		const branchName = options.branch;
-		await runCommand(runtime, "bucket.list", options, (context) => runBucketList(context, {
-			projectRef,
-			branchName
-		}), {
-			renderHuman: (context, descriptor, result) => renderBucketList(context, descriptor, result),
-			renderJson: (result) => serializeBucketList(result)
-		});
-	});
-	return command;
-}
-function createBucketCreateCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "bucket.create");
-	command.addOption(new Option("--name <name>", "Bucket display name (auto-generated if omitted)"));
-	addProjectAndBranchOptions(command);
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const projectRef = options.project;
-		const branchName = options.branch;
-		const name = options.name;
-		await runCommand(runtime, "bucket.create", options, (context) => runBucketCreate(context, {
-			projectRef,
-			branchName,
-			name
-		}), {
-			renderHuman: (context, descriptor, result) => renderBucketCreate(context, descriptor, result),
-			renderJson: (result) => serializeBucketCreate(result)
-		});
-	});
-	return command;
-}
-function createBucketDeleteCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("delete"), runtime), "bucket.delete");
-	command.argument("<bucketId>", "Bucket id");
-	command.addOption(new Option("--confirm <bucket-id>", "Exact bucket id to confirm deletion"));
-	addGlobalFlags(command);
-	command.action(async (bucketId, options) => {
-		const confirm = options.confirm;
-		await runCommand(runtime, "bucket.delete", options, (context) => runBucketDelete(context, bucketId, { confirm }), {
-			renderHuman: (context, descriptor, result) => renderBucketDelete(context, descriptor, result),
-			renderJson: (result) => serializeBucketDelete(result)
-		});
-	});
-	return command;
-}
-function createBucketKeyCommand(runtime) {
-	const key = attachCommandDescriptor(configureRuntimeCommand(new Command("key"), runtime), "bucket.key");
-	addCompactGlobalFlags(key);
-	key.addCommand(createBucketKeyListCommand(runtime));
-	key.addCommand(createBucketKeyCreateCommand(runtime));
-	key.addCommand(createBucketKeyDeleteCommand(runtime));
-	return key;
-}
-function createBucketKeyListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "bucket.key.list");
-	command.argument("<bucketId>", "Bucket id");
-	addGlobalFlags(command);
-	command.action(async (bucketId, options) => {
-		await runCommand(runtime, "bucket.key.list", options, (context) => runBucketKeyList(context, bucketId), {
-			renderHuman: (context, descriptor, result) => renderBucketKeyList(context, descriptor, result),
-			renderJson: (result) => serializeBucketKeyList(result)
-		});
-	});
-	return command;
-}
-function createBucketKeyCreateCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("create"), runtime), "bucket.key.create");
-	command.argument("<bucketId>", "Bucket id").addOption(new Option("--role <role>", "Access role (default: read_write)").choices(["read", "read_write"])).addOption(new Option("--name <name>", "Key display name (auto-generated if omitted)"));
-	addGlobalFlags(command);
-	command.action(async (bucketId, options) => {
-		const role = options.role;
-		const name = options.name;
-		await runCommand(runtime, "bucket.key.create", options, (context) => runBucketKeyCreate(context, bucketId, {
-			role,
-			name
-		}), {
-			renderStdout: (context, descriptor, result) => renderBucketKeyCreateStdout(context, descriptor, result),
-			renderHuman: (context, descriptor, result) => renderBucketKeyCreate(context, descriptor, result),
-			renderJson: (result) => serializeBucketKeyCreate(result)
-		});
-	});
-	return command;
-}
-function createBucketKeyDeleteCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("delete"), runtime), "bucket.key.delete");
-	command.argument("<bucketId>", "Bucket id").argument("<keyId>", "Key id");
-	addGlobalFlags(command);
-	command.action(async (bucketId, keyId, options) => {
-		await runCommand(runtime, "bucket.key.delete", options, (context) => runBucketKeyDelete(context, bucketId, keyId), {
-			renderHuman: (context, descriptor, result) => renderBucketKeyDelete(context, descriptor, result),
-			renderJson: (result) => serializeBucketKeyDelete(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createBucketCommand };

package/dist/commands/build/index.js

@@ -1,29 +0,0 @@
-import { attachCommandDescriptor } from "../../shell/command-meta.js";
-import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
-import { configureRuntimeCommand } from "../../shell/runtime.js";
-import { runStreamingCommand } from "../../shell/command-runner.js";
-import { runBuildLogs } from "../../controllers/build.js";
-import { Command, Option } from "commander";
-//#region src/commands/build/index.ts
-function createBuildCommand(runtime) {
-	const build = attachCommandDescriptor(configureRuntimeCommand(new Command("build"), runtime), "build");
-	addCompactGlobalFlags(build);
-	build.addCommand(createLogsCommand(runtime));
-	return build;
-}
-function createLogsCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("logs"), runtime), "build.logs");
-	command.argument("<buildId>", "Build id from a git-push or Console deploy").addOption(new Option("--follow", "Keep the connection open and stream new logs as the build runs")).addOption(new Option("--cursor <cursor>", "Resume from a prior terminal cursor"));
-	addGlobalFlags(command);
-	command.action(async (buildId, options) => {
-		const follow = options.follow;
-		const cursor = options.cursor;
-		await runStreamingCommand(runtime, "build.logs", options, (context) => runBuildLogs(context, buildId, {
-			follow,
-			cursor
-		}), { emitJsonSuccessEvent: false });
-	});
-	return command;
-}
-//#endregion
-export { createBuildCommand };

package/dist/commands/database/index.js

@@ -1,249 +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 { runDatabaseBackupList, runDatabaseConnectionCreate, runDatabaseConnectionList, runDatabaseConnectionRemove, runDatabaseConnectionRotate, runDatabaseCreate, runDatabaseList, runDatabaseRemove, runDatabaseRestore, runDatabaseShow, runDatabaseUsage } from "../../controllers/database.js";
-import { renderDatabaseBackupList, renderDatabaseConnectionCreate, renderDatabaseConnectionCreateStdout, renderDatabaseConnectionList, renderDatabaseConnectionRemove, renderDatabaseConnectionRotate, renderDatabaseConnectionRotateStdout, renderDatabaseCreate, renderDatabaseCreateStdout, renderDatabaseList, renderDatabaseRemove, renderDatabaseRestore, renderDatabaseShow, renderDatabaseUsage, serializeDatabaseBackupList, serializeDatabaseConnectionCreate, serializeDatabaseConnectionList, serializeDatabaseConnectionRemove, serializeDatabaseConnectionRotate, serializeDatabaseCreate, serializeDatabaseList, serializeDatabaseRemove, serializeDatabaseRestore, serializeDatabaseShow, serializeDatabaseUsage } 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(createDatabaseUsageCommand(runtime));
-	database.addCommand(createDatabaseRestoreCommand(runtime));
-	database.addCommand(createDatabaseRemoveCommand(runtime));
-	database.addCommand(createDatabaseBackupCommand(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 createDatabaseUsageCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("usage"), runtime), "database.usage");
-	command.argument("<database>", "Database id or name").addOption(new Option("--from <iso-date>", "Start of the usage period")).addOption(new Option("--to <iso-date>", "End of the usage period"));
-	addProjectAndBranchOptions(command);
-	addGlobalFlags(command);
-	command.action(async (databaseRef, options) => {
-		const projectRef = options.project;
-		const branchName = options.branch;
-		const from = options.from;
-		const to = options.to;
-		await runCommand(runtime, "database.usage", options, (context) => runDatabaseUsage(context, databaseRef, {
-			projectRef,
-			branchName,
-			from,
-			to
-		}), {
-			renderHuman: (context, descriptor, result) => renderDatabaseUsage(context, descriptor, result),
-			renderJson: (result) => serializeDatabaseUsage(result)
-		});
-	});
-	return command;
-}
-function createDatabaseRestoreCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("restore"), runtime), "database.restore");
-	command.argument("<database>", "Target database id or name").addOption(new Option("--backup <backup-id>", "Backup to restore from")).addOption(new Option("--source-database <database>", "Database the backup belongs to (defaults to the target)")).addOption(new Option("--confirm <database-id>", "Exact target database id required to restore"));
-	addProjectAndBranchOptions(command);
-	addGlobalFlags(command);
-	command.action(async (databaseRef, options) => {
-		const projectRef = options.project;
-		const branchName = options.branch;
-		const backupId = options.backup;
-		const sourceDatabaseRef = options.sourceDatabase;
-		const confirm = options.confirm;
-		await runCommand(runtime, "database.restore", options, (context) => runDatabaseRestore(context, databaseRef, {
-			projectRef,
-			branchName,
-			backupId,
-			sourceDatabaseRef,
-			confirm
-		}), {
-			renderHuman: (context, descriptor, result) => renderDatabaseRestore(context, descriptor, result),
-			renderJson: (result) => serializeDatabaseRestore(result)
-		});
-	});
-	return command;
-}
-function createDatabaseBackupCommand(runtime) {
-	const backup = attachCommandDescriptor(configureRuntimeCommand(new Command("backup"), runtime), "database.backup");
-	addCompactGlobalFlags(backup);
-	backup.addCommand(createDatabaseBackupListCommand(runtime));
-	return backup;
-}
-function createDatabaseBackupListCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list"), runtime), "database.backup.list");
-	command.argument("<database>", "Database id or name").addOption(new Option("--limit <n>", "Maximum number of backups to return"));
-	addProjectAndBranchOptions(command);
-	addGlobalFlags(command);
-	command.action(async (databaseRef, options) => {
-		const projectRef = options.project;
-		const branchName = options.branch;
-		const limit = options.limit;
-		await runCommand(runtime, "database.backup.list", options, (context) => runDatabaseBackupList(context, databaseRef, {
-			projectRef,
-			branchName,
-			limit
-		}), {
-			renderHuman: (context, descriptor, result) => renderDatabaseBackupList(context, descriptor, result),
-			renderJson: (result) => serializeDatabaseBackupList(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(createDatabaseConnectionRotateCommand(runtime));
-	connection.addCommand(createDatabaseConnectionRemoveCommand(runtime));
-	return connection;
-}
-function createDatabaseConnectionRotateCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rotate"), runtime), "database.connection.rotate");
-	command.argument("<connection>", "Connection id").addOption(new Option("--confirm <connection-id>", "Exact connection id required to rotate"));
-	addGlobalFlags(command);
-	command.action(async (connectionRef, options) => {
-		const confirm = options.confirm;
-		await runCommand(runtime, "database.connection.rotate", options, (context) => runDatabaseConnectionRotate(context, connectionRef, { confirm }), {
-			renderStdout: (context, descriptor, result) => renderDatabaseConnectionRotateStdout(context, descriptor, result),
-			renderHuman: (context, descriptor, result) => renderDatabaseConnectionRotate(context, descriptor, result),
-			renderJson: (result) => serializeDatabaseConnectionRotate(result)
-		});
-	});
-	return command;
-}
-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 };

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/feedback/index.js

@@ -1,20 +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 { runFeedback } from "../../controllers/feedback.js";
-import { renderFeedbackSuccess } from "../../presenters/feedback.js";
-import { Command, Option } from "commander";
-//#region src/commands/feedback/index.ts
-function createFeedbackCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("feedback"), runtime), "feedback");
-	command.argument("<message>", "Feedback text (up to 4000 characters)").addOption(new Option("--email <address>", "Contact email if you want a reply; feedback is anonymous without it"));
-	addGlobalFlags(command);
-	command.action(async (message, options) => {
-		const flags = options;
-		await runCommand(runtime, "feedback", options, (context) => runFeedback(context, message, { email: flags.email }), { renderHuman: (context, descriptor, result) => renderFeedbackSuccess(context, descriptor, result) });
-	});
-	return command;
-}
-//#endregion
-export { createFeedbackCommand };

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 { runCommand } from "../../shell/command-runner.js";
-import { runGitConnect, runGitDisconnect } from "../../controllers/project.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/init/index.js

@@ -1,33 +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 { runInit } from "../../controllers/init.js";
-import { renderInit, serializeInit } from "../../presenters/init.js";
-import { Command, Option } from "commander";
-//#region src/commands/init/index.ts
-function createInitCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("init"), runtime), "init");
-	command.addOption(new Option("--framework <framework>", "Framework override; detected when omitted")).addOption(new Option("--entry <path>", "Source entrypoint for entrypoint frameworks (Bun, Hono)")).addOption(new Option("--http-port <port>", "HTTP port the app listens on")).addOption(new Option("--region <region>", "Region used when deploy creates the app")).addOption(new Option("--name <app-name>", "App name")).addOption(new Option("--link", "Link this directory to a Project")).addOption(new Option("--no-link", "Skip the Project link step")).addOption(new Option("--project <id-or-name>", "Project to link this directory to")).addOption(new Option("--install", "Install @prisma/compute-sdk for config types")).addOption(new Option("--no-install", "Skip the types install step")).addOption(new Option("--format <ts|json>", "Config file format: ts (default) writes prisma.compute.ts, json writes dependency-free prisma.compute.json; --format ts converts an existing prisma.compute.json"));
-	addGlobalFlags(command);
-	command.action(async (options) => {
-		const flags = options;
-		await runCommand(runtime, "init", options, (context) => runInit(context, {
-			framework: flags.framework,
-			entry: flags.entry,
-			httpPort: flags.httpPort,
-			region: flags.region,
-			name: flags.name,
-			link: flags.link,
-			project: flags.project,
-			install: flags.install,
-			format: flags.format
-		}), {
-			renderHuman: (context, descriptor, result) => renderInit(context, descriptor, result),
-			renderJson: (result) => serializeInit(result)
-		});
-	});
-	return command;
-}
-//#endregion
-export { createInitCommand };