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

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

@@ -1,501 +0,0 @@
-import { readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import { hasAnyPackageDependency, hasPackageDependency, hasRootFile, joinPosix, nextOutputRootFromStandaloneDirectory, resolvePreviewBuildSettings, runResolvedBuildCommand } from "./preview-build-settings.js";
-import { resolveSourceRoot } from "@prisma/compute-sdk/config";
-import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readdir, readlink, rm, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-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",
-	"bun",
-	"nextjs",
-	"nuxt",
-	"astro",
-	"tanstack-start"
-];
-const RESOLVED_PREVIEW_BUILD_TYPES = PREVIEW_BUILD_TYPES.filter((buildType) => buildType !== "auto");
-var PreviewBuildStrategy = class {
-	#appPath;
-	#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,
-			buildSettings: this.#buildSettings
-		});
-		return strategy.canBuild(signal);
-	}
-	async execute(signal = this.#signal) {
-		const { artifact } = await executePreviewBuild({
-			appPath: this.#appPath,
-			entrypoint: this.#entrypoint,
-			buildType: this.#buildType,
-			signal,
-			buildSettings: this.#buildSettings
-		});
-		return artifact;
-	}
-};
-async function executePreviewBuild(options) {
-	const { strategy, buildType } = await resolvePreviewBuildStrategy({
-		appPath: options.appPath,
-		entrypoint: options.entrypoint,
-		buildType: options.buildType ?? "auto",
-		signal: options.signal,
-		buildSettings: options.buildSettings
-	});
-	const artifact = await strategy.execute(options.signal);
-	try {
-		await normalizeArtifactSymlinks(artifact.directory, options.appPath, options.signal);
-		return {
-			artifact,
-			buildType
-		};
-	} catch (error) {
-		await artifact.cleanup?.().catch(() => void 0);
-		throw error;
-	}
-}
-async function resolvePreviewBuildStrategy(options) {
-	if (options.buildType !== "auto") {
-		const strategy = await createPreviewBuildStrategy({
-			appPath: options.appPath,
-			entrypoint: options.entrypoint,
-			buildType: options.buildType,
-			signal: options.signal,
-			buildSettings: options.buildSettings
-		});
-		return {
-			buildType: options.buildType,
-			strategy
-		};
-	}
-	for (const buildType of RESOLVED_PREVIEW_BUILD_TYPES) {
-		if (buildType === "bun") continue;
-		const strategy = await createPreviewBuildStrategy({
-			appPath: options.appPath,
-			entrypoint: options.entrypoint,
-			buildType,
-			signal: options.signal,
-			buildSettings: options.buildSettings
-		});
-		if (await strategy.canBuild(options.signal)) return {
-			buildType,
-			strategy
-		};
-	}
-	return {
-		buildType: "bun",
-		strategy: await createPreviewBuildStrategy({
-			appPath: options.appPath,
-			entrypoint: options.entrypoint,
-			buildType: "bun",
-			signal: options.signal,
-			buildSettings: options.buildSettings
-		})
-	};
-}
-async function createPreviewBuildStrategy(options) {
-	switch (options.buildType) {
-		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 PreviewTanstackStartBuild({
-			appPath: options.appPath,
-			buildSettings: options.buildSettings
-		});
-		case "bun": {
-			const entrypoint = await resolveBunEntrypoint(options.appPath, options.entrypoint, options.signal);
-			return new PreviewBunBuild({
-				appPath: options.appPath,
-				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)) return stageNextjsFullTreeFallbackArtifact(this.#appPath, signal);
-		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;
-		}
-	}
-};
-const FULL_TREE_NEXT_START_ENTRYPOINT = "prisma-next-start.cjs";
-const FULL_TREE_NEXT_START_SOURCE = [
-	"process.chdir(__dirname);",
-	"process.env.NODE_ENV = \"production\";",
-	"process.argv.push(\"start\", \"-p\", process.env.PORT ?? \"3000\");",
-	"require(\"next/dist/bin/next\");",
-	""
-].join("\n");
-async function stageNextjsFullTreeFallbackArtifact(appPath, signal) {
-	const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
-	try {
-		const artifactDir = path.join(outDir, "app");
-		await unsupportedFilesystemBoundary(signal, () => cp(appPath, artifactDir, {
-			recursive: true,
-			verbatimSymlinks: true,
-			filter: (source) => !isExcludedFromFullTreeArtifact(path.basename(source))
-		}));
-		await unsupportedFilesystemBoundary(signal, () => writeFile(path.join(artifactDir, FULL_TREE_NEXT_START_ENTRYPOINT), FULL_TREE_NEXT_START_SOURCE));
-		return {
-			directory: artifactDir,
-			entrypoint: FULL_TREE_NEXT_START_ENTRYPOINT,
-			defaultPortMapping: { http: 3e3 },
-			cleanup: () => rm(outDir, {
-				recursive: true,
-				force: true
-			})
-		};
-	} catch (error) {
-		await rm(outDir, {
-			recursive: true,
-			force: true
-		});
-		throw error;
-	}
-}
-/** Excludes VCS internals and dotenv files (local secrets, superseded by the deploy env). */
-function isExcludedFromFullTreeArtifact(basename) {
-	return basename === ".git" || basename === ".env" || basename.startsWith(".env.");
-}
-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 set build.outputDirectory in prisma.compute.ts.`);
-		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);
-	const appRoot = path.resolve(options.appPath);
-	await copyPathMaterializingSymlinks(standaloneRoot, artifactRoot, {
-		standaloneRoot,
-		appRoot,
-		sourceRoot: await resolveSourceRoot(appRoot, options.signal),
-		signal: options.signal
-	});
-	await hoistIsolatedStoreDependencies(path.join(artifactRoot, "node_modules"), options.signal);
-}
-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(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;
-}
-/**
-* pnpm and bun (isolated linker) both keep packages in a virtual store with a
-* shared symlink farm (`.pnpm/node_modules`, `.bun/node_modules`). Hoist the
-* farm entries to the artifact's node_modules root so Node-style resolution
-* works after symlinks are materialized.
-*/
-async function hoistIsolatedStoreDependencies(nodeModulesDir, signal) {
-	await hoistStoreDependencies(nodeModulesDir, path.join(nodeModulesDir, ".pnpm", "node_modules"), signal);
-	await hoistStoreDependencies(nodeModulesDir, path.join(nodeModulesDir, ".bun", "node_modules"), signal);
-}
-async function hoistStoreDependencies(nodeModulesDir, storeNodeModulesDir, signal) {
-	if (!await directoryExists(storeNodeModulesDir, signal)) return;
-	const entries = await unsupportedFilesystemBoundary(signal, () => readdir(storeNodeModulesDir, { withFileTypes: true }));
-	for (const entry of entries) {
-		const sourcePath = path.join(storeNodeModulesDir, entry.name);
-		if (entry.name.startsWith("@") && entry.isDirectory()) {
-			const scopedEntries = await unsupportedFilesystemBoundary(signal, () => readdir(sourcePath, { withFileTypes: true }));
-			for (const scopedEntry of scopedEntries) {
-				const scopedDestination = path.join(nodeModulesDir, entry.name, scopedEntry.name);
-				if (await pathExists(scopedDestination, signal)) continue;
-				await unsupportedFilesystemBoundary(signal, () => mkdir(path.dirname(scopedDestination), { recursive: true }));
-				await copyPathMaterializingSymlinks(path.join(sourcePath, scopedEntry.name), scopedDestination, {
-					standaloneRoot: storeNodeModulesDir,
-					appRoot: nodeModulesDir,
-					sourceRoot: nodeModulesDir,
-					signal
-				});
-			}
-			continue;
-		}
-		const destinationPath = path.join(nodeModulesDir, entry.name);
-		if (await pathExists(destinationPath, signal)) continue;
-		await copyPathMaterializingSymlinks(sourcePath, destinationPath, {
-			standaloneRoot: storeNodeModulesDir,
-			appRoot: nodeModulesDir,
-			sourceRoot: nodeModulesDir,
-			signal
-		});
-	}
-}
-async function normalizeArtifactSymlinks(artifactDir, appPath, signal) {
-	const normalizedArtifactDir = path.resolve(artifactDir);
-	const normalizedAppPath = path.resolve(appPath);
-	await walkDirectory(normalizedArtifactDir);
-	async function walkDirectory(directory) {
-		const entries = await unsupportedFilesystemBoundary(signal, () => readdir(directory, { withFileTypes: true }));
-		for (const entry of entries) {
-			const fullPath = path.join(directory, entry.name);
-			if (entry.isDirectory()) {
-				await walkDirectory(fullPath);
-				continue;
-			}
-			if (!entry.isSymbolicLink()) continue;
-			const target = await unsupportedFilesystemBoundary(signal, () => readlink(fullPath));
-			const resolvedTarget = path.resolve(path.dirname(fullPath), target);
-			if (isPathWithin(normalizedArtifactDir, resolvedTarget)) continue;
-			if (!isPathWithin(normalizedAppPath, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
-			const targetStat = await unsupportedFilesystemBoundary(signal, () => stat(resolvedTarget));
-			await unsupportedFilesystemBoundary(signal, () => rm(fullPath, {
-				force: true,
-				recursive: true
-			}));
-			await unsupportedFilesystemBoundary(signal, () => cp(resolvedTarget, fullPath, {
-				recursive: targetStat.isDirectory(),
-				dereference: true
-			}));
-			if (targetStat.isDirectory()) await walkDirectory(fullPath);
-		}
-	}
-}
-function isPathWithin(rootPath, candidatePath) {
-	const relativePath = path.relative(rootPath, candidatePath);
-	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
-}
-function isPathWithinWorkspaceDependency(sourceRoot, candidatePath) {
-	return isPathWithin(path.join(sourceRoot, "node_modules"), candidatePath);
-}
-async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
-	const sourceStat = await unsupportedFilesystemBoundary(options.signal, () => lstat(sourcePath));
-	if (sourceStat.isSymbolicLink()) {
-		const resolvedTarget = await resolveSymlinkTarget(sourcePath, options);
-		if (resolvedTarget === null) return;
-		await copyPathMaterializingSymlinks(resolvedTarget, destinationPath, options);
-		return;
-	}
-	if (sourceStat.isDirectory()) {
-		await unsupportedFilesystemBoundary(options.signal, () => mkdir(destinationPath, { recursive: true }));
-		const entries = await unsupportedFilesystemBoundary(options.signal, () => readdir(sourcePath, { withFileTypes: true }));
-		for (const entry of entries) await copyPathMaterializingSymlinks(path.join(sourcePath, entry.name), path.join(destinationPath, entry.name), options);
-		return;
-	}
-	if (sourceStat.isFile()) {
-		await unsupportedFilesystemBoundary(options.signal, () => mkdir(path.dirname(destinationPath), { recursive: true }));
-		await unsupportedFilesystemBoundary(options.signal, () => copyFile(sourcePath, destinationPath));
-		await unsupportedFilesystemBoundary(options.signal, () => chmod(destinationPath, sourceStat.mode));
-	}
-}
-async function resolveSymlinkTarget(symlinkPath, options) {
-	const linkTarget = await unsupportedFilesystemBoundary(options.signal, () => readlink(symlinkPath));
-	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
-	if (await pathExists(resolvedTarget, options.signal)) {
-		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithinWorkspaceDependency(options.sourceRoot, resolvedTarget)) throw new Error(`Build artifact symlink escapes the app directory: ${resolvedTarget}`);
-		return resolvedTarget;
-	}
-	if (isPathWithin(options.standaloneRoot, resolvedTarget)) {
-		const fallbackTarget = path.join(options.appRoot, path.relative(options.standaloneRoot, resolvedTarget));
-		if (await pathExists(fallbackTarget, options.signal)) return fallbackTarget;
-	}
-	if (isPnpmHoistLink(symlinkPath)) return null;
-	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
-}
-function isPnpmHoistLink(symlinkPath) {
-	const parts = path.dirname(symlinkPath).split(path.sep);
-	for (let i = 0; i < parts.length - 1; i++) if (parts[i] === ".pnpm" && parts[i + 1] === "node_modules") return true;
-	return false;
-}
-async function pathExists(targetPath, signal) {
-	try {
-		await unsupportedFilesystemBoundary(signal, () => stat(targetPath));
-		return true;
-	} catch (error) {
-		if (signal?.aborted) throw error;
-		return false;
-	}
-}
-async function directoryExists(targetPath, signal) {
-	try {
-		return (await unsupportedFilesystemBoundary(signal, () => stat(targetPath))).isDirectory();
-	} catch (error) {
-		if (signal?.aborted) throw error;
-		return false;
-	}
-}
-async function unsupportedFilesystemBoundary(signal, operation) {
-	signal?.throwIfAborted();
-	const result = await operation();
-	signal?.throwIfAborted();
-	return result;
-}
-//#endregion
-export { PREVIEW_BUILD_TYPES, PreviewBuildStrategy, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild };

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

@@ -1,5 +0,0 @@
-import "../../shell/prompt.js";
-//#region src/lib/app/preview-interaction.ts
-const PREVIEW_DEFAULT_REGION = "eu-central-1";
-//#endregion
-export { PREVIEW_DEFAULT_REGION };