@prisma/compute-sdk 0.29.0 → 0.31.0

package/src/config/index.ts

@@ -51,10 +51,13 @@ export { serializeComputeConfig } from "./serialize.ts";
 export { resolveSourceRoot, sourceRootLineage } from "./source-root.ts";
 export {
   COMPUTE_FRAMEWORKS,
+  COMPUTE_REGIONS,
   type ComputeAppConfig,
   type ComputeBuildConfig,
   type ComputeConfig,
+  type ComputeConfigDefaults,
   type ComputeEnvConfig,
   type ComputeFramework,
+  type ComputeRegion,
   defineComputeConfig,
 } from "./types.ts";

package/src/config/normalize.ts

@@ -3,7 +3,12 @@ import path from "node:path";
 import { Result, TaggedError } from "better-result";
 
 import { frameworkByKey } from "./frameworks.ts";
-import { COMPUTE_FRAMEWORKS, type ComputeFramework } from "./types.ts";
+import {
+  COMPUTE_FRAMEWORKS,
+  COMPUTE_REGIONS,
+  type ComputeFramework,
+  type ComputeRegion,
+} from "./types.ts";
 
 export interface ComputeDeployTargetBuild {
   /** Build command, null to skip the build step, undefined when not configured. */
@@ -21,6 +26,8 @@ export interface ComputeDeployTarget {
   /** `apps` map key, or null for a single-app `app` config. */
   key: string | null;
   name: string | null;
+  /** Region used when creating a new app, or null to use the consumer default. */
+  region: ComputeRegion | null;
   /** Normalized app directory relative to the config file, or null for the config directory. */
   root: string | null;
   framework: ComputeFramework | null;
@@ -102,6 +109,7 @@ export type ComputeConfigTargetError =
 
 const KNOWN_APP_KEYS = [
   "name",
+  "region",
   "root",
   "framework",
   "entry",
@@ -109,6 +117,7 @@ const KNOWN_APP_KEYS = [
   "env",
   "build",
 ] as const;
+const KNOWN_TOP_LEVEL_KEYS = ["app", "apps", "region"] as const;
 const KNOWN_ENV_KEYS = ["file", "vars"] as const;
 const KNOWN_BUILD_KEYS = ["command", "outputDirectory", "entrypoint"] as const;
 
@@ -123,6 +132,7 @@ export function normalizeComputeConfig(
   const issues: string[] = [];
   const targets: ComputeDeployTarget[] = [];
   let kind: LoadedComputeConfig["kind"] = "single";
+  let projectRegion: ComputeRegion | null = null;
 
   if (!isPlainObject(exported)) {
     issues.push(
@@ -131,11 +141,16 @@ export function normalizeComputeConfig(
   } else {
     const hasApp = exported.app !== undefined;
     const hasApps = exported.apps !== undefined;
+    projectRegion = readOptionalComputeRegion(
+      exported.region,
+      "region",
+      issues,
+    );
 
     for (const key of Object.keys(exported)) {
-      if (key !== "app" && key !== "apps") {
+      if (!(KNOWN_TOP_LEVEL_KEYS as readonly string[]).includes(key)) {
         issues.push(
-          `Unknown top-level key "${key}". Expected "app" or "apps".`,
+          `Unknown top-level key "${key}". Expected one of: ${KNOWN_TOP_LEVEL_KEYS.join(", ")}.`,
         );
       }
     }
@@ -145,7 +160,13 @@ export function normalizeComputeConfig(
         "Use either `app` (single app) or `apps` (multi-app), not both.",
       );
     } else if (hasApp) {
-      const target = normalizeAppEntry(exported.app, "app", null, issues);
+      const target = normalizeAppEntry(
+        exported.app,
+        "app",
+        null,
+        projectRegion,
+        issues,
+      );
       if (target) {
         targets.push(target);
       }
@@ -163,7 +184,13 @@ export function normalizeComputeConfig(
             issues.push("`apps` keys must be non-empty target names.");
             continue;
           }
-          const target = normalizeAppEntry(value, `apps.${key}`, key, issues);
+          const target = normalizeAppEntry(
+            value,
+            `apps.${key}`,
+            key,
+            projectRegion,
+            issues,
+          );
           if (target) {
             targets.push(target);
           }
@@ -294,6 +321,7 @@ function normalizeAppEntry(
   value: unknown,
   label: string,
   key: string | null,
+  projectRegion: ComputeRegion | null,
   issues: string[],
 ): ComputeDeployTarget | null {
   if (!isPlainObject(value)) {
@@ -310,6 +338,12 @@ function normalizeAppEntry(
   }
 
   const name = readOptionalNonEmptyString(value.name, `${label}.name`, issues);
+  const appRegion = readOptionalComputeRegion(
+    value.region,
+    `${label}.region`,
+    issues,
+  );
+  const region = appRegion ?? projectRegion;
   const entry = readOptionalNonEmptyString(
     value.entry,
     `${label}.entry`,
@@ -414,6 +448,7 @@ function normalizeAppEntry(
   return {
     key,
     name,
+    region,
     root,
     framework,
     entry:
@@ -601,6 +636,24 @@ function readOptionalNonEmptyString(
   return value.trim();
 }
 
+function readOptionalComputeRegion(
+  value: unknown,
+  label: string,
+  issues: string[],
+): ComputeRegion | null {
+  if (value === undefined) {
+    return null;
+  }
+
+  const region = typeof value === "string" ? value.trim() : "";
+  if (!(COMPUTE_REGIONS as readonly string[]).includes(region)) {
+    issues.push(`\`${label}\` must be one of: ${COMPUTE_REGIONS.join(", ")}.`);
+    return null;
+  }
+
+  return region as ComputeRegion;
+}
+
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }

package/src/config/serialize.ts

@@ -1,5 +1,11 @@
 import type { ComputeAppConfig, ComputeConfig } from "./types.ts";
 
+type SerializableComputeConfig = {
+  region?: ComputeConfig["region"];
+  app?: ComputeAppConfig;
+  apps?: Record<string, ComputeAppConfig>;
+};
+
 /**
  * Renders a `prisma.compute.ts` source file for a config — the scaffolding
  * counterpart of `loadComputeConfig`. Output round-trips through
@@ -13,10 +19,7 @@ export function serializeComputeConfig(
   },
 ): string {
   const importFrom = options?.importFrom ?? "@prisma/compute-sdk/config";
-  const body =
-    "app" in config && config.app !== undefined
-      ? `{\n  app: ${renderValue(config.app, 1)},\n}`
-      : `{\n  apps: ${renderValue((config as { apps: Record<string, ComputeAppConfig> }).apps, 1)},\n}`;
+  const body = renderValue(serializableComputeConfig(config), 0);
 
   return [
     `import { defineComputeConfig } from ${JSON.stringify(importFrom)};`,
@@ -26,6 +29,38 @@ export function serializeComputeConfig(
   ].join("\n");
 }
 
+function serializableComputeConfig(
+  config: ComputeConfig,
+): SerializableComputeConfig {
+  const serializable: SerializableComputeConfig = {};
+  if (config.region !== undefined) {
+    serializable.region = config.region;
+  }
+  if ("app" in config && config.app !== undefined) {
+    serializable.app = serializableComputeAppConfig(config.app);
+  } else {
+    serializable.apps = Object.fromEntries(
+      Object.entries(
+        (config as { apps: Record<string, ComputeAppConfig> }).apps,
+      ).map(([key, app]) => [key, serializableComputeAppConfig(app)]),
+    );
+  }
+  return serializable;
+}
+
+function serializableComputeAppConfig(app: ComputeAppConfig): ComputeAppConfig {
+  return {
+    name: app.name,
+    region: app.region,
+    root: app.root,
+    framework: app.framework,
+    entry: app.entry,
+    httpPort: app.httpPort,
+    env: app.env,
+    build: app.build,
+  };
+}
+
 const IDENTIFIER_KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 
 function renderValue(value: unknown, depth: number): string {

package/src/config/types.ts

@@ -19,6 +19,18 @@ export const COMPUTE_FRAMEWORKS = [
 
 export type ComputeFramework = (typeof COMPUTE_FRAMEWORKS)[number];
 
+/** Supported Compute region identifiers. */
+export const COMPUTE_REGIONS = Object.freeze([
+  "us-east-1",
+  "us-west-1",
+  "eu-west-3",
+  "eu-central-1",
+  "ap-northeast-1",
+  "ap-southeast-1",
+] as const);
+
+export type ComputeRegion = (typeof COMPUTE_REGIONS)[number];
+
 export interface ComputeEnvConfig {
   /** Dotenv file path(s) resolved relative to the config file directory. */
   file?: string | string[];
@@ -42,6 +54,8 @@ export interface ComputeBuildConfig {
 export interface ComputeAppConfig {
   /** Deployed app name. Defaults to the `apps` key, then consumer-side inference. */
   name?: string;
+  /** App region override. Defaults to the project region, then consumer-side inference. */
+  region?: ComputeRegion;
   /** App directory relative to the config file. Defaults to the config file directory. */
   root?: string;
   /** Framework to deploy. Defaults to detection from the app directory. */
@@ -56,6 +70,14 @@ export interface ComputeAppConfig {
   build?: ComputeBuildConfig;
 }
 
+/**
+ * Project-level defaults for every app in the config.
+ */
+export interface ComputeConfigDefaults {
+  /** Default region used when creating new apps. Existing apps keep their current region. */
+  region?: ComputeRegion;
+}
+
 /**
  * `prisma.compute.ts` accepts exactly one of:
  *
@@ -63,8 +85,11 @@ export interface ComputeAppConfig {
  * - `apps` — a monorepo or multi-app repository, keyed by deploy target
  */
 export type ComputeConfig =
-  | { app: ComputeAppConfig; apps?: never }
-  | { apps: Record<string, ComputeAppConfig>; app?: never };
+  | (ComputeConfigDefaults & { app: ComputeAppConfig; apps?: never })
+  | (ComputeConfigDefaults & {
+      apps: Record<string, ComputeAppConfig>;
+      app?: never;
+    });
 
 /**
  * Identity helper that gives `prisma.compute.ts` full type checking:

package/src/errors.ts

@@ -37,57 +37,61 @@ export class ArtifactError extends TaggedError("ArtifactError")<{
 }>() {}
 
 export class TimeoutError extends TaggedError("TimeoutError")<{
-  versionId: string;
+  deploymentId: string;
   elapsedMs: number;
   lastStatus: string;
   message: string;
 }>() {
   constructor(args: {
-    versionId: string;
+    deploymentId: string;
     elapsedMs: number;
     lastStatus: string;
   }) {
     super({
       ...args,
-      message: `Timed out waiting for version ${args.versionId} to reach target state (last status: ${args.lastStatus}, elapsed: ${Math.round(args.elapsedMs / 1000)}s)`,
+      message: `Timed out waiting for deployment ${args.deploymentId} to reach target state (last status: ${args.lastStatus}, elapsed: ${Math.round(args.elapsedMs / 1000)}s)`,
     });
   }
 }
 
-export class VersionFailedError extends TaggedError("VersionFailedError")<{
-  versionId: string;
+export class DeploymentFailedError extends TaggedError(
+  "DeploymentFailedError",
+)<{
+  deploymentId: string;
   message: string;
 }>() {
-  constructor(args: { versionId: string }) {
+  constructor(args: { deploymentId: string }) {
     super({
-      versionId: args.versionId,
-      message: `Version ${args.versionId} transitioned to failed status`,
+      deploymentId: args.deploymentId,
+      message: `Deployment ${args.deploymentId} transitioned to failed status`,
     });
   }
 }
 
-export class NoExistingVersionError extends TaggedError(
-  "NoExistingVersionError",
+export class NoExistingDeploymentError extends TaggedError(
+  "NoExistingDeploymentError",
 )<{
-  serviceId: string;
+  appId: string;
   message: string;
 }>() {
-  constructor(args: { serviceId: string }) {
+  constructor(args: { appId: string }) {
     super({
-      serviceId: args.serviceId,
-      message: `Service ${args.serviceId} has no existing versions. Environment-only updates require at least one prior deployment.`,
+      appId: args.appId,
+      message: `App ${args.appId} has no existing deployments. Environment-only updates require at least one prior deployment.`,
     });
   }
 }
 
-export class NoVersionsFoundError extends TaggedError("NoVersionsFoundError")<{
-  serviceId: string;
+export class NoDeploymentsFoundError extends TaggedError(
+  "NoDeploymentsFoundError",
+)<{
+  appId: string;
   message: string;
 }>() {
-  constructor(args: { serviceId: string }) {
+  constructor(args: { appId: string }) {
     super({
-      serviceId: args.serviceId,
-      message: `Service ${args.serviceId} has no versions`,
+      appId: args.appId,
+      message: `App ${args.appId} has no deployments`,
     });
   }
 }
@@ -104,19 +108,19 @@ export class DestroyAggregateError extends TaggedError(
   "DestroyAggregateError",
 )<{
   message: string;
-  succeededVersionIds: string[];
-  failures: Array<{ versionId: string; error: VersionOperationError }>;
-  serviceDeleted: boolean;
+  succeededDeploymentIds: string[];
+  failures: Array<{ deploymentId: string; error: DeploymentOperationError }>;
+  appDeleted: boolean;
 }>() {
   constructor(args: {
-    succeededVersionIds: string[];
-    failures: Array<{ versionId: string; error: VersionOperationError }>;
-    serviceDeleted: boolean;
+    succeededDeploymentIds: string[];
+    failures: Array<{ deploymentId: string; error: DeploymentOperationError }>;
+    appDeleted: boolean;
   }) {
-    const failedIds = args.failures.map((f) => f.versionId).join(", ");
+    const failedIds = args.failures.map((f) => f.deploymentId).join(", ");
     super({
       ...args,
-      message: `Failed to destroy ${args.failures.length} version(s): ${failedIds}`,
+      message: `Failed to destroy ${args.failures.length} deployment(s): ${failedIds}`,
     });
   }
 }
@@ -138,7 +142,7 @@ export type DeployError =
   | BuildError
   | ArtifactError
   | TimeoutError
-  | VersionFailedError
+  | DeploymentFailedError
   | CancelledError;
 
 export type UpdateEnvError =
@@ -146,21 +150,21 @@ export type UpdateEnvError =
   | ApiError
   | MissingArgumentError
   | InvalidOptionsError
-  | NoExistingVersionError
+  | NoExistingDeploymentError
   | TimeoutError
-  | VersionFailedError
+  | DeploymentFailedError
   | CancelledError;
 
-export type DestroyVersionError =
+export type DestroyDeploymentError =
   | CancelledError
   | MissingArgumentError
-  | NoVersionsFoundError
+  | NoDeploymentsFoundError
   | AuthenticationError
   | ApiError
   | TimeoutError
-  | VersionFailedError;
+  | DeploymentFailedError;
 
-export type DestroyServiceError =
+export type DestroyAppError =
   | CancelledError
   | AuthenticationError
   | ApiError
@@ -170,16 +174,16 @@ export type PromoteError =
   | AuthenticationError
   | ApiError
   | MissingArgumentError
-  | NoVersionsFoundError
+  | NoDeploymentsFoundError
   | TimeoutError
-  | VersionFailedError
+  | DeploymentFailedError
   | CancelledError;
 
 export type ApiRequestError = CancelledError | AuthenticationError | ApiError;
 
-export type VersionOperationError =
+export type DeploymentOperationError =
   | CancelledError
   | AuthenticationError
   | ApiError
   | TimeoutError
-  | VersionFailedError;
+  | DeploymentFailedError;

package/src/index.ts

@@ -40,32 +40,32 @@ export { BunBuild } from "./bun-build.ts";
 export type {
   DeployInteraction,
   DeployProgress,
-  DestroyServiceProgress,
-  DestroyVersionInteraction,
-  DestroyVersionProgress,
+  DestroyAppProgress,
+  DestroyDeploymentInteraction,
+  DestroyDeploymentProgress,
   PromoteProgress,
   UpdateEnvProgress,
 } from "./callbacks.ts";
 export type {
+  CreateAppOptions,
   CreateProjectOptions,
-  CreateServiceOptions,
-  DeleteServiceOptions,
-  DeleteVersionOptions,
+  DeleteAppOptions,
+  DeleteDeploymentOptions,
   DeployOptions,
   DeployResult,
-  DestroyServiceOptions,
-  DestroyServiceResult,
-  DestroyVersionOptions,
-  DestroyVersionResult,
+  DestroyAppOptions,
+  DestroyAppResult,
+  DestroyDeploymentOptions,
+  DestroyDeploymentResult,
+  ListAppsOptions,
+  ListDeploymentsOptions,
   ListProjectsOptions,
-  ListServicesOptions,
-  ListVersionsOptions,
   PromoteOptions,
   PromoteResult,
-  ShowServiceOptions,
-  ShowVersionOptions,
-  StartVersionOptions,
-  StopVersionOptions,
+  ShowAppOptions,
+  ShowDeploymentOptions,
+  StartDeploymentOptions,
+  StopDeploymentOptions,
   UpdateEnvOptions,
   UpdateEnvResult,
 } from "./compute-client.ts";
@@ -83,11 +83,11 @@ export { detectAppSchema } from "./detect-schema.ts";
 export type {
   ApiRequestError,
   DeployError,
-  DestroyServiceError,
-  DestroyVersionError,
+  DeploymentOperationError,
+  DestroyAppError,
+  DestroyDeploymentError,
   PromoteError,
   UpdateEnvError,
-  VersionOperationError,
 } from "./errors.ts";
 export {
   ApiError,
@@ -95,14 +95,14 @@ export {
   AuthenticationError,
   BuildError,
   CancelledError,
+  DeploymentFailedError,
   DestroyAggregateError,
   InvalidOptionsError,
   LogStreamError,
   MissingArgumentError,
-  NoExistingVersionError,
-  NoVersionsFoundError,
+  NoDeploymentsFoundError,
+  NoExistingDeploymentError,
   TimeoutError,
-  VersionFailedError,
 } from "./errors.ts";
 export type {
   LogRecord,
@@ -118,16 +118,17 @@ export { NextjsBuild } from "./nextjs-build.ts";
 export { NuxtBuild } from "./nuxt-build.ts";
 export { TanstackStartBuild } from "./tanstack-start-build.ts";
 export type {
+  AppDetail,
+  AppInfo,
+  ComputeRegion,
   CreateProjectResult,
   DatabaseInfo,
+  DeploymentDetail,
+  DeploymentInfo,
   PortMapping,
   ProjectInfo,
   RegionInfo,
   ResolvedConfig,
-  ServiceDetail,
-  ServiceInfo,
-  VersionDetail,
-  VersionInfo,
 } from "./types.ts";
 export { KNOWN_REGION_IDS, REGIONS } from "./types.ts";
 export { uploadArtifact } from "./upload-artifact.ts";

package/src/log-stream.ts

@@ -27,7 +27,7 @@ export type StreamRecord = LogRecord | TerminalRecord;
 export type LogStreamOptions = {
   baseUrl: string;
   token: string;
-  versionId: string;
+  deploymentId: string;
   tail?: number;
   fromStart?: boolean;
   cursor?: string;
@@ -71,7 +71,7 @@ function toError(value: unknown): Error {
 
 function buildWebSocketUrl(options: LogStreamOptions): string {
   const httpUrl = new URL(
-    `/v1/compute-services/versions/${encodeURIComponent(options.versionId)}/logs`,
+    `/v1/deployments/${encodeURIComponent(options.deploymentId)}/logs`,
     options.baseUrl,
   );
   httpUrl.protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";

package/src/polling.ts

@@ -3,8 +3,8 @@ import type { ApiClientError, InternalApiClient } from "./api-client.ts";
 import {
   ApiError,
   CancelledError,
+  DeploymentFailedError,
   TimeoutError,
-  VersionFailedError,
 } from "./errors.ts";
 
 export type PollOptions = {
@@ -23,17 +23,17 @@ export type PollResult = {
 export type PollError =
   | CancelledError
   | TimeoutError
-  | VersionFailedError
+  | DeploymentFailedError
   | ApiClientError;
 
 /**
- * Polls a compute version until it reaches the target status, fails, or times out.
+ * Polls a deployment until it reaches the target status, fails, or times out.
  *
  * Returns a Result with the preview domain on success or a typed error.
  */
-export async function pollVersionStatus(
+export async function pollDeploymentStatus(
   api: InternalApiClient,
-  versionId: string,
+  deploymentId: string,
   options: PollOptions,
 ): Promise<Result<PollResult, PollError>> {
   return Result.gen(async function* () {
@@ -45,34 +45,35 @@ export async function pollVersionStatus(
         return Result.err(new CancelledError());
       }
 
-      const version = yield* Result.await(
-        api.getVersion(versionId, options.signal),
+      const deployment = yield* Result.await(
+        api.getDeployment(deploymentId, options.signal),
       );
 
-      if (version.status !== lastStatus) {
-        lastStatus = version.status;
-        options.onStatusChange?.(version.status);
+      if (deployment.status !== lastStatus) {
+        lastStatus = deployment.status;
+        options.onStatusChange?.(deployment.status);
       }
 
-      if (version.status === options.targetStatus) {
-        if (options.targetStatus === "running" && !version.previewDomain) {
+      if (deployment.status === options.targetStatus) {
+        if (options.targetStatus === "running" && !deployment.previewDomain) {
           return Result.err(
             new ApiError({
               statusCode: 0,
               statusText: "",
-              message: "Version reached running state without a previewDomain",
+              message:
+                "Deployment reached running state without a previewDomain",
               traceHeaders: {},
             }),
           );
         }
         return Result.ok({
-          previewDomain: version.previewDomain ?? "",
-          lastStatus: version.status,
+          previewDomain: deployment.previewDomain ?? "",
+          lastStatus: deployment.status,
         });
       }
 
-      if (version.status === "failed") {
-        return Result.err(new VersionFailedError({ versionId }));
+      if (deployment.status === "failed") {
+        return Result.err(new DeploymentFailedError({ deploymentId }));
       }
 
       await sleep(options.pollIntervalMs, options.signal);
@@ -80,7 +81,7 @@ export async function pollVersionStatus(
 
     return Result.err(
       new TimeoutError({
-        versionId,
+        deploymentId,
         elapsedMs: Date.now() - (deadline - options.timeoutSeconds * 1_000),
         lastStatus,
       }),