@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.5

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

@@ -0,0 +1,316 @@
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region src/lib/app/branch-database.ts
+const SKIPPED_DIRECTORIES = new Set([
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".prisma",
+	".turbo",
+	".vercel",
+	".wrangler",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out"
+]);
+const DATABASE_URL_SCAN_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".env",
+	".js",
+	".json",
+	".jsx",
+	".mjs",
+	".mts",
+	".prisma",
+	".ts",
+	".tsx"
+]);
+const MAX_SCAN_DEPTH = 6;
+const MAX_SCAN_FILES = 1e3;
+const MAX_DATABASE_URL_REFERENCE_FILES = 10;
+const MAX_TEXT_FILE_BYTES = 1024 * 1024;
+async function inspectBranchDatabaseSignal(cwd, signal) {
+	const state = {
+		filesVisited: 0,
+		schemaCandidates: [],
+		prismaNextConfigCandidates: [],
+		databaseUrlReferences: []
+	};
+	await scanDirectory(cwd, cwd, 0, state, signal);
+	const prismaNextConfigs = await Promise.all(state.prismaNextConfigCandidates.map((configPath) => classifyPrismaNextConfig(configPath, signal)));
+	const supportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "supported");
+	const unsupportedPrismaNextConfig = selectPrismaNextConfig(cwd, prismaNextConfigs, "unsupported");
+	const selectedPrismaOrmSchema = await selectPrismaOrmSchema(cwd, state.schemaCandidates, signal);
+	const schema = supportedPrismaNextConfig ? {
+		kind: "prisma-next",
+		path: supportedPrismaNextConfig.path,
+		hasMigrations: false,
+		command: "prisma-next-db-init",
+		target: supportedPrismaNextConfig.target
+	} : selectedPrismaOrmSchema.schema;
+	return {
+		schema,
+		unsupportedSchema: schema ? null : unsupportedPrismaNextConfig ? {
+			kind: "prisma-next",
+			path: unsupportedPrismaNextConfig.path,
+			target: unsupportedPrismaNextConfig.target
+		} : selectedPrismaOrmSchema.unsupportedSchema,
+		databaseUrlReferences: state.databaseUrlReferences
+	};
+}
+function hasBranchDatabaseSignal(signal) {
+	if (signal.unsupportedSchema) return false;
+	return Boolean(signal.schema || signal.databaseUrlReferences.length > 0);
+}
+async function runBranchDatabaseSchemaSetup(options) {
+	const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || defaultSchemaSourcePath(options.schema);
+	const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl);
+	for (const command of commands) await runPrismaCommand({
+		context: options.context,
+		...command,
+		env: {
+			DATABASE_URL: options.databaseUrl,
+			...options.directUrl ? { DIRECT_URL: options.directUrl } : {}
+		}
+	});
+	return {
+		command: options.schema.command,
+		source: options.schema.kind,
+		schemaPath
+	};
+}
+async function scanDirectory(cwd, directory, depth, state, signal) {
+	signal.throwIfAborted();
+	if (depth > MAX_SCAN_DEPTH || state.filesVisited >= MAX_SCAN_FILES) return;
+	let entries;
+	try {
+		entries = await readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	entries.sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		signal.throwIfAborted();
+		if (state.filesVisited >= MAX_SCAN_FILES) return;
+		const entryPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) {
+			if (!SKIPPED_DIRECTORIES.has(entry.name)) await scanDirectory(cwd, entryPath, depth + 1, state, signal);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		state.filesVisited += 1;
+		if (entry.name === "schema.prisma") state.schemaCandidates.push(entryPath);
+		if (isPrismaNextConfigFile(entry.name)) state.prismaNextConfigCandidates.push(entryPath);
+		if (state.databaseUrlReferences.length < MAX_DATABASE_URL_REFERENCE_FILES && shouldScanForDatabaseUrl(entry.name) && await fileContainsDatabaseUrl(entryPath, signal)) state.databaseUrlReferences.push(path.relative(cwd, entryPath) || entry.name);
+	}
+}
+async function selectPrismaOrmSchema(cwd, candidates, signal) {
+	const sorted = sortByPreferredRelativePath(cwd, candidates, "schema.prisma");
+	for (const schemaPath of sorted) {
+		const target = await classifyPrismaOrmSchemaTarget(schemaPath, signal);
+		if (target === "postgresql" || target === "unknown") {
+			const hasMigrations = await hasMigrationsDirectory(path.dirname(schemaPath), signal);
+			return {
+				schema: {
+					kind: "prisma-orm",
+					path: schemaPath,
+					hasMigrations,
+					command: hasMigrations ? "migrate-deploy" : "db-push",
+					target
+				},
+				unsupportedSchema: null
+			};
+		}
+		return {
+			schema: null,
+			unsupportedSchema: {
+				kind: "prisma-orm",
+				path: schemaPath,
+				target
+			}
+		};
+	}
+	return {
+		schema: null,
+		unsupportedSchema: null
+	};
+}
+function selectPrismaNextConfig(cwd, candidates, mode) {
+	const matches = candidates.filter((candidate) => {
+		const isSupported = candidate.target === "postgresql" || candidate.target === "unknown";
+		return mode === "supported" ? isSupported : !isSupported;
+	});
+	return sortByPreferredRelativePath(cwd, matches.map((candidate) => candidate.path), "prisma-next.config.ts").map((candidatePath) => matches.find((candidate) => candidate.path === candidatePath)).find((candidate) => Boolean(candidate)) ?? null;
+}
+function sortByPreferredRelativePath(cwd, candidates, preferredRootFile) {
+	return candidates.map((candidate) => ({
+		absolute: candidate,
+		relative: path.relative(cwd, candidate) || preferredRootFile
+	})).sort((left, right) => {
+		if (left.relative === preferredRootFile) return -1;
+		if (right.relative === preferredRootFile) return 1;
+		return left.relative.length - right.relative.length || left.relative.localeCompare(right.relative);
+	}).map((candidate) => candidate.absolute);
+}
+async function hasMigrationsDirectory(schemaDirectory, signal) {
+	signal.throwIfAborted();
+	const migrationsPath = path.join(schemaDirectory, "migrations");
+	try {
+		await access(migrationsPath);
+		return (await readdir(migrationsPath)).length > 0;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function classifyPrismaNextConfig(configPath, signal) {
+	const content = await readTextFileIfSmall(configPath, signal);
+	if (!content) return {
+		path: configPath,
+		target: "unknown"
+	};
+	if (content.includes("@prisma-next/postgres/config")) return {
+		path: configPath,
+		target: "postgresql"
+	};
+	if (content.includes("@prisma-next/mongo/config")) return {
+		path: configPath,
+		target: "mongodb"
+	};
+	if (content.includes("@prisma-next/sqlite/config")) return {
+		path: configPath,
+		target: "sqlite"
+	};
+	return {
+		path: configPath,
+		target: "unknown"
+	};
+}
+async function classifyPrismaOrmSchemaTarget(schemaPath, signal) {
+	switch ((await readTextFileIfSmall(schemaPath, signal))?.match(/\bprovider\s*=\s*"([^"]+)"/)?.[1] ?? null) {
+		case "postgresql": return "postgresql";
+		case "mongodb": return "mongodb";
+		case "mysql": return "mysql";
+		case "sqlite": return "sqlite";
+		case "sqlserver": return "sqlserver";
+		case "cockroachdb": return "cockroachdb";
+		default: return "unknown";
+	}
+}
+function shouldScanForDatabaseUrl(fileName) {
+	if (fileName === ".env" || fileName.startsWith(".env.")) return true;
+	return DATABASE_URL_SCAN_EXTENSIONS.has(path.extname(fileName));
+}
+function isPrismaNextConfigFile(fileName) {
+	if (!fileName.startsWith("prisma-next.config.")) return false;
+	return [
+		".cjs",
+		".cts",
+		".js",
+		".mjs",
+		".mts",
+		".ts"
+	].some((extension) => fileName.endsWith(extension));
+}
+async function fileContainsDatabaseUrl(filePath, signal) {
+	return (await readTextFileIfSmall(filePath, signal))?.includes("DATABASE_URL") ?? false;
+}
+async function readTextFileIfSmall(filePath, signal) {
+	signal.throwIfAborted();
+	if ((await stat(filePath)).size > MAX_TEXT_FILE_BYTES) return null;
+	return readFile(filePath, {
+		encoding: "utf8",
+		signal
+	});
+}
+function buildSchemaSetupCommands(schema, schemaPath, databaseUrl) {
+	if (schema.command === "migrate-deploy") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"migrate",
+			"deploy",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma migrate deploy"
+	}];
+	if (schema.command === "db-push") return [{
+		args: [
+			"--no-install",
+			"prisma",
+			"db",
+			"push",
+			"--schema",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma db push"
+	}];
+	return [{
+		args: [
+			"--no-install",
+			"prisma-next",
+			"contract",
+			"emit",
+			"--config",
+			schemaPath
+		],
+		displayCommand: "npx --no-install prisma-next contract emit"
+	}, {
+		args: [
+			"--no-install",
+			"prisma-next",
+			"db",
+			"init",
+			"--config",
+			schemaPath,
+			"--db",
+			databaseUrl
+		],
+		displayCommand: "npx --no-install prisma-next db init"
+	}];
+}
+function defaultSchemaSourcePath(schema) {
+	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
+}
+async function runPrismaCommand(options) {
+	const shouldPipeOutput = !options.context.flags.json && !options.context.flags.quiet;
+	const child = spawn("npx", options.args, {
+		cwd: options.context.runtime.cwd,
+		env: {
+			...options.context.runtime.env,
+			...options.env
+		},
+		signal: options.context.runtime.signal,
+		stdio: shouldPipeOutput ? [
+			"ignore",
+			"pipe",
+			"pipe"
+		] : [
+			"ignore",
+			"ignore",
+			"ignore"
+		]
+	});
+	if (shouldPipeOutput) {
+		child.stdout?.pipe(options.context.output.stderr, { end: false });
+		child.stderr?.pipe(options.context.output.stderr, { end: false });
+	}
+	const exit = await new Promise((resolve, reject) => {
+		child.once("error", reject);
+		child.once("close", (code, signal) => resolve({
+			code,
+			signal
+		}));
+	});
+	if (exit.signal) throw new Error(`${options.displayCommand} was terminated by ${exit.signal}.`);
+	if (exit.code !== 0) throw new Error(`${options.displayCommand} exited with code ${exit.code ?? 1}.`);
+}
+//#endregion
+export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal, runBranchDatabaseSchemaSetup };

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.", [`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);
+	} 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/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 };

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

@@ -1,5 +1,6 @@
 import { envVarNames } from "./env-vars.js";
 import { PreviewBuildStrategy } from "./preview-build.js";
+import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./preview-branch-database.js";
 import path from "node:path";
 import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
@@ -36,6 +37,36 @@ function createPreviewAppProvider(client, options) {
 				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,
@@ -316,17 +347,19 @@ async function listBranches(client, options) {
 		signal: options.signal
 	});
 	if (result.error || !result.data) throw apiCallError("Failed to list branches", result.response, result.error);
-	return result.data.data;
+	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,
-			isDefault: options.gitName === "main"
-		},
+		body: { gitName: options.gitName },
 		signal: options.signal
 	});
 	if (result.error || !result.data) {
@@ -336,7 +369,13 @@ async function resolveOrCreateBranch(client, options) {
 		}
 		throw apiCallError(`Failed to create branch "${options.gitName}"`, result.response, result.error);
 	}
-	return result.data.data;
+	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 = [];