@prisma/compute-sdk 0.26.0 → 0.27.0

package/src/bun-build.ts

@@ -1,4 +1,3 @@
-import { execFile } from "node:child_process";
 import {
   access,
   mkdir,
@@ -9,20 +8,40 @@ import {
 } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import type { BuildSettings } from "./build-settings.ts";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
 import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
+import {
+  type BuildCommandIo,
+  buildCommandEnv,
+  runBuildCommand,
+  runChildProcess,
+} from "./workspace.ts";
 
 /**
  * Build strategy that runs `bun build` CLI and manages its own temp output directory.
  * Owns entrypoint resolution from explicit arg or package.json main field.
+ *
+ * When build settings carry a build command (a `package.json` build script),
+ * it runs first — so a Bun app can compile assets or generate code before the
+ * entrypoint is bundled.
  */
 export class BunBuild implements BuildStrategy {
   readonly #appPath: string;
   readonly #entrypoint?: string;
-
-  constructor(options: { appPath: string; entrypoint?: string }) {
+  readonly #buildSettings?: BuildSettings;
+  readonly #io?: BuildCommandIo;
+
+  constructor(options: {
+    appPath: string;
+    entrypoint?: string;
+    buildSettings?: BuildSettings;
+    io?: BuildCommandIo;
+  }) {
     this.#appPath = options.appPath;
     this.#entrypoint = options.entrypoint;
+    this.#buildSettings = options.buildSettings;
+    this.#io = options.io;
   }
 
   async canBuild(_signal?: AbortSignal): Promise<boolean> {
@@ -31,6 +50,16 @@ export class BunBuild implements BuildStrategy {
 
   async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     signal?.throwIfAborted();
+    if (this.#buildSettings?.buildCommand) {
+      await runBuildCommand({
+        appPath: this.#appPath,
+        command: this.#buildSettings.buildCommand,
+        failurePrefix: "Bun",
+        env: this.#io?.env,
+        onOutput: this.#io?.onOutput,
+        signal,
+      });
+    }
     const entrypoint = await this.#resolveEntrypoint(signal);
 
     const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
@@ -129,15 +158,20 @@ export class BunBuild implements BuildStrategy {
     return typeof parsed.main === "string" ? parsed.main : undefined;
   }
 
-  #runBuild(
+  async #runBuild(
     absoluteEntrypoint: string,
     bundleDir: string,
     signal?: AbortSignal,
   ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      execFile(
-        "bun",
-        [
+    const env = await buildCommandEnv(
+      this.#appPath,
+      { ...process.env, ...this.#io?.env },
+      signal,
+    );
+    try {
+      await runChildProcess({
+        command: "bun",
+        args: [
           "build",
           absoluteEntrypoint,
           "--outdir",
@@ -146,25 +180,24 @@ export class BunBuild implements BuildStrategy {
           "bun",
           "--sourcemap=external",
         ],
-        { signal },
-        (error, _stdout, stderr) => {
-          if (error) {
-            if ("code" in error && error.code === "ENOENT") {
-              reject(
-                new Error(
-                  "Bun is required to build the application but was not found. Install it from https://bun.sh",
-                ),
-              );
-              return;
-            }
-            const message = stderr.trim() || error.message;
-            reject(new Error(`Bun build failed:\n${message}`));
-            return;
-          }
-          resolve();
-        },
-      );
-    });
+        cwd: this.#appPath,
+        env,
+        failurePrefix: "Bun",
+        onOutput: this.#io?.onOutput,
+        signal,
+      });
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        (error as NodeJS.ErrnoException).code === "ENOENT"
+      ) {
+        throw new Error(
+          "Bun is required to build the application but was not found. Install it from https://bun.sh",
+        );
+      }
+      throw error;
+    }
   }
 
   #selectRuntimeEntrypoint(

package/src/index.ts

@@ -14,8 +14,26 @@ export type {
 export { applyMigrations } from "./apply-migrations.ts";
 export { createArchive } from "./archive.ts";
 export { normalizeArtifactSymlinks } from "./artifact-postprocess.ts";
+export {
+  hoistIsolatedStoreDependencies,
+  stageStandaloneArtifact,
+} from "./artifact-stage.ts";
 export { AstroBuild } from "./astro-build.ts";
 export { AutoBuild } from "./auto-build.ts";
+export {
+  type BuildStrategyHooks,
+  type BuildType,
+  createBuildStrategy,
+  resolveBuildStrategy,
+} from "./build.ts";
+export {
+  type BuildSettings,
+  joinPosix,
+  nextOutputRootFromStandaloneDirectory,
+  readStaticNextConfig,
+  resolveBuildSettings,
+  resolveConfiguredBuildSettings,
+} from "./build-settings.ts";
 export type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
 export { PreBuilt } from "./build-strategy.ts";
 export { BunBuild } from "./bun-build.ts";
@@ -111,3 +129,13 @@ export type {
 } from "./types.ts";
 export { KNOWN_REGION_IDS, REGIONS } from "./types.ts";
 export { uploadArtifact } from "./upload-artifact.ts";
+export {
+  type BuildCommandIo,
+  buildCommandEnv,
+  type PackageManager,
+  type PackageManifest,
+  readBuildScript,
+  readPackageManifest,
+  resolvePackageManager,
+  runBuildCommand,
+} from "./workspace.ts";

package/src/nextjs-build.ts

@@ -1,14 +1,17 @@
-import { cp, mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import { cp, mkdtemp, readdir, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { normalizeArtifactSymlinks } from "./artifact-postprocess.ts";
-import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+
+import { stageStandaloneArtifact } from "./artifact-stage.ts";
 import {
-  hasPackageDependency,
-  hasRootFile,
-  runPackageCli,
-} from "./build-strategy.ts";
+  type BuildSettings,
+  nextOutputRootFromStandaloneDirectory,
+  resolveBuildSettings,
+} from "./build-settings.ts";
+import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+import { hasPackageDependency, hasRootFile } from "./build-strategy.ts";
 import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
+import { type BuildCommandIo, runBuildCommand } from "./workspace.ts";
 
 const NEXT_CONFIG_FILENAMES = [
   "next.config.js",
@@ -18,14 +21,30 @@ const NEXT_CONFIG_FILENAMES = [
 ];
 
 /**
- * Build strategy for Next.js applications using standalone output mode.
- * Runs `next build` and produces an artifact from `.next/standalone`.
+ * Build strategy for Next.js applications. Runs the resolved build command
+ * (the user's `package.json` build script, or `next build`), then stages the
+ * `output: "standalone"` tree — materializing workspace symlinks and hoisting
+ * isolated-store dependencies. Apps built without standalone output fall back
+ * to packaging the full tree and serving with `next start`, unless
+ * `requireStandalone` is set (a disk-limited deploy target opts out of that).
  */
 export class NextjsBuild implements BuildStrategy {
   readonly #appPath: string;
+  readonly #buildSettings?: BuildSettings;
+  readonly #io?: BuildCommandIo;
+  readonly #requireStandalone: boolean;
 
-  constructor(options: { appPath: string }) {
+  constructor(options: {
+    appPath: string;
+    buildSettings?: BuildSettings;
+    io?: BuildCommandIo;
+    /** Fail instead of falling back to the full-tree `next start` artifact. */
+    requireStandalone?: boolean;
+  }) {
     this.#appPath = options.appPath;
+    this.#buildSettings = options.buildSettings;
+    this.#io = options.io;
+    this.#requireStandalone = options.requireStandalone ?? false;
   }
 
   async canBuild(signal?: AbortSignal): Promise<boolean> {
@@ -37,67 +56,57 @@ export class NextjsBuild implements BuildStrategy {
 
   async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     signal?.throwIfAborted();
-    await runPackageCli({
-      appPath: this.#appPath,
-      cliName: "next",
-      args: ["build"],
-      failurePrefix: "Next.js",
-      missingMessage:
-        "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.",
-      signal,
-    });
+    const settings =
+      this.#buildSettings ??
+      (await resolveBuildSettings({
+        appPath: this.#appPath,
+        buildType: "nextjs",
+        signal,
+      }));
+    if (settings.buildCommand) {
+      await runBuildCommand({
+        appPath: this.#appPath,
+        command: settings.buildCommand,
+        failurePrefix: "Next.js",
+        env: this.#io?.env,
+        onOutput: this.#io?.onOutput,
+        signal,
+      });
+    }
 
-    const standaloneDir = path.join(this.#appPath, ".next", "standalone");
-    const standaloneStat = await stat(standaloneDir).catch(() => null);
-    if (!standaloneStat?.isDirectory()) {
-      throw new Error(
-        'Next.js build did not produce standalone output. Add output: "standalone" to your next.config file.',
-      );
+    const standaloneDir = path.join(this.#appPath, settings.outputDirectory);
+    if (!(await directoryExists(standaloneDir))) {
+      if (this.#requireStandalone) {
+        throw new Error(
+          `Next.js build did not produce standalone output at ${settings.outputDirectory}. ` +
+            'Set output: "standalone" in your next.config; this deploy target requires it.',
+        );
+      }
+      // No `output: "standalone"` in next.config: the build succeeded, so
+      // package the full tree and serve with `next start`. Bigger artifact,
+      // same running app.
+      return stageFullTreeFallbackArtifact(this.#appPath, signal);
     }
 
     const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
-
     try {
       const artifactDir = path.join(outDir, "app");
-
-      await cp(standaloneDir, artifactDir, {
-        recursive: true,
-        verbatimSymlinks: true,
+      await stageStandaloneArtifact({
+        standaloneDir,
+        artifactDir,
+        appPath: this.#appPath,
+        signal,
+      });
+      const entrypoint = await findStandaloneEntrypoint(artifactDir);
+      await copyStaticAssets({
+        appPath: this.#appPath,
+        artifactDir,
+        outputRoot: nextOutputRootFromStandaloneDirectory(
+          settings.outputDirectory,
+        ),
+        entrypoint,
+        signal,
       });
-
-      // In monorepos, Next preserves the workspace-relative path from the
-      // workspace root down to the app, so server.js lands at e.g.
-      // .next/standalone/apps/web/server.js, not at the standalone root.
-      // The runtime needs the correct entrypoint, and Next expects public/
-      // and .next/static/ to be siblings of server.js.
-      const serverSubpath = await findServerSubpath(artifactDir);
-      const serverDir =
-        serverSubpath === undefined
-          ? artifactDir
-          : path.join(artifactDir, serverSubpath);
-
-      const publicDir = path.join(this.#appPath, "public");
-      if (await directoryExists(publicDir)) {
-        await cp(publicDir, path.join(serverDir, "public"), {
-          recursive: true,
-          verbatimSymlinks: true,
-        });
-      }
-
-      const staticDir = path.join(this.#appPath, ".next", "static");
-      if (await directoryExists(staticDir)) {
-        await cp(staticDir, path.join(serverDir, ".next", "static"), {
-          recursive: true,
-          verbatimSymlinks: true,
-        });
-      }
-
-      const entrypoint =
-        serverSubpath === undefined
-          ? "server.js"
-          : path.posix.join(serverSubpath, "server.js");
-
-      await normalizeArtifactSymlinks(artifactDir, this.#appPath, signal);
 
       return {
         directory: artifactDir,
@@ -112,55 +121,149 @@ export class NextjsBuild implements BuildStrategy {
   }
 }
 
-async function directoryExists(dirPath: string): Promise<boolean> {
-  const s = await stat(dirPath).catch(() => null);
-  return s?.isDirectory() ?? false;
+const FULL_TREE_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_START_SOURCE = [
+  // The runtime unpacks us at the artifact 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 stageFullTreeFallbackArtifact(
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<BuildArtifact> {
+  const outDir = await 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`.
+    signal?.throwIfAborted();
+    await 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) => !isExcludedFromFullTree(path.basename(source)),
+    });
+    signal?.throwIfAborted();
+    await writeFile(
+      path.join(artifactDir, FULL_TREE_ENTRYPOINT),
+      FULL_TREE_START_SOURCE,
+    );
+
+    return {
+      directory: artifactDir,
+      entrypoint: FULL_TREE_ENTRYPOINT,
+      defaultPortMapping: { http: defaultHttpPortForBuildType("nextjs") },
+      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 isExcludedFromFullTree(basename: string): boolean {
+  return (
+    basename === ".git" || basename === ".env" || basename.startsWith(".env.")
+  );
+}
+
+async function copyStaticAssets(options: {
+  appPath: string;
+  artifactDir: string;
+  outputRoot: string;
+  entrypoint: string;
+  signal?: AbortSignal;
+}): Promise<void> {
+  const serverSubpath = serverSubpathOf(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?.throwIfAborted();
+    await 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?.throwIfAborted();
+    await cp(staticDir, path.join(serverDir, options.outputRoot, "static"), {
+      recursive: true,
+      verbatimSymlinks: true,
+    });
+  }
 }
 
 /**
- * Scan the Next.js standalone output to find the directory that contains
- * server.js, relative to the standalone root. Returns undefined when
- * server.js is at the root (single-app repos) and a posix-joined subpath
- * like "apps/web" for monorepos. node_modules is skipped because
- * third-party packages may ship a file named server.js.
+ * Locates `server.js` in the staged standalone output. In monorepos Next
+ * preserves the workspace-relative path (e.g. `apps/web/server.js`), so the
+ * entrypoint is the shallowest match. `node_modules` is skipped because
+ * third-party packages may ship their own `server.js`.
  */
-async function findServerSubpath(
-  standaloneDir: string,
-): Promise<string | undefined> {
-  const matches: (string | undefined)[] = [];
-
-  async function walk(
-    currentDir: string,
-    relative: string | undefined,
-  ): Promise<void> {
-    const entries = await readdir(currentDir, { withFileTypes: true });
+async function findStandaloneEntrypoint(artifactDir: string): Promise<string> {
+  const rootStat = await stat(path.join(artifactDir, "server.js")).catch(
+    () => null,
+  );
+  if (rootStat?.isFile()) {
+    return "server.js";
+  }
+
+  const candidates: string[] = [];
+  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: string): Promise<void> {
+    const entries = await readdir(directory, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.name === "node_modules") continue;
-      const fullPath = path.join(currentDir, entry.name);
+      if (entry.name === "node_modules") {
+        continue;
+      }
+      const fullPath = path.join(directory, entry.name);
       if (entry.isDirectory()) {
-        const nextRelative =
-          relative === undefined
-            ? entry.name
-            : path.posix.join(relative, entry.name);
-        await walk(fullPath, nextRelative);
+        await walk(fullPath);
       } else if (entry.isFile() && entry.name === "server.js") {
-        matches.push(relative);
+        candidates.push(
+          path.relative(artifactDir, fullPath).split(path.sep).join("/"),
+        );
       }
     }
   }
+}
 
-  await walk(standaloneDir, undefined);
+function serverSubpathOf(entrypoint: string): string {
+  const dir = path.posix.dirname(entrypoint);
+  return dir === "." ? "" : dir;
+}
 
-  if (matches.length > 1) {
-    const locations = matches.map((m) => m ?? "<root>").join(", ");
-    throw new Error(
-      `Next.js standalone output has multiple server.js files (${locations}). Cannot determine the application entrypoint.`,
-    );
-  }
-  if (matches.length === 0) {
-    throw new Error(
-      "Next.js standalone output is missing server.js. The build may not have completed successfully.",
-    );
-  }
-  return matches[0];
+async function directoryExists(dirPath: string): Promise<boolean> {
+  const s = await stat(dirPath).catch(() => null);
+  return s?.isDirectory() ?? false;
 }

package/src/nuxt-build.ts

@@ -1,6 +1,8 @@
 import { cp, mkdtemp, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+
+import { normalizeArtifactSymlinks } from "./artifact-postprocess.ts";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
 import {
   hasPackageDependency,
@@ -8,6 +10,7 @@ import {
   runPackageCli,
 } from "./build-strategy.ts";
 import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
+import type { BuildCommandIo } from "./workspace.ts";
 
 const NUXT_CONFIG_FILENAMES = [
   "nuxt.config.js",
@@ -23,9 +26,11 @@ const NUXT_CONFIG_FILENAMES = [
  */
 export class NuxtBuild implements BuildStrategy {
   readonly #appPath: string;
+  readonly #io?: BuildCommandIo;
 
-  constructor(options: { appPath: string }) {
+  constructor(options: { appPath: string; io?: BuildCommandIo }) {
     this.#appPath = options.appPath;
+    this.#io = options.io;
   }
 
   async canBuild(signal?: AbortSignal): Promise<boolean> {
@@ -44,6 +49,8 @@ export class NuxtBuild implements BuildStrategy {
       failurePrefix: "Nuxt",
       missingMessage:
         "Could not find the Nuxt CLI. Install it with `npm install nuxt` or ensure npx/bunx is available.",
+      env: this.#io?.env,
+      onOutput: this.#io?.onOutput,
       signal,
     });
 
@@ -64,6 +71,9 @@ export class NuxtBuild implements BuildStrategy {
         recursive: true,
         verbatimSymlinks: true,
       });
+      // Materialize any symlinks into the app/workspace node_modules so the
+      // artifact is self-contained once unpacked elsewhere.
+      await normalizeArtifactSymlinks(artifactDir, this.#appPath, signal);
 
       return {
         directory: artifactDir,