@prisma/cli 3.0.0-dev.99.1 → 8.0.0-rc.2

package/dist/controllers/select-prompt-port.js

@@ -1,12 +0,0 @@
-import { selectPrompt } from "../shell/prompt.js";
-//#region src/controllers/select-prompt-port.ts
-function createSelectPromptPort(context) {
-	return { select: ({ message, choices }) => selectPrompt({
-		input: context.runtime.stdin,
-		output: context.runtime.stderr,
-		message,
-		choices
-	}) };
-}
-//#endregion
-export { createSelectPromptPort };

package/dist/controllers/version.js

@@ -1,12 +0,0 @@
-import { buildVersionResult } from "../lib/version.js";
-//#region src/controllers/version.ts
-async function runVersion(context) {
-	return {
-		command: "version",
-		result: buildVersionResult(context.runtime.env, context.runtime.argv),
-		warnings: [],
-		nextSteps: []
-	};
-}
-//#endregion
-export { runVersion };

package/dist/lib/app/app-interaction.js

@@ -1,5 +0,0 @@
-import "../../shell/prompt.js";
-//#region src/lib/app/app-interaction.ts
-const DEFAULT_REGION = "eu-central-1";
-//#endregion
-export { DEFAULT_REGION };

package/dist/lib/app/app-provider.js

@@ -1,544 +0,0 @@
-import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./branch-database-api.js";
-import { AppBuildStrategy } from "./build.js";
-import { envVarNames } from "./env-vars.js";
-import path from "node:path";
-import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
-//#region src/lib/app/app-provider.ts
-var DomainApiError = class extends Error {
-	status;
-	code;
-	hint;
-	constructor(options) {
-		super(`${options.summary}: ${options.message}${options.hint ? ` ${options.hint}` : ""}`);
-		this.name = "DomainApiError";
-		this.status = options.status;
-		this.code = options.code ?? null;
-		this.hint = options.hint ?? null;
-	}
-};
-function createAppProvider(client, options) {
-	const sdk = new ComputeClient(client);
-	return {
-		async createProject(options) {
-			const projectResult = await sdk.createProject({
-				name: options.name,
-				signal: options.signal
-			});
-			if (projectResult.isErr()) throw new Error(projectResult.error.message);
-			return {
-				id: projectResult.value.id,
-				name: projectResult.value.name
-			};
-		},
-		async listApps(projectId, options) {
-			return listComputeServices(client, {
-				projectId,
-				branchGitName: options?.branchName,
-				signal: options?.signal
-			});
-		},
-		async resolveBranch(projectId, options) {
-			const branch = await resolveOrCreateBranch(client, {
-				projectId,
-				gitName: options.branchName,
-				signal: options.signal
-			});
-			return {
-				id: branch.id,
-				name: branch.gitName,
-				role: branch.role
-			};
-		},
-		async createBranchDatabase(options) {
-			return createBranchDatabase(client, options);
-		},
-		async deleteBranchDatabase(options) {
-			return deleteBranchDatabase(client, options);
-		},
-		async listEnvironmentVariables(options) {
-			return listEnvironmentVariables(client, options);
-		},
-		async createEnvironmentVariable(options) {
-			return createEnvironmentVariable(client, options);
-		},
-		async updateEnvironmentVariable(options) {
-			return updateEnvironmentVariable(client, options);
-		},
-		async deleteEnvironmentVariable(options) {
-			return deleteEnvironmentVariable(client, options);
-		},
-		async removeApp(appId, options) {
-			const appResult = await sdk.showService({
-				serviceId: appId,
-				signal: options?.signal
-			});
-			if (appResult.isErr()) throw new Error(appResult.error.message);
-			const destroyResult = await sdk.destroyService({
-				serviceId: appId,
-				keepService: false,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				signal: options?.signal
-			});
-			if (destroyResult.isErr()) throw new Error(destroyResult.error.message);
-			return {
-				id: appResult.value.id,
-				name: appResult.value.name
-			};
-		},
-		async listDomains(appId, options) {
-			return listComputeServiceDomains(client, appId, options?.signal);
-		},
-		async addDomain(options) {
-			const result = await client.POST("/v1/compute-services/{computeServiceId}/domains", {
-				params: { path: { computeServiceId: options.appId } },
-				body: { hostname: options.hostname },
-				signal: options.signal
-			});
-			if (result.error || !result.data) {
-				if (result.response.status === 409) {
-					const existing = (await listComputeServiceDomains(client, options.appId, options.signal)).find((domain) => sameHostname(domain.hostname, options.hostname));
-					if (existing) return {
-						domain: existing,
-						existing: true
-					};
-				}
-				throw domainApiCallError("Failed to add custom domain", result.response, result.error);
-			}
-			return {
-				domain: normalizeDomainRecord(result.data.data),
-				existing: false
-			};
-		},
-		async showDomain(domainId, options) {
-			const result = await client.GET("/v1/domains/{domainId}", {
-				params: { path: { domainId } },
-				signal: options?.signal
-			});
-			if (result.error || !result.data) throw domainApiCallError("Failed to show custom domain", result.response, result.error);
-			return normalizeDomainRecord(result.data.data);
-		},
-		async removeDomain(domainId, options) {
-			const result = await client.DELETE("/v1/domains/{domainId}", {
-				params: { path: { domainId } },
-				signal: options?.signal
-			});
-			if (result.error) throw domainApiCallError("Failed to remove custom domain", result.response, result.error);
-		},
-		async retryDomain(domainId, options) {
-			const result = await client.POST("/v1/domains/{domainId}/retry", {
-				params: { path: { domainId } },
-				signal: options?.signal
-			});
-			if (result.error || !result.data) throw domainApiCallError("Failed to retry custom domain", result.response, result.error);
-			return normalizeDomainRecord(result.data.data);
-		},
-		async promoteDeployment(options) {
-			const promoteResult = await sdk.promote({
-				serviceId: options.appId,
-				versionId: options.deploymentId,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				signal: options.signal,
-				progress: options.progress
-			});
-			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
-		},
-		async deployApp(options) {
-			const resolvedApp = options.appId ? {
-				appId: options.appId,
-				appName: options.appName,
-				region: options.region
-			} : options.branchName && options.appName ? await createBranchApp(client, {
-				projectId: options.projectId,
-				branchName: options.branchName,
-				appName: options.appName,
-				region: options.region,
-				signal: options.signal
-			}) : {
-				appId: void 0,
-				appName: options.appName,
-				region: options.region
-			};
-			const deployResult = await sdk.deploy({
-				strategy: new AppBuildStrategy({
-					appPath: path.resolve(options.cwd),
-					entrypoint: options.entrypoint,
-					buildType: options.buildType,
-					signal: options.signal,
-					buildSettings: options.buildSettings
-				}),
-				projectId: options.projectId,
-				serviceId: resolvedApp.appId,
-				serviceName: resolvedApp.appName,
-				region: resolvedApp.region,
-				portMapping: options.portMapping,
-				envVars: options.envVars,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				interaction: options.interaction,
-				signal: options.signal,
-				progress: options.progress
-			});
-			if (deployResult.isErr()) throw new Error(deployResult.error.message);
-			const deployed = deployResult.value;
-			return {
-				projectId: deployed.projectId,
-				app: {
-					id: deployed.serviceId,
-					name: deployed.serviceName,
-					region: deployed.region ?? null,
-					liveDeploymentId: deployed.versionId,
-					liveUrl: toAbsoluteUrl(deployed.serviceEndpointDomain ?? null)
-				},
-				deployment: {
-					id: deployed.versionId,
-					status: "running",
-					url: toAbsoluteUrl(deployed.serviceEndpointDomain ?? deployed.versionEndpointDomain ?? null)
-				}
-			};
-		},
-		async updateAppEnv(options) {
-			const updateResult = await sdk.updateEnv({
-				serviceId: options.appId,
-				envVars: options.envVars,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				signal: options.signal,
-				progress: options.progress
-			});
-			if (updateResult.isErr()) throw new Error(updateResult.error.message);
-			const promoteResult = await sdk.promote({
-				serviceId: options.appId,
-				versionId: updateResult.value.versionId,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				signal: options.signal,
-				progress: options.promoteProgress
-			});
-			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
-			const [serviceResult, versionResult] = await Promise.all([sdk.showService({
-				serviceId: options.appId,
-				signal: options.signal
-			}), sdk.showVersion({
-				versionId: updateResult.value.versionId,
-				signal: options.signal
-			})]);
-			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
-			if (versionResult.isErr()) throw new Error(versionResult.error.message);
-			return {
-				projectId: updateResult.value.projectId,
-				app: {
-					id: serviceResult.value.id,
-					name: serviceResult.value.name,
-					region: serviceResult.value.region ?? null,
-					liveDeploymentId: serviceResult.value.latestVersionId ?? null,
-					liveUrl: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? null)
-				},
-				deployment: {
-					id: versionResult.value.id,
-					status: versionResult.value.status,
-					createdAt: versionResult.value.createdAt,
-					url: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? versionResult.value.previewDomain ?? null),
-					live: true
-				},
-				variables: envVarNames(versionResult.value.envVars)
-			};
-		},
-		async listAppEnvNames(options) {
-			const [serviceResult, versionResult] = await Promise.all([sdk.showService({
-				serviceId: options.appId,
-				signal: options.signal
-			}), sdk.showVersion({
-				versionId: options.deploymentId,
-				signal: options.signal
-			})]);
-			if (serviceResult.isErr()) throw new Error(serviceResult.error.message);
-			if (versionResult.isErr()) throw new Error(versionResult.error.message);
-			return {
-				projectId: serviceResult.value.projectId,
-				app: {
-					id: serviceResult.value.id,
-					name: serviceResult.value.name,
-					region: serviceResult.value.region ?? null,
-					liveDeploymentId: serviceResult.value.latestVersionId ?? null,
-					liveUrl: toAbsoluteUrl(serviceResult.value.serviceEndpointDomain ?? null)
-				},
-				deployment: {
-					id: versionResult.value.id,
-					status: versionResult.value.status,
-					createdAt: versionResult.value.createdAt,
-					url: toAbsoluteUrl(versionResult.value.previewDomain ?? null),
-					live: serviceResult.value.latestVersionId === versionResult.value.id
-				},
-				variables: envVarNames(versionResult.value.envVars)
-			};
-		},
-		async listDeployments(appId, options) {
-			const [appResult, versionsResult] = await Promise.all([sdk.showService({
-				serviceId: appId,
-				signal: options?.signal
-			}), sdk.listVersions({
-				serviceId: appId,
-				signal: options?.signal
-			})]);
-			if (appResult.isErr()) throw new Error(appResult.error.message);
-			if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
-			return {
-				app: {
-					id: appResult.value.id,
-					name: appResult.value.name,
-					region: appResult.value.region ?? null,
-					liveDeploymentId: appResult.value.latestVersionId ?? null,
-					liveUrl: toAbsoluteUrl(appResult.value.serviceEndpointDomain ?? null)
-				},
-				deployments: versionsResult.value.slice().sort((left, right) => {
-					const byDate = right.createdAt.localeCompare(left.createdAt);
-					return byDate !== 0 ? byDate : right.id.localeCompare(left.id);
-				}).map((deployment) => ({
-					id: deployment.id,
-					status: deployment.status,
-					createdAt: deployment.createdAt,
-					url: toAbsoluteUrl(deployment.previewDomain ?? null),
-					live: null
-				}))
-			};
-		},
-		async showDeployment(deploymentId, options) {
-			const deploymentResult = await sdk.showVersion({
-				versionId: deploymentId,
-				signal: options?.signal
-			});
-			if (deploymentResult.isErr()) {
-				if (ApiError.is(deploymentResult.error) && deploymentResult.error.statusCode === 404) return null;
-				throw new Error(deploymentResult.error.message);
-			}
-			return {
-				app: await findAppForDeployment(sdk, deploymentId, options?.signal),
-				deployment: {
-					id: deploymentResult.value.id,
-					status: deploymentResult.value.status,
-					createdAt: deploymentResult.value.createdAt,
-					url: toAbsoluteUrl(deploymentResult.value.previewDomain ?? null),
-					live: null
-				}
-			};
-		},
-		async streamDeploymentLogs(streamOptions) {
-			if (!options?.baseUrl || !options.getToken) throw new Error("Log streaming requires an authenticated API base URL and token.");
-			const result = await streamLogs({
-				baseUrl: options.baseUrl,
-				token: await options.getToken(),
-				versionId: streamOptions.deploymentId,
-				signal: streamOptions.signal
-			}, streamOptions.onRecord);
-			if (result.isErr()) {
-				if (CancelledError.is(result.error)) return;
-				throw result.error;
-			}
-		}
-	};
-}
-async function listBranches(client, options) {
-	const result = await client.GET("/v1/projects/{projectId}/branches", {
-		params: {
-			path: { projectId: options.projectId },
-			query: { gitName: options.gitName }
-		},
-		signal: options.signal
-	});
-	if (result.error || !result.data) throw apiCallError("Failed to list branches", result.response, result.error);
-	return result.data.data.map((branch) => ({
-		id: branch.id,
-		gitName: branch.gitName,
-		isDefault: branch.isDefault,
-		role: branch.role
-	}));
-}
-async function resolveOrCreateBranch(client, options) {
-	const existing = (await listBranches(client, options))[0];
-	if (existing) return existing;
-	const result = await client.POST("/v1/projects/{projectId}/branches", {
-		params: { path: { projectId: options.projectId } },
-		body: { gitName: options.gitName },
-		signal: options.signal
-	});
-	if (result.error || !result.data) {
-		if (result.response.status === 409) {
-			const raced = (await listBranches(client, options))[0];
-			if (raced) return raced;
-		}
-		throw apiCallError(`Failed to create branch "${options.gitName}"`, result.response, result.error);
-	}
-	const branch = result.data.data;
-	return {
-		id: branch.id,
-		gitName: branch.gitName,
-		isDefault: branch.isDefault,
-		role: branch.role
-	};
-}
-async function listComputeServices(client, options) {
-	const services = [];
-	let cursor;
-	while (true) {
-		const result = await client.GET("/v1/compute-services", {
-			params: { query: {
-				projectId: options.projectId,
-				branchGitName: options.branchGitName,
-				cursor
-			} },
-			signal: options.signal
-		});
-		if (result.error || !result.data) throw apiCallError("Failed to list apps", result.response, result.error);
-		services.push(...result.data.data);
-		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
-		cursor = result.data.pagination.nextCursor;
-	}
-	return services.map((service) => ({
-		id: service.id,
-		name: service.name,
-		region: service.region.id ?? null,
-		branchId: service.branchId,
-		liveDeploymentId: service.latestVersionId ?? null,
-		liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
-	}));
-}
-async function listComputeServiceDomains(client, computeServiceId, signal) {
-	const result = await client.GET("/v1/compute-services/{computeServiceId}/domains", {
-		params: { path: { computeServiceId } },
-		signal
-	});
-	if (result.error || !result.data) throw domainApiCallError("Failed to list custom domains", result.response, result.error);
-	return result.data.data.map((domain) => normalizeDomainRecord(domain));
-}
-function normalizeDomainRecord(domain) {
-	return {
-		id: domain.id,
-		type: domain.type,
-		url: domain.url,
-		hostname: domain.hostname,
-		computeServiceId: domain.computeServiceId,
-		status: domain.status,
-		foundryStatus: domain.foundryStatus,
-		failureReason: domain.failureReason,
-		failureCategory: domain.failureCategory,
-		certExpiresAt: domain.certExpiresAt,
-		createdAt: domain.createdAt,
-		updatedAt: domain.updatedAt,
-		dnsRecords: normalizeDomainDnsRecords(domain.dnsRecords)
-	};
-}
-function normalizeDomainDnsRecords(records) {
-	if (!Array.isArray(records)) return [];
-	return records.map((record) => {
-		if (typeof record.type !== "string" || typeof record.name !== "string" || typeof record.value !== "string") return null;
-		return {
-			type: record.type,
-			name: record.name,
-			value: record.value,
-			ttl: typeof record.ttl === "number" ? record.ttl : null
-		};
-	}).filter((record) => Boolean(record));
-}
-function sameHostname(left, right) {
-	return normalizeHostnameForComparison(left) === normalizeHostnameForComparison(right);
-}
-function normalizeHostnameForComparison(hostname) {
-	return hostname.trim().replace(/\.$/, "").toLowerCase();
-}
-async function createBranchApp(client, options) {
-	const branch = await resolveOrCreateBranch(client, {
-		projectId: options.projectId,
-		gitName: options.branchName,
-		signal: options.signal
-	});
-	const result = await client.POST("/v1/compute-services", {
-		body: {
-			projectId: options.projectId,
-			branchId: branch.id,
-			displayName: options.appName,
-			...options.region ? { regionId: options.region } : {}
-		},
-		signal: options.signal
-	});
-	if (result.error || !result.data) {
-		if (result.response.status === 409) {
-			const matched = (await listComputeServices(client, {
-				projectId: options.projectId,
-				branchGitName: options.branchName,
-				signal: options.signal
-			})).find((app) => app.name === options.appName);
-			if (matched) return {
-				appId: matched.id,
-				appName: matched.name,
-				region: matched.region ?? options.region
-			};
-		}
-		throw apiCallError(`Failed to create app "${options.appName}"`, result.response, result.error);
-	}
-	const service = result.data.data;
-	return {
-		appId: service.id,
-		appName: service.name,
-		region: service.region.id ?? options.region
-	};
-}
-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}`);
-}
-function domainApiCallError(summary, response, error) {
-	return new DomainApiError({
-		summary,
-		status: response.status,
-		code: error.error?.code ?? null,
-		message: error.error?.message ?? `Management API returned HTTP ${response.status}.`,
-		hint: error.error?.hint ?? null
-	});
-}
-async function findAppForDeployment(sdk, deploymentId, signal) {
-	const projectsResult = await sdk.listProjects({ signal });
-	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);
-	for (const project of projectsResult.value) {
-		const servicesResult = await sdk.listServices({
-			projectId: project.id,
-			signal
-		});
-		if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
-		for (const service of servicesResult.value) {
-			const app = await findServiceAppForDeployment(sdk, service.id, deploymentId, signal);
-			if (app) return app;
-		}
-	}
-	return null;
-}
-async function findServiceAppForDeployment(sdk, serviceId, deploymentId, signal) {
-	const detailResult = await sdk.showService({
-		serviceId,
-		signal
-	});
-	if (detailResult.isErr()) throw new Error(detailResult.error.message);
-	const app = {
-		id: detailResult.value.id,
-		name: detailResult.value.name,
-		region: detailResult.value.region ?? null,
-		liveDeploymentId: detailResult.value.latestVersionId ?? null,
-		liveUrl: toAbsoluteUrl(detailResult.value.serviceEndpointDomain ?? null)
-	};
-	if (app.liveDeploymentId === deploymentId) return app;
-	const versionsResult = await sdk.listVersions({
-		serviceId,
-		signal
-	});
-	if (versionsResult.isErr()) throw new Error(versionsResult.error.message);
-	return versionsResult.value.some((version) => version.id === deploymentId) ? app : null;
-}
-function toAbsoluteUrl(url) {
-	if (!url) return null;
-	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
-}
-//#endregion
-export { DomainApiError, createAppProvider };

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

@@ -1,102 +0,0 @@
-//#region src/lib/app/branch-database-api.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 };