@prisma/cli 8.0.0-rc.1 → 8.0.0-rc.2-dev.49

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

@@ -1,617 +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,
-				region: options.region,
-				signal: options.signal
-			});
-			if (projectResult.isErr()) throw new Error(projectResult.error.message);
-			return {
-				id: projectResult.value.id,
-				name: projectResult.value.name,
-				defaultRegion: projectResult.value.defaultRegion
-			};
-		},
-		async listApps(projectId, options) {
-			return listComputeServices(client, {
-				projectId,
-				branchGitName: options?.branchName,
-				signal: options?.signal
-			});
-		},
-		async createApp(options) {
-			return createComputeService(client, {
-				projectId: options.projectId,
-				branchName: options.branchName,
-				displayName: options.name,
-				...options.region !== void 0 ? { region: options.region } : {},
-				...options.signal !== void 0 ? { 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.showApp({
-				appId,
-				signal: options?.signal
-			});
-			if (appResult.isErr()) throw new Error(appResult.error.message);
-			const destroyResult = await sdk.destroyApp({
-				appId,
-				keepApp: false,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				signal: options?.signal,
-				progress: options?.progress
-			});
-			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/apps/{appId}/domains", {
-				params: { path: { appId: 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({
-				appId: options.appId,
-				deploymentId: options.deploymentId,
-				timeoutSeconds: 120,
-				pollIntervalMs: 2e3,
-				signal: options.signal,
-				progress: options.progress
-			});
-			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
-		},
-		async startDeployment(options) {
-			const result = await sdk.startDeployment({
-				deploymentId: options.deploymentId,
-				signal: options.signal
-			});
-			if (result.isErr()) throw new Error(result.error.message);
-		},
-		async stopDeployment(options) {
-			const result = await sdk.stopDeployment({
-				deploymentId: options.deploymentId,
-				signal: options.signal
-			});
-			if (result.isErr()) throw new Error(result.error.message);
-		},
-		async deleteDeployment(options) {
-			const result = await sdk.deleteDeployment({
-				deploymentId: options.deploymentId,
-				signal: options.signal
-			});
-			if (result.isErr()) throw new Error(result.error.message);
-		},
-		async readDeployment(options) {
-			const result = await sdk.showDeployment({
-				deploymentId: options.deploymentId,
-				signal: options.signal
-			});
-			if (result.isErr()) throw new Error(result.error.message);
-			return {
-				id: result.value.id,
-				status: result.value.status,
-				createdAt: result.value.createdAt,
-				url: toAbsoluteUrl(result.value.previewDomain ?? null),
-				live: null
-			};
-		},
-		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,
-				appId: resolvedApp.appId,
-				appName: resolvedApp.appName,
-				region: resolvedApp.region,
-				portMapping: options.portMapping,
-				envVars: options.envVars,
-				skipPromote: options.skipPromote,
-				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.appId,
-					name: deployed.appName,
-					region: deployed.region ?? null,
-					liveDeploymentId: deployed.promoted ? deployed.deploymentId : deployed.previousDeploymentId,
-					liveUrl: toAbsoluteUrl(deployed.appEndpointDomain ?? null)
-				},
-				deployment: {
-					id: deployed.deploymentId,
-					status: "running",
-					url: toAbsoluteUrl(deployed.appEndpointDomain ?? deployed.deploymentEndpointDomain ?? null),
-					live: deployed.promoted
-				},
-				promoted: deployed.promoted
-			};
-		},
-		async updateAppEnv(options) {
-			const updateResult = await sdk.updateEnv({
-				appId: 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({
-				appId: options.appId,
-				deploymentId: updateResult.value.deploymentId,
-				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.showApp({
-				appId: options.appId,
-				signal: options.signal
-			}), sdk.showDeployment({
-				deploymentId: updateResult.value.deploymentId,
-				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.latestDeploymentId ?? null,
-					liveUrl: toAbsoluteUrl(serviceResult.value.appEndpointDomain ?? null)
-				},
-				deployment: {
-					id: versionResult.value.id,
-					status: versionResult.value.status,
-					createdAt: versionResult.value.createdAt,
-					url: toAbsoluteUrl(serviceResult.value.appEndpointDomain ?? versionResult.value.previewDomain ?? null),
-					live: true
-				},
-				variables: envVarNames(versionResult.value.envVars)
-			};
-		},
-		async listAppEnvNames(options) {
-			const [serviceResult, versionResult] = await Promise.all([sdk.showApp({
-				appId: options.appId,
-				signal: options.signal
-			}), sdk.showDeployment({
-				deploymentId: 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.latestDeploymentId ?? null,
-					liveUrl: toAbsoluteUrl(serviceResult.value.appEndpointDomain ?? null)
-				},
-				deployment: {
-					id: versionResult.value.id,
-					status: versionResult.value.status,
-					createdAt: versionResult.value.createdAt,
-					url: toAbsoluteUrl(versionResult.value.previewDomain ?? null),
-					live: serviceResult.value.latestDeploymentId === versionResult.value.id
-				},
-				variables: envVarNames(versionResult.value.envVars)
-			};
-		},
-		async listDeployments(appId, options) {
-			const [appResult, versionsResult] = await Promise.all([sdk.showApp({
-				appId,
-				signal: options?.signal
-			}), sdk.listDeployments({
-				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.latestDeploymentId ?? null,
-					liveUrl: toAbsoluteUrl(appResult.value.appEndpointDomain ?? 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.showDeployment({
-				deploymentId,
-				signal: options?.signal
-			});
-			if (deploymentResult.isErr()) {
-				if (ApiError.is(deploymentResult.error) && deploymentResult.error.statusCode === 404) return null;
-				throw new Error(deploymentResult.error.message);
-			}
-			const app = await findAppForDeployment(sdk, deploymentId, options?.signal);
-			const promotedUrl = app !== null && app.liveDeploymentId === deploymentResult.value.id ? app.liveUrl : null;
-			return {
-				app,
-				deployment: {
-					id: deploymentResult.value.id,
-					status: deploymentResult.value.status,
-					createdAt: deploymentResult.value.createdAt,
-					url: promotedUrl ?? 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(),
-				deploymentId: 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/apps", {
-			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(toAppRecord);
-}
-function toAppRecord(service) {
-	return {
-		id: service.id,
-		name: service.name,
-		region: service.region.id ?? null,
-		branchId: service.branchId,
-		liveDeploymentId: service.latestDeploymentId ?? null,
-		liveUrl: toAbsoluteUrl(service.appEndpointDomain ?? null)
-	};
-}
-/**
-* Creates a service on a branch, resolving (or creating) the branch
-* first because the create body needs its id. A name already taken on
-* the branch comes back as the existing service rather than an error:
-* the API answers 409 and the caller asked for a service by that name,
-* which already exists.
-*/
-async function createComputeService(client, options) {
-	const branch = await resolveOrCreateBranch(client, {
-		projectId: options.projectId,
-		gitName: options.branchName,
-		signal: options.signal
-	});
-	const result = await client.POST("/v1/apps", {
-		body: {
-			projectId: options.projectId,
-			branchId: branch.id,
-			displayName: options.displayName,
-			...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((service) => service.name === options.displayName);
-			if (matched) return {
-				service: matched,
-				existing: true
-			};
-		}
-		throw apiCallError(`Failed to create app "${options.displayName}"`, result.response, result.error);
-	}
-	return {
-		service: toAppRecord(result.data.data),
-		existing: false
-	};
-}
-async function listComputeServiceDomains(client, appId, signal) {
-	const result = await client.GET("/v1/apps/{appId}/domains", {
-		params: { path: { appId } },
-		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,
-		appId: domain.appId,
-		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 created = await createComputeService(client, {
-		projectId: options.projectId,
-		branchName: options.branchName,
-		displayName: options.appName,
-		...options.region !== void 0 ? { region: options.region } : {},
-		...options.signal !== void 0 ? { signal: options.signal } : {}
-	});
-	return {
-		appId: created.service.id,
-		appName: created.service.name,
-		region: created.service.region ?? 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.listApps({
-			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.showApp({
-		appId: 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.latestDeploymentId ?? null,
-		liveUrl: toAbsoluteUrl(detailResult.value.appEndpointDomain ?? null)
-	};
-	if (app.liveDeploymentId === deploymentId) return app;
-	const versionsResult = await sdk.listDeployments({
-		appId: 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 };