@prisma/cli 3.0.0-beta.1 → 3.0.0-beta.11

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

@@ -0,0 +1,147 @@
+import { CliError } from "../../shell/errors.js";
+import { COMPUTE_CONFIG_FILENAME, COMPUTE_CONFIG_FILENAME as COMPUTE_CONFIG_FILENAME$1, ComputeConfigTargetRequiredError, computeTargetAppDir, frameworkByKey, inferComputeTargetFromCwd, loadComputeConfig, selectComputeDeployTarget } from "@prisma/compute-sdk/config";
+import path from "node:path";
+import { matchError } from "better-result";
+//#region src/lib/app/compute-config.ts
+/**
+* Loads the nearest compute config, searching from `cwd` up to the source
+* root (repository or workspace boundary). Thin adapter over the SDK loader
+* keeping the CLI's positional-signal call shape.
+*/
+async function loadComputeConfig$1(cwd, signal) {
+	return loadComputeConfig(cwd, { signal });
+}
+/** Local build/run strategy implied by a configured framework. */
+function computeFrameworkToBuildType(framework) {
+	return frameworkByKey(framework).buildType;
+}
+function mergeComputeDeployInputs(options) {
+	const { cli, target, configFilename } = options;
+	const configAnnotation = `set by ${configFilename}`;
+	const framework = cli.framework ? {
+		value: cli.framework,
+		annotation: "set by --framework"
+	} : target?.framework ? {
+		value: target.framework,
+		annotation: configAnnotation
+	} : void 0;
+	const entrypoint = cli.entrypoint ? {
+		value: cli.entrypoint,
+		annotation: "set by --entry"
+	} : target?.entry ? {
+		value: target.entry,
+		annotation: configAnnotation
+	} : void 0;
+	const httpPort = cli.httpPort ? {
+		value: cli.httpPort,
+		annotation: "set by --http-port"
+	} : target?.httpPort ? {
+		value: String(target.httpPort),
+		annotation: configAnnotation
+	} : void 0;
+	const cliEnvInputs = cli.envInputs && cli.envInputs.length > 0 ? cli.envInputs : void 0;
+	const configEnvInputs = target && target.envInputs.length > 0 ? target.envInputs : void 0;
+	const envInputs = cliEnvInputs ?? configEnvInputs;
+	const configAppName = target?.name ? {
+		value: target.name,
+		annotation: configAnnotation
+	} : target?.key ? {
+		value: target.key,
+		annotation: configAnnotation
+	} : void 0;
+	return {
+		framework,
+		entrypoint,
+		httpPort,
+		envInputs,
+		envInputsFromConfig: !cliEnvInputs && configEnvInputs !== void 0,
+		configAppName,
+		appRoot: target?.root ?? void 0
+	};
+}
+/**
+* Merges CLI inputs for the local `app build` and `app run` commands with a
+* selected config target. Explicit flags win; `--build-type auto` is the
+* flag default and defers to the configured framework.
+*/
+function mergeComputeLocalInputs(options) {
+	const { cli, target } = options;
+	const cliBuildType = cli.buildType && cli.buildType !== "auto" ? cli.buildType : void 0;
+	const configBuildType = target?.framework ? computeFrameworkToBuildType(target.framework) : void 0;
+	return {
+		entrypoint: cli.entrypoint ?? target?.entry ?? void 0,
+		buildType: cliBuildType ?? configBuildType,
+		buildTypeFromConfig: !cliBuildType && configBuildType !== void 0,
+		port: cli.port ?? (target?.httpPort ? String(target.httpPort) : void 0),
+		appRoot: target?.root ?? void 0
+	};
+}
+function computeConfigErrorToCliError(error, commandName = "deploy") {
+	const command = `prisma-cli app ${commandName}`;
+	return matchError(error, {
+		ComputeConfigAmbiguousError: (ambiguous) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: "Multiple compute config files found",
+			why: ambiguous.message,
+			fix: `Keep exactly one compute config file, preferably ${COMPUTE_CONFIG_FILENAME}.`,
+			meta: { configPaths: ambiguous.configPaths },
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigLoadError: (load) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `Could not load ${path.basename(load.configPath)}`,
+			why: load.message,
+			fix: `Fix the error in ${path.basename(load.configPath)} and rerun the command.`,
+			where: load.configPath,
+			meta: { configPath: load.configPath },
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigInvalidError: (invalid) => new CliError({
+			code: "COMPUTE_CONFIG_INVALID",
+			domain: "app",
+			summary: `Invalid ${path.basename(invalid.configPath)}`,
+			why: invalid.issues.join(" "),
+			fix: `Edit ${path.basename(invalid.configPath)} so it default-exports defineComputeConfig({ app }) or defineComputeConfig({ apps }).`,
+			where: invalid.configPath,
+			meta: {
+				configPath: invalid.configPath,
+				issues: invalid.issues
+			},
+			exitCode: 2,
+			nextSteps: [command]
+		}),
+		ComputeConfigTargetRequiredError: (required) => new CliError({
+			code: "COMPUTE_CONFIG_TARGET_REQUIRED",
+			domain: "app",
+			summary: "App target required",
+			why: required.message,
+			fix: `Pass the app target, for example ${command} <target>.`,
+			meta: {
+				configPath: required.configPath,
+				availableTargets: required.availableTargets
+			},
+			exitCode: 2,
+			nextSteps: required.availableTargets.map((target) => `${command} ${target}`)
+		}),
+		ComputeConfigTargetUnknownError: (unknown) => new CliError({
+			code: "COMPUTE_CONFIG_TARGET_UNKNOWN",
+			domain: "app",
+			summary: `Unknown app target "${unknown.requestedTarget}"`,
+			why: unknown.message,
+			fix: unknown.availableTargets.length > 0 ? `Pass one of the configured targets: ${unknown.availableTargets.join(", ")}.` : "Remove the target argument; this config defines a single app.",
+			meta: {
+				configPath: unknown.configPath,
+				requestedTarget: unknown.requestedTarget,
+				availableTargets: unknown.availableTargets
+			},
+			exitCode: 2,
+			nextSteps: unknown.availableTargets.length > 0 ? unknown.availableTargets.map((target) => `${command} ${target}`) : [command]
+		})
+	});
+}
+//#endregion
+export { COMPUTE_CONFIG_FILENAME$1 as COMPUTE_CONFIG_FILENAME, ComputeConfigTargetRequiredError, computeConfigErrorToCliError, computeFrameworkToBuildType, computeTargetAppDir, inferComputeTargetFromCwd, loadComputeConfig$1 as loadComputeConfig, mergeComputeDeployInputs, mergeComputeLocalInputs, selectComputeDeployTarget };

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/deploy-plan.js

@@ -0,0 +1,58 @@
+//#region src/lib/app/deploy-plan.ts
+/**
+* Decides whether a deploy covers one app or the whole system. A multi-app
+* config with no target named or inferred deploys every target in declaration
+* order; everything else (single-app config, an explicit/inferred target, or
+* no config at all) is a single deploy.
+*/
+function planAppDeploy(options) {
+	const { config, requestedTarget, hasCreateProject } = options;
+	if (!(config !== null && config.kind === "multi" && !requestedTarget && config.targets.length > 1)) return { mode: "single" };
+	const total = config.targets.length;
+	return {
+		mode: "all",
+		targets: config.targets.map((target, index) => ({
+			targetKey: target.key,
+			index,
+			total,
+			bindsCreateProject: index === 0 && hasCreateProject
+		}))
+	};
+}
+/**
+* Names the per-app inputs present in a deploy-all invocation, in the order
+* they should be reported. An empty list means the run is unambiguous; the
+* caller renders the usage error when it is not.
+*/
+function perAppInputsForDeployAll(inputs) {
+	return [
+		["--app", inputs.appName],
+		["--framework", inputs.framework],
+		["--entry", inputs.entrypoint],
+		["--http-port", inputs.httpPort],
+		["--env", inputs.envAssignments?.length ? inputs.envAssignments : void 0],
+		[inputs.appIdEnvVar.name, inputs.appIdEnvVar.value]
+	].filter(([, value]) => value !== void 0).map(([flag]) => flag);
+}
+/**
+* Describes a deploy-all run that stopped at the first failing target: which
+* targets already went live and which were never attempted, so the caller can
+* surface a converge path. Pure; the caller folds this into the CliError.
+*/
+function describeDeployAllFailure(options) {
+	const { targetKeys, failedIndex, completed } = options;
+	const failedTarget = targetKeys[failedIndex];
+	const notAttempted = targetKeys.slice(failedIndex + 1);
+	return {
+		failedTarget,
+		completed,
+		notAttempted,
+		contextLines: [
+			`Deploying all apps stopped at "${failedTarget}" (${failedIndex + 1}/${targetKeys.length}).`,
+			...completed.length > 0 ? [`Already live: ${completed.map((entry) => entry.target).join(", ")}.`] : [],
+			...notAttempted.length > 0 ? [`Not attempted: ${notAttempted.join(", ")}.`] : []
+		]
+	};
+}
+//#endregion
+export { describeDeployAllFailure, perAppInputsForDeployAll, planAppDeploy };

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

@@ -1,25 +1,9 @@
-import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import { access } from "node:fs/promises";
+import { resolveBunEntrypoint } from "./bun-project.js";
+import "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 //#region src/lib/app/local-dev.ts
-const NEXT_CONFIG_FILENAMES = [
-	"next.config.js",
-	"next.config.mjs",
-	"next.config.ts",
-	"next.config.mts"
-];
 const DEFAULT_LOCAL_DEV_PORT = 3e3;
-async function resolveLocalBuildType(appPath, buildType) {
-	if (buildType === "bun" || buildType === "nextjs") return buildType;
-	if (buildType !== "auto") return null;
-	return detectLocalBuildType(appPath);
-}
-async function detectLocalBuildType(appPath) {
-	if (await isNextProject(appPath)) return "nextjs";
-	if (await isBunProject(appPath)) return "bun";
-	return null;
-}
 async function runLocalApp(options) {
 	const spawnImpl = options.spawnImpl ?? spawn;
 	if (options.buildType === "nextjs") {
@@ -58,7 +42,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 +54,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 +64,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,33 +76,6 @@ 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 isBunProject(appPath) {
-	try {
-		await access(path.join(appPath, "bun.lock"));
-		return true;
-	} catch {}
-	try {
-		await access(path.join(appPath, "bun.lockb"));
-		return true;
-	} catch {}
-	const packageJson = await readBunPackageJson(appPath);
-	if (!packageJson) return false;
-	const hasEntrypoint = typeof readBunPackageEntrypoint(packageJson) === "string";
-	const hasBunDependency = hasDependency(packageJson, "@types/bun") || hasDependency(packageJson, "bun");
-	const usesBunScripts = (typeof packageJson.scripts === "object" && packageJson.scripts !== null ? Object.values(packageJson.scripts) : []).some((value) => typeof value === "string" && /\bbun\b/.test(value));
-	return hasEntrypoint && (hasBunDependency || usesBunScripts);
-}
-function hasDependency(packageJson, dependencyName) {
-	if (!packageJson) return false;
-	return [packageJson.dependencies, packageJson.devDependencies].some((group) => typeof group === "object" && group !== null && dependencyName in group);
-}
 async function runWithFallback(candidates, options, spawnImpl, missingCommandMessage) {
 	for (const candidate of candidates) try {
 		const result = await spawnCommand(candidate, options, spawnImpl);
@@ -147,4 +106,4 @@ function spawnCommand(candidate, options, spawnImpl) {
 	});
 }
 //#endregion
-export { DEFAULT_LOCAL_DEV_PORT, resolveLocalBuildType, runLocalApp };
+export { DEFAULT_LOCAL_DEV_PORT, runLocalApp };

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 };