@prisma/cli 3.0.0-dev.69.1 → 3.0.0-dev.70.1

package/dist/controllers/app.js

@@ -17,6 +17,7 @@ import { buildProjectSetupNextActions, inferTargetName, projectNotFoundError, re
 import { bindProjectToDirectory, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary } from "../lib/project/setup.js";
 import { promptForProjectSetupChoice } from "../lib/project/interactive-setup.js";
 import { readLocalGitBranch } from "../lib/git/local-branch.js";
+import { resolveOrCreatePreviewBuildSettings } from "../lib/app/preview-build-settings.js";
 import { PREVIEW_BUILD_TYPES, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild } from "../lib/app/preview-build.js";
 import { PREVIEW_DEFAULT_REGION } from "../lib/app/preview-interaction.js";
 import { maybeSetupBranchDatabase } from "../lib/app/branch-database-deploy.js";
@@ -170,6 +171,12 @@ async function runAppDeploy(context, appName, options) {
 	const buildType = framework.buildType;
 	assertSupportedEntrypoint(buildType, options?.entrypoint, "deploy");
 	const entrypoint = await resolveDeployEntrypoint(context.runtime.cwd, framework, options?.entrypoint, context.runtime.signal);
+	const buildSettingsResolution = await resolveOrCreatePreviewBuildSettings({
+		appPath: context.runtime.cwd,
+		buildType,
+		signal: context.runtime.signal
+	});
+	maybeRenderDeployBuildSettings(context, buildSettingsResolution);
 	const portMapping = parseDeployPortMapping(String(runtime.port));
 	const branchDatabaseSetup = await maybeSetupBranchDatabase(context, provider, projectId, toBranchDatabaseDeployBranch(target.branch), {
 		db: options?.db,
@@ -186,6 +193,7 @@ async function runAppDeploy(context, appName, options) {
 		region: selectedApp.region,
 		entrypoint,
 		buildType,
+		buildSettings: buildSettingsResolution.settings,
 		portMapping,
 		envVars,
 		interaction: void 0,
@@ -214,6 +222,18 @@ async function runAppDeploy(context, appName, options) {
 			},
 			deployment: deployResult.deployment,
 			deploySettings: {
+				config: {
+					path: buildSettingsResolution.relativeConfigPath,
+					status: buildSettingsResolution.status
+				},
+				buildCommand: {
+					value: buildSettingsResolution.settings.buildCommand,
+					source: buildSettingsResolution.settings.buildCommandSource
+				},
+				outputDirectory: {
+					value: buildSettingsResolution.settings.outputDirectory,
+					source: buildSettingsResolution.settings.outputDirectorySource
+				},
 				framework: {
 					key: framework.key,
 					buildType,
@@ -1603,7 +1623,6 @@ async function detectNextConfig(cwd, signal) {
 	for (const candidate of [
 		"next.config.js",
 		"next.config.mjs",
-		"next.config.cjs",
 		"next.config.ts",
 		"next.config.mts"
 	]) {
@@ -1696,6 +1715,20 @@ async function maybeRenderDeploySetupBlock(context, details) {
 	const prefix = details.includeDirectory ? `Deploying ${directory} to` : "Deploying to";
 	context.output.stderr.write(`${prefix} ${details.projectName} / ${details.branchName} / ${details.appName}\n\n`);
 }
+function maybeRenderDeployBuildSettings(context, resolution) {
+	if (context.flags.json || context.flags.quiet) return;
+	const settings = resolution.settings;
+	const title = resolution.status === "created" ? `Created ${resolution.relativeConfigPath}` : `Using ${resolution.relativeConfigPath}`;
+	context.output.stderr.write(`${title}\n${renderDeployOutputRows(context.ui, [{
+		label: "Build Command",
+		value: settings.buildCommand ?? "none",
+		origin: settings.buildCommandSource ?? void 0
+	}, {
+		label: "Output Directory",
+		value: settings.outputDirectory,
+		origin: settings.outputDirectorySource ?? void 0
+	}]).join("\n")}\n\n`);
+}
 function maybeRenderProjectLinked(context, directory, projectName, localPinPath) {
 	if (context.flags.json || context.flags.quiet) return;
 	context.output.stderr.write(`${context.ui.success("✔")} Linked "${directory}" to Project "${projectName}"\nSaved ${localPinPath}\n\n`);

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

@@ -0,0 +1,385 @@
+import { CliError } from "../../shell/errors.js";
+import { readBunPackageJson } from "./bun-project.js";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { exec } from "node:child_process";
+import { parseModule } from "magicast";
+//#region src/lib/app/preview-build-settings.ts
+const PRISMA_APP_CONFIG_FILENAME = "prisma.app.json";
+const PRISMA_APP_CONFIG_SCHEMA_URL = "https://pris.ly/schemas/prisma-app-config.v1.json";
+async function resolveOrCreatePreviewBuildSettings(options) {
+	const configPath = path.join(options.appPath, PRISMA_APP_CONFIG_FILENAME);
+	const existing = await readPreviewBuildSettingsConfig(configPath, options.signal);
+	if (existing) return {
+		status: "used",
+		configPath,
+		relativeConfigPath: PRISMA_APP_CONFIG_FILENAME,
+		settings: {
+			buildCommand: existing.buildCommand,
+			buildCommandSource: null,
+			outputDirectory: existing.outputDirectory,
+			outputDirectorySource: null
+		}
+	};
+	const settings = await resolvePreviewBuildSettings(options);
+	const config = {
+		$schema: PRISMA_APP_CONFIG_SCHEMA_URL,
+		buildCommand: settings.buildCommand,
+		outputDirectory: settings.outputDirectory
+	};
+	try {
+		await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			signal: options.signal
+		});
+	} catch (error) {
+		if (error.code === "EEXIST") {
+			const raced = await readPreviewBuildSettingsConfig(configPath, options.signal);
+			if (raced) return {
+				status: "used",
+				configPath,
+				relativeConfigPath: PRISMA_APP_CONFIG_FILENAME,
+				settings: {
+					buildCommand: raced.buildCommand,
+					buildCommandSource: null,
+					outputDirectory: raced.outputDirectory,
+					outputDirectorySource: null
+				}
+			};
+		}
+		throw error;
+	}
+	return {
+		status: "created",
+		configPath,
+		relativeConfigPath: PRISMA_APP_CONFIG_FILENAME,
+		settings
+	};
+}
+async function resolvePreviewBuildSettings(options) {
+	switch (options.buildType) {
+		case "nextjs": {
+			const packageJson = await readBunPackageJson(options.appPath, options.signal);
+			const buildCommand = await resolveFrameworkBuildCommand(options.appPath, packageJson, {
+				command: "next build",
+				source: "Next.js default",
+				signal: options.signal
+			});
+			const outputRoot = await resolveNextOutputRoot(options.appPath, options.signal);
+			return {
+				buildCommand: buildCommand.command,
+				buildCommandSource: buildCommand.source,
+				outputDirectory: joinPosix(outputRoot, "standalone"),
+				outputDirectorySource: outputRoot === ".next" ? "Next.js output" : "next.config distDir"
+			};
+		}
+		case "tanstack-start": {
+			const packageJson = await readBunPackageJson(options.appPath, options.signal);
+			const buildCommand = await resolveFrameworkBuildCommand(options.appPath, packageJson, {
+				command: "vite build",
+				source: "TanStack Start default",
+				signal: options.signal
+			});
+			return {
+				buildCommand: buildCommand.command,
+				buildCommandSource: buildCommand.source,
+				outputDirectory: ".output",
+				outputDirectorySource: "TanStack Start output"
+			};
+		}
+		case "bun": {
+			const packageJson = await readBunPackageJson(options.appPath, options.signal);
+			const buildCommand = await resolveFrameworkBuildCommand(options.appPath, packageJson, {
+				command: null,
+				source: null,
+				signal: options.signal
+			});
+			return {
+				buildCommand: buildCommand.command,
+				buildCommandSource: buildCommand.source,
+				outputDirectory: ".",
+				outputDirectorySource: "app root"
+			};
+		}
+	}
+}
+async function readPreviewBuildSettingsConfig(configPath, signal) {
+	let content;
+	try {
+		content = await readFile(configPath, {
+			encoding: "utf8",
+			signal
+		});
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		throw invalidPrismaAppConfigError(configPath, `The file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw invalidPrismaAppConfigError(configPath, "The file must contain a JSON object.");
+	const raw = parsed;
+	if ("$schema" in raw && raw.$schema !== void 0 && typeof raw.$schema !== "string") throw invalidPrismaAppConfigError(configPath, "The $schema field must be a string when present.");
+	if (raw.buildCommand !== null && typeof raw.buildCommand !== "string") throw invalidPrismaAppConfigError(configPath, "The buildCommand field must be a string or null.");
+	let buildCommand = null;
+	if (typeof raw.buildCommand === "string") {
+		buildCommand = raw.buildCommand.trim();
+		if (buildCommand.length === 0) throw invalidPrismaAppConfigError(configPath, "The buildCommand field must not be an empty string. Use null to skip the build step.");
+	}
+	const outputDirectory = normalizeConfigOutputDirectory(configPath, raw.outputDirectory);
+	return {
+		buildCommand,
+		outputDirectory
+	};
+}
+function normalizeConfigOutputDirectory(configPath, value) {
+	if (typeof value !== "string" || value.trim().length === 0) throw invalidPrismaAppConfigError(configPath, "The outputDirectory field must be a non-empty string.");
+	const normalized = normalizeRelativePath(value);
+	if (!normalized) throw invalidPrismaAppConfigError(configPath, "The outputDirectory field must be a relative path inside the app directory.");
+	return normalized;
+}
+function invalidPrismaAppConfigError(configPath, why) {
+	return new CliError({
+		code: "APP_CONFIG_INVALID",
+		domain: "app",
+		summary: `Invalid ${PRISMA_APP_CONFIG_FILENAME}`,
+		why,
+		fix: `Edit ${PRISMA_APP_CONFIG_FILENAME} so buildCommand is a string or null and outputDirectory is a relative path inside the app root. Delete the file and rerun prisma-cli app deploy to regenerate defaults.`,
+		where: configPath,
+		meta: { configPath },
+		exitCode: 2,
+		nextSteps: ["prisma-cli app deploy"]
+	});
+}
+async function hasRootFile(appPath, filenames, signal) {
+	let entries;
+	try {
+		signal?.throwIfAborted();
+		entries = await readdir(appPath);
+		signal?.throwIfAborted();
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return false;
+	}
+	return entries.some((entry) => filenames.includes(entry));
+}
+function hasPackageDependency(packageJson, dependencyName) {
+	return hasAnyPackageDependency(packageJson, [dependencyName]);
+}
+function hasAnyPackageDependency(packageJson, dependencyNames) {
+	if (!packageJson) return false;
+	return [packageJson.dependencies, packageJson.devDependencies].some((group) => {
+		if (!group || typeof group !== "object") return false;
+		return dependencyNames.some((dependencyName) => dependencyName in group);
+	});
+}
+async function resolveFrameworkBuildCommand(appPath, packageJson, fallback) {
+	const buildScript = readBuildScript(packageJson);
+	if (buildScript) {
+		const packageManager = await resolvePackageManager(appPath, packageJson, fallback.signal);
+		if (!packageManager) return {
+			command: buildScript,
+			source: "package.json scripts.build"
+		};
+		return {
+			command: `${packageManager} run build`,
+			source: "package.json scripts.build"
+		};
+	}
+	return {
+		command: fallback.command,
+		source: fallback.source
+	};
+}
+function readBuildScript(packageJson) {
+	if (!packageJson?.scripts || typeof packageJson.scripts !== "object") return null;
+	const scripts = packageJson.scripts;
+	if (typeof scripts.build !== "string") return null;
+	const buildScript = scripts.build.trim();
+	return buildScript.length > 0 ? buildScript : null;
+}
+async function resolvePackageManager(appPath, packageJson, signal) {
+	const fromPackageManager = packageManagerFromPackageJson(packageJson?.packageManager);
+	if (fromPackageManager) return fromPackageManager;
+	if (await pathExists(path.join(appPath, "bun.lock"), signal) || await pathExists(path.join(appPath, "bun.lockb"), signal)) return "bun";
+	if (await pathExists(path.join(appPath, "pnpm-lock.yaml"), signal)) return "pnpm";
+	if (await pathExists(path.join(appPath, "yarn.lock"), signal)) return "yarn";
+	if (await pathExists(path.join(appPath, "package-lock.json"), signal)) return "npm";
+}
+function packageManagerFromPackageJson(value) {
+	if (typeof value !== "string") return null;
+	const name = value.split("@")[0];
+	return name === "bun" || name === "pnpm" || name === "yarn" || name === "npm" ? name : null;
+}
+async function runResolvedBuildCommand(appPath, settings, failurePrefix, signal) {
+	if (!settings.buildCommand) return;
+	await execBuildCommand(settings.buildCommand, appPath, failurePrefix, signal);
+}
+function execBuildCommand(command, cwd, failurePrefix, signal) {
+	return new Promise((resolve, reject) => {
+		const child = exec(command, {
+			cwd,
+			env: {
+				...process.env,
+				PATH: [path.join(cwd, "node_modules", ".bin"), process.env.PATH].filter(Boolean).join(path.delimiter)
+			},
+			maxBuffer: 10 * 1024 * 1024,
+			signal
+		}, (error, stdout, stderr) => {
+			if (error) {
+				const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+				reject(/* @__PURE__ */ new Error(`${failurePrefix} failed:\n${output || error.message}`));
+				return;
+			}
+			resolve();
+		});
+		if (signal?.aborted) child.kill();
+	});
+}
+async function resolveNextOutputRoot(appPath, signal) {
+	return (await readNextConfig(appPath, signal)).distDir ?? ".next";
+}
+async function readNextConfig(appPath, signal) {
+	for (const fileName of NEXT_CONFIG_FILENAMES) {
+		const filePath = path.join(appPath, fileName);
+		let content;
+		try {
+			content = await readFile(filePath, {
+				encoding: "utf8",
+				signal
+			});
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		return readStaticNextConfig(content);
+	}
+	return {};
+}
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
+function readStaticNextConfig(content) {
+	try {
+		const program = asAstNode(parseModule(content).$ast);
+		const bindings = program ? collectStaticBindings(program) : /* @__PURE__ */ new Map();
+		const configObject = program ? findExportedConfigObject(program, bindings) : null;
+		if (!configObject) return {};
+		const rawDistDir = readStaticStringProperty(configObject, "distDir");
+		const output = readStaticStringProperty(configObject, "output");
+		return {
+			distDir: rawDistDir ? normalizeRelativePath(rawDistDir) : void 0,
+			output: output === "standalone" || output === "export" ? output : void 0
+		};
+	} catch {
+		return {};
+	}
+}
+function joinPosix(...parts) {
+	return parts.join("/").replace(/\/+/g, "/");
+}
+function nextOutputRootFromStandaloneDirectory(outputDirectory) {
+	const normalized = outputDirectory.replace(/\/+$/g, "");
+	if (normalized === "standalone") return ".";
+	if (normalized.endsWith("/standalone")) {
+		const outputRoot = normalized.slice(0, -11);
+		return outputRoot.length > 0 ? outputRoot : ".";
+	}
+	const dirname = path.posix.dirname(normalized);
+	return dirname === "." ? "." : dirname;
+}
+function asAstNode(value) {
+	if (!value || typeof value !== "object") return null;
+	return typeof value.type === "string" ? value : null;
+}
+function astNodes(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map(asAstNode).filter((node) => Boolean(node));
+}
+function collectStaticBindings(program) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const statement of astNodes(program.body)) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declaration of astNodes(statement.declarations)) {
+			const id = asAstNode(declaration.id);
+			const init = asAstNode(declaration.init);
+			if (id?.type === "Identifier" && typeof id.name === "string" && init) bindings.set(id.name, init);
+		}
+	}
+	return bindings;
+}
+function findExportedConfigObject(program, bindings) {
+	for (const statement of astNodes(program.body)) {
+		if (statement.type === "ExportDefaultDeclaration") return resolveConfigObject(statement.declaration, bindings);
+		if (statement.type !== "ExpressionStatement") continue;
+		const expression = asAstNode(statement.expression);
+		if (expression?.type !== "AssignmentExpression" || expression.operator !== "=") continue;
+		if (isModuleExports(expression.left)) return resolveConfigObject(expression.right, bindings);
+	}
+	return null;
+}
+function resolveConfigObject(value, bindings, depth = 0) {
+	if (depth > 4) return null;
+	const node = unwrapStaticExpression(asAstNode(value));
+	if (!node) return null;
+	if (node.type === "ObjectExpression") return node;
+	if (node.type === "Identifier" && typeof node.name === "string") return resolveConfigObject(bindings.get(node.name), bindings, depth + 1);
+	if (node.type === "CallExpression") return resolveConfigObject(astNodes(node.arguments)[0], bindings, depth + 1);
+	return null;
+}
+function unwrapStaticExpression(node) {
+	let current = node;
+	while (current?.type === "TSAsExpression" || current?.type === "TSSatisfiesExpression" || current?.type === "TSNonNullExpression") current = asAstNode(current.expression);
+	return current;
+}
+function isModuleExports(value) {
+	const node = asAstNode(value);
+	if (node?.type !== "MemberExpression" || node.computed === true) return false;
+	const object = asAstNode(node.object);
+	const property = asAstNode(node.property);
+	return object?.type === "Identifier" && object.name === "module" && property?.type === "Identifier" && property.name === "exports";
+}
+function readStaticStringProperty(objectExpression, propertyName) {
+	for (const property of astNodes(objectExpression.properties)) {
+		if (property.type !== "ObjectProperty" || property.computed === true) continue;
+		if (propertyKeyName(property.key) !== propertyName) continue;
+		const value = unwrapStaticExpression(asAstNode(property.value));
+		if (value?.type === "StringLiteral" && typeof value.value === "string") {
+			const trimmed = value.value.trim();
+			return trimmed.length > 0 ? trimmed : void 0;
+		}
+	}
+}
+function propertyKeyName(value) {
+	const key = asAstNode(value);
+	if (key?.type === "Identifier" && typeof key.name === "string") return key.name;
+	if (key?.type === "StringLiteral" && typeof key.value === "string") return key.value;
+}
+function normalizeRelativePath(value) {
+	const raw = value.trim().replace(/\\/g, "/");
+	if (raw.length === 0 || raw.split("/").includes("..")) 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;
+}
+async function pathExists(targetPath, signal) {
+	try {
+		signal?.throwIfAborted();
+		await stat(targetPath);
+		signal?.throwIfAborted();
+		return true;
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return false;
+	}
+}
+//#endregion
+export { PRISMA_APP_CONFIG_FILENAME, PRISMA_APP_CONFIG_SCHEMA_URL, hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolveOrCreatePreviewBuildSettings, resolvePreviewBuildSettings, runResolvedBuildCommand };

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

@@ -1,7 +1,9 @@
-import { resolveBunEntrypoint } from "./bun-project.js";
-import { chmod, copyFile, cp, lstat, mkdir, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
+import { readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
+import { PRISMA_APP_CONFIG_FILENAME, hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolvePreviewBuildSettings, runResolvedBuildCommand } from "./preview-build-settings.js";
+import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
 import path from "node:path";
-import { AstroBuild, BunBuild, NextjsBuild, NuxtBuild, TanstackStartBuild } from "@prisma/compute-sdk";
+import os from "node:os";
+import { AstroBuild, BunBuild, NuxtBuild } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-build.ts
 const PREVIEW_BUILD_TYPES = [
 	"auto",
@@ -17,18 +19,21 @@ var PreviewBuildStrategy = class {
 	#entrypoint;
 	#buildType;
 	#signal;
+	#buildSettings;
 	constructor(options) {
 		this.#appPath = options.appPath;
 		this.#entrypoint = options.entrypoint;
 		this.#buildType = options.buildType ?? "auto";
 		this.#signal = options.signal;
+		this.#buildSettings = options.buildSettings;
 	}
 	async canBuild(signal = this.#signal) {
 		const { strategy } = await resolvePreviewBuildStrategy({
 			appPath: this.#appPath,
 			entrypoint: this.#entrypoint,
 			buildType: this.#buildType,
-			signal
+			signal,
+			buildSettings: this.#buildSettings
 		});
 		return strategy.canBuild(signal);
 	}
@@ -37,7 +42,8 @@ var PreviewBuildStrategy = class {
 			appPath: this.#appPath,
 			entrypoint: this.#entrypoint,
 			buildType: this.#buildType,
-			signal
+			signal,
+			buildSettings: this.#buildSettings
 		});
 		return artifact;
 	}
@@ -47,11 +53,11 @@ async function executePreviewBuild(options) {
 		appPath: options.appPath,
 		entrypoint: options.entrypoint,
 		buildType: options.buildType ?? "auto",
-		signal: options.signal
+		signal: options.signal,
+		buildSettings: options.buildSettings
 	});
 	const artifact = await strategy.execute(options.signal);
 	try {
-		if (buildType === "nextjs") await restageNextjsArtifact(artifact, options.appPath, options.signal);
 		await normalizeArtifactSymlinks(artifact.directory, options.appPath, options.signal);
 		return {
 			artifact,
@@ -68,7 +74,8 @@ async function resolvePreviewBuildStrategy(options) {
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
 			buildType: options.buildType,
-			signal: options.signal
+			signal: options.signal,
+			buildSettings: options.buildSettings
 		});
 		return {
 			buildType: options.buildType,
@@ -81,7 +88,8 @@ async function resolvePreviewBuildStrategy(options) {
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
 			buildType,
-			signal: options.signal
+			signal: options.signal,
+			buildSettings: options.buildSettings
 		});
 		if (await strategy.canBuild(options.signal)) return {
 			buildType,
@@ -94,25 +102,170 @@ async function resolvePreviewBuildStrategy(options) {
 			appPath: options.appPath,
 			entrypoint: options.entrypoint,
 			buildType: "bun",
-			signal: options.signal
+			signal: options.signal,
+			buildSettings: options.buildSettings
 		})
 	};
 }
 async function createPreviewBuildStrategy(options) {
 	switch (options.buildType) {
-		case "nextjs": return new NextjsBuild({ appPath: options.appPath });
+		case "nextjs": return new PreviewNextjsBuild({
+			appPath: options.appPath,
+			buildSettings: options.buildSettings
+		});
 		case "nuxt": return new NuxtBuild({ appPath: options.appPath });
 		case "astro": return new AstroBuild({ appPath: options.appPath });
-		case "tanstack-start": return new TanstackStartBuild({ appPath: options.appPath });
+		case "tanstack-start": return new PreviewTanstackStartBuild({
+			appPath: options.appPath,
+			buildSettings: options.buildSettings
+		});
 		case "bun": {
 			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint, options.signal);
-			return new BunBuild({
+			return new PreviewBunBuild({
 				appPath: options.appPath,
-				entrypoint
+				strategy: new BunBuild({
+					appPath: options.appPath,
+					entrypoint
+				}),
+				buildSettings: options.buildSettings
 			});
 		}
 	}
 }
+var PreviewNextjsBuild = class {
+	#appPath;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal) {
+		const packageJson = await readBunPackageJson(this.#appPath, signal);
+		return await hasRootFile(this.#appPath, NEXT_CONFIG_FILENAMES, signal) || hasPackageDependency(packageJson, "next");
+	}
+	async execute(signal) {
+		const settings = this.#buildSettings ?? await resolvePreviewBuildSettings({
+			appPath: this.#appPath,
+			buildType: "nextjs",
+			signal
+		});
+		await runResolvedBuildCommand(this.#appPath, settings, "Next.js", signal);
+		const standaloneDir = path.join(this.#appPath, settings.outputDirectory);
+		if (!await directoryExists(standaloneDir, signal)) throw new Error(`Next.js build did not produce standalone output at ${settings.outputDirectory}. Add output: "standalone" to your next.config file, or update ${PRISMA_APP_CONFIG_FILENAME}.`);
+		const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
+		try {
+			const artifactDir = path.join(outDir, "app");
+			await stageNextjsStandaloneArtifact({
+				standaloneDir,
+				artifactDir,
+				appPath: this.#appPath,
+				signal
+			});
+			const entrypoint = await findNextStandaloneEntrypoint(artifactDir, signal);
+			await copyNextjsStaticAssets({
+				appPath: this.#appPath,
+				artifactDir,
+				outputRoot: nextOutputRootFromStandaloneDirectory(settings.outputDirectory),
+				entrypoint,
+				signal
+			});
+			return {
+				directory: artifactDir,
+				entrypoint,
+				defaultPortMapping: { http: 3e3 },
+				cleanup: () => rm(outDir, {
+					recursive: true,
+					force: true
+				})
+			};
+		} catch (error) {
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+};
+var PreviewTanstackStartBuild = class {
+	#appPath;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal) {
+		return hasAnyPackageDependency(await readBunPackageJson(this.#appPath, signal), TANSTACK_START_PACKAGES);
+	}
+	async execute(signal) {
+		const settings = this.#buildSettings ?? await resolvePreviewBuildSettings({
+			appPath: this.#appPath,
+			buildType: "tanstack-start",
+			signal
+		});
+		await runResolvedBuildCommand(this.#appPath, settings, "TanStack Start", signal);
+		const outputDir = path.join(this.#appPath, settings.outputDirectory);
+		const entrypoint = "server/index.mjs";
+		const entryPath = path.join(outputDir, entrypoint);
+		if (!(await unsupportedFilesystemBoundary(signal, () => stat(entryPath).catch(() => null)))?.isFile()) throw new Error(`TanStack Start build did not produce a Nitro node server entrypoint at ${joinPosix(settings.outputDirectory, entrypoint)}. Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset, or update ${PRISMA_APP_CONFIG_FILENAME}.`);
+		const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
+		try {
+			const artifactDir = path.join(outDir, "app");
+			await unsupportedFilesystemBoundary(signal, () => cp(outputDir, artifactDir, {
+				recursive: true,
+				verbatimSymlinks: true
+			}));
+			return {
+				directory: artifactDir,
+				entrypoint,
+				defaultPortMapping: { http: 3e3 },
+				cleanup: () => rm(outDir, {
+					recursive: true,
+					force: true
+				})
+			};
+		} catch (error) {
+			await rm(outDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+};
+var PreviewBunBuild = class {
+	#appPath;
+	#strategy;
+	#buildSettings;
+	constructor(options) {
+		this.#appPath = options.appPath;
+		this.#strategy = options.strategy;
+		this.#buildSettings = options.buildSettings;
+	}
+	async canBuild(signal) {
+		return this.#strategy.canBuild(signal);
+	}
+	async execute(signal) {
+		const settings = this.#buildSettings ?? await resolvePreviewBuildSettings({
+			appPath: this.#appPath,
+			buildType: "bun",
+			signal
+		});
+		await runResolvedBuildCommand(this.#appPath, settings, "Bun", signal);
+		return this.#strategy.execute(signal);
+	}
+};
+const NEXT_CONFIG_FILENAMES = [
+	"next.config.js",
+	"next.config.mjs",
+	"next.config.ts",
+	"next.config.mts"
+];
+const TANSTACK_START_PACKAGES = [
+	"@tanstack/react-start",
+	"@tanstack/solid-start",
+	"@tanstack/start"
+];
 async function stageNextjsStandaloneArtifact(options) {
 	const standaloneRoot = path.resolve(options.standaloneDir);
 	const artifactRoot = path.resolve(options.artifactDir);
@@ -125,32 +278,42 @@ async function stageNextjsStandaloneArtifact(options) {
 	});
 	await hoistPnpmDependencies(path.join(artifactRoot, "node_modules"), options.signal);
 }
-async function restageNextjsArtifact(artifact, appPath, signal) {
-	const artifactDir = artifact.directory;
-	const standaloneDir = path.join(appPath, ".next", "standalone");
-	await unsupportedFilesystemBoundary(signal, () => rm(artifactDir, {
-		recursive: true,
-		force: true
-	}));
-	await stageNextjsStandaloneArtifact({
-		standaloneDir,
-		artifactDir,
-		appPath,
-		signal
-	});
-	const serverSubpath = nextjsServerSubpath(artifact.entrypoint);
-	const serverDir = serverSubpath ? path.join(artifactDir, serverSubpath) : artifactDir;
-	const publicDir = path.join(appPath, "public");
-	if (await directoryExists(publicDir, signal)) await unsupportedFilesystemBoundary(signal, () => cp(publicDir, path.join(serverDir, "public"), {
+async function copyNextjsStaticAssets(options) {
+	const serverSubpath = nextjsServerSubpath(options.entrypoint);
+	const serverDir = serverSubpath ? path.join(options.artifactDir, serverSubpath) : options.artifactDir;
+	const publicDir = path.join(options.appPath, "public");
+	if (await directoryExists(publicDir, options.signal)) await unsupportedFilesystemBoundary(options.signal, () => cp(publicDir, path.join(serverDir, "public"), {
 		recursive: true,
 		verbatimSymlinks: true
 	}));
-	const staticDir = path.join(appPath, ".next", "static");
-	if (await directoryExists(staticDir, signal)) await unsupportedFilesystemBoundary(signal, () => cp(staticDir, path.join(serverDir, ".next", "static"), {
+	const staticDir = path.join(options.appPath, options.outputRoot, "static");
+	if (await directoryExists(staticDir, options.signal)) await unsupportedFilesystemBoundary(options.signal, () => cp(staticDir, path.join(serverDir, options.outputRoot, "static"), {
 		recursive: true,
 		verbatimSymlinks: true
 	}));
 }
+async function findNextStandaloneEntrypoint(artifactDir, signal) {
+	const rootEntrypoint = path.join(artifactDir, "server.js");
+	if ((await unsupportedFilesystemBoundary(signal, () => stat(rootEntrypoint).catch(() => null)))?.isFile()) return "server.js";
+	const candidates = [];
+	await walk(artifactDir);
+	candidates.sort((left, right) => left.split("/").length - right.split("/").length || left.localeCompare(right));
+	const selected = candidates[0];
+	if (!selected) throw new Error(`Next.js standalone output did not contain server.js in ${artifactDir}`);
+	return selected;
+	async function walk(directory) {
+		const entries = await unsupportedFilesystemBoundary(signal, () => readdir(directory, { withFileTypes: true }));
+		for (const entry of entries) {
+			if (entry.name === "node_modules") continue;
+			const fullPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				await walk(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name === "server.js") candidates.push(path.relative(artifactDir, fullPath).split(path.sep).join("/"));
+		}
+	}
+}
 function nextjsServerSubpath(entrypoint) {
 	const dir = path.posix.dirname(entrypoint);
 	return dir === "." ? "" : dir;

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

@@ -165,7 +165,8 @@ function createPreviewAppProvider(client, options) {
 					appPath: path.resolve(options.cwd),
 					entrypoint: options.entrypoint,
 					buildType: options.buildType,
-					signal: options.signal
+					signal: options.signal,
+					buildSettings: options.buildSettings
 				}),
 				projectId: options.projectId,
 				serviceId: resolvedApp.appId,

package/dist/presenters/app.js

@@ -43,11 +43,16 @@ function renderAppDeploy(context, descriptor, result) {
 	];
 }
 function serializeAppDeploy(result) {
-	const { deploySettings: _deploySettings, localPin: _localPin, ...serialized } = result;
+	const { deploySettings, localPin: _localPin, ...serialized } = result;
 	const { id: _branchId, ...branch } = serialized.branch;
 	return {
 		...serialized,
-		branch
+		branch,
+		deploySettings: {
+			config: deploySettings.config,
+			buildCommand: deploySettings.buildCommand,
+			outputDirectory: deploySettings.outputDirectory
+		}
 	};
 }
 function renderBranchDatabaseDeploySummary(context, result) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.69.1",
+  "version": "3.0.0-dev.70.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {