@prisma/cli 3.0.0-alpha.9 → 3.0.0-dev.30.1.shadd35c2356731

package/README.md

@@ -1,11 +1,11 @@
-# Prisma CLI Preview
+# Prisma CLI Beta
 
-Preview npm package for the unified Prisma CLI.
+Beta npm package for the unified Prisma CLI.
 
 Install:
 
 ```bash
-pnpm add -D @prisma/cli@preview
+pnpm add -D @prisma/cli
 ```
 
 Run:
@@ -22,6 +22,6 @@ executable.
 
 Notes:
 
-- This is a preview package and may change quickly.
+- This is a beta package and may change quickly.
 - `prisma.config.ts` stores linked project context for this CLI.
 - Environment variable values passed with `--env` are not printed back to the terminal.

package/dist/adapters/token-storage.js

@@ -1,5 +1,8 @@
 import { getAuthFilePath } from "../lib/auth/client.js";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { CredentialsStore } from "@prisma/credentials-store";
+import { randomUUID } from "node:crypto";
 //#region src/adapters/token-storage.ts
 function findLatestValidTokens(allCredentials) {
 	for (let i = allCredentials.length - 1; i >= 0; i -= 1) {
@@ -14,10 +17,19 @@ function findLatestValidTokens(allCredentials) {
 	}
 	return null;
 }
+function tokensEqual(a, b) {
+	return a?.workspaceId === b?.workspaceId && a?.accessToken === b?.accessToken && a?.refreshToken === b?.refreshToken;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
 var FileTokenStorage = class {
 	credentialsStore;
+	lockFilePath;
 	constructor(env = process.env) {
-		this.credentialsStore = new CredentialsStore(getAuthFilePath(env));
+		const authFilePath = getAuthFilePath(env);
+		this.credentialsStore = new CredentialsStore(authFilePath);
+		this.lockFilePath = `${authFilePath}.lock`;
 	}
 	async getTokens() {
 		try {
@@ -38,6 +50,50 @@ var FileTokenStorage = class {
 		if (!tokens) return;
 		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
 	}
+	async clearTokensIfCurrent(tokens) {
+		if (!tokensEqual(await this.getTokens(), tokens)) return;
+		await this.clearTokens();
+	}
+	async withRefreshLock(fn) {
+		const lockId = await this.acquireRefreshLock();
+		try {
+			return await fn();
+		} finally {
+			await this.releaseRefreshLock(lockId);
+		}
+	}
+	async acquireRefreshLock() {
+		const lockId = randomUUID();
+		await fs.mkdir(path.dirname(this.lockFilePath), { recursive: true });
+		while (true) try {
+			const handle = await fs.open(this.lockFilePath, "wx");
+			try {
+				await handle.writeFile(lockId, "utf8");
+			} finally {
+				await handle.close();
+			}
+			return lockId;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			const staleLockId = await this.getStaleRefreshLockId();
+			if (staleLockId) {
+				await this.releaseRefreshLock(staleLockId);
+				continue;
+			}
+			await sleep(100);
+		}
+	}
+	async getStaleRefreshLockId() {
+		const lockId = await fs.readFile(this.lockFilePath, "utf8").catch(() => null);
+		if (lockId === null) return null;
+		const stats = await fs.stat(this.lockFilePath).catch(() => null);
+		if (!stats) return null;
+		return Date.now() - stats.mtimeMs > 3e4 ? lockId : null;
+	}
+	async releaseRefreshLock(lockId) {
+		if (await fs.readFile(this.lockFilePath, "utf8").catch(() => null) !== lockId) return;
+		await fs.unlink(this.lockFilePath).catch(() => {});
+	}
 };
 //#endregion
 export { FileTokenStorage };

package/dist/commands/app/index.js

@@ -2,8 +2,8 @@ import { attachCommandDescriptor } from "../../shell/command-meta.js";
 import { addCompactGlobalFlags, addGlobalFlags } from "../../shell/global-flags.js";
 import { configureRuntimeCommand } from "../../shell/runtime.js";
 import { PREVIEW_BUILD_TYPES } from "../../lib/app/preview-build.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 { runAppBuild, runAppDeploy, runAppDomainAdd, runAppDomainRemove, runAppDomainRetry, runAppDomainShow, runAppDomainWait, runAppListDeploys, runAppLogs, runAppOpen, runAppPromote, runAppRemove, runAppRollback, runAppRun, runAppShow, runAppShowDeploy } from "../../controllers/app.js";
+import { renderAppBuild, renderAppDeploy, renderAppDomainAdd, renderAppDomainRemove, renderAppDomainRetry, renderAppDomainShow, renderAppListDeploys, renderAppOpen, renderAppPromote, renderAppRemove, renderAppRollback, renderAppRun, renderAppShow, renderAppShowDeploy, serializeAppBuild, serializeAppDeploy, 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";
 //#region src/commands/app/index.ts
@@ -13,10 +13,9 @@ function createAppCommand(runtime) {
 	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(createDomainCommand(runtime));
 	app.addCommand(createLogsCommand(runtime));
 	app.addCommand(createListDeploysCommand(runtime));
 	app.addCommand(createShowDeployCommand(runtime));
@@ -90,63 +89,147 @@ function createDeployCommand(runtime) {
 	});
 	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("--project <id-or-name>", "Project id or name")).addOption(new Option("--env <name=value>", "Environment variable").argParser(collectRepeatableValues));
+function createShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
+	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
-		const envAssignments = options.env;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.update-env", options, (context) => runAppUpdateEnv(context, appName, envAssignments, projectRef), {
-			renderHuman: (context, descriptor, result) => renderAppUpdateEnv(context, descriptor, result),
-			renderJson: (result) => serializeAppUpdateEnv(result)
+		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef), {
+			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
+			renderJson: (result) => serializeAppShow(result)
 		});
 	});
 	return command;
 }
-function createListEnvCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("list-env"), runtime), "app.list-env");
+function createOpenCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("open"), runtime), "app.open");
 	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.list-env", options, (context) => runAppListEnv(context, appName, projectRef), {
-			renderHuman: (context, descriptor, result) => renderAppListEnv(context, descriptor, result),
-			renderJson: (result) => serializeAppListEnv(result)
+		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef), {
+			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
+			renderJson: (result) => serializeAppOpen(result)
 		});
 	});
 	return command;
 }
-function createShowCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.show");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+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");
+	addDomainTargetOptions(command);
 	addGlobalFlags(command);
-	command.action(async (options) => {
+	command.action(async (hostname, options) => {
 		const appName = options.app;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.show", options, (context) => runAppShow(context, appName, projectRef), {
-			renderHuman: (context, descriptor, result) => renderAppShow(context, descriptor, result),
-			renderJson: (result) => serializeAppShow(result)
+		const branchName = options.branch;
+		await runCommand(runtime, "app.domain.add", options, (context) => runAppDomainAdd(context, hostname, {
+			appName,
+			projectRef,
+			branchName
+		}), {
+			renderHuman: (context, descriptor, result) => renderAppDomainAdd(context, descriptor, result),
+			renderJson: (result) => serializeAppDomainAdd(result)
 		});
 	});
 	return command;
 }
-function createOpenCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("open"), runtime), "app.open");
-	command.addOption(new Option("--app <name>", "App name")).addOption(new Option("--project <id-or-name>", "Project id or name"));
+function createDomainShowCommand(runtime) {
+	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("show"), runtime), "app.domain.show");
+	command.argument("<hostname>", "Custom domain hostname");
+	addDomainTargetOptions(command);
 	addGlobalFlags(command);
-	command.action(async (options) => {
+	command.action(async (hostname, options) => {
 		const appName = options.app;
 		const projectRef = options.project;
-		await runCommand(runtime, "app.open", options, (context) => runAppOpen(context, appName, projectRef), {
-			renderHuman: (context, descriptor, result) => renderAppOpen(context, descriptor, result),
-			renderJson: (result) => serializeAppOpen(result)
+		const branchName = options.branch;
+		await runCommand(runtime, "app.domain.show", options, (context) => runAppDomainShow(context, hostname, {
+			appName,
+			projectRef,
+			branchName
+		}), {
+			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");
+	addDomainTargetOptions(command);
+	addGlobalFlags(command);
+	command.action(async (hostname, 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
+		}), {
+			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");
+	addDomainTargetOptions(command);
+	addGlobalFlags(command);
+	command.action(async (hostname, 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
+		}), {
+			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");
+	addDomainTargetOptions(command);
+	command.addOption(new Option("--timeout <duration>", "Maximum time to wait").default("15m"));
+	addGlobalFlags(command);
+	command.action(async (hostname, 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
+		}));
+	});
+	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("--project <id-or-name>", "Project id or name")).addOption(new Option("--deployment <id>", "Deployment id"));

package/dist/commands/env.js

@@ -2,7 +2,7 @@ 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, runEnvRm, runEnvUpdate } from "../controllers/app-env.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
@@ -12,18 +12,20 @@ function createEnvCommand(runtime) {
 	env.addCommand(createEnvAddCommand(runtime));
 	env.addCommand(createEnvUpdateCommand(runtime));
 	env.addCommand(createEnvListCommand(runtime));
-	env.addCommand(createEnvRmCommand(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("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").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;
 		await runCommand(runtime, "project.env.add", options, (context) => runEnvAdd(context, assignment, {
 			roleName,
+			branchName,
 			projectRef
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvAdd(context, descriptor, result),
@@ -34,13 +36,15 @@ function createEnvAddCommand(runtime) {
 }
 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("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
+	command.argument("<assignment>", "Variable assignment as KEY=VALUE or KEY from the current environment").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;
 		await runCommand(runtime, "project.env.update", options, (context) => runEnvUpdate(context, assignment, {
 			roleName,
+			branchName,
 			projectRef
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvUpdate(context, descriptor, result),
@@ -51,13 +55,15 @@ function createEnvUpdateCommand(runtime) {
 }
 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("--project <id-or-name>", "Project id or name"));
+	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),
@@ -66,15 +72,17 @@ function createEnvListCommand(runtime) {
 	});
 	return command;
 }
-function createEnvRmCommand(runtime) {
-	const command = attachCommandDescriptor(configureRuntimeCommand(new Command("rm"), runtime), "project.env.rm");
-	command.argument("<key>", "Variable key to remove").addOption(new Option("--role <role>", "Project template scope (production or preview)").choices(["production", "preview"])).addOption(new Option("--project <id-or-name>", "Project id or name"));
+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.rm", options, (context) => runEnvRm(context, key, {
+		await runCommand(runtime, "project.env.remove", options, (context) => runEnvRemove(context, key, {
 			roleName,
+			branchName,
 			projectRef
 		}), {
 			renderHuman: (context, descriptor, result) => renderEnvRm(context, descriptor, result),