Merge pull request #82 from prisma/feat/sandbox-build-fallbacks

kristof-siket · web-flow · commit 683504df7242 · 2026-06-12T10:19:07.000+02:00
feat(app): degrade gracefully when standalone output or the prisma CLI is missing
diff --git a/packages/cli/src/lib/app/branch-database.ts b/packages/cli/src/lib/app/branch-database.ts
@@ -134,7 +134,8 @@ export async function runBranchDatabaseSchemaSetup(options: {
   directUrl: string | null;
 }): Promise<BranchDatabaseSchemaSetupResult> {
   const schemaPath = path.relative(options.context.runtime.cwd, options.schema.path) || defaultSchemaSourcePath(options.schema);
-  const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl);
+  const prisma = await resolvePrismaInvocation(options.context.runtime.cwd);
+  const commands = buildSchemaSetupCommands(options.schema, schemaPath, options.databaseUrl, prisma);
 
   for (const command of commands) {
     await runPrismaCommand({
@@ -411,21 +412,92 @@ async function readTextFileIfSmall(filePath: string, signal: AbortSignal): Promi
   return readFile(filePath, { encoding: "utf8", signal });
 }
 
-function buildSchemaSetupCommands(schema: BranchDatabaseSchema, schemaPath: string, databaseUrl: string): Array<{
+// Last resort for repos that ship a schema with no Prisma packages
+// installed at all. Pinned to the 6.x line: Prisma 7 rejects the classic
+// `url = env(...)` datasource form (P1012), which is exactly the schema
+// shape such repos have. Bump deliberately, never to `latest`.
+const FALLBACK_PRISMA_CLI_VERSION = "6.19.3";
+
+interface PrismaInvocation {
+  argsPrefix: string[];
+  displayPrefix: string;
+}
+
+/**
+ * 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: string): Promise<PrismaInvocation> {
+  if (await localPrismaBinExists(cwd)) {
+    return {
+      argsPrefix: ["--no-install", "prisma"],
+      displayPrefix: "npx --no-install prisma",
+    };
+  }
+
+  const clientVersion = await readInstalledPrismaClientVersion(cwd);
+  const pinned = clientVersion ?? 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: string): Promise<boolean> {
+  const binDir = path.join(cwd, "node_modules", ".bin");
+  const checks = await Promise.all(
+    ["prisma", "prisma.cmd", "prisma.ps1"].map((name) =>
+      fileExists(path.join(binDir, name)),
+    ),
+  );
+  return checks.some(Boolean);
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readInstalledPrismaClientVersion(cwd: string): Promise<string | null> {
+  try {
+    const raw = await readFile(
+      path.join(cwd, "node_modules", "@prisma", "client", "package.json"),
+      { encoding: "utf8" },
+    );
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const version = (parsed as { version?: unknown }).version;
+    return typeof version === "string" && version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+function buildSchemaSetupCommands(schema: BranchDatabaseSchema, schemaPath: string, databaseUrl: string, prisma: PrismaInvocation): Array<{
   args: string[];
   displayCommand: string;
 }> {
   if (schema.command === "migrate-deploy") {
     return [{
-      args: ["--no-install", "prisma", "migrate", "deploy", "--schema", schemaPath],
-      displayCommand: "npx --no-install prisma migrate deploy",
+      args: [...prisma.argsPrefix, "migrate", "deploy", "--schema", schemaPath],
+      displayCommand: `${prisma.displayPrefix} migrate deploy`,
     }];
   }
 
   if (schema.command === "db-push") {
     return [{
-      args: ["--no-install", "prisma", "db", "push", "--schema", schemaPath],
-      displayCommand: "npx --no-install prisma db push",
+      args: [...prisma.argsPrefix, "db", "push", "--schema", schemaPath],
+      displayCommand: `${prisma.displayPrefix} db push`,
     }];
   }
 
diff --git a/packages/cli/src/lib/app/preview-build.ts b/packages/cli/src/lib/app/preview-build.ts
@@ -1,4 +1,4 @@
-import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readdir, readFile, readlink, rm, stat } from "node:fs/promises";
+import { chmod, copyFile, cp, lstat, mkdir, mkdtemp, readdir, readFile, readlink, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
@@ -236,10 +236,10 @@ class PreviewNextjsBuild implements BuildStrategy {
 
     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}.`,
-      );
+      // No `output: "standalone"` in next.config: the build itself
+      // succeeded, so package the full tree and serve with `next start`
+      // instead of failing. Bigger artifact, same running app.
+      return stageNextjsFullTreeFallbackArtifact(this.#appPath, signal);
     }
 
     const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
@@ -274,6 +274,66 @@ class PreviewNextjsBuild implements BuildStrategy {
   }
 }
 
+const FULL_TREE_NEXT_START_ENTRYPOINT = "prisma-next-start.cjs";
+
+// Bootstrap for apps built without `output: "standalone"`. Entering through
+// the CLI bin (not `next/dist/server/lib/start-server`) keeps Next in charge
+// of config loading, which is the part that drifts across Next majors.
+const FULL_TREE_NEXT_START_SOURCE = [
+  // The runtime starts us at the unpack root, but `next start` resolves `.next` from cwd.
+  "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: string, signal?: AbortSignal): Promise<BuildArtifact> {
+  const outDir = await unsupportedFilesystemBoundary(signal, () => mkdtemp(path.join(os.tmpdir(), "compute-build-")));
+
+  try {
+    const artifactDir = path.join(outDir, "app");
+    // node_modules ships on purpose: without standalone output the artifact
+    // must carry the full runtime dependency tree for `next start`.
+    await unsupportedFilesystemBoundary(signal, () =>
+      cp(appPath, artifactDir, {
+        recursive: true,
+        // Keep relative symlinks relative (node_modules/.bin/*): the default
+        // rewrites them to absolute paths into the source tree, which the
+        // archiver rejects as escaping the artifact root.
+        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: 3000 },
+      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: string): boolean {
+  return (
+    basename === ".git" ||
+    basename === ".env" ||
+    basename.startsWith(".env.")
+  );
+}
+
 class PreviewTanstackStartBuild implements BuildStrategy {
   readonly #appPath: string;
   readonly #buildSettings?: PreviewBuildSettings;
diff --git a/packages/cli/tests/app-branch-database.test.ts b/packages/cli/tests/app-branch-database.test.ts
@@ -123,6 +123,8 @@ describe("app deploy branch database setup", () => {
     );
 
     spawn.mockClear();
+    await mkdir(path.join(cwd, "node_modules/.bin"), { recursive: true });
+    await writeFile(path.join(cwd, "node_modules/.bin/prisma"), "");
     await runBranchDatabaseSchemaSetup({
       context,
       schema: {
@@ -150,6 +152,113 @@ describe("app deploy branch database setup", () => {
     expect(spawn.mock.calls[0]?.[1]).not.toContain("--skip-generate");
   });
 
+  it("falls back to a versioned npx prisma matched to @prisma/client when the prisma CLI is not installed", async () => {
+    const spawn = vi.fn().mockImplementation(() => {
+      const child = new EventEmitter();
+      queueMicrotask(() => child.emit("close", 0, null));
+      return child;
+    });
+    vi.doMock("node:child_process", async (importOriginal) => {
+      const actual = await importOriginal<typeof import("node:child_process")>();
+      return {
+        ...actual,
+        spawn,
+      };
+    });
+
+    const { createTempCwd, createTestCommandContext } = await import("./helpers");
+    const { runBranchDatabaseSchemaSetup } = await import("../src/lib/app/branch-database");
+    const cwd = await createTempCwd();
+    await mkdir(path.join(cwd, "prisma"), { recursive: true });
+    await writeFile(path.join(cwd, "prisma/schema.prisma"), "datasource db { provider = \"postgresql\" url = env(\"DATABASE_URL\") }\n");
+    await mkdir(path.join(cwd, "node_modules/@prisma/client"), { recursive: true });
+    await writeFile(
+      path.join(cwd, "node_modules/@prisma/client/package.json"),
+      JSON.stringify({ name: "@prisma/client", version: "5.22.0" }),
+    );
+    const { context } = await createTestCommandContext({
+      cwd,
+      stateDir: path.join(cwd, ".state"),
+      flags: {
+        quiet: true,
+      },
+      env: {
+        ...process.env,
+        PRISMA_CLI_MOCK_FIXTURE_PATH: undefined,
+      },
+    });
+
+    await runBranchDatabaseSchemaSetup({
+      context,
+      schema: {
+        kind: "prisma-orm",
+        path: path.join(cwd, "prisma/schema.prisma"),
+        command: "db-push",
+        hasMigrations: false,
+        target: "postgresql",
+      },
+      databaseUrl: "postgres://pooled",
+      directUrl: null,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      "npx",
+      ["--yes", "prisma@5.22.0", "db", "push", "--schema", "prisma/schema.prisma"],
+      expect.objectContaining({ cwd }),
+    );
+  });
+
+  it("falls back to the pinned prisma version when neither the CLI nor @prisma/client is installed", async () => {
+    const spawn = vi.fn().mockImplementation(() => {
+      const child = new EventEmitter();
+      queueMicrotask(() => child.emit("close", 0, null));
+      return child;
+    });
+    vi.doMock("node:child_process", async (importOriginal) => {
+      const actual = await importOriginal<typeof import("node:child_process")>();
+      return {
+        ...actual,
+        spawn,
+      };
+    });
+
+    const { createTempCwd, createTestCommandContext } = await import("./helpers");
+    const { runBranchDatabaseSchemaSetup } = await import("../src/lib/app/branch-database");
+    const cwd = await createTempCwd();
+    await mkdir(path.join(cwd, "prisma"), { recursive: true });
+    await writeFile(path.join(cwd, "prisma/schema.prisma"), "datasource db { provider = \"postgresql\" url = env(\"DATABASE_URL\") }\n");
+    const { context } = await createTestCommandContext({
+      cwd,
+      stateDir: path.join(cwd, ".state"),
+      flags: {
+        quiet: true,
+      },
+      env: {
+        ...process.env,
+        PRISMA_CLI_MOCK_FIXTURE_PATH: undefined,
+      },
+    });
+
+    await runBranchDatabaseSchemaSetup({
+      context,
+      schema: {
+        kind: "prisma-orm",
+        path: path.join(cwd, "prisma/schema.prisma"),
+        command: "migrate-deploy",
+        hasMigrations: true,
+        target: "postgresql",
+      },
+      databaseUrl: "postgres://pooled",
+      directUrl: null,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      "npx",
+      ["--yes", "prisma@6.19.3", "migrate", "deploy", "--schema", "prisma/schema.prisma"],
+      expect.objectContaining({ cwd }),
+    );
+  });
+
   it("deploy --db creates a branch database, applies schema, and writes branch env overrides before deploying", async () => {
     const requireComputeAuth = vi.fn().mockResolvedValue(createProjectClient());
     const branchId = "branch_feature_db";
diff --git a/packages/cli/tests/app-build.test.ts b/packages/cli/tests/app-build.test.ts
@@ -1,4 +1,4 @@
-import { lstat, mkdir, readFile, symlink, writeFile } from "node:fs/promises";
+import { access, lstat, mkdir, readFile, readlink, symlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
 
@@ -52,6 +52,66 @@ describe("preview build strategy", () => {
     }, null, 2)}\n`);
   });
 
+  it("packages the full tree with a next start launcher when the build produces no standalone output", async () => {
+    const { PreviewBuildStrategy } = await import("../src/lib/app/preview-build");
+    const cwd = await createTempCwd();
+    const appPath = path.join(cwd, "app");
+
+    await mkdir(path.join(appPath, ".next"), { recursive: true });
+    await mkdir(path.join(appPath, "node_modules/next"), { recursive: true });
+    await writeFile(
+      path.join(appPath, "package.json"),
+      JSON.stringify({ dependencies: { next: "15.0.0" } }),
+      "utf8",
+    );
+    await writeFile(path.join(appPath, ".next/BUILD_ID"), "fallback-test", "utf8");
+    await writeFile(path.join(appPath, ".env"), "SECRET=should-not-ship", "utf8");
+    await writeFile(path.join(appPath, ".env.local"), "SECRET=should-not-ship", "utf8");
+    await writeFile(
+      path.join(appPath, "node_modules/next/package.json"),
+      JSON.stringify({ name: "next", version: "15.0.0" }),
+      "utf8",
+    );
+    await mkdir(path.join(appPath, "node_modules/.bin"), { recursive: true });
+    await symlink("../next/package.json", path.join(appPath, "node_modules/.bin/next-link"));
+
+    const strategy = new PreviewBuildStrategy({
+      appPath,
+      buildType: "nextjs",
+      buildSettings: {
+        buildCommand: null,
+        buildCommandSource: null,
+        outputDirectory: ".next/standalone",
+        outputDirectorySource: null,
+      },
+    });
+
+    const artifact = await strategy.execute();
+    try {
+      expect(artifact.entrypoint).toBe("prisma-next-start.cjs");
+      expect(artifact.defaultPortMapping).toEqual({ http: 3000 });
+
+      const launcher = await readFile(path.join(artifact.directory, "prisma-next-start.cjs"), "utf8");
+      expect(launcher).toContain('require("next/dist/bin/next")');
+      expect(launcher).toContain('process.argv.push("start"');
+      expect(launcher).toContain("process.chdir(__dirname)");
+
+      await expect(readFile(path.join(artifact.directory, ".next/BUILD_ID"), "utf8")).resolves.toBe("fallback-test");
+      await expect(readFile(path.join(artifact.directory, "node_modules/next/package.json"), "utf8")).resolves.toContain("15.0.0");
+
+      const linkPath = path.join(artifact.directory, "node_modules/.bin/next-link");
+      expect((await lstat(linkPath)).isSymbolicLink()).toBe(true);
+      await expect(readlink(linkPath)).resolves.toBe("../next/package.json");
+
+      await expect(access(path.join(artifact.directory, ".env"))).rejects.toThrow();
+      await expect(access(path.join(artifact.directory, ".env.local"))).rejects.toThrow();
+    } finally {
+      const stagedDir = artifact.directory;
+      await artifact.cleanup?.();
+      await expect(access(stagedDir)).rejects.toThrow();
+    }
+  });
+
   it("creates TanStack and Hono build config defaults", async () => {
     const { resolveOrCreatePreviewBuildSettings } = await import("../src/lib/app/preview-build");
     const cwd = await createTempCwd();
