@prisma/cli 3.0.0-dev.53.1 → 3.0.0-dev.56.1

package/dist/adapters/git.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region src/adapters/git.ts
 const execFileAsync = promisify(execFile);
-async function readGitOriginRemote(cwd) {
+async function readGitOriginRemote(cwd, signal) {
 	try {
 		const { stdout } = await execFileAsync("git", [
 			"config",
@@ -10,14 +10,19 @@ async function readGitOriginRemote(cwd) {
 			"remote.origin.url"
 		], {
 			cwd,
-			timeout: 5e3
+			timeout: 5e3,
+			signal
 		});
 		const remote = stdout.trim();
 		return remote.length > 0 ? remote : null;
-	} catch {
+	} catch (error) {
+		if (signal?.aborted || isAbortError(error)) throw error;
 		return null;
 	}
 }
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
 function parseGitHubRepositoryUrl(value) {
 	const input = value.trim();
 	const shorthand = input.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/);

package/dist/adapters/local-state.js

@@ -20,12 +20,17 @@ function resolveLocalStateFilePath(stateDir) {
 }
 var LocalStateStore = class {
 	stateFilePath;
-	constructor(stateDir) {
+	constructor(stateDir, signal) {
+		this.signal = signal;
 		this.stateFilePath = resolveLocalStateFilePath(stateDir);
 	}
 	async read() {
+		this.signal?.throwIfAborted();
 		try {
-			const raw = await readFile(this.stateFilePath, "utf8");
+			const raw = await readFile(this.stateFilePath, {
+				encoding: "utf8",
+				signal: this.signal
+			});
 			const parsed = JSON.parse(raw);
 			return {
 				auth: parsed.auth ?? structuredClone(DEFAULT_STATE.auth),
@@ -46,8 +51,11 @@ var LocalStateStore = class {
 		}
 	}
 	async write(state) {
+		this.signal?.throwIfAborted();
 		await mkdir(path.dirname(this.stateFilePath), { recursive: true });
-		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+		this.signal?.throwIfAborted();
+		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8" });
+		this.signal?.throwIfAborted();
 	}
 	async setAuthSession(session) {
 		const state = await this.read();

package/dist/adapters/mock-api.js

@@ -5,8 +5,12 @@ var MockApi = class MockApi {
 	constructor(data) {
 		this.data = data;
 	}
-	static async load(fixturePath) {
-		const raw = await readFile(fixturePath, "utf8");
+	static async load(fixturePath, signal) {
+		signal?.throwIfAborted();
+		const raw = await readFile(fixturePath, {
+			encoding: "utf8",
+			signal
+		});
 		return new MockApi(JSON.parse(raw));
 	}
 	listProviders() {

package/dist/adapters/token-storage.js

@@ -20,37 +20,60 @@ function findLatestValidTokens(allCredentials) {
 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));
+function sleep(ms, signal) {
+	signal?.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timeout);
+			reject(signal?.reason);
+		};
+		const timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
 }
 var FileTokenStorage = class {
 	credentialsStore;
 	lockFilePath;
-	constructor(env = process.env) {
+	constructor(env = process.env, signal) {
+		this.signal = signal;
 		const authFilePath = getAuthFilePath(env);
 		this.credentialsStore = new CredentialsStore(authFilePath);
 		this.lockFilePath = `${authFilePath}.lock`;
 	}
 	async getTokens() {
+		this.signal?.throwIfAborted();
 		try {
-			return findLatestValidTokens(await this.credentialsStore.getCredentials());
-		} catch {
+			const all = await this.credentialsStore.getCredentials();
+			this.signal?.throwIfAborted();
+			return findLatestValidTokens(all);
+		} catch (error) {
+			if (this.signal?.aborted) throw this.signal.reason;
 			return null;
 		}
 	}
 	async setTokens(tokens) {
+		this.signal?.throwIfAborted();
 		await this.credentialsStore.storeCredentials({
 			workspaceId: tokens.workspaceId,
 			token: tokens.accessToken,
 			refreshToken: tokens.refreshToken
 		});
+		this.signal?.throwIfAborted();
 	}
 	async clearTokens() {
-		const tokens = findLatestValidTokens(await this.credentialsStore.getCredentials());
+		this.signal?.throwIfAborted();
+		const all = await this.credentialsStore.getCredentials();
+		this.signal?.throwIfAborted();
+		const tokens = findLatestValidTokens(all);
 		if (!tokens) return;
 		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
+		this.signal?.throwIfAborted();
 	}
 	async clearTokensIfCurrent(tokens) {
+		this.signal?.throwIfAborted();
 		if (!tokensEqual(await this.getTokens(), tokens)) return;
 		await this.clearTokens();
 	}
@@ -64,34 +87,52 @@ var FileTokenStorage = class {
 	}
 	async acquireRefreshLock() {
 		const lockId = randomUUID();
+		this.signal?.throwIfAborted();
 		await fs.mkdir(path.dirname(this.lockFilePath), { recursive: true });
-		while (true) try {
-			const handle = await fs.open(this.lockFilePath, "wx");
+		while (true) {
+			this.signal?.throwIfAborted();
+			let lockFileCreated = false;
 			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;
+				const handle = await fs.open(this.lockFilePath, "wx");
+				lockFileCreated = true;
+				try {
+					this.signal?.throwIfAborted();
+					await handle.writeFile(lockId, { encoding: "utf8" });
+					this.signal?.throwIfAborted();
+				} finally {
+					await handle.close();
+				}
+				return lockId;
+			} catch (error) {
+				if (lockFileCreated) await fs.unlink(this.lockFilePath).catch(() => void 0);
+				if (error.code !== "EEXIST") throw error;
+				const staleLockId = await this.getStaleRefreshLockId();
+				if (staleLockId) {
+					await this.releaseRefreshLock(staleLockId);
+					continue;
+				}
+				await sleep(100, this.signal);
 			}
-			await sleep(100);
 		}
 	}
 	async getStaleRefreshLockId() {
-		const lockId = await fs.readFile(this.lockFilePath, "utf8").catch(() => null);
+		this.signal?.throwIfAborted();
+		const lockId = await fs.readFile(this.lockFilePath, {
+			encoding: "utf8",
+			signal: this.signal
+		}).catch((error) => {
+			if (this.signal?.aborted) throw error;
+			return null;
+		});
 		if (lockId === null) return null;
+		this.signal?.throwIfAborted();
 		const stats = await fs.stat(this.lockFilePath).catch(() => null);
+		this.signal?.throwIfAborted();
 		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;
+		if (await fs.readFile(this.lockFilePath, { encoding: "utf8" }).catch(() => null) !== lockId) return;
 		await fs.unlink(this.lockFilePath).catch(() => {});
 	}
 };

package/dist/cli.js

@@ -6,8 +6,19 @@ import process from "node:process";
 if (process.env.PRISMA_CLI_RUN_UPDATE_CHECK_WORKER === "1") runUpdateDiscoveryWorker().then(() => {
 	process.exitCode = 0;
 });
-else runCli().then((exitCode) => {
-	process.exitCode = exitCode;
-});
+else {
+	const controller = new AbortController();
+	const abortCli = () => {
+		if (!controller.signal.aborted) controller.abort(new DOMException("Command canceled", "AbortError"));
+	};
+	process.once("SIGINT", abortCli);
+	process.once("SIGTERM", abortCli);
+	runCli({ signal: controller.signal }).then((exitCode) => {
+		process.exitCode = exitCode;
+	}).finally(() => {
+		process.off("SIGINT", abortCli);
+		process.off("SIGTERM", abortCli);
+	});
+}
 //#endregion
 export {};

package/dist/cli2.js

@@ -106,6 +106,7 @@ function resolveRuntime(options) {
 		argv: options.argv ?? process.argv.slice(2),
 		cwd: options.cwd ?? process.env.INIT_CWD ?? process.cwd(),
 		env: options.env ?? process.env,
+		signal: options.signal ?? new AbortController().signal,
 		stdin: options.stdin ?? process.stdin,
 		stdout: options.stdout ?? process.stdout,
 		stderr: options.stderr ?? process.stderr,

package/dist/commands/app/index.js

@@ -64,7 +64,7 @@ function createDeployCommand(runtime) {
 		"hono",
 		"tanstack-start",
 		"bun"
-	])).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>", "Environment variable").argParser(collectRepeatableValues));
+	])).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>", "Environment variable").argParser(collectRepeatableValues)).addOption(new Option("--prod", "Confirm intent to deploy to production"));
 	addGlobalFlags(command);
 	command.action(async (options) => {
 		const appName = options.app;
@@ -75,6 +75,7 @@ function createDeployCommand(runtime) {
 		const envAssignments = options.env;
 		const projectRef = options.project;
 		const createProjectName = options.createProject;
+		const prod = options.prod;
 		await runCommand(runtime, "app.deploy", options, (context) => runAppDeploy(context, appName, {
 			projectRef,
 			createProjectName,
@@ -82,7 +83,8 @@ function createDeployCommand(runtime) {
 			entrypoint: entry,
 			framework,
 			httpPort,
-			envAssignments
+			envAssignments,
+			prod: prod === true
 		}), {
 			renderHuman: (context, descriptor, result) => renderAppDeploy(context, descriptor, result),
 			renderJson: (result) => serializeAppDeploy(result)

package/dist/controllers/app-env.js

@@ -19,8 +19,11 @@ async function runEnvAdd(context, rawAssignment, flags) {
 	});
 	if (!scope) throw usageError(`prisma-cli project env add requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env add ${key}=${value} --role production`], "app");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env add");
-	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: true });
-	if (await findVariableByNaturalKey(client, projectId, key, resolved)) throw new CliError({
+	const resolved = await resolveScopeToApi(client, projectId, scope, {
+		createBranchIfMissing: true,
+		signal: context.runtime.signal
+	});
+	if (await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal)) throw new CliError({
 		code: "ENV_VARIABLE_ALREADY_EXISTS",
 		domain: "app",
 		summary: `Variable "${key}" already exists in ${formatScopeLabel(scope)}`,
@@ -42,14 +45,17 @@ async function runEnvAdd(context, rawAssignment, flags) {
 			class: "preview",
 			branchId: null
 		}
-	}) ? [`Variable "${key}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`] : [];
-	const { data, error, response } = await client.POST("/v1/environment-variables", { body: {
-		projectId,
-		class: resolved.apiTarget.class,
-		...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {},
-		key,
-		value
-	} });
+	}, context.runtime.signal) ? [`Variable "${key}" does not exist in preview. It will only exist on ${formatScopeLabel(scope)}.`] : [];
+	const { data, error, response } = await client.POST("/v1/environment-variables", {
+		body: {
+			projectId,
+			class: resolved.apiTarget.class,
+			...resolved.apiTarget.branchId !== null ? { branchId: resolved.apiTarget.branchId } : {},
+			key,
+			value
+		},
+		signal: context.runtime.signal
+	});
 	if (error || !data) throw apiCallError(`Failed to add ${key}`, response, error);
 	return {
 		command: "project.env.add",
@@ -70,8 +76,11 @@ async function runEnvUpdate(context, rawAssignment, flags) {
 	});
 	if (!scope) throw usageError(`prisma-cli project env update requires --role or --branch`, "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env update ${key}=${value} --role production`], "app");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env update");
-	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: false });
-	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
+	const resolved = await resolveScopeToApi(client, projectId, scope, {
+		createBranchIfMissing: false,
+		signal: context.runtime.signal
+	});
+	const existing = await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal);
 	if (!existing) throw new CliError({
 		code: "ENV_VARIABLE_NOT_FOUND",
 		domain: "app",
@@ -83,7 +92,8 @@ async function runEnvUpdate(context, rawAssignment, flags) {
 	});
 	const { data, error, response } = await client.PATCH("/v1/environment-variables/{envVarId}", {
 		params: { path: { envVarId: existing.id } },
-		body: { value }
+		body: { value },
+		signal: context.runtime.signal
 	});
 	if (error || !data) throw apiCallError(`Failed to update value for ${key}`, response, error);
 	return {
@@ -103,8 +113,11 @@ async function runEnvList(context, flags) {
 		command: "list"
 	}) ?? defaultRoleScope();
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env list");
-	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: false });
-	const variables = await listVariables(client, projectId, resolved);
+	const resolved = await resolveScopeToApi(client, projectId, scope, {
+		createBranchIfMissing: false,
+		signal: context.runtime.signal
+	});
+	const variables = await listVariables(client, projectId, resolved, context.runtime.signal);
 	return {
 		command: "project.env.list",
 		result: {
@@ -124,8 +137,11 @@ async function runEnvRemove(context, key, flags) {
 	});
 	if (!scope) throw usageError("prisma-cli project env remove requires --role or --branch", "Writing without an explicit scope is rejected.", "Pass --role production, --role preview, or --branch <git-name>.", [`prisma-cli project env remove ${key} --role production`], "app");
 	const { client, projectId } = await requireClientAndProject(context, flags.projectRef, "project env remove");
-	const resolved = await resolveScopeToApi(client, projectId, scope, { createBranchIfMissing: false });
-	const existing = await findVariableByNaturalKey(client, projectId, key, resolved);
+	const resolved = await resolveScopeToApi(client, projectId, scope, {
+		createBranchIfMissing: false,
+		signal: context.runtime.signal
+	});
+	const existing = await findVariableByNaturalKey(client, projectId, key, resolved, context.runtime.signal);
 	if (!existing) throw new CliError({
 		code: "ENV_VARIABLE_NOT_FOUND",
 		domain: "app",
@@ -135,7 +151,10 @@ async function runEnvRemove(context, key, flags) {
 		exitCode: 1,
 		nextSteps: [`prisma-cli project env list ${formatScopeFlag(scope)}`]
 	});
-	const { error, response } = await client.DELETE("/v1/environment-variables/{envVarId}", { params: { path: { envVarId: existing.id } } });
+	const { error, response } = await client.DELETE("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: existing.id } },
+		signal: context.runtime.signal
+	});
 	if (error) throw apiCallError(`Failed to remove ${key}`, response, error);
 	return {
 		command: "project.env.remove",
@@ -150,7 +169,7 @@ async function runEnvRemove(context, key, flags) {
 }
 async function requireClientAndProject(context, explicitProject, commandName) {
 	const authState = await requireAuthenticatedAuthState(context);
-	const client = await requireComputeAuth(context.runtime.env);
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError(["prisma-cli auth login"]);
 	if (!authState.workspace) throw workspaceRequiredError();
 	return {
@@ -159,7 +178,7 @@ async function requireClientAndProject(context, explicitProject, commandName) {
 			context,
 			workspace: authState.workspace,
 			explicitProject,
-			listProjects: () => listRealWorkspaceProjects(client, authState.workspace),
+			listProjects: () => listRealWorkspaceProjects(client, authState.workspace, context.runtime.signal),
 			commandName
 		})).project.id
 	};
@@ -176,7 +195,7 @@ async function resolveScopeToApi(client, projectId, scope, options) {
 			branchId: null
 		}
 	};
-	const branch = options.createBranchIfMissing ? await resolveOrCreateBranch(client, projectId, scope.branchName) : await resolveExistingBranch(client, projectId, scope.branchName);
+	const branch = options.createBranchIfMissing ? await resolveOrCreateBranch(client, projectId, scope.branchName, options.signal) : await resolveExistingBranch(client, projectId, scope.branchName, options.signal);
 	if (branch.isDefault) throw new CliError({
 		code: "ENV_BRANCH_SCOPE_IS_PRODUCTION",
 		domain: "app",
@@ -203,16 +222,19 @@ function formatScopeFlag(scope) {
 	if (scope.kind === "role") return `--role ${scope.role}`;
 	return `--branch ${scope.branchName}`;
 }
-async function listBranchesByName(client, projectId, branchName) {
-	const { data, error, response } = await client.GET("/v1/projects/{projectId}/branches", { params: {
-		path: { projectId },
-		query: { gitName: branchName }
-	} });
+async function listBranchesByName(client, projectId, branchName, signal) {
+	const { data, error, response } = await client.GET("/v1/projects/{projectId}/branches", {
+		params: {
+			path: { projectId },
+			query: { gitName: branchName }
+		},
+		signal
+	});
 	if (error || !data) throw apiCallError(`Failed to resolve branch "${branchName}"`, response, error);
 	return data.data;
 }
-async function resolveExistingBranch(client, projectId, branchName) {
-	const branch = (await listBranchesByName(client, projectId, branchName))[0];
+async function resolveExistingBranch(client, projectId, branchName, signal) {
+	const branch = (await listBranchesByName(client, projectId, branchName, signal))[0];
 	if (!branch) throw new CliError({
 		code: "ENV_BRANCH_NOT_FOUND",
 		domain: "app",
@@ -224,10 +246,10 @@ async function resolveExistingBranch(client, projectId, branchName) {
 	});
 	return branch;
 }
-async function resolveOrCreateBranch(client, projectId, branchName) {
-	const existing = (await listBranchesByName(client, projectId, branchName))[0];
+async function resolveOrCreateBranch(client, projectId, branchName, signal) {
+	const existing = (await listBranchesByName(client, projectId, branchName, signal))[0];
 	if (existing) return existing;
-	if (!await projectHasDefaultBranch(client, projectId)) throw new CliError({
+	if (!await projectHasDefaultBranch(client, projectId, signal)) throw new CliError({
 		code: "ENV_BRANCH_CREATE_REQUIRES_DEFAULT_BRANCH",
 		domain: "app",
 		summary: `Cannot create branch "${branchName}" from project env`,
@@ -241,42 +263,49 @@ async function resolveOrCreateBranch(client, projectId, branchName) {
 		body: {
 			gitName: branchName,
 			isDefault: false
-		}
+		},
+		signal
 	});
 	if (error || !data) {
 		if (response?.status === 409) {
-			const raced = (await listBranchesByName(client, projectId, branchName))[0];
+			const raced = (await listBranchesByName(client, projectId, branchName, signal))[0];
 			if (raced) return raced;
 		}
 		throw apiCallError(`Failed to create branch "${branchName}"`, response, error);
 	}
 	return data.data;
 }
-async function projectHasDefaultBranch(client, projectId) {
+async function projectHasDefaultBranch(client, projectId, signal) {
 	let cursor;
 	while (true) {
 		const query = {};
 		if (cursor !== void 0) query.cursor = cursor;
-		const result = await client.GET("/v1/projects/{projectId}/branches", { params: {
-			path: { projectId },
-			query
-		} });
+		const result = await client.GET("/v1/projects/{projectId}/branches", {
+			params: {
+				path: { projectId },
+				query
+			},
+			signal
+		});
 		if (result.error || !result.data) throw apiCallError("Failed to check project default branch", result.response, result.error);
 		if (result.data.data.some((branch) => branch.isDefault)) return true;
 		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) return false;
 		cursor = result.data.pagination.nextCursor;
 	}
 }
-async function findVariableByNaturalKey(client, projectId, key, resolved) {
-	const { data, error, response } = await client.GET("/v1/environment-variables", { params: { query: {
-		projectId,
-		class: resolved.apiTarget.class,
-		key
-	} } });
+async function findVariableByNaturalKey(client, projectId, key, resolved, signal) {
+	const { data, error, response } = await client.GET("/v1/environment-variables", {
+		params: { query: {
+			projectId,
+			class: resolved.apiTarget.class,
+			key
+		} },
+		signal
+	});
 	if (error || !data) throw apiCallError(`Failed to look up ${key}`, response, error);
 	return data.data.filter((row) => rowMatchesExactScope(row, resolved))[0] ?? null;
 }
-async function listVariables(client, projectId, resolved) {
+async function listVariables(client, projectId, resolved, signal) {
 	const collected = [];
 	let cursor;
 	while (true) {
@@ -285,7 +314,10 @@ async function listVariables(client, projectId, resolved) {
 			class: resolved.apiTarget.class
 		};
 		if (cursor !== void 0) query.cursor = cursor;
-		const result = await client.GET("/v1/environment-variables", { params: { query } });
+		const result = await client.GET("/v1/environment-variables", {
+			params: { query },
+			signal
+		});
 		if (result.error || !result.data) throw apiCallError(`Failed to list environment variables`, result.response, result.error);
 		const page = result.data.data.filter((row) => rowMatchesScope(row, resolved));
 		collected.push(...page);