@prisma/compute-sdk 0.28.0 → 0.29.0

package/src/astro-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 ASTRO_CONFIG_FILENAMES = [
@@ -26,10 +22,16 @@ const ASTRO_CONFIG_FILENAMES = [
  */
 export class AstroBuild 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 AstroBuild implements BuildStrategy {
 
   async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     signal?.throwIfAborted();
-    await runPackageCli({
+    const settings =
+      this.#buildSettings ??
+      (await resolveBuildSettings({
+        appPath: this.#appPath,
+        buildType: "astro",
+        signal,
+      }));
+
+    await runBuildSettingsCommand({
       appPath: this.#appPath,
-      cliName: "astro",
-      args: ["build"],
+      settings,
       failurePrefix: "Astro",
-      missingMessage:
-        "Could not find the Astro CLI. Install it with `npm install astro` or ensure npx/bunx is available.",
-      env: this.#io?.env,
-      onOutput: this.#io?.onOutput,
+      defaultCli: {
+        source: "Astro default",
+        cliName: "astro",
+        args: ["build"],
+        missingMessage:
+          "Could not find the Astro CLI. Install it with `npm install astro` or ensure npx/bunx is available.",
+      },
+      io: this.#io,
       signal,
     });
 
-    const distDir = path.join(this.#appPath, "dist");
-    const entryPath = path.join(distDir, "server", "entry.mjs");
-    const entryStat = await stat(entryPath).catch(() => null);
-    if (!entryStat?.isFile()) {
-      throw new Error(
-        'Astro build did not produce a standalone server entrypoint. Install @astrojs/node and configure it with adapter: node({ mode: "standalone" }) in your astro.config file.',
-      );
-    }
-
-    const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
-
-    try {
-      const artifactDir = path.join(outDir, "app");
-      await cp(distDir, 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/entry.mjs",
-        defaultPortMapping: { http: defaultHttpPortForBuildType("astro") },
-        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/entry.mjs",
+      buildType: "astro",
+      label: "Astro",
+      missingEntrypointMessage: settings.entrypoint
+        ? undefined
+        : 'Astro build did not produce a standalone server entrypoint. Install @astrojs/node and configure it with adapter: node({ mode: "standalone" }) in your astro.config file.',
+      signal,
+    });
   }
 }

package/src/build-settings.ts

@@ -22,6 +22,8 @@ export interface BuildSettings {
   buildCommandSource: string | null;
   outputDirectory: string;
   outputDirectorySource: string | null;
+  entrypoint?: string;
+  entrypointSource?: string | null;
 }
 
 /**
@@ -111,6 +113,13 @@ export async function resolveBuildSettings(options: {
         outputDirectorySource: "TanStack Start output",
       };
     }
+    case "custom":
+      return {
+        buildCommand: null,
+        buildCommandSource: null,
+        outputDirectory: ".",
+        outputDirectorySource: "app root",
+      };
     case "bun": {
       const manifest = await readPackageManifest(
         options.appPath,
@@ -143,6 +152,7 @@ export async function resolveConfiguredBuildSettings(options: {
   configured: {
     command: string | null | undefined;
     outputDirectory: string | undefined;
+    entrypoint?: string | undefined;
   };
   /** Label for configured values, e.g. the config file basename. */
   source: string;
@@ -169,6 +179,12 @@ export async function resolveConfiguredBuildSettings(options: {
       options.configured.outputDirectory !== undefined
         ? options.source
         : (fallback as BuildSettings).outputDirectorySource,
+    ...(options.configured.entrypoint !== undefined
+      ? {
+          entrypoint: options.configured.entrypoint,
+          entrypointSource: options.source,
+        }
+      : {}),
   };
 }
 

package/src/build-strategy.ts

@@ -1,7 +1,13 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import type { BuildSettings } from "./build-settings.ts";
 import type { PortMapping } from "./types.ts";
-import { buildCommandEnv, runChildProcess } from "./workspace.ts";
+import {
+  type BuildCommandIo,
+  buildCommandEnv,
+  runBuildCommand,
+  runChildProcess,
+} from "./workspace.ts";
 
 /**
  * The result of executing a build strategy.
@@ -207,6 +213,55 @@ export async function runPackageCli(opts: {
   throw new Error(opts.missingMessage);
 }
 
+/**
+ * Runs the command described by build settings. A configured shell command runs
+ * as-is; a framework default can use the launcher ladder so local binaries,
+ * npx, and bunx all work consistently. `null` means "skip build".
+ */
+export async function runBuildSettingsCommand(options: {
+  appPath: string;
+  settings: Pick<BuildSettings, "buildCommand" | "buildCommandSource">;
+  failurePrefix: string;
+  defaultCli?: {
+    source: string;
+    cliName: string;
+    args: string[];
+    missingMessage: string;
+  };
+  io?: BuildCommandIo;
+  signal?: AbortSignal;
+}): Promise<void> {
+  if (!options.settings.buildCommand) {
+    return;
+  }
+
+  if (
+    options.defaultCli &&
+    options.settings.buildCommandSource === options.defaultCli.source
+  ) {
+    await runPackageCli({
+      appPath: options.appPath,
+      cliName: options.defaultCli.cliName,
+      args: options.defaultCli.args,
+      failurePrefix: options.failurePrefix,
+      missingMessage: options.defaultCli.missingMessage,
+      env: options.io?.env,
+      onOutput: options.io?.onOutput,
+      signal: options.signal,
+    });
+    return;
+  }
+
+  await runBuildCommand({
+    appPath: options.appPath,
+    command: options.settings.buildCommand,
+    failurePrefix: options.failurePrefix,
+    env: options.io?.env,
+    onOutput: options.io?.onOutput,
+    signal: options.signal,
+  });
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }

package/src/build.ts

@@ -3,6 +3,7 @@ import type { BuildSettings } from "./build-settings.ts";
 import type { BuildStrategy } from "./build-strategy.ts";
 import { BunBuild } from "./bun-build.ts";
 import { FRAMEWORKS, type FrameworkBuildType } from "./config/frameworks.ts";
+import { CustomBuild } from "./custom-build.ts";
 import { NestjsBuild } from "./nestjs-build.ts";
 import { NextjsBuild } from "./nextjs-build.ts";
 import { NuxtBuild } from "./nuxt-build.ts";
@@ -33,12 +34,16 @@ const DETECTION_ORDER: FrameworkBuildType[] = (() => {
   const buildTypes = [
     ...new Set(FRAMEWORKS.map((framework) => framework.buildType)),
   ];
-  return [...buildTypes.filter((type) => type !== "bun"), "bun"];
+  return [
+    ...buildTypes.filter((type) => type !== "bun" && type !== "custom"),
+    "bun",
+  ];
 })();
 
 /**
  * Constructs the build strategy for an explicit framework build type, wiring
- * through optional committed build settings and (for bun) the entrypoint.
+ * through optional committed build settings and entrypoints for strategies
+ * that need one.
  */
 export function createBuildStrategy(
   options: {
@@ -58,13 +63,20 @@ export function createBuildStrategy(
         requireStandalone: options.requireStandalone,
       });
     case "nuxt":
-      return new NuxtBuild({ appPath, io });
+      return new NuxtBuild({ appPath, buildSettings, io });
     case "astro":
-      return new AstroBuild({ appPath, io });
+      return new AstroBuild({ appPath, buildSettings, io });
     case "nestjs":
       return new NestjsBuild({ appPath, buildSettings, io });
     case "tanstack-start":
       return new TanstackStartBuild({ appPath, buildSettings, io });
+    case "custom":
+      return new CustomBuild({
+        appPath,
+        entrypoint: options.entrypoint,
+        buildSettings,
+        io,
+      });
     case "bun":
       return new BunBuild({
         appPath,

package/src/bun-build.ts

@@ -9,12 +9,16 @@ import {
 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 {
+  type BuildArtifact,
+  type BuildStrategy,
+  runBuildSettingsCommand,
+} from "./build-strategy.ts";
 import { defaultHttpPortForBuildType } from "./config/frameworks.ts";
+import { stageConfiguredArtifact } from "./configured-artifact.ts";
 import {
   type BuildCommandIo,
   buildCommandEnv,
-  runBuildCommand,
   runChildProcess,
 } from "./workspace.ts";
 
@@ -50,17 +54,36 @@ export class BunBuild implements BuildStrategy {
 
   async execute(signal?: AbortSignal): Promise<BuildArtifact> {
     signal?.throwIfAborted();
-    if (this.#buildSettings?.buildCommand) {
-      await runBuildCommand({
+    if (this.#buildSettings) {
+      await runBuildSettingsCommand({
         appPath: this.#appPath,
-        command: this.#buildSettings.buildCommand,
+        settings: this.#buildSettings,
         failurePrefix: "Bun",
-        env: this.#io?.env,
-        onOutput: this.#io?.onOutput,
+        io: this.#io,
+        signal,
+      });
+    }
+
+    if (this.#buildSettings && this.#buildSettings.outputDirectory !== ".") {
+      if (!this.#buildSettings.entrypoint) {
+        throw new Error(
+          "Bun build entrypoint is required when outputDirectory is configured",
+        );
+      }
+      return stageConfiguredArtifact({
+        appPath: this.#appPath,
+        outputDirectory: this.#buildSettings.outputDirectory,
+        entrypoint: this.#buildSettings.entrypoint,
+        buildType: "bun",
+        label: "Bun",
         signal,
       });
     }
-    const entrypoint = await this.#resolveEntrypoint(signal);
+
+    const entrypoint = await this.#resolveEntrypoint(
+      signal,
+      this.#buildSettings?.entrypoint,
+    );
 
     const outDir = await mkdtemp(path.join(os.tmpdir(), "compute-build-"));
     const bundleDir = path.join(outDir, "bundle");
@@ -94,9 +117,15 @@ export class BunBuild implements BuildStrategy {
     };
   }
 
-  async #resolveEntrypoint(signal?: AbortSignal): Promise<string> {
+  async #resolveEntrypoint(
+    signal?: AbortSignal,
+    configuredEntrypoint?: string,
+  ): Promise<string> {
     signal?.throwIfAborted();
-    const candidate = this.#entrypoint ?? (await this.#readPackageJsonMain());
+    const candidate =
+      this.#entrypoint ??
+      configuredEntrypoint ??
+      (await this.#readPackageJsonMain());
 
     if (!candidate) {
       throw new Error(

package/src/config/frameworks.ts

@@ -13,6 +13,7 @@ export type FrameworkBuildType =
   | "astro"
   | "nestjs"
   | "tanstack-start"
+  | "custom"
   | "bun";
 
 export interface FrameworkDescriptor {
@@ -138,6 +139,18 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
     hasLocalDevServer: false,
     defaultHttpPort: 3000,
   },
+  {
+    key: "custom",
+    displayName: "Custom",
+    buildType: "custom",
+    aliases: ["custom"],
+    detectPackages: [],
+    detectConfigFiles: [],
+    usesEntrypoint: false,
+    defaultEntrypoint: null,
+    hasLocalDevServer: false,
+    defaultHttpPort: 3000,
+  },
   {
     key: "bun",
     displayName: "Bun",
@@ -154,14 +167,14 @@ export const FRAMEWORKS: readonly FrameworkDescriptor[] = [
 
 export const FRAMEWORK_KEYS = FRAMEWORKS.map((framework) => framework.key);
 
-/**
- * Build types whose preview build consumes committed build settings. The
- * others (nuxt, astro) run their framework CLI and stage fixed output, so a
- * config `build` block has nothing to apply to.
- */
+/** Build types whose preview build consumes committed build settings. */
 export const CONFIG_BACKED_BUILD_TYPES = [
   "nextjs",
+  "nuxt",
+  "astro",
+  "nestjs",
   "tanstack-start",
+  "custom",
   "bun",
 ] as const satisfies readonly FrameworkBuildType[];
 

package/src/config/normalize.ts

@@ -2,7 +2,7 @@ import path from "node:path";
 
 import { Result, TaggedError } from "better-result";
 
-import { frameworkByKey, isConfigBackedBuildType } from "./frameworks.ts";
+import { frameworkByKey } from "./frameworks.ts";
 import { COMPUTE_FRAMEWORKS, type ComputeFramework } from "./types.ts";
 
 export interface ComputeDeployTargetBuild {
@@ -10,6 +10,11 @@ export interface ComputeDeployTargetBuild {
   command: string | null | undefined;
   /** Normalized output path relative to the app root, undefined when not configured. */
   outputDirectory: string | undefined;
+  /**
+   * Normalized configured entrypoint. With outputDirectory it is relative to
+   * that output directory; otherwise it is relative to the app root.
+   */
+  entrypoint: string | undefined;
 }
 
 export interface ComputeDeployTarget {
@@ -19,6 +24,7 @@ export interface ComputeDeployTarget {
   /** Normalized app directory relative to the config file, or null for the config directory. */
   root: string | null;
   framework: ComputeFramework | null;
+  /** Runtime/source entrypoint normalized from `entry` or an entrypoint-backed `build.entrypoint`. */
   entry: string | null;
   httpPort: number | null;
   /** Env inputs in deploy order: dotenv file paths first, then NAME=VALUE assignments. */
@@ -104,7 +110,7 @@ const KNOWN_APP_KEYS = [
   "build",
 ] as const;
 const KNOWN_ENV_KEYS = ["file", "vars"] as const;
-const KNOWN_BUILD_KEYS = ["command", "outputDirectory"] as const;
+const KNOWN_BUILD_KEYS = ["command", "outputDirectory", "entrypoint"] as const;
 
 /**
  * Validates and normalizes a config module's default export. Reports every
@@ -343,7 +349,8 @@ function normalizeAppEntry(
     }
   }
 
-  if (entry && framework && !frameworkByKey(framework).usesEntrypoint) {
+  const frameworkDescriptor = framework ? frameworkByKey(framework) : null;
+  if (entry && frameworkDescriptor && !frameworkDescriptor.usesEntrypoint) {
     issues.push(
       `\`${label}.entry\` is not supported with the ${framework} framework; it derives its entrypoint from build output.`,
     );
@@ -367,22 +374,53 @@ function normalizeAppEntry(
 
   const envInputs = normalizeEnvConfig(value.env, `${label}.env`, issues);
   const build = normalizeBuildConfig(value.build, `${label}.build`, issues);
+  if (framework === "custom") {
+    if (!build) {
+      issues.push(
+        `\`${label}.build\` is required with the custom framework and must set \`outputDirectory\` and \`entrypoint\`.`,
+      );
+    } else {
+      if (!build.outputDirectory) {
+        issues.push(
+          `\`${label}.build.outputDirectory\` is required with the custom framework.`,
+        );
+      }
+      if (!build.entrypoint) {
+        issues.push(
+          `\`${label}.build.entrypoint\` is required with the custom framework.`,
+        );
+      }
+    }
+  } else if (
+    build?.outputDirectory &&
+    build.outputDirectory !== "." &&
+    !build.entrypoint &&
+    frameworkDescriptor?.usesEntrypoint
+  ) {
+    issues.push(
+      `\`${label}.build.entrypoint\` is required when \`${label}.build.outputDirectory\` is set with the ${framework} framework.`,
+    );
+  }
   if (
-    build &&
-    framework &&
-    !isConfigBackedBuildType(frameworkByKey(framework).buildType)
+    entry &&
+    build?.entrypoint &&
+    frameworkDescriptor?.usesEntrypoint &&
+    entry !== build.entrypoint
   ) {
     issues.push(
-      `\`${label}.build\` is not supported with the ${framework} framework; its build runs automatically during deploy.`,
+      `\`${label}.entry\` and \`${label}.build.entrypoint\` both configure the runtime entrypoint; set only one, or make them match.`,
     );
   }
-
   return {
     key,
     name,
     root,
     framework,
-    entry,
+    entry:
+      entry ??
+      (frameworkDescriptor?.usesEntrypoint || !frameworkDescriptor
+        ? (build?.entrypoint ?? null)
+        : null),
     httpPort,
     envInputs,
     build,
@@ -400,7 +438,7 @@ function normalizeBuildConfig(
 
   if (!isPlainObject(value)) {
     issues.push(
-      `\`${label}\` must be an object with \`command\` and/or \`outputDirectory\`.`,
+      `\`${label}\` must be an object with \`command\`, \`outputDirectory\`, and/or \`entrypoint\`.`,
     );
     return null;
   }
@@ -444,14 +482,37 @@ function normalizeBuildConfig(
     }
   }
 
-  if (command === undefined && outputDirectory === undefined) {
+  let entrypoint: string | undefined;
+  if (value.entrypoint !== undefined) {
+    const normalized =
+      typeof value.entrypoint === "string"
+        ? normalizeRelativePath(value.entrypoint)
+        : undefined;
+    if (!normalized) {
+      issues.push(
+        `\`${label}.entrypoint\` must be a relative path that stays inside its base directory.`,
+      );
+    } else if (normalized === ".") {
+      issues.push(
+        `\`${label}.entrypoint\` must be a relative file path inside its base directory.`,
+      );
+    } else {
+      entrypoint = normalized;
+    }
+  }
+
+  if (
+    command === undefined &&
+    outputDirectory === undefined &&
+    entrypoint === undefined
+  ) {
     issues.push(
-      `\`${label}\` must set \`command\` and/or \`outputDirectory\`.`,
+      `\`${label}\` must set \`command\`, \`outputDirectory\`, and/or \`entrypoint\`.`,
     );
     return null;
   }
 
-  return { command, outputDirectory };
+  return { command, outputDirectory, entrypoint };
 }
 
 function normalizeEnvConfig(

package/src/config/types.ts

@@ -13,6 +13,7 @@ export const COMPUTE_FRAMEWORKS = [
   "hono",
   "nestjs",
   "tanstack-start",
+  "custom",
   "bun",
 ] as const;
 
@@ -34,6 +35,8 @@ export interface ComputeBuildConfig {
   command?: string | null;
   /** Framework output path relative to the app root, e.g. ".next/standalone". */
   outputDirectory?: string;
+  /** Entrypoint for the built artifact, relative to `outputDirectory` when one is set. */
+  entrypoint?: string;
 }
 
 export interface ComputeAppConfig {