@prisma/compute-sdk 0.28.0 → 0.30.0

package/src/api-client.ts

@@ -54,43 +54,44 @@ export class InternalApiClient {
     ).then((r) => r.map((body) => body.data));
   }
 
-  async listProjectServices(projectId: string, signal?: AbortSignal) {
+  async listProjectApps(projectId: string, signal?: AbortSignal) {
     return this.#requestPaginated(
       (cursor) =>
-        this.#client.GET("/v1/projects/{projectId}/compute-services", {
-          params: { path: { projectId }, query: cursor ? { cursor } : {} },
+        this.#client.GET("/v1/apps", {
+          params: {
+            query: cursor ? { projectId, cursor } : { projectId },
+          },
           signal,
         }),
-      "/v1/projects/{projectId}/compute-services",
+      "/v1/apps",
       signal,
     );
   }
 
-  async createProjectService(
+  async createProjectApp(
     projectId: string,
-    body: CreateProjectServiceBody,
+    body: CreateProjectAppBody,
     signal?: AbortSignal,
   ) {
     signal?.throwIfAborted();
     return this.#request(
-      this.#client.POST("/v1/projects/{projectId}/compute-services", {
-        params: { path: { projectId } },
-        body: body as SdkCreateProjectServiceBody,
+      this.#client.POST("/v1/apps", {
+        body: { ...body, projectId } as SdkCreateAppBody,
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
-      "/v1/projects/{projectId}/compute-services",
+      "/v1/apps",
       signal,
     ).then((r) => r.map((body) => body.data));
   }
 
-  async getService(computeServiceId: string, signal?: AbortSignal) {
+  async getApp(appId: string, signal?: AbortSignal) {
     return this.#request(
-      this.#client.GET("/v1/compute-services/{computeServiceId}", {
-        params: { path: { computeServiceId } },
+      this.#client.GET("/v1/apps/{appId}", {
+        params: { path: { appId } },
         signal,
       }),
-      "/v1/compute-services/{computeServiceId}",
+      "/v1/apps/{appId}",
       signal,
     ).then((r) => r.map((body) => body.data));
   }
@@ -106,14 +107,14 @@ export class InternalApiClient {
     ).then((r) => r.map((body) => body.data));
   }
 
-  async deleteService(
-    computeServiceId: string,
+  async deleteApp(
+    appId: string,
     signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
     signal?.throwIfAborted();
     return this.#unwrapVoid(
-      this.#client.DELETE("/v1/compute-services/{computeServiceId}", {
-        params: { path: { computeServiceId } },
+      this.#client.DELETE("/v1/apps/{appId}", {
+        params: { path: { appId } },
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
@@ -121,71 +122,71 @@ export class InternalApiClient {
     );
   }
 
-  async listServiceVersions(computeServiceId: string, signal?: AbortSignal) {
+  async listAppDeployments(appId: string, signal?: AbortSignal) {
     return this.#requestPaginated(
       (cursor) =>
-        this.#client.GET("/v1/compute-services/{computeServiceId}/versions", {
+        this.#client.GET("/v1/apps/{appId}/deployments", {
           params: {
-            path: { computeServiceId },
+            path: { appId },
             query: cursor ? { cursor } : {},
           },
           signal,
         }),
-      "/v1/compute-services/{computeServiceId}/versions",
+      "/v1/apps/{appId}/deployments",
       signal,
     );
   }
 
-  async createServiceVersion(
-    computeServiceId: string,
-    body?: CreateServiceVersionBody,
+  async createAppDeployment(
+    appId: string,
+    body?: CreateAppDeploymentBody,
     signal?: AbortSignal,
   ) {
     signal?.throwIfAborted();
     return this.#request(
-      this.#client.POST("/v1/compute-services/{computeServiceId}/versions", {
-        params: { path: { computeServiceId } },
+      this.#client.POST("/v1/apps/{appId}/deployments", {
+        params: { path: { appId } },
         body,
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
-      "/v1/compute-services/{computeServiceId}/versions",
+      "/v1/apps/{appId}/deployments",
       signal,
     ).then((r) => r.map((body) => body.data));
   }
 
-  async getVersion(versionId: string, signal?: AbortSignal) {
+  async getDeployment(deploymentId: string, signal?: AbortSignal) {
     return this.#request(
-      this.#client.GET("/v1/compute-services/versions/{versionId}", {
-        params: { path: { versionId } },
+      this.#client.GET("/v1/deployments/{deploymentId}", {
+        params: { path: { deploymentId } },
         signal,
       }),
-      "/v1/compute-services/versions/{versionId}",
+      "/v1/deployments/{deploymentId}",
       signal,
     ).then((r) => r.map((body) => body.data));
   }
 
-  async startVersion(versionId: string, signal?: AbortSignal) {
+  async startDeployment(deploymentId: string, signal?: AbortSignal) {
     signal?.throwIfAborted();
     return this.#request(
-      this.#client.POST("/v1/compute-services/versions/{versionId}/start", {
-        params: { path: { versionId } },
+      this.#client.POST("/v1/deployments/{deploymentId}/start", {
+        params: { path: { deploymentId } },
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
-      "/v1/compute-services/versions/{versionId}/start",
+      "/v1/deployments/{deploymentId}/start",
       signal,
     ).then((r) => r.map((body) => body.data));
   }
 
-  async stopVersion(
-    versionId: string,
+  async stopDeployment(
+    deploymentId: string,
     signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
     signal?.throwIfAborted();
     return this.#unwrapVoid(
-      this.#client.POST("/v1/compute-services/versions/{versionId}/stop", {
-        params: { path: { versionId } },
+      this.#client.POST("/v1/deployments/{deploymentId}/stop", {
+        params: { path: { deploymentId } },
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
@@ -193,14 +194,14 @@ export class InternalApiClient {
     );
   }
 
-  async deleteVersion(
-    versionId: string,
+  async deleteDeployment(
+    deploymentId: string,
     signal?: AbortSignal,
   ): Promise<Result<void, ApiClientError>> {
     signal?.throwIfAborted();
     return this.#unwrapVoid(
-      this.#client.DELETE("/v1/compute-services/versions/{versionId}", {
-        params: { path: { versionId } },
+      this.#client.DELETE("/v1/deployments/{deploymentId}", {
+        params: { path: { deploymentId } },
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
@@ -208,20 +209,16 @@ export class InternalApiClient {
     );
   }
 
-  async promoteService(
-    computeServiceId: string,
-    body: PromoteServiceBody,
-    signal?: AbortSignal,
-  ) {
+  async promoteApp(appId: string, body: PromoteAppBody, signal?: AbortSignal) {
     signal?.throwIfAborted();
     return this.#request(
-      this.#client.POST("/v1/compute-services/{computeServiceId}/promote", {
-        params: { path: { computeServiceId } },
+      this.#client.POST("/v1/apps/{appId}/promote", {
+        params: { path: { appId } },
         body,
         // Intentionally do not pass AbortSignal for mutating operations.
         // Aborting transport can leave remote completion ambiguous.
       }),
-      "/v1/compute-services/{computeServiceId}/promote",
+      "/v1/apps/{appId}/promote",
       signal,
     ).then((r) => r.map((body) => body.data));
   }
@@ -380,23 +377,20 @@ type CreateProjectBody = Omit<SdkCreateProjectBody, "region"> & {
   region?: string;
 };
 
-type SdkCreateProjectServiceBody = NonNullable<
-  paths["/v1/projects/{projectId}/compute-services"]["post"]["requestBody"]
+type SdkCreateAppBody = NonNullable<
+  paths["/v1/apps"]["post"]["requestBody"]
 >["content"]["application/json"];
 
-type CreateProjectServiceBody = Omit<
-  SdkCreateProjectServiceBody,
-  "regionId"
-> & {
+type CreateProjectAppBody = Omit<SdkCreateAppBody, "regionId" | "projectId"> & {
   regionId?: string;
 };
 
-export type CreateServiceVersionBody = NonNullable<
-  paths["/v1/compute-services/{computeServiceId}/versions"]["post"]["requestBody"]
+export type CreateAppDeploymentBody = NonNullable<
+  paths["/v1/apps/{appId}/deployments"]["post"]["requestBody"]
 >["content"]["application/json"];
 
-export type PromoteServiceBody = NonNullable<
-  paths["/v1/compute-services/{computeServiceId}/promote"]["post"]["requestBody"]
+export type PromoteAppBody = NonNullable<
+  paths["/v1/apps/{appId}/promote"]["post"]["requestBody"]
 >["content"]["application/json"];
 
 type ListEnvironmentVariablesQuery = NonNullable<
@@ -489,7 +483,7 @@ function parseRequestError(
   return parseApiError(error, response, fallbackMessage);
 }
 
-/** Extract the upload URL from a version creation response. */
+/** Extract the upload URL from a deployment creation response. */
 export function readUploadUrl(data: {
   uploadUrl?: string | null;
 }): string | null {

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(