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

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

@@ -1,325 +0,0 @@
-import { CliError, usageError } from "../../shell/errors.js";
-import { confirmPrompt } from "../../shell/prompt.js";
-import { renderSummaryLine } from "../../shell/ui.js";
-import { canPrompt } from "../../shell/runtime.js";
-import { formatCommandArgument } from "../../shell/command-arguments.js";
-import "../project/setup.js";
-import { hasBranchDatabaseSignal, inspectBranchDatabaseSignal } from "./branch-database.js";
-import path from "node:path";
-//#region src/lib/app/branch-database-deploy.ts
-async function maybeSetupBranchDatabase(context, provider, projectId, branch, options) {
-	if (options.db === false) return emptyBranchDatabaseSetupOutcome();
-	if (hasProvidedDatabaseEnvVars(options.providedEnvVars)) {
-		if (options.db === true) throw usageError("Database setup cannot be combined with provided database env vars", "The deploy command received --db and a DATABASE_URL or DIRECT_URL value from --env.", "Remove the --env database value to let --db create and wire a database, or remove --db to deploy with the provided value.", ["prisma-cli app deploy --db", "prisma-cli app deploy --env DATABASE_URL=postgresql://example"], "app");
-		return emptyBranchDatabaseSetupOutcome();
-	}
-	if (branch.kind === "production" && !options.firstProductionDeploy) {
-		if (options.db === true) throw productionDatabaseSetupAfterFirstDeployError();
-		return emptyBranchDatabaseSetupOutcome();
-	}
-	const envState = await inspectBranchDatabaseEnv(provider, projectId, branch, context.runtime.signal);
-	const targetEnvVars = getTargetDatabaseEnvVarKeys(envState);
-	if (hasExistingDatabaseEnvForTarget(branch, envState)) {
-		const warning = options.db === true ? existingDatabaseEnvWarning(branch, targetEnvVars) : null;
-		if (warning) emitBranchDatabaseWarning(context, warning);
-		return {
-			result: options.db === true ? {
-				status: "skipped",
-				reason: existingDatabaseEnvReason(branch),
-				envVars: targetEnvVars
-			} : void 0,
-			warnings: warning ? [warning] : []
-		};
-	}
-	const localSignal = await inspectBranchDatabaseSignal(options.projectDir, context.runtime.signal);
-	if (localSignal.unsupportedSchema) {
-		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch, context);
-		return emptyBranchDatabaseSetupOutcome();
-	}
-	const hasSignal = hasBranchDatabaseSignal(localSignal) || Boolean(envState.inheritedPreviewDatabaseUrl);
-	if (options.db !== true) {
-		if (!hasSignal) return emptyBranchDatabaseSetupOutcome();
-		if (!canPrompt(context) || context.flags.yes) {
-			const warning = databasePromptSuppressedWarning(branch);
-			emitBranchDatabaseWarning(context, warning);
-			return {
-				result: void 0,
-				warnings: [warning]
-			};
-		}
-		maybeRenderBranchDatabaseSignal(context, branch, localSignal, envState);
-		if (!await confirmPrompt({
-			input: context.runtime.stdin,
-			output: context.output.stderr,
-			message: databasePromptMessage(branch),
-			initialValue: false
-		})) return emptyBranchDatabaseSetupOutcome();
-	} else if (!canPrompt(context) && !context.flags.yes) throw nonInteractiveDatabaseSetupRequiresYesError(branch);
-	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState, options.projectDir);
-}
-async function setupBranchDatabase(context, provider, projectId, branch, signal, envState, projectDir) {
-	emitBranchDatabaseProgress(context, "pending", "Creating database");
-	const database = await provider.createBranchDatabase({
-		projectId,
-		branchId: branch.id,
-		branchName: branch.name,
-		signal: context.runtime.signal
-	}).catch((error) => {
-		throw branchDatabaseSetupFailedError("Failed to create database", error, branch);
-	});
-	emitBranchDatabaseProgress(context, "success", "Created database");
-	try {
-		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
-		emitBranchDatabaseProgress(context, "success", `Added ${envScopeLabel(branch)} env var${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")} — shared by every app on ${envScopeLabel(branch) === "production" ? "production" : `branch "${branch.name}"`}`);
-		const schemaCommand = signal.schema ? `DATABASE_URL=<url> npx ${formatSchemaSetupCommand(signal.schema.command)} (detected ${path.relative(projectDir, signal.schema.path) || signal.schema.path})` : "your own migration tooling";
-		const schemaSuggestion = `The new database is empty. Get a connection URL with \`prisma-cli database connection create ${database.id}\`, then apply your schema with ${schemaCommand}.`;
-		emitBranchDatabaseWarning(context, schemaSuggestion);
-		return {
-			result: {
-				status: "created",
-				database: {
-					id: database.id,
-					name: database.name
-				},
-				envVars
-			},
-			warnings: [schemaSuggestion]
-		};
-	} catch (error) {
-		throw await cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch, error);
-	}
-}
-async function upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState) {
-	const scope = envScopeForBranch(branch);
-	const written = [];
-	await upsertBranchDatabaseEnvVar(context, provider, {
-		projectId,
-		...scope,
-		key: "DATABASE_URL",
-		value: database.databaseUrl,
-		existing: envState.targetDatabaseUrl,
-		branch
-	});
-	written.push("DATABASE_URL");
-	if (database.directUrl) {
-		await upsertBranchDatabaseEnvVar(context, provider, {
-			projectId,
-			...scope,
-			key: "DIRECT_URL",
-			value: database.directUrl,
-			existing: envState.targetDirectUrl,
-			branch
-		});
-		written.push("DIRECT_URL");
-	} else if (branch.kind === "preview" && envState.targetDirectUrl) await provider.deleteEnvironmentVariable({
-		envVarId: envState.targetDirectUrl.id,
-		signal: context.runtime.signal
-	}).catch((error) => {
-		throw branchDatabaseSetupFailedError("Failed to remove stale DIRECT_URL", error, branch);
-	});
-	return written;
-}
-async function upsertBranchDatabaseEnvVar(context, provider, options) {
-	if (options.existing) {
-		await provider.updateEnvironmentVariable({
-			envVarId: options.existing.id,
-			value: options.value,
-			signal: context.runtime.signal
-		}).catch((error) => {
-			throw branchDatabaseSetupFailedError(`Failed to update ${options.key}`, error, options.branch);
-		});
-		return;
-	}
-	await provider.createEnvironmentVariable({
-		projectId: options.projectId,
-		className: options.className,
-		key: options.key,
-		value: options.value,
-		...options.branchId ? { branchId: options.branchId } : {},
-		signal: context.runtime.signal
-	}).catch((error) => {
-		throw branchDatabaseSetupFailedError(`Failed to write ${options.key}`, error, options.branch);
-	});
-}
-async function inspectBranchDatabaseEnv(provider, projectId, branch, signal) {
-	const scope = envScopeForBranch(branch);
-	const [databaseUrlRows, directUrlRows] = await Promise.all([provider.listEnvironmentVariables({
-		projectId,
-		className: scope.className,
-		key: "DATABASE_URL",
-		signal
-	}), provider.listEnvironmentVariables({
-		projectId,
-		className: scope.className,
-		key: "DIRECT_URL",
-		signal
-	})]);
-	const targetBranchId = branch.kind === "preview" ? branch.id : null;
-	return {
-		targetDatabaseUrl: findEnvVar(databaseUrlRows, { branchId: targetBranchId }),
-		targetDirectUrl: findEnvVar(directUrlRows, { branchId: targetBranchId }),
-		inheritedPreviewDatabaseUrl: branch.kind === "preview" ? findEnvVar(databaseUrlRows, { branchId: null }) : null
-	};
-}
-function findEnvVar(rows, options) {
-	return rows.find((row) => row.branchId === options.branchId) ?? null;
-}
-function hasProvidedDatabaseEnvVars(envVars) {
-	return Boolean(envVars && ("DATABASE_URL" in envVars || "DIRECT_URL" in envVars));
-}
-function envScopeForBranch(branch) {
-	return branch.kind === "production" ? { className: "production" } : {
-		className: "preview",
-		branchId: branch.id
-	};
-}
-function envScopeLabel(branch) {
-	return branch.kind === "production" ? "production" : "branch";
-}
-function getTargetDatabaseEnvVarKeys(envState) {
-	return [envState.targetDatabaseUrl, envState.targetDirectUrl].filter((variable) => Boolean(variable)).map((variable) => variable.key).sort();
-}
-function hasExistingDatabaseEnvForTarget(branch, envState) {
-	if (branch.kind === "production") return Boolean(envState.targetDatabaseUrl || envState.targetDirectUrl);
-	return Boolean(envState.targetDatabaseUrl);
-}
-function existingDatabaseEnvReason(branch) {
-	return branch.kind === "production" ? "production-env-exists" : "branch-env-exists";
-}
-function existingDatabaseEnvWarning(branch, envVars) {
-	if (branch.kind === "production") return `Production already has ${envVars.join(" and ")}. Treating it as BYO database configuration and leaving env vars unchanged.`;
-	return `Branch "${branch.name}" already has DATABASE_URL. Leaving branch database env vars unchanged.`;
-}
-function databasePromptSuppressedWarning(branch) {
-	if (branch.kind === "production") return "This app appears to use DATABASE_URL. Run prisma-cli app deploy --db --yes to create and wire a Prisma Postgres database for this first production deploy.";
-	return "This app appears to use DATABASE_URL. Run prisma-cli app deploy --db to create an isolated database for this preview branch.";
-}
-function databasePromptMessage(branch) {
-	return branch.kind === "production" ? "Create a Prisma Postgres database for production?" : `Create an isolated database for branch "${branch.name}"?`;
-}
-function maybeRenderBranchDatabaseSignal(context, branch, signal, envState) {
-	if (context.flags.json || context.flags.quiet) return;
-	const rows = [
-		signal.schema ? `  Schema  ${path.relative(context.runtime.cwd, signal.schema.path) || defaultSchemaSourcePath(signal.schema)}` : null,
-		signal.databaseUrlReferences.length > 0 ? `  Code    ${signal.databaseUrlReferences.slice(0, 3).join(", ")}` : null,
-		envState.inheritedPreviewDatabaseUrl ? "  Env     preview DATABASE_URL is inherited by this branch" : null
-	].filter((row) => Boolean(row));
-	context.output.stderr.write(`Database signal found for ${databaseTargetLabel(branch)}\n${rows.join("\n")}\n\n`);
-}
-function databaseTargetLabel(branch) {
-	return branch.kind === "production" ? `production branch "${branch.name}"` : `branch "${branch.name}"`;
-}
-function emitBranchDatabaseProgress(context, status, message) {
-	if (context.flags.json || context.flags.quiet) return;
-	const line = status === "pending" ? `${context.ui.warning("◇")} ${message}...` : renderSummaryLine(context.ui, "success", message);
-	context.output.stderr.write(`${line}\n`);
-}
-function emitBranchDatabaseWarning(context, warning) {
-	if (context.flags.json || context.flags.quiet) return;
-	context.output.stderr.write(`${renderSummaryLine(context.ui, "warning", warning)}\n`);
-}
-function emptyBranchDatabaseSetupOutcome() {
-	return {
-		result: void 0,
-		warnings: []
-	};
-}
-function productionDatabaseSetupAfterFirstDeployError() {
-	return usageError("Database setup is only available during the first production deploy", "The selected production app already has a live deployment.", "Use project env commands to manage production DATABASE_URL, or deploy a preview branch with --db.", ["prisma-cli project env add DATABASE_URL=<value> --role production", "prisma-cli app deploy --branch feature/db --db"], "app");
-}
-function nonInteractiveDatabaseSetupRequiresYesError(branch) {
-	return usageError("Database setup requires --yes in non-interactive mode", "The deploy command received --db, but prompts are not available and --yes was not passed.", "Pass --yes together with --db to confirm non-interactive database creation.", [branch.kind === "production" ? "prisma-cli app deploy --prod --db --yes" : `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)} --db --yes`], "app");
-}
-function formatSchemaSetupCommand(command) {
-	switch (command) {
-		case "migrate-deploy": return "prisma migrate deploy";
-		case "db-push": return "prisma db push";
-		case "prisma-next-db-init": return "prisma-next db init";
-	}
-}
-function branchDatabaseSetupFailedError(summary, error, branch) {
-	return new CliError({
-		code: "BRANCH_DATABASE_SETUP_FAILED",
-		domain: "app",
-		summary,
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Retry the command, or create the database and env vars manually with project env commands.",
-		debug: formatDebugDetails(error),
-		meta: { branch: branch.name },
-		exitCode: 1,
-		nextSteps: [formatAppDeployWithDbNextStep(branch), formatProjectEnvListNextStep(branch)]
-	});
-}
-async function cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch, error) {
-	const setupError = error instanceof CliError ? error : branchDatabaseSetupFailedError("Database setup failed", error, branch);
-	emitBranchDatabaseProgress(context, "pending", "Removing database after setup failed");
-	try {
-		await provider.deleteBranchDatabase({
-			databaseId: database.id,
-			signal: context.runtime.signal
-		});
-		emitBranchDatabaseProgress(context, "success", "Removed database after setup failed");
-	} catch (cleanupError) {
-		return branchDatabaseCleanupFailedError(setupError, cleanupError, database, branch);
-	}
-	return setupError;
-}
-function branchDatabaseCleanupFailedError(setupError, cleanupError, database, branch) {
-	const cleanupWhy = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
-	const setupWhy = setupError.why ?? "Database setup failed.";
-	return new CliError({
-		code: setupError.code,
-		domain: setupError.domain,
-		summary: setupError.summary,
-		why: `${setupWhy} Prisma could not delete the created database "${database.name}" (${database.id}): ${cleanupWhy}`,
-		fix: "Delete the created database from Console or contact Prisma support, then rerun deploy with --db.",
-		debug: formatCombinedDebugDetails(setupError, cleanupError),
-		meta: {
-			...setupError.meta,
-			branch: branch.name,
-			databaseId: database.id,
-			databaseName: database.name,
-			cleanupFailed: true
-		},
-		exitCode: setupError.exitCode,
-		nextSteps: []
-	});
-}
-function unsupportedBranchDatabaseSchemaError(schema, branch, context) {
-	return usageError("Database setup is not available for this Prisma schema", `${path.relative(context.runtime.cwd, schema.path) || defaultUnsupportedSchemaSourcePath(schema)} targets ${formatUnsupportedSchemaTarget(schema.target)}, but --db creates Prisma Postgres databases.`, "Use project env commands to provide a database URL, or switch the Prisma schema source to PostgreSQL before using --db.", [formatProjectEnvAddNextStep(branch), `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)}`], "app");
-}
-function formatAppDeployWithDbNextStep(branch) {
-	return `prisma-cli app deploy --branch ${formatCommandArgument(branch.name)} --db`;
-}
-function formatProjectEnvListNextStep(branch) {
-	return branch.kind === "production" ? "prisma-cli project env list --role production" : `prisma-cli project env list --branch ${formatCommandArgument(branch.name)}`;
-}
-function formatProjectEnvAddNextStep(branch) {
-	return branch.kind === "production" ? "prisma-cli project env add DATABASE_URL=<value> --role production" : `prisma-cli project env add DATABASE_URL=<value> --branch ${formatCommandArgument(branch.name)}`;
-}
-function defaultSchemaSourcePath(schema) {
-	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
-}
-function defaultUnsupportedSchemaSourcePath(schema) {
-	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
-}
-function formatUnsupportedSchemaTarget(target) {
-	switch (target) {
-		case "cockroachdb": return "CockroachDB";
-		case "mongodb": return "MongoDB";
-		case "mysql": return "MySQL";
-		case "sqlite": return "SQLite";
-		case "sqlserver": return "SQL Server";
-	}
-}
-function formatDebugDetails(error) {
-	if (error instanceof Error) return error.stack ?? error.message;
-	return typeof error === "string" ? error : null;
-}
-function formatCombinedDebugDetails(setupError, cleanupError) {
-	const setupDebug = setupError.debug ?? setupError.stack ?? setupError.message;
-	const cleanupDebug = formatDebugDetails(cleanupError);
-	return [setupDebug ? `Setup error:\n${setupDebug}` : null, cleanupDebug ? `Cleanup error:\n${cleanupDebug}` : null].filter((line) => Boolean(line)).join("\n\n") || null;
-}
-//#endregion
-export { maybeSetupBranchDatabase };

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

@@ -1,215 +0,0 @@
-import { access, readFile, readdir, stat } from "node:fs/promises";
-import path from "node:path";
-//#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 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
-	});
-}
-//#endregion
-export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal };

package/dist/lib/app/build-settings.js

@@ -1,93 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveBuildSettings, resolveConfiguredBuildSettings } from "@prisma/compute-sdk";
-//#region src/lib/app/build-settings.ts
-/** Legacy build-settings file: no longer read or written, only detected for migration. */
-const PRISMA_APP_CONFIG_FILENAME = "prisma.app.json";
-/**
-* Detects a leftover `prisma.app.json`. The file is no longer used: one that
-* matches the effective settings is reported for deletion, one with custom
-* values must be migrated to the compute config so builds never silently
-* change.
-*/
-async function detectLegacyBuildSettings(options) {
-	const configPath = path.join(options.appPath, PRISMA_APP_CONFIG_FILENAME);
-	let content;
-	try {
-		options.signal?.throwIfAborted();
-		content = await readFile(configPath, {
-			encoding: "utf8",
-			signal: options.signal
-		});
-	} catch (error) {
-		if (options.signal?.aborted) throw error;
-		return { kind: "absent" };
-	}
-	let legacy;
-	try {
-		const parsed = JSON.parse(content);
-		const buildCommand = parsed.buildCommand === null || typeof parsed.buildCommand === "string" ? typeof parsed.buildCommand === "string" ? parsed.buildCommand.trim() || null : null : void 0;
-		const outputDirectory = typeof parsed.outputDirectory === "string" ? normalizeRelativePath(parsed.outputDirectory) : void 0;
-		if (buildCommand === void 0 || !outputDirectory) return {
-			kind: "invalid",
-			configPath
-		};
-		legacy = {
-			buildCommand,
-			outputDirectory
-		};
-	} catch {
-		return {
-			kind: "invalid",
-			configPath
-		};
-	}
-	return legacy.buildCommand === options.effective.buildCommand && legacy.outputDirectory === options.effective.outputDirectory ? {
-		kind: "matching",
-		configPath
-	} : {
-		kind: "custom",
-		configPath,
-		...legacy
-	};
-}
-/** Resolves build settings purely from framework inference; nothing is read or written. */
-async function resolveInferredAppBuildSettings(options) {
-	return {
-		status: "inferred",
-		configPath: null,
-		relativeConfigPath: null,
-		settings: await resolveBuildSettings(options)
-	};
-}
-/**
-* Resolves build settings when the compute config owns them: configured
-* fields win, omitted fields fall back to framework defaults.
-*/
-async function resolveConfiguredAppBuildSettings(options) {
-	const configFilename = path.basename(options.configPath);
-	const settings = await resolveConfiguredBuildSettings({
-		appPath: options.appPath,
-		buildType: options.buildType,
-		configured: options.configured,
-		source: `set by ${configFilename}`,
-		signal: options.signal
-	});
-	return {
-		status: "config",
-		configPath: options.configPath,
-		relativeConfigPath: configFilename,
-		settings
-	};
-}
-function normalizeRelativePath(value) {
-	const raw = value.trim().replace(/\\/g, "/");
-	if (raw.length === 0 || raw.split("/").includes("..")) return;
-	if (/^[A-Za-z]:/.test(raw)) return;
-	const normalized = path.posix.normalize(raw);
-	const segments = normalized.split("/");
-	if (path.win32.isAbsolute(value) || path.posix.isAbsolute(normalized) || segments.includes("..")) return;
-	return normalized === "." ? "." : normalized;
-}
-//#endregion
-export { PRISMA_APP_CONFIG_FILENAME, detectLegacyBuildSettings, resolveConfiguredAppBuildSettings, resolveInferredAppBuildSettings };