@prisma/compute-sdk 0.26.0 → 0.28.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/config/frameworks.ts

@@ -11,6 +11,7 @@ export type FrameworkBuildType =
   | "nextjs"
   | "nuxt"
   | "astro"
+  | "nestjs"
   | "tanstack-start"
   | "bun";
 
@@ -108,6 +109,18 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     hasLocalDevServer: true,
     defaultHttpPort: 3000,
   },
+  {
+    key: "nestjs",
+    displayName: "NestJS",
+    buildType: "nestjs",
+    aliases: ["nestjs", "nest"],
+    detectPackages: ["@nestjs/core"],
+    detectConfigFiles: ["nest-cli.json"],
+    usesEntrypoint: false,
+    defaultEntrypoint: null,
+    hasLocalDevServer: false,
+    defaultHttpPort: 3000,
+  },
   {
     key: "tanstack-start",
     displayName: "TanStack Start",

package/src/config/types.ts

@@ -11,6 +11,7 @@ export const COMPUTE_FRAMEWORKS = [
   "nuxt",
   "astro",
   "hono",
+  "nestjs",
   "tanstack-start",
   "bun",
 ] as const;

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";
@@ -94,6 +112,7 @@ export type {
   TerminalRecord,
 } from "./log-stream.ts";
 export { streamLogs } from "./log-stream.ts";
+export { NestjsBuild } from "./nestjs-build.ts";
 export { NextjsBuild } from "./nextjs-build.ts";
 export { NuxtBuild } from "./nuxt-build.ts";
 export { TanstackStartBuild } from "./tanstack-start-build.ts";
@@ -111,3 +130,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/nestjs-build.ts

@@ -0,0 +1,425 @@
+import {
+  chmod,
+  copyFile,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readlink,
+  rm,
+  stat,
+  symlink,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { nodeFileTrace } from "@vercel/nft";
+
+import {
+  type BuildSettings,
+  joinPosix,
+  resolveBuildSettings,
+} from "./build-settings.ts";
+import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+import {
+  hasPackageDependency,
+  hasRootFile,
+  runPackageCli,
+} from "./build-strategy.ts";
+import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
+import { resolveSourceRoot } from "./config/source-root.ts";
+import {
+  type BuildCommandIo,
+  readPackageManifest,
+  runBuildCommand,
+} from "./workspace.ts";
+
+const NEST_CLI_FILENAME = "nest-cli.json";
+
+/** Compiled entrypoints probed, in order, when config does not resolve one. */
+const DEFAULT_COMPILED_ENTRYPOINTS = ["dist/src/main.js", "dist/main.js"];
+
+/**
+ * Build strategy for NestJS applications. Runs the user's build (so `nest build`
+ * and any `prisma generate` in the `build` script run), resolves the compiled
+ * entrypoint, then stages a lean artifact by file-tracing that entrypoint with
+ * `@vercel/nft`: it ships only the compiled output and the `node_modules` files
+ * actually reachable, not the full dependency tree. NestJS has no Next-style
+ * standalone output, so the trace is the lean equivalent that keeps the
+ * artifact under the compute runtime's disk ceiling.
+ */
+export class NestjsBuild implements BuildStrategy {
+  readonly #appPath: string;
+  readonly #buildSettings?: BuildSettings;
+  readonly #io?: BuildCommandIo;
+
+  constructor(options: {
+    appPath: string;
+    buildSettings?: BuildSettings;
+    io?: BuildCommandIo;
+  }) {
+    this.#appPath = options.appPath;
+    this.#buildSettings = options.buildSettings;
+    this.#io = options.io;
+  }
+
+  async canBuild(signal?: AbortSignal): Promise<boolean> {
+    return (
+      (await hasRootFile(this.#appPath, [NEST_CLI_FILENAME], signal)) ||
+      (await hasPackageDependency(this.#appPath, ["@nestjs/core"], signal))
+    );
+  }
+
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
+
+    const settings =
+      this.#buildSettings ??
+      (await resolveBuildSettings({
+        appPath: this.#appPath,
+        buildType: "nestjs",
+        signal,
+      }));
+
+    // `resolveBuildSettings` always returns a non-null `nest build` fallback, so
+    // route by source: a user `build` script runs as-is, the framework default
+    // goes through the launcher ladder (local bin -> npx -> bunx).
+    const usingFrameworkDefault =
+      settings.buildCommand === null ||
+      settings.buildCommandSource === "NestJS default";
+    if (!usingFrameworkDefault && settings.buildCommand) {
+      await runBuildCommand({
+        appPath: this.#appPath,
+        command: settings.buildCommand,
+        failurePrefix: "NestJS",
+        env: this.#io?.env,
+        onOutput: this.#io?.onOutput,
+        signal,
+      });
+    } else {
+      await runPackageCli({
+        appPath: this.#appPath,
+        cliName: "nest",
+        args: ["build"],
+        failurePrefix: "NestJS",
+        missingMessage:
+          "Could not find the Nest CLI. Add a `build` script to package.json, install @nestjs/cli, or ensure npx/bunx is available.",
+        env: this.#io?.env,
+        onOutput: this.#io?.onOutput,
+        signal,
+      });
+    }
+
+    signal?.throwIfAborted();
+    const compiledEntry = await this.#resolveCompiledEntrypoint(signal);
+
+    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+    try {
+      const artifactDir = path.join(outDir, "app");
+      const entrypoint = await stageTracedArtifact({
+        appPath: this.#appPath,
+        artifactDir,
+        compiledEntry,
+        signal,
+      });
+
+      return {
+        directory: artifactDir,
+        entrypoint,
+        defaultPortMapping: { http: defaultHttpPortForBuildType("nestjs") },
+        cleanup: () => rm(outDir, { recursive: true, force: true }),
+      };
+    } catch (error) {
+      await rm(outDir, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
+  /**
+   * Resolves the compiled entrypoint relative to the app root, using posix
+   * separators. Prefers `package.json` `main`, then the path computed from
+   * `nest-cli.json` and the tsconfig `outDir`, then the common defaults.
+   */
+  async #resolveCompiledEntrypoint(signal?: AbortSignal): Promise<string> {
+    const candidates: string[] = [];
+
+    const fromMain = await this.#mainFieldEntrypoint(signal);
+    if (fromMain) {
+      candidates.push(fromMain);
+    }
+
+    const fromConfig = await this.#configuredCompiledEntrypoint(signal);
+    if (fromConfig) {
+      candidates.push(fromConfig);
+    }
+
+    candidates.push(...DEFAULT_COMPILED_ENTRYPOINTS);
+
+    for (const candidate of candidates) {
+      signal?.throwIfAborted();
+      const normalized = normalizeRelative(candidate);
+      if (!normalized) {
+        continue;
+      }
+      if (await isFile(path.join(this.#appPath, normalized))) {
+        return normalized;
+      }
+    }
+
+    throw new Error(
+      `NestJS build did not produce a compiled entrypoint. Looked for ${candidates.join(", ")} under ${this.#appPath}. ` +
+        "Ensure `nest build` ran and check the `main` field, nest-cli.json, or tsconfig outDir.",
+    );
+  }
+
+  async #mainFieldEntrypoint(signal?: AbortSignal): Promise<string | null> {
+    const manifest = await readPackageManifest(this.#appPath, signal);
+    return typeof manifest?.main === "string" && manifest.main.trim().length > 0
+      ? manifest.main.trim()
+      : null;
+  }
+
+  async #configuredCompiledEntrypoint(
+    signal?: AbortSignal,
+  ): Promise<string | null> {
+    const nestCli = await readNestCliConfig(this.#appPath, signal);
+    const sourceRoot = nestCli.sourceRoot ?? "src";
+    const entryFile = nestCli.entryFile ?? "main";
+    const outDir = await readTsconfigOutDir(this.#appPath, signal);
+
+    const relativeEntry = path.posix.join(
+      path.posix.relative(".", sourceRoot) || ".",
+      `${entryFile}.js`,
+    );
+    return joinPosix(outDir, relativeEntry);
+  }
+}
+
+interface NestCliConfig {
+  sourceRoot?: string;
+  entryFile?: string;
+}
+
+async function readNestCliConfig(
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<NestCliConfig> {
+  signal?.throwIfAborted();
+  let content: string;
+  try {
+    content = await readFile(path.join(appPath, NEST_CLI_FILENAME), {
+      encoding: "utf-8",
+      signal,
+    });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(content) as {
+      sourceRoot?: unknown;
+      entryFile?: unknown;
+    };
+    return {
+      sourceRoot:
+        typeof parsed.sourceRoot === "string" ? parsed.sourceRoot : undefined,
+      entryFile:
+        typeof parsed.entryFile === "string" ? parsed.entryFile : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+const TSCONFIG_FILENAMES = ["tsconfig.build.json", "tsconfig.json"] as const;
+
+/** Best-effort read of `compilerOptions.outDir`, defaulting to `dist`. */
+async function readTsconfigOutDir(
+  appPath: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  for (const fileName of TSCONFIG_FILENAMES) {
+    signal?.throwIfAborted();
+    let content: string;
+    try {
+      content = await readFile(path.join(appPath, fileName), {
+        encoding: "utf-8",
+        signal,
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      continue;
+    }
+    const outDir = parseTsconfigOutDir(content);
+    if (outDir) {
+      return outDir;
+    }
+  }
+  return "dist";
+}
+
+/** Reads `compilerOptions.outDir` from a tsconfig source, tolerating comments. */
+function parseTsconfigOutDir(content: string): string | null {
+  try {
+    const parsed = JSON.parse(stripJsonComments(content)) as {
+      compilerOptions?: { outDir?: unknown };
+    };
+    const outDir = parsed.compilerOptions?.outDir;
+    if (typeof outDir !== "string") {
+      return null;
+    }
+    return normalizeRelative(outDir);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Stages the compiled entrypoint and its transitive dependencies into
+ * `artifactDir` by tracing with `@vercel/nft`, then copying only the traced
+ * paths. Returns the artifact-root-relative entrypoint to run with `node`.
+ *
+ * The trace base is the source root, not the app dir, because nft ignores
+ * everything above `base`: in a workspace, deps hoisted to the repo root sit
+ * above the app and would be dropped, leaving the artifact with no usable
+ * `node_modules`. Tracing from the source root keeps the workspace-relative
+ * layout (e.g. `apps/api/dist/main.js` plus root and app-local `node_modules`),
+ * so `node <dir>/<entrypoint>` resolves deps by walking up. For a single-app
+ * repo the source root equals the app dir, so the entrypoint stays `dist/main.js`.
+ *
+ * The trace lists both the visible `node_modules/<pkg>` symlinks and the real
+ * files they resolve to (e.g. pnpm `.pnpm/<pkg>` / bun `.bun/<pkg>` stores), so
+ * symlinks are recreated verbatim and the store files are copied alongside.
+ */
+async function stageTracedArtifact(options: {
+  appPath: string;
+  artifactDir: string;
+  compiledEntry: string;
+  signal?: AbortSignal;
+}): Promise<string> {
+  const appPath = path.resolve(options.appPath);
+  const sourceRoot = await resolveSourceRoot(appPath, options.signal);
+  const entry = path.join(appPath, options.compiledEntry);
+  const entrypoint = path.posix.normalize(
+    path.relative(sourceRoot, entry).split(path.sep).join("/"),
+  );
+
+  options.signal?.throwIfAborted();
+  const { fileList } = await nodeFileTrace([entry], { base: sourceRoot });
+
+  await mkdir(options.artifactDir, { recursive: true });
+  for (const relativePath of fileList) {
+    options.signal?.throwIfAborted();
+    await stageTracedPath(
+      path.join(sourceRoot, relativePath),
+      path.join(options.artifactDir, relativePath),
+    );
+  }
+
+  return entrypoint;
+}
+
+/** Copies one traced path, preserving symlinks and file mode. */
+async function stageTracedPath(
+  sourcePath: string,
+  destinationPath: string,
+): Promise<void> {
+  const info = await lstat(sourcePath).catch(() => null);
+  if (!info) {
+    return;
+  }
+
+  await mkdir(path.dirname(destinationPath), { recursive: true });
+
+  if (info.isSymbolicLink()) {
+    await symlink(await readlink(sourcePath), destinationPath);
+    return;
+  }
+
+  if (info.isFile()) {
+    await copyFile(sourcePath, destinationPath);
+    await chmod(destinationPath, info.mode);
+  }
+}
+
+function normalizeRelative(value: string): string | null {
+  const raw = value.trim().replace(/\\/g, "/");
+  if (raw.length === 0) {
+    return null;
+  }
+  const normalized = path.posix.normalize(raw);
+  if (
+    path.posix.isAbsolute(normalized) ||
+    normalized === ".." ||
+    normalized.startsWith("../")
+  ) {
+    return null;
+  }
+  return normalized === "." ? null : normalized;
+}
+
+/**
+ * Removes `//` line comments and block comments from JSONC, tracking
+ * string state so a `//` inside a string value (e.g. `"https://..."`) is
+ * preserved. A naive regex strips such content and mis-reads the surrounding
+ * keys; on any malformed input the caller falls back to the default outDir.
+ */
+function stripJsonComments(content: string): string {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+
+    const next = content[i + 1];
+    if (char === "/" && next === "/") {
+      while (i < content.length && content[i] !== "\n") {
+        i++;
+      }
+      if (i < content.length) {
+        result += content[i];
+      }
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      i += 2;
+      while (
+        i < content.length &&
+        !(content[i] === "*" && content[i + 1] === "/")
+      ) {
+        i++;
+      }
+      i++;
+      continue;
+    }
+
+    result += char;
+  }
+
+  return result;
+}
+
+async function isFile(targetPath: string): Promise<boolean> {
+  const info = await stat(targetPath).catch(() => null);
+  return info?.isFile() ?? false;
+}