@prisma/cli 3.0.0-dev.87.1 → 3.0.0-dev.90.1

package/dist/controllers/project.js

@@ -1,11 +1,11 @@
 import { CliError, authRequiredError, featureUnavailableError, usageError, workspaceRequiredError } from "../shell/errors.js";
+import { createAppProvider } from "../lib/app/app-provider.js";
 import { renderSummaryLine } from "../shell/ui.js";
 import { canPrompt } from "../shell/runtime.js";
 import { readLocalResolutionPin } from "../lib/project/local-pin.js";
 import { formatCommandArgument } from "../shell/command-arguments.js";
 import { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectResolutionErrorToCliError, resolveProjectTarget, sortProjects } from "../lib/project/resolution.js";
 import { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectDirectoryBindingErrorToCliError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
-import { createPreviewAppProvider } from "../lib/app/preview-provider.js";
 import { requireComputeAuth } from "../lib/auth/guard.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { createCliUseCaseGateways } from "../use-cases/create-cli-gateways.js";
@@ -104,7 +104,7 @@ async function runProjectCreate(context, projectName) {
 	if (!isRealMode(context)) throw featureUnavailableError("Project create is not available in fixture mode", "Creating Projects requires live platform integration.", "Rerun without fixture mode enabled to create a Project.", ["prisma-cli auth login"], "project");
 	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 	if (!client) throw authRequiredError();
-	const provider = createPreviewAppProvider(client);
+	const provider = createAppProvider(client);
 	const name = projectName.trim();
 	const created = await provider.createProject({
 		name,
@@ -136,7 +136,7 @@ async function runProjectLink(context, projectRef) {
 	if (isRealMode(context)) {
 		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
 		if (!client) throw authRequiredError();
-		provider = createPreviewAppProvider(client);
+		provider = createAppProvider(client);
 		projects = await listRealWorkspaceProjects(client, workspace, context.runtime.signal);
 	} else projects = listFixtureWorkspaceProjects(context, workspace);
 	let result;

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

@@ -0,0 +1,5 @@
+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/{preview-provider.js → app-provider.js}

@@ -1,22 +1,22 @@
+import { createBranchDatabase, createEnvironmentVariable, deleteBranchDatabase, deleteEnvironmentVariable, listEnvironmentVariables, updateEnvironmentVariable } from "./branch-database-api.js";
+import { AppBuildStrategy } from "./build.js";
 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
-var PreviewDomainApiError = class extends Error {
+//#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 = "PreviewDomainApiError";
+		this.name = "DomainApiError";
 		this.status = options.status;
 		this.code = options.code ?? null;
 		this.hint = options.hint ?? null;
 	}
 };
-function createPreviewAppProvider(client, options) {
+function createAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
 		async createProject(options) {
@@ -161,7 +161,7 @@ function createPreviewAppProvider(client, options) {
 				region: options.region
 			};
 			const deployResult = await sdk.deploy({
-				strategy: new PreviewBuildStrategy({
+				strategy: new AppBuildStrategy({
 					appPath: path.resolve(options.cwd),
 					entrypoint: options.entrypoint,
 					buildType: options.buildType,
@@ -491,7 +491,7 @@ function apiCallError(summary, response, error) {
 	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
 }
 function domainApiCallError(summary, response, error) {
-	return new PreviewDomainApiError({
+	return new DomainApiError({
 		summary,
 		status: response.status,
 		code: error.error?.code ?? null,
@@ -541,4 +541,4 @@ function toAbsoluteUrl(url) {
 	return url.startsWith("https://") || url.startsWith("http://") ? url : `https://${url}`;
 }
 //#endregion
-export { PreviewDomainApiError, createPreviewAppProvider };
+export { DomainApiError, createAppProvider };

package/dist/lib/app/{preview-branch-database.js → branch-database-api.js}

@@ -1,4 +1,4 @@
-//#region src/lib/app/preview-branch-database.ts
+//#region src/lib/app/branch-database-api.ts
 async function createBranchDatabase(client, options) {
 	const result = await client.POST("/v1/databases", {
 		body: {

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

@@ -4,27 +4,11 @@ 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, runBranchDatabaseSchemaSetup } from "./branch-database.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();
-	const preflight = branchDatabasePreflight(branch, options);
-	if (preflight) return preflight;
-	const envState = await inspectBranchDatabaseEnv(provider, projectId, branch, context.runtime.signal);
-	const existingEnvOutcome = existingBranchDatabaseEnvOutcome(context, branch, getTargetDatabaseEnvVarKeys(envState), envState, options.db);
-	if (existingEnvOutcome) return existingEnvOutcome;
-	const localSignal = await inspectBranchDatabaseSignal(context.runtime.cwd, context.runtime.signal);
-	if (localSignal.unsupportedSchema) {
-		if (options.db === true) throw unsupportedBranchDatabaseSchemaError(localSignal.unsupportedSchema, branch, context);
-		return emptyBranchDatabaseSetupOutcome();
-	}
-	const promptOutcome = await branchDatabasePromptOutcome(context, branch, localSignal, envState, options.db);
-	if (promptOutcome) return promptOutcome;
-	if (options.db === true && !canPrompt(context) && !context.flags.yes) throw nonInteractiveDatabaseSetupRequiresYesError(branch);
-	return setupBranchDatabase(context, provider, projectId, branch, localSignal, envState);
-}
-function branchDatabasePreflight(branch, options) {
 	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();
@@ -33,42 +17,47 @@ function branchDatabasePreflight(branch, options) {
 		if (options.db === true) throw productionDatabaseSetupAfterFirstDeployError();
 		return emptyBranchDatabaseSetupOutcome();
 	}
-	return null;
-}
-function existingBranchDatabaseEnvOutcome(context, branch, targetEnvVars, envState, requested) {
-	if (!hasExistingDatabaseEnvForTarget(branch, envState)) return null;
-	const warning = requested === true ? existingDatabaseEnvWarning(branch, targetEnvVars) : null;
-	if (warning) emitBranchDatabaseWarning(context, warning);
-	return {
-		result: requested === true ? {
-			status: "skipped",
-			reason: existingDatabaseEnvReason(branch),
-			envVars: targetEnvVars,
-			schema: null
-		} : void 0,
-		warnings: warning ? [warning] : []
-	};
-}
-async function branchDatabasePromptOutcome(context, branch, localSignal, envState, requested) {
-	if (requested === true) return null;
-	if (!(hasBranchDatabaseSignal(localSignal) || Boolean(envState.inheritedPreviewDatabaseUrl))) return emptyBranchDatabaseSetupOutcome();
-	if (!canPrompt(context) || context.flags.yes) {
-		const warning = databasePromptSuppressedWarning(branch);
-		emitBranchDatabaseWarning(context, warning);
+	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: void 0,
-			warnings: [warning]
+			result: options.db === true ? {
+				status: "skipped",
+				reason: existingDatabaseEnvReason(branch),
+				envVars: targetEnvVars
+			} : void 0,
+			warnings: warning ? [warning] : []
 		};
 	}
-	maybeRenderBranchDatabaseSignal(context, branch, localSignal, envState);
-	return await confirmPrompt({
-		input: context.runtime.stdin,
-		output: context.output.stderr,
-		message: databasePromptMessage(branch),
-		initialValue: false
-	}) ? null : emptyBranchDatabaseSetupOutcome();
-}
-async function setupBranchDatabase(context, provider, projectId, branch, signal, envState) {
+	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,
@@ -80,28 +69,11 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 	});
 	emitBranchDatabaseProgress(context, "success", "Created database");
 	try {
-		let schemaSetup = null;
-		const warnings = [];
-		let skippedSchemaWarning = null;
-		const schema = signal.schema;
-		if (schema) {
-			emitBranchDatabaseProgress(context, "pending", `Applying database schema with ${formatSchemaSetupCommand(schema.command)}`);
-			schemaSetup = await runBranchDatabaseSchemaSetup({
-				context,
-				schema,
-				databaseUrl: database.databaseUrl,
-				directUrl: database.directUrl
-			}).catch((error) => {
-				throw schemaSetupFailedError(error, schema, branch, context.runtime.cwd);
-			});
-			emitBranchDatabaseProgress(context, "success", "Applied database schema");
-		} else skippedSchemaWarning = "No supported Prisma schema source was found. Database env vars were created, but schema setup was skipped.";
 		const envVars = await upsertBranchDatabaseEnvVars(context, provider, projectId, branch, database, envState);
-		emitBranchDatabaseProgress(context, "success", `Added ${envScopeLabel(branch)} env var${envVars.length === 1 ? "" : "s"} ${envVars.join(", ")}`);
-		if (skippedSchemaWarning) {
-			emitBranchDatabaseWarning(context, skippedSchemaWarning);
-			warnings.push(skippedSchemaWarning);
-		}
+		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",
@@ -109,14 +81,9 @@ async function setupBranchDatabase(context, provider, projectId, branch, signal,
 					id: database.id,
 					name: database.name
 				},
-				envVars,
-				schema: schemaSetup ? {
-					command: schemaSetup.command,
-					source: schemaSetup.source,
-					path: schemaSetup.schemaPath
-				} : null
+				envVars
 			},
-			warnings
+			warnings: [schemaSuggestion]
 		};
 	} catch (error) {
 		throw await cleanupCreatedBranchDatabaseAfterFailure(context, provider, database, branch, error);
@@ -318,24 +285,6 @@ function branchDatabaseCleanupFailedError(setupError, cleanupError, database, br
 		nextSteps: []
 	});
 }
-function schemaSetupFailedError(error, schema, branch, cwd) {
-	return new CliError({
-		code: "SCHEMA_SETUP_FAILED",
-		domain: "app",
-		summary: "Database schema setup failed",
-		why: error instanceof Error ? error.message : String(error),
-		fix: "Fix the Prisma schema or migrations, then rerun deploy with --db.",
-		debug: formatDebugDetails(error),
-		meta: {
-			branch: branch.name,
-			schemaPath: schema.path,
-			source: schema.kind,
-			command: schema.command
-		},
-		exitCode: 1,
-		nextSteps: [...formatSchemaSetupNextSteps(schema, cwd), formatAppDeployWithDbNextStep(branch)]
-	});
-}
 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");
 }
@@ -348,14 +297,6 @@ function formatProjectEnvListNextStep(branch) {
 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 formatSchemaSetupNextSteps(schema, cwd) {
-	const sourcePath = path.relative(cwd, schema.path) || defaultSchemaSourcePath(schema);
-	switch (schema.command) {
-		case "migrate-deploy": return [`npx --no-install prisma migrate deploy --schema ${formatCommandArgument(sourcePath)}`];
-		case "db-push": return [`npx --no-install prisma db push --schema ${formatCommandArgument(sourcePath)}`];
-		case "prisma-next-db-init": return [`npx --no-install prisma-next contract emit --config ${formatCommandArgument(sourcePath)}`, `npx --no-install prisma-next db init --config ${formatCommandArgument(sourcePath)} --db <DATABASE_URL>`];
-	}
-}
 function defaultSchemaSourcePath(schema) {
 	return schema.kind === "prisma-next" ? "prisma-next.config.ts" : "schema.prisma";
 }

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

@@ -1,6 +1,5 @@
 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",
@@ -67,61 +66,31 @@ 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 prisma = await resolvePrismaInvocation(options.context.runtime.cwd);
-	const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl, prisma);
-	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;
-	const entries = await readDirectoryEntries(directory);
-	if (!entries) return;
-	entries.sort((left, right) => left.name.localeCompare(right.name));
-	for (const entry of entries) {
-		signal.throwIfAborted();
-		if (state.filesVisited >= MAX_SCAN_FILES) return;
-		await scanDirectoryEntry(cwd, directory, entry, depth, state, signal);
-	}
-}
-async function readDirectoryEntries(directory) {
+	let entries;
 	try {
-		return await readdir(directory, { withFileTypes: true });
+		entries = await readdir(directory, { withFileTypes: true });
 	} catch (error) {
-		if (error.code === "ENOENT") return null;
+		if (error.code === "ENOENT") return;
 		throw error;
 	}
-}
-async function scanDirectoryEntry(cwd, directory, entry, depth, state, signal) {
-	const entryPath = path.join(directory, entry.name);
-	if (entry.isDirectory()) {
-		if (!SKIPPED_DIRECTORIES.has(entry.name)) await scanDirectory(cwd, entryPath, depth + 1, state, signal);
-		return;
+	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);
 	}
-	if (!entry.isFile()) return;
-	state.filesVisited += 1;
-	collectBranchDatabaseCandidate(entryPath, entry.name, state);
-	if (await shouldRecordDatabaseUrlReference(entryPath, entry.name, state, signal)) state.databaseUrlReferences.push(path.relative(cwd, entryPath) || entry.name);
-}
-function collectBranchDatabaseCandidate(entryPath, entryName, state) {
-	if (entryName === "schema.prisma") state.schemaCandidates.push(entryPath);
-	if (isPrismaNextConfigFile(entryName)) state.prismaNextConfigCandidates.push(entryPath);
-}
-async function shouldRecordDatabaseUrlReference(entryPath, entryName, state, signal) {
-	return state.databaseUrlReferences.length < MAX_DATABASE_URL_REFERENCE_FILES && shouldScanForDatabaseUrl(entryName) && await fileContainsDatabaseUrl(entryPath, signal);
 }
 async function selectPrismaOrmSchema(cwd, candidates, signal) {
 	const sorted = sortByPreferredRelativePath(cwd, candidates, "schema.prisma");
@@ -155,15 +124,12 @@ async function selectPrismaOrmSchema(cwd, candidates, signal) {
 	};
 }
 function selectPrismaNextConfig(cwd, candidates, mode) {
-	const matches = candidates.filter(mode === "supported" ? isSupportedPrismaNextConfig : isUnsupportedPrismaNextConfig);
+	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 isSupportedPrismaNextConfig(candidate) {
-	return candidate.target === "postgresql" || candidate.target === "unknown";
-}
-function isUnsupportedPrismaNextConfig(candidate) {
-	return !isSupportedPrismaNextConfig(candidate);
-}
 function sortByPreferredRelativePath(cwd, candidates, preferredRootFile) {
 	return candidates.map((candidate) => ({
 		absolute: candidate,
@@ -245,133 +211,5 @@ async function readTextFileIfSmall(filePath, signal) {
 		signal
 	});
 }
-const FALLBACK_PRISMA_CLI_VERSION = "6.19.3";
-/**
-* Picks how `prisma` CLI commands are invoked for schema setup. Projects
-* with the CLI installed run their own binary (version-exact). Projects
-* without it fall back to a versioned `npx prisma@<x>` pinned to the
-* installed `@prisma/client` — never bare `npx prisma`, which resolves to
-* latest and can be a major version ahead of the project's schema.
-*/
-async function resolvePrismaInvocation(cwd) {
-	if (await localPrismaBinExists(cwd)) return {
-		argsPrefix: ["--no-install", "prisma"],
-		displayPrefix: "npx --no-install prisma"
-	};
-	const pinned = await readInstalledPrismaClientVersion(cwd) ?? FALLBACK_PRISMA_CLI_VERSION;
-	return {
-		argsPrefix: ["--yes", `prisma@${pinned}`],
-		displayPrefix: `npx prisma@${pinned}`
-	};
-}
-/** npm/pnpm name the local CLI shim `prisma` on POSIX and `prisma.cmd`/`prisma.ps1` on Windows. */
-async function localPrismaBinExists(cwd) {
-	const binDir = path.join(cwd, "node_modules", ".bin");
-	return (await Promise.all([
-		"prisma",
-		"prisma.cmd",
-		"prisma.ps1"
-	].map((name) => fileExists(path.join(binDir, name))))).some(Boolean);
-}
-async function fileExists(filePath) {
-	try {
-		await access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function readInstalledPrismaClientVersion(cwd) {
-	try {
-		const raw = await readFile(path.join(cwd, "node_modules", "@prisma", "client", "package.json"), { encoding: "utf8" });
-		const parsed = JSON.parse(raw);
-		if (typeof parsed !== "object" || parsed === null) return null;
-		const version = parsed.version;
-		return typeof version === "string" && version.length > 0 ? version : null;
-	} catch {
-		return null;
-	}
-}
-function buildSchemaSetupCommands(schema, schemaPath, databaseUrl, prisma) {
-	if (schema.command === "migrate-deploy") return [{
-		args: [
-			...prisma.argsPrefix,
-			"migrate",
-			"deploy",
-			"--schema",
-			schemaPath
-		],
-		displayCommand: `${prisma.displayPrefix} migrate deploy`
-	}];
-	if (schema.command === "db-push") return [{
-		args: [
-			...prisma.argsPrefix,
-			"db",
-			"push",
-			"--schema",
-			schemaPath
-		],
-		displayCommand: `${prisma.displayPrefix} 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 };
+export { hasBranchDatabaseSignal, inspectBranchDatabaseSignal };

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

@@ -0,0 +1,93 @@
+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 };