@prisma/cli 3.0.0-alpha.8 → 3.0.0-alpha.9

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

@@ -1,5 +1,5 @@
 import { resolveBunEntrypoint } from "./bun-project.js";
-import { cp, readdir, readlink, rm, stat } from "node:fs/promises";
+import { chmod, copyFile, cp, lstat, mkdir, readFile, readdir, readlink, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { AstroBuild, BunBuild, NextjsBuild, NuxtBuild, TanstackStartBuild } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-build.ts
@@ -46,6 +46,7 @@ async function executePreviewBuild(options) {
 	});
 	const artifact = await strategy.execute();
 	try {
+		if (buildType === "nextjs") await restageNextjsArtifact(artifact.directory, options.appPath);
 		await normalizeArtifactSymlinks(artifact.directory, options.appPath);
 		return {
 			artifact,
@@ -104,6 +105,38 @@ async function createPreviewBuildStrategy(options) {
 		}
 	}
 }
+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)
+	});
+}
+async function restageNextjsArtifact(artifactDir, appPath) {
+	const standaloneDir = path.join(appPath, ".next", "standalone");
+	await rm(artifactDir, {
+		recursive: true,
+		force: true
+	});
+	await stageNextjsStandaloneArtifact({
+		standaloneDir,
+		artifactDir,
+		appPath
+	});
+	const publicDir = path.join(appPath, "public");
+	if (await directoryExists(publicDir)) await cp(publicDir, path.join(artifactDir, "public"), {
+		recursive: true,
+		verbatimSymlinks: true
+	});
+	const staticDir = path.join(appPath, ".next", "static");
+	if (await directoryExists(staticDir)) await cp(staticDir, path.join(artifactDir, ".next", "static"), {
+		recursive: true,
+		verbatimSymlinks: true
+	});
+}
 async function normalizeArtifactSymlinks(artifactDir, appPath) {
 	const normalizedArtifactDir = path.resolve(artifactDir);
 	const normalizedAppPath = path.resolve(appPath);
@@ -138,5 +171,69 @@ function isPathWithin(rootPath, candidatePath) {
 	const relativePath = path.relative(rootPath, candidatePath);
 	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
 }
+async function copyPathMaterializingSymlinks(sourcePath, destinationPath, options) {
+	const sourceStat = await lstat(sourcePath);
+	if (sourceStat.isSymbolicLink()) {
+		await copyPathMaterializingSymlinks(await resolveSymlinkTarget(sourcePath, options), destinationPath, options);
+		return;
+	}
+	if (sourceStat.isDirectory()) {
+		await mkdir(destinationPath, { recursive: true });
+		const entries = await 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 mkdir(path.dirname(destinationPath), { recursive: true });
+		await copyFile(sourcePath, destinationPath);
+		await chmod(destinationPath, sourceStat.mode);
+	}
+}
+async function resolveSymlinkTarget(symlinkPath, options) {
+	const linkTarget = await readlink(symlinkPath);
+	const resolvedTarget = path.resolve(path.dirname(symlinkPath), linkTarget);
+	if (await pathExists(resolvedTarget)) {
+		if (!isPathWithin(options.appRoot, resolvedTarget) && !isPathWithin(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)) return fallbackTarget;
+	}
+	throw new Error(`Next.js standalone symlink target is missing: ${symlinkPath} -> ${linkTarget} (resolved to ${resolvedTarget})`);
+}
+async function pathExists(targetPath) {
+	try {
+		await stat(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function directoryExists(targetPath) {
+	try {
+		return (await stat(targetPath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveSourceRoot(appRoot) {
+	let current = path.resolve(appRoot);
+	while (true) {
+		if (await pathExists(path.join(current, ".git")) || await pathExists(path.join(current, "pnpm-workspace.yaml")) || await pathExists(path.join(current, "bun.lock")) || await pathExists(path.join(current, "bun.lockb")) || await packageJsonDeclaresWorkspaces(current)) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return path.resolve(appRoot);
+		current = parent;
+	}
+}
+async function packageJsonDeclaresWorkspaces(directory) {
+	try {
+		const content = await readFile(path.join(directory, "package.json"), "utf8");
+		const parsed = JSON.parse(content);
+		return Boolean(parsed.workspaces);
+	} catch {
+		return false;
+	}
+}
 //#endregion
 export { PREVIEW_BUILD_TYPES, PreviewBuildStrategy, RESOLVED_PREVIEW_BUILD_TYPES, executePreviewBuild };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-alpha.8",
+  "version": "3.0.0-alpha.9",
   "description": "Preview of the unified Prisma CLI.",
   "type": "module",
   "bin": {