@prisma/cli 3.0.0-beta.0 → 3.0.0-beta.10

package/dist/lib/app/bun-project.js

@@ -1,11 +1,15 @@
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/app/bun-project.ts
-async function readBunPackageJson(appPath) {
+async function readBunPackageJson(appPath, signal) {
 	const packageJsonPath = path.join(appPath, "package.json");
 	let content;
+	signal?.throwIfAborted();
 	try {
-		content = await readFile(packageJsonPath, "utf8");
+		content = await readFile(packageJsonPath, {
+			encoding: "utf8",
+			signal
+		});
 	} catch (error) {
 		if (error.code === "ENOENT") return null;
 		throw new Error(`Failed to read ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -20,17 +24,20 @@ function readBunPackageEntrypoint(packageJson) {
 	if (typeof packageJson?.main === "string") return packageJson.main;
 	if (typeof packageJson?.module === "string") return packageJson.module;
 }
-async function resolveBunEntrypoint(appPath, explicitEntrypoint) {
-	const packageJson = await readBunPackageJson(appPath);
+async function resolveBunEntrypoint(appPath, explicitEntrypoint, signal) {
+	const packageJson = await readBunPackageJson(appPath, signal);
 	const candidate = explicitEntrypoint ?? readBunPackageEntrypoint(packageJson);
 	if (!candidate) throw new Error("Entrypoint is required. Pass --entry or define package.json main or module.");
 	if (path.isAbsolute(candidate)) throw new Error("Entrypoint must be a relative path.");
 	const normalized = path.normalize(candidate);
 	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized.includes(`${path.sep}..${path.sep}`)) throw new Error("Entrypoint must not escape the app directory.");
 	const entrypointPath = path.join(appPath, normalized);
+	signal?.throwIfAborted();
 	try {
 		await access(entrypointPath);
-	} catch {
+		signal?.throwIfAborted();
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		throw new Error(`Entrypoint file does not exist: ${entrypointPath}`);
 	}
 	return normalized.split(path.sep).join("/");

package/dist/lib/app/deploy-output.js

@@ -2,6 +2,7 @@ import { padDisplay } from "../../shell/ui.js";
 //#region src/lib/app/deploy-output.ts
 const DEPLOY_OUTPUT_MIN_LABEL_WIDTH = 9;
 const DEPLOY_OUTPUT_MIN_VALUE_WIDTH = 9;
+const DEPLOY_SETTINGS_MIN_KEY_WIDTH = 10;
 function renderDeployOutputRows(ui, rows) {
 	if (rows.length === 0) return [];
 	const labelWidth = Math.max(DEPLOY_OUTPUT_MIN_LABEL_WIDTH, ...rows.map((row) => row.label.length));
@@ -11,5 +12,13 @@ function renderDeployOutputRows(ui, rows) {
 		return `  ${padDisplay(row.label, labelWidth)}  ${padDisplay(ui.strong(row.value), valueWidth)}${row.origin ? `  ${ui.dim(`· ${row.origin}`)}` : ""}`.trimEnd();
 	});
 }
+function renderDeploySettingsPreview(ui, rows) {
+	if (rows.length === 0) return [];
+	const keyWidth = Math.max(DEPLOY_SETTINGS_MIN_KEY_WIDTH, ...rows.map((row) => `${row.key}:`.length));
+	const rail = ui.dim("│");
+	return rows.map((row) => {
+		return `${rail}  ${ui.accent(padDisplay(`${row.key}:`, keyWidth))}  ${ui.strong(row.value)}`;
+	});
+}
 //#endregion
-export { renderDeployOutputRows };
+export { renderDeployOutputRows, renderDeploySettingsPreview };

package/dist/lib/app/env-config.js

@@ -64,4 +64,4 @@ function formatScopeLabel(scope) {
 	return `branch:${scope.branchName}`;
 }
 //#endregion
-export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope };
+export { formatScopeLabel, parseKeyValuePositional, resolveEnvScope, validateKey };

package/dist/lib/app/env-file.js

@@ -0,0 +1,82 @@
+import { usageError } from "../../shell/errors.js";
+import { validateKey } from "./env-config.js";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse } from "dotenv";
+//#region src/lib/app/env-file.ts
+const ASSIGNMENT_KEY_PATTERN = /^\s*(?:export\s+)?([^#=\s]+)\s*=/;
+async function readEnvFileAssignments(cwd, filePath, command) {
+	const resolvedPath = path.resolve(cwd, filePath);
+	let contents;
+	try {
+		contents = await readFile(resolvedPath, "utf8");
+	} catch (error) {
+		throw usageError(`Failed to read env file "${filePath}"`, error instanceof Error ? error.message : "The file could not be read.", "Pass a readable dotenv file path.", [command === "deploy" ? "prisma-cli app deploy --env .env" : `prisma-cli project env ${command} --file .env --role preview`], "app");
+	}
+	return parseEnvFileContents(contents, filePath, command);
+}
+function parseEnvFileContents(contents, filePath, command) {
+	const parsedKeys = extractParsedKeys(contents);
+	if (parsedKeys.length === 0) throw usageError(`No environment variables found in "${filePath}"`, "The file does not contain any KEY=VALUE assignments.", "Pass a dotenv file with at least one non-empty variable.", [], "app");
+	const seen = /* @__PURE__ */ new Map();
+	for (const entry of parsedKeys) {
+		validateEnvFileKey(entry.key, entry.line, filePath, command);
+		const firstLine = seen.get(entry.key);
+		if (firstLine !== void 0) throw usageError(`Duplicate environment variable "${entry.key}" in "${filePath}"`, `Lines ${firstLine} and ${entry.line} both define ${entry.key}.`, "Keep one assignment for each key before importing the file.", [], "app");
+		seen.set(entry.key, entry.line);
+	}
+	const parsedValues = parse(contents);
+	return parsedKeys.map(({ key }) => {
+		const value = parsedValues[key];
+		if (typeof value !== "string" || value.length === 0) {
+			const line = seen.get(key);
+			throw usageError(`Environment variable "${key}" in "${filePath}" has an empty value`, line === void 0 ? `${key} has an empty value.` : `Line ${line} defines ${key} with an empty value.`, "Pass a non-empty value, or omit the key from the file.", [], "app");
+		}
+		return {
+			key,
+			value
+		};
+	});
+}
+function extractParsedKeys(contents) {
+	const keys = [];
+	let multilineQuote = null;
+	const lines = contents.split(/\n/);
+	for (const [index, line] of lines.entries()) {
+		const lineNumber = index + 1;
+		if (multilineQuote !== null) {
+			if (hasClosingQuote(line, multilineQuote, 0)) multilineQuote = null;
+			continue;
+		}
+		const match = ASSIGNMENT_KEY_PATTERN.exec(line);
+		if (!match) continue;
+		const key = match[1];
+		keys.push({
+			key,
+			line: lineNumber
+		});
+		const valueStart = line.slice(match[0].length).trimStart();
+		const openingQuote = valueStart[0];
+		if ((openingQuote === "\"" || openingQuote === "'" || openingQuote === "`") && !hasClosingQuote(valueStart, openingQuote, 1)) multilineQuote = openingQuote;
+	}
+	return keys;
+}
+function validateEnvFileKey(key, line, filePath, command) {
+	try {
+		validateKey(key, command === "deploy" ? "add" : command);
+	} catch (error) {
+		const reason = error instanceof Error && error.message.length > 0 ? error.message : "Invalid environment variable key.";
+		throw usageError(`Invalid environment variable "${key}" in "${filePath}"`, `Line ${line}: ${reason}`, "Use a valid env-var key and retry the import.", [], "app");
+	}
+}
+function hasClosingQuote(value, quote, startIndex) {
+	for (let index = startIndex; index < value.length; index += 1) if (value[index] === quote && !isEscaped(value, index)) return true;
+	return false;
+}
+function isEscaped(value, index) {
+	let backslashes = 0;
+	for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) backslashes += 1;
+	return backslashes % 2 === 1;
+}
+//#endregion
+export { readEnvFileAssignments };

package/dist/lib/app/env-vars.js

@@ -1,4 +1,6 @@
 import { usageError } from "../../shell/errors.js";
+import { validateKey } from "./env-config.js";
+import { readEnvFileAssignments } from "./env-file.js";
 //#region src/lib/app/env-vars.ts
 function parseEnvAssignments(assignments, options) {
 	const values = assignments ?? [];
@@ -10,15 +12,39 @@ function parseEnvAssignments(assignments, options) {
 		if (separatorIndex === -1) throw usageError("Environment variable assignment must use NAME=VALUE", "A provided --env flag is missing the = separator.", `Pass repeated --env NAME=VALUE flags, for example prisma-cli app ${options.commandName} --env DATABASE_URL=postgresql://example.`, [`prisma-cli app ${options.commandName} --env DATABASE_URL=postgresql://example`], "app");
 		const name = assignment.slice(0, separatorIndex);
 		if (name.length === 0) throw usageError("Environment variable name is required", "A provided --env flag has an empty variable name.", `Pass repeated --env NAME=VALUE flags, for example prisma-cli app ${options.commandName} --env DATABASE_URL=postgresql://example.`, [`prisma-cli app ${options.commandName} --env DATABASE_URL=postgresql://example`], "app");
+		validateEnvAssignmentName(name, options.commandName);
 		if (seen.has(name)) throw usageError(`Environment variable "${name}" was provided more than once`, "Each environment variable name may be set only once per command invocation.", `Remove the duplicate "${name}" assignment and rerun prisma-cli app ${options.commandName}.`, [`prisma-cli app ${options.commandName} --env ${name}=value`], "app");
+		const value = assignment.slice(separatorIndex + 1);
+		if (value.length === 0) throw usageError(`Environment variable "${name}" has an empty value`, `A provided --env flag defines ${name} with no value.`, "Pass a non-empty value, or omit the key from the deploy command.", [`prisma-cli app ${options.commandName} --env ${name}=value`], "app");
 		seen.add(name);
-		parsed[name] = assignment.slice(separatorIndex + 1);
+		parsed[name] = value;
 	}
 	return parsed;
 }
+async function parseEnvInputs(cwd, inputs, options) {
+	const values = inputs ?? [];
+	const expandedAssignments = [];
+	for (const value of values) {
+		if (value.includes("=")) {
+			expandedAssignments.push(value);
+			continue;
+		}
+		const fileAssignments = await readEnvFileAssignments(cwd, value, options.commandName);
+		expandedAssignments.push(...fileAssignments.map((assignment) => `${assignment.key}=${assignment.value}`));
+	}
+	return parseEnvAssignments(expandedAssignments, options);
+}
+function validateEnvAssignmentName(name, commandName) {
+	try {
+		validateKey(name, "add");
+	} catch (error) {
+		const reason = error instanceof Error && error.message.length > 0 ? error.message : "Invalid environment variable name.";
+		throw usageError(`Invalid environment variable "${name}"`, reason, "Use a valid env-var name and retry the deploy.", [`prisma-cli app ${commandName} --env DATABASE_URL=postgresql://example`], "app");
+	}
+}
 function envVarNames(envVars) {
 	if (!envVars) return [];
 	return Object.entries(envVars).filter(([, value]) => value !== null).map(([name]) => name).sort((left, right) => left.localeCompare(right));
 }
 //#endregion
-export { envVarNames, parseEnvAssignments };
+export { envVarNames, parseEnvInputs };

package/dist/lib/app/local-dev.js

@@ -10,14 +10,14 @@ const NEXT_CONFIG_FILENAMES = [
 	"next.config.mts"
 ];
 const DEFAULT_LOCAL_DEV_PORT = 3e3;
-async function resolveLocalBuildType(appPath, buildType) {
+async function resolveLocalBuildType(appPath, buildType, signal) {
 	if (buildType === "bun" || buildType === "nextjs") return buildType;
 	if (buildType !== "auto") return null;
-	return detectLocalBuildType(appPath);
+	return detectLocalBuildType(appPath, signal);
 }
-async function detectLocalBuildType(appPath) {
-	if (await isNextProject(appPath)) return "nextjs";
-	if (await isBunProject(appPath)) return "bun";
+async function detectLocalBuildType(appPath, signal) {
+	if (await isNextProject(appPath, signal)) return "nextjs";
+	if (await isBunProject(appPath, signal)) return "bun";
 	return null;
 }
 async function runLocalApp(options) {
@@ -58,7 +58,8 @@ async function runLocalApp(options) {
 			env: {
 				...options.env,
 				PORT: String(options.port)
-			}
+			},
+			signal: options.signal
 		}, spawnImpl, "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.");
 		return {
 			framework: "nextjs",
@@ -69,7 +70,7 @@ async function runLocalApp(options) {
 			signal: command.signal
 		};
 	}
-	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint);
+	const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint, options.signal);
 	const command = await runWithFallback([{
 		command: "bun",
 		args: ["--watch", entrypoint],
@@ -79,7 +80,8 @@ async function runLocalApp(options) {
 		env: {
 			...options.env,
 			PORT: String(options.port)
-		}
+		},
+		signal: options.signal
 	}, spawnImpl, "Bun is required to run this app locally. Install it from https://bun.sh.");
 	return {
 		framework: "bun",
@@ -90,23 +92,37 @@ async function runLocalApp(options) {
 		signal: command.signal
 	};
 }
-async function isNextProject(appPath) {
-	for (const fileName of NEXT_CONFIG_FILENAMES) try {
-		await access(path.join(appPath, fileName));
-		return true;
-	} catch {}
-	return hasDependency(await readBunPackageJson(appPath), "next");
+async function isNextProject(appPath, signal) {
+	for (const fileName of NEXT_CONFIG_FILENAMES) {
+		signal?.throwIfAborted();
+		try {
+			await access(path.join(appPath, fileName));
+			signal?.throwIfAborted();
+			return true;
+		} catch (error) {
+			if (signal?.aborted) throw error;
+		}
+	}
+	return hasDependency(await readBunPackageJson(appPath, signal), "next");
 }
-async function isBunProject(appPath) {
+async function isBunProject(appPath, signal) {
+	signal?.throwIfAborted();
 	try {
 		await access(path.join(appPath, "bun.lock"));
+		signal?.throwIfAborted();
 		return true;
-	} catch {}
+	} catch (error) {
+		if (signal?.aborted) throw error;
+	}
+	signal?.throwIfAborted();
 	try {
 		await access(path.join(appPath, "bun.lockb"));
+		signal?.throwIfAborted();
 		return true;
-	} catch {}
-	const packageJson = await readBunPackageJson(appPath);
+	} catch (error) {
+		if (signal?.aborted) throw error;
+	}
+	const packageJson = await readBunPackageJson(appPath, signal);
 	if (!packageJson) return false;
 	const hasEntrypoint = typeof readBunPackageEntrypoint(packageJson) === "string";
 	const hasBunDependency = hasDependency(packageJson, "@types/bun") || hasDependency(packageJson, "bun");

package/dist/lib/app/preview-branch-database.js

@@ -0,0 +1,102 @@
+//#region src/lib/app/preview-branch-database.ts
+async function createBranchDatabase(client, options) {
+	const result = await client.POST("/v1/databases", {
+		body: {
+			projectId: options.projectId,
+			branchId: options.branchId,
+			name: options.branchName,
+			source: { type: "empty" }
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to create database for branch "${options.branchName}"`, result.response, result.error);
+	return normalizeBranchDatabaseRecord(result.data.data);
+}
+async function listEnvironmentVariables(client, options) {
+	const variables = [];
+	let cursor;
+	while (true) {
+		const result = await client.GET("/v1/environment-variables", {
+			params: { query: {
+				projectId: options.projectId,
+				class: options.className,
+				key: options.key,
+				branchId: options.branchId,
+				cursor
+			} },
+			signal: options.signal
+		});
+		if (result.error || !result.data) throw apiCallError("Failed to list environment variables", result.response, result.error);
+		variables.push(...result.data.data);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return variables.map((variable) => normalizeEnvironmentVariable(variable));
+}
+async function createEnvironmentVariable(client, options) {
+	const result = await client.POST("/v1/environment-variables", {
+		body: {
+			projectId: options.projectId,
+			class: options.className,
+			key: options.key,
+			value: options.value,
+			...options.branchId ? { branchId: options.branchId } : {}
+		},
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError(`Failed to add ${options.key}`, result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteBranchDatabase(client, options) {
+	const result = await client.DELETE("/v1/databases/{databaseId}", {
+		params: { path: { databaseId: options.databaseId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete branch database", result.response, result.error);
+}
+async function updateEnvironmentVariable(client, options) {
+	const result = await client.PATCH("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		body: { value: options.value },
+		signal: options.signal
+	});
+	if (result.error || !result.data) throw apiCallError("Failed to update environment variable", result.response, result.error);
+	return normalizeEnvironmentVariable(result.data.data);
+}
+async function deleteEnvironmentVariable(client, options) {
+	const result = await client.DELETE("/v1/environment-variables/{envVarId}", {
+		params: { path: { envVarId: options.envVarId } },
+		signal: options.signal
+	});
+	if (result.error) throw apiCallError("Failed to delete environment variable", result.response, result.error);
+}
+function normalizeEnvironmentVariable(variable) {
+	return {
+		id: variable.id,
+		key: variable.key,
+		branchId: variable.branchId,
+		className: variable.class,
+		isManagedBySystem: variable.isManagedBySystem
+	};
+}
+function normalizeBranchDatabaseRecord(database) {
+	const connection = database.connections?.[0];
+	const databaseUrl = connection?.endpoints?.pooled?.connectionString;
+	const directUrl = connection?.endpoints?.direct?.connectionString ?? null;
+	if (!databaseUrl) throw new Error("Created database did not return a pooled connection string.");
+	return {
+		id: database.id,
+		name: database.name,
+		branchId: database.branchId,
+		databaseUrl,
+		directUrl
+	};
+}
+function apiCallError(summary, response, error) {
+	if (response.status === 404) return /* @__PURE__ */ new Error("Resource Not Found");
+	const message = error.error?.message ?? `Management API returned HTTP ${response.status}.`;
+	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
+	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
+}
+//#endregion
+export { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable };