@prisma/compute-sdk 0.28.0 → 0.29.0

package/src/configured-artifact.ts

@@ -0,0 +1,169 @@
+import { cp, mkdtemp, realpath, 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 } from "./build-strategy.ts";
+import {
+  defaultHttpPortForBuildType,
+  type FrameworkBuildType,
+} from "./config/frameworks.ts";
+
+export async function stageConfiguredArtifact(options: {
+  appPath: string;
+  outputDirectory: string;
+  entrypoint: string;
+  buildType: FrameworkBuildType;
+  label: string;
+  missingEntrypointMessage?: string;
+  signal?: AbortSignal;
+}): Promise<BuildArtifact> {
+  options.signal?.throwIfAborted();
+  const outputDir = resolvePathInside(
+    options.appPath,
+    options.outputDirectory,
+    `${options.label} build output directory must be a relative path inside the app directory`,
+  );
+  const outputStat = await stat(outputDir).catch(() => null);
+  if (!outputStat?.isDirectory()) {
+    throw new Error(
+      `${options.label} build output directory does not exist: ${options.outputDirectory}`,
+    );
+  }
+
+  const [realAppPath, realOutputDir] = await Promise.all([
+    realpath(path.resolve(options.appPath)),
+    realpath(outputDir),
+  ]);
+  if (!isPathWithin(realAppPath, realOutputDir)) {
+    throw new Error(
+      `${options.label} build output directory must stay inside the app directory`,
+    );
+  }
+
+  const entrypoint = await resolveConfiguredArtifactEntrypoint({
+    directory: realOutputDir,
+    entrypoint: options.entrypoint,
+    label: options.label,
+    displayDirectory: options.outputDirectory,
+    missingEntrypointMessage: options.missingEntrypointMessage,
+  });
+
+  const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
+  try {
+    const artifactDir = path.join(outDir, "app");
+    await cp(realOutputDir, artifactDir, {
+      recursive: true,
+      verbatimSymlinks: true,
+    });
+    await normalizeArtifactSymlinks(
+      artifactDir,
+      options.appPath,
+      options.signal,
+    );
+
+    return {
+      directory: artifactDir,
+      entrypoint,
+      defaultPortMapping: {
+        http: defaultHttpPortForBuildType(options.buildType),
+      },
+      cleanup: () => rm(outDir, { recursive: true, force: true }),
+    };
+  } catch (error) {
+    await rm(outDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export async function resolveConfiguredArtifactEntrypoint(options: {
+  directory: string;
+  entrypoint: string;
+  label: string;
+  displayDirectory?: string;
+  missingEntrypointMessage?: string;
+}): Promise<string> {
+  const entrypoint = normalizeConfiguredArtifactEntrypoint(
+    options.entrypoint,
+    options.label,
+  );
+  const entryPath = path.join(options.directory, entrypoint);
+  const entryStat = await stat(entryPath).catch(() => null);
+  if (!entryStat?.isFile()) {
+    if (options.missingEntrypointMessage) {
+      throw new Error(options.missingEntrypointMessage);
+    }
+    const directory = options.displayDirectory ?? options.directory;
+    throw new Error(
+      `${options.label} build entrypoint does not exist: ${directory}/${entrypoint}`,
+    );
+  }
+  return entrypoint;
+}
+
+export function normalizeConfiguredArtifactEntrypoint(
+  entrypoint: string,
+  label: string,
+): string {
+  const normalized = path.posix.normalize(
+    entrypoint.trim().replace(/\\/g, "/"),
+  );
+  if (
+    normalized.length === 0 ||
+    normalized === "." ||
+    normalized === ".." ||
+    normalized.startsWith("../") ||
+    normalized.includes("/../") ||
+    path.win32.isAbsolute(entrypoint) ||
+    path.posix.isAbsolute(normalized) ||
+    /^[A-Za-z]:/.test(normalized)
+  ) {
+    throw new Error(
+      `${label} build entrypoint must be a relative path inside the output directory`,
+    );
+  }
+
+  return normalized;
+}
+
+function resolvePathInside(
+  root: string,
+  relativePath: string,
+  errorMessage: string,
+): string {
+  const raw = relativePath.trim().replace(/\\/g, "/");
+  const normalized = path.posix.normalize(raw);
+  if (
+    raw.length === 0 ||
+    normalized === ".." ||
+    normalized.startsWith("../") ||
+    normalized.includes("/../") ||
+    path.win32.isAbsolute(relativePath) ||
+    path.posix.isAbsolute(normalized) ||
+    /^[A-Za-z]:/.test(normalized)
+  ) {
+    throw new Error(errorMessage);
+  }
+
+  const resolved = path.resolve(root, normalized);
+  const relative = path.relative(root, resolved);
+  if (
+    relative === ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  ) {
+    throw new Error(errorMessage);
+  }
+
+  return resolved;
+}
+
+function isPathWithin(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return (
+    relative === "" ||
+    (!relative.startsWith(`..${path.sep}`) &&
+      relative !== ".." &&
+      !path.isAbsolute(relative))
+  );
+}

package/src/custom-build.ts

@@ -0,0 +1,73 @@
+import { type BuildSettings, resolveBuildSettings } from "./build-settings.ts";
+import {
+  type BuildArtifact,
+  type BuildStrategy,
+  runBuildSettingsCommand,
+} from "./build-strategy.ts";
+import {
+  normalizeConfiguredArtifactEntrypoint,
+  stageConfiguredArtifact,
+} from "./configured-artifact.ts";
+import type { BuildCommandIo } from "./workspace.ts";
+
+/**
+ * Generic artifact strategy for frameworks the SDK does not know about yet.
+ * Runs an optional command, stages a configured output directory as-is, and
+ * starts the configured entrypoint from inside that artifact.
+ */
+export class CustomBuild implements BuildStrategy {
+  readonly #appPath: string;
+  readonly #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> {
+    return Boolean(this.#entrypoint ?? this.#buildSettings?.entrypoint);
+  }
+
+  async execute(signal?: AbortSignal): Promise<BuildArtifact> {
+    signal?.throwIfAborted();
+    const settings =
+      this.#buildSettings ??
+      (await resolveBuildSettings({
+        appPath: this.#appPath,
+        buildType: "custom",
+        signal,
+      }));
+
+    const entrypoint = this.#entrypoint ?? settings.entrypoint;
+    if (!entrypoint) {
+      throw new Error("Custom build entrypoint is required");
+    }
+    normalizeConfiguredArtifactEntrypoint(entrypoint, "Custom");
+
+    await runBuildSettingsCommand({
+      appPath: this.#appPath,
+      settings,
+      failurePrefix: "Custom",
+      io: this.#io,
+      signal,
+    });
+
+    return stageConfiguredArtifact({
+      appPath: this.#appPath,
+      outputDirectory: settings.outputDirectory,
+      entrypoint,
+      buildType: "custom",
+      label: "Custom",
+      signal,
+    });
+  }
+}

package/src/index.ts

@@ -70,6 +70,7 @@ export type {
   UpdateEnvResult,
 } from "./compute-client.ts";
 export { ComputeClient } from "./compute-client.ts";
+export { CustomBuild } from "./custom-build.ts";
 export type {
   DetectedSchema,
   MigrationCommand,

package/src/nestjs-build.ts

@@ -24,15 +24,11 @@ import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
 import {
   hasPackageDependency,
   hasRootFile,
-  runPackageCli,
+  runBuildSettingsCommand,
 } 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";
+import { type BuildCommandIo, readPackageManifest } from "./workspace.ts";
 
 const NEST_CLI_FILENAME = "nest-cli.json";
 
@@ -81,37 +77,26 @@ export class NestjsBuild implements BuildStrategy {
         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,
+    await runBuildSettingsCommand({
+      appPath: this.#appPath,
+      settings,
+      failurePrefix: "NestJS",
+      defaultCli: {
+        source: "NestJS default",
         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,
-      });
-    }
+      },
+      io: this.#io,
+      signal,
+    });
 
     signal?.throwIfAborted();
-    const compiledEntry = await this.#resolveCompiledEntrypoint(signal);
+    const compiledEntry = await this.#resolveCompiledEntrypoint(
+      settings,
+      signal,
+    );
 
     const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
     try {
@@ -140,9 +125,16 @@ export class NestjsBuild implements BuildStrategy {
    * 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> {
+  async #resolveCompiledEntrypoint(
+    settings: BuildSettings,
+    signal?: AbortSignal,
+  ): Promise<string> {
     const candidates: string[] = [];
 
+    if (settings.entrypoint) {
+      candidates.push(joinPosix(settings.outputDirectory, settings.entrypoint));
+    }
+
     const fromMain = await this.#mainFieldEntrypoint(signal);
     if (fromMain) {
       candidates.push(fromMain);
@@ -153,7 +145,7 @@ export class NestjsBuild implements BuildStrategy {
       candidates.push(fromConfig);
     }
 
-    candidates.push(...DEFAULT_COMPILED_ENTRYPOINTS);
+    candidates.push(...compiledEntrypointDefaults(settings.outputDirectory));
 
     for (const candidate of candidates) {
       signal?.throwIfAborted();
@@ -195,6 +187,17 @@ export class NestjsBuild implements BuildStrategy {
   }
 }
 
+function compiledEntrypointDefaults(outputDirectory: string): string[] {
+  if (outputDirectory === "dist") {
+    return DEFAULT_COMPILED_ENTRYPOINTS;
+  }
+  return [
+    joinPosix(outputDirectory, "src/main.js"),
+    joinPosix(outputDirectory, "main.js"),
+    ...DEFAULT_COMPILED_ENTRYPOINTS,
+  ];
+}
+
 interface NestCliConfig {
   sourceRoot?: string;
   entryFile?: string;

package/src/nextjs-build.ts

@@ -9,9 +9,14 @@ import {
   resolveBuildSettings,
 } from "./build-settings.ts";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
-import { hasPackageDependency, hasRootFile } from "./build-strategy.ts";
+import {
+  hasPackageDependency,
+  hasRootFile,
+  runBuildSettingsCommand,
+} from "./build-strategy.ts";
 import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
-import { type BuildCommandIo, runBuildCommand } from "./workspace.ts";
+import { resolveConfiguredArtifactEntrypoint } from "./configured-artifact.ts";
+import type { BuildCommandIo } from "./workspace.ts";
 
 const NEXT_CONFIG_FILENAMES = [
   "next.config.js",
@@ -63,20 +68,24 @@ export class NextjsBuild implements BuildStrategy {
         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,
-      });
-    }
+    await runBuildSettingsCommand({
+      appPath: this.#appPath,
+      settings,
+      failurePrefix: "Next.js",
+      defaultCli: {
+        source: "Next.js default",
+        cliName: "next",
+        args: ["build"],
+        missingMessage:
+          "Could not find the Next.js CLI. Install it with `npm install next` or ensure npx/bunx is available.",
+      },
+      io: this.#io,
+      signal,
+    });
 
     const standaloneDir = path.join(this.#appPath, settings.outputDirectory);
     if (!(await directoryExists(standaloneDir))) {
-      if (this.#requireStandalone) {
+      if (this.#requireStandalone || settings.entrypoint) {
         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.',
@@ -97,7 +106,15 @@ export class NextjsBuild implements BuildStrategy {
         appPath: this.#appPath,
         signal,
       });
-      const entrypoint = await findStandaloneEntrypoint(artifactDir);
+      const entrypoint = settings.entrypoint
+        ? await resolveConfiguredArtifactEntrypoint({
+            directory: artifactDir,
+            entrypoint: settings.entrypoint,
+            label: "Next.js",
+            displayDirectory: settings.outputDirectory,
+            missingEntrypointMessage: `Next.js standalone output did not contain configured entrypoint ${settings.outputDirectory}/${settings.entrypoint}.`,
+          })
+        : await findStandaloneEntrypoint(artifactDir);
       await copyStaticAssets({
         appPath: this.#appPath,
         artifactDir,

package/src/nuxt-build.ts

@@ -1,15 +1,11 @@
-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 BuildSettings, resolveBuildSettings } from "./build-settings.ts";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
 import {
   hasPackageDependency,
   hasRootFile,
-  runPackageCli,
+  runBuildSettingsCommand,
 } from "./build-strategy.ts";
-import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
+import { stageConfiguredArtifact } from "./configured-artifact.ts";
 import type { BuildCommandIo } from "./workspace.ts";
 
 const NUXT_CONFIG_FILENAMES = [
@@ -26,10 +22,16 @@ const NUXT_CONFIG_FILENAMES = [
  */
 export class NuxtBuild implements BuildStrategy {
   readonly #appPath: string;
+  readonly #buildSettings?: BuildSettings;
   readonly #io?: BuildCommandIo;
 
-  constructor(options: { appPath: string; io?: BuildCommandIo }) {
+  constructor(options: {
+    appPath: string;
+    buildSettings?: BuildSettings;
+    io?: BuildCommandIo;
+  }) {
     this.#appPath = options.appPath;
+    this.#buildSettings = options.buildSettings;
     this.#io = options.io;
   }
 
@@ -42,48 +44,39 @@ export class NuxtBuild implements BuildStrategy {
 
   async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     signal?.throwIfAborted();
-    await runPackageCli({
+    const settings =
+      this.#buildSettings ??
+      (await resolveBuildSettings({
+        appPath: this.#appPath,
+        buildType: "nuxt",
+        signal,
+      }));
+
+    await runBuildSettingsCommand({
       appPath: this.#appPath,
-      cliName: "nuxt",
-      args: ["build"],
+      settings,
       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,
+      defaultCli: {
+        source: "Nuxt default",
+        cliName: "nuxt",
+        args: ["build"],
+        missingMessage:
+          "Could not find the Nuxt CLI. Install it with `npm install nuxt` or ensure npx/bunx is available.",
+      },
+      io: this.#io,
       signal,
     });
 
-    const outputDir = path.join(this.#appPath, ".output");
-    const entryPath = path.join(outputDir, "server", "index.mjs");
-    const entryStat = await stat(entryPath).catch(() => null);
-    if (!entryStat?.isFile()) {
-      throw new Error(
-        "Nuxt build did not produce a Nitro node server entrypoint at .output/server/index.mjs. Ensure nitro.preset is 'node-server' (the default) — set NITRO_PRESET=node-server or remove any custom preset from nuxt.config.",
-      );
-    }
-
-    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
-
-    try {
-      const artifactDir = path.join(outDir, "app");
-      await cp(outputDir, artifactDir, {
-        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,
-        entrypoint: "server/index.mjs",
-        defaultPortMapping: { http: defaultHttpPortForBuildType("nuxt") },
-        cleanup: () => rm(outDir, { recursive: true, force: true }),
-      };
-    } catch (error) {
-      await rm(outDir, { recursive: true, force: true });
-      throw error;
-    }
+    return stageConfiguredArtifact({
+      appPath: this.#appPath,
+      outputDirectory: settings.outputDirectory,
+      entrypoint: settings.entrypoint ?? "server/index.mjs",
+      buildType: "nuxt",
+      label: "Nuxt",
+      missingEntrypointMessage: settings.entrypoint
+        ? undefined
+        : `Nuxt build did not produce a Nitro node server entrypoint at ${settings.outputDirectory}/server/index.mjs. Ensure nitro.preset is 'node-server' (the default) - set NITRO_PRESET=node-server or remove any custom preset from nuxt.config.`,
+      signal,
+    });
   }
 }

package/src/tanstack-start-build.ts

@@ -1,13 +1,11 @@
-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 BuildSettings, resolveBuildSettings } from "./build-settings.ts";
 import type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
-import { hasPackageDependency } from "./build-strategy.ts";
-import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
-import { type BuildCommandIo, runBuildCommand } from "./workspace.ts";
+import {
+  hasPackageDependency,
+  runBuildSettingsCommand,
+} from "./build-strategy.ts";
+import { stageConfiguredArtifact } from "./configured-artifact.ts";
+import type { BuildCommandIo } from "./workspace.ts";
 
 const TANSTACK_START_PACKAGES = [
   "@tanstack/react-start",
@@ -47,51 +45,31 @@ export class TanstackStartBuild implements BuildStrategy {
         buildType: "tanstack-start",
         signal,
       }));
-    if (settings.buildCommand) {
-      await runBuildCommand({
-        appPath: this.#appPath,
-        command: settings.buildCommand,
-        failurePrefix: "TanStack Start",
-        env: this.#io?.env,
-        onOutput: this.#io?.onOutput,
-        signal,
-      });
-    }
-
-    const outputDir = path.join(this.#appPath, settings.outputDirectory);
-    const entrypoint = "server/index.mjs";
-    const entryStat = await stat(path.join(outputDir, entrypoint)).catch(
-      () => null,
-    );
-    if (!entryStat?.isFile()) {
-      throw new Error(
-        `TanStack Start build did not produce a Nitro node server entrypoint at ${settings.outputDirectory}/${entrypoint}. ` +
-          "Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset.",
-      );
-    }
-
-    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
-    try {
-      const artifactDir = path.join(outDir, "app");
-      await cp(outputDir, artifactDir, {
-        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);
+    await runBuildSettingsCommand({
+      appPath: this.#appPath,
+      settings,
+      failurePrefix: "TanStack Start",
+      defaultCli: {
+        source: "TanStack Start default",
+        cliName: "vite",
+        args: ["build"],
+        missingMessage:
+          "Could not find the Vite CLI. Install it with `npm install vite` or ensure npx/bunx is available.",
+      },
+      io: this.#io,
+      signal,
+    });
 
-      return {
-        directory: artifactDir,
-        entrypoint,
-        defaultPortMapping: {
-          http: defaultHttpPortForBuildType("tanstack-start"),
-        },
-        cleanup: () => rm(outDir, { recursive: true, force: true }),
-      };
-    } catch (error) {
-      await rm(outDir, { recursive: true, force: true });
-      throw error;
-    }
+    return stageConfiguredArtifact({
+      appPath: this.#appPath,
+      outputDirectory: settings.outputDirectory,
+      entrypoint: settings.entrypoint ?? "server/index.mjs",
+      buildType: "tanstack-start",
+      label: "TanStack Start",
+      missingEntrypointMessage: settings.entrypoint
+        ? undefined
+        : `TanStack Start build did not produce a Nitro node server entrypoint at ${settings.outputDirectory}/server/index.mjs. Ensure your vite.config includes the tanstackStart() and nitro() plugins with the default node preset.`,
+      signal,
+    });
   }
 }