@prisma/compute-sdk 0.35.0 → 0.36.0

package/README.md

@@ -60,12 +60,12 @@ const result = await compute.deploy({
     entrypoint: "index.js",
   }),
   projectId: "your-project-id",
-  serviceName: "my-app",
+  appName: "my-app",
   region: "us-east-1",
 });
 
 if (result.isOk()) {
-  console.log(`Deployed to ${result.value.deploymentUrl}`);
+  console.log(`Deployed to ${result.value.deploymentEndpointDomain}`);
 } else {
   console.error(`Deploy failed: ${result.error.message}`);
 }
@@ -89,27 +89,29 @@ All methods return `Promise<Result<T, E>>` — a discriminated union that is eit
 
 #### `deploy(options): Promise<Result<DeployResult, DeployError>>`
 
-Builds, uploads, and deploys an application version.
+Builds, uploads, and deploys an application, then promotes it to the app's live endpoint.
 
 ```ts
 const result = await compute.deploy({
   // Required: how to produce the deployable artifact
   strategy: new PreBuilt({ appPath: "./dist", entrypoint: "index.js" }),
 
-  // Target (provide serviceId OR projectId + serviceName + region)
+  // Target (provide appId OR projectId + appName + region)
   projectId: "proj_abc",
-  serviceName: "my-app",
+  appName: "my-app",
   region: "us-east-1",
   // OR:
-  serviceId: "svc_xyz",
+  appId: "app_xyz",
 
   // Optional
-  // Stored through the environment-variable API before the version is created.
-  // Production services use project vars; preview-branch services use branch overrides.
+  // Stored through the environment-variable API before the deployment is created.
+  // Production apps use project vars; preview-branch apps use branch overrides.
   envVars: { DATABASE_URL: "postgresql://..." },
   portMapping: { http: 3000 },
   timeoutSeconds: 120, // max time to wait for "running" status
   pollIntervalMs: 1000, // how often to check status
+  skipPromote: false, // deploy without promoting to the app's live endpoint
+  destroyOldDeployment: false, // destroy (rather than just stop) the previously promoted deployment
   signal: abortController.signal,
   progress: {
     /* DeployProgress callbacks */
@@ -120,31 +122,38 @@ const result = await compute.deploy({
 });
 
 if (result.isOk()) {
-  const { deploymentUrl, versionId, serviceId, resolvedConfig } = result.value;
+  const { deploymentEndpointDomain, deploymentId, appId, resolvedConfig } =
+    result.value;
 }
 ```
 
+`skipPromote` and `destroyOldDeployment` are mutually exclusive — combining them returns an `InvalidOptionsError`, since there is no previously-active deployment to destroy when promotion is skipped.
+
 **Returns** `DeployResult`:
 
-| Field            | Type             | Description                  |
-| ---------------- | ---------------- | ---------------------------- |
-| `projectId`      | `string`         | Project ID                   |
-| `serviceId`      | `string`         | Service ID                   |
-| `serviceName`    | `string`         | Service display name         |
-| `region`         | `string`         | Region identifier            |
-| `versionId`      | `string`         | Created version ID           |
-| `deploymentUrl`  | `string`         | Live URL of the deployment   |
-| `resolvedConfig` | `ResolvedConfig` | Final resolved configuration |
+| Field                      | Type                                                | Description                                             |
+| -------------------------- | ---------------------------------------------------- | -------------------------------------------------------- |
+| `projectId`                 | `string`                                              | Project ID                                                |
+| `appId`                     | `string`                                              | App ID                                                    |
+| `appName`                   | `string`                                              | App display name                                          |
+| `region`                    | `string`                                              | Region identifier                                          |
+| `deploymentId`               | `string`                                              | Created deployment ID                                      |
+| `deploymentEndpointDomain`   | `string`                                              | Live URL of the new deployment                             |
+| `appEndpointDomain`          | `string \| null`                                     | The app's live URL, or `null` when `skipPromote` was set   |
+| `promoted`                   | `boolean`                                             | Whether the new deployment was promoted                    |
+| `previousDeploymentId`       | `string \| null`                                     | The previously active deployment, if any                   |
+| `previousDeploymentAction`   | `"stopped" \| "destroyed" \| "still-active" \| null`  | What happened to the previous deployment                   |
+| `resolvedConfig`             | `ResolvedConfig`                                      | Final resolved configuration                                |
 
 ---
 
 #### `updateEnv(options): Promise<Result<UpdateEnvResult, UpdateEnvError>>`
 
-Updates project environment variables and/or port mapping, then creates a new version that reuses the code from the most recent deployment. Preview-branch services update preview branch overrides.
+Updates project environment variables and/or port mapping, then creates a new deployment that reuses the code from the most recent deployment. Preview-branch apps update preview branch overrides.
 
 ```ts
 const result = await compute.updateEnv({
-  serviceId: "svc_xyz",
+  appId: "app_xyz",
   envVars: { DATABASE_URL: "postgresql://new-url..." },
   portMapping: { http: 8080 },
 });
@@ -154,7 +163,7 @@ To remove an environment variable, set its value to `null`:
 
 ```ts
 const result = await compute.updateEnv({
-  serviceId: "svc_xyz",
+  appId: "app_xyz",
   envVars: {
     DATABASE_URL: "postgresql://new-url...", // set or update
     OLD_SECRET: null, // remove
@@ -162,44 +171,97 @@ const result = await compute.updateEnv({
 });
 ```
 
-The service must have at least one existing version. If not, this returns a `NoExistingVersionError`.
+The app must have at least one existing deployment. If not, this returns a `NoExistingDeploymentError`.
 
 ---
 
-#### `destroyVersion(options): Promise<Result<DestroyVersionResult, DestroyVersionError>>`
+#### `destroyDeployment(options): Promise<Result<DestroyDeploymentResult, DestroyDeploymentError>>`
 
-Stops (if running) and deletes a single version.
+Stops (if running) and deletes a single deployment.
 
 ```ts
-const result = await compute.destroyVersion({
-  versionId: "ver_abc",
-  // OR provide serviceId + interaction.selectVersion for interactive selection
+const result = await compute.destroyDeployment({
+  deploymentId: "dep_abc",
+  // OR provide appId + interaction.selectDeployment for interactive selection
 });
 ```
 
-**Returns** `DestroyVersionResult`:
+**Returns** `DestroyDeploymentResult`:
+
+| Field            | Type      | Description                  |
+| ---------------- | --------- | ----------------------------- |
+| `deploymentId`   | `string`  | The destroyed deployment ID   |
+| `previousStatus` | `string`  | Status before destruction     |
+| `stopped`        | `boolean` | Whether a stop was required   |
+| `deleted`        | `boolean` | Whether deletion succeeded    |
+
+---
+
+#### `destroyApp(options): Promise<Result<DestroyAppResult, DestroyAppError>>`
+
+Stops all running deployments, deletes all deployments, and optionally deletes the app itself.
+
+```ts
+const result = await compute.destroyApp({
+  appId: "app_xyz",
+  keepApp: false, // set to true to keep the app record
+});
+```
 
-| Field            | Type      | Description                 |
-| ---------------- | --------- | --------------------------- |
-| `versionId`      | `string`  | The destroyed version ID    |
-| `previousStatus` | `string`  | Status before destruction   |
-| `stopped`        | `boolean` | Whether a stop was required |
-| `deleted`        | `boolean` | Whether deletion succeeded  |
+If some deployments fail to stop or delete, returns a `DestroyAggregateError` with details on which succeeded and which failed.
 
 ---
 
-#### `destroyService(options): Promise<Result<DestroyServiceResult, DestroyServiceError>>`
+#### `promote(options): Promise<Result<PromoteResult, PromoteError>>`
 
-Stops all running versions, deletes all versions, and optionally deletes the service itself.
+Promotes an existing deployment to the app's live endpoint, starting it first if it isn't already running. Unlike `deploy`, this does not build, upload, or create a new deployment — it operates on one that already exists.
 
 ```ts
-const result = await compute.destroyService({
-  serviceId: "svc_xyz",
-  keepService: false, // set to true to keep the service record
+const result = await compute.promote({
+  appId: "app_xyz",
+  deploymentId: "dep_abc",
+  // OR provide interaction.selectDeployment for interactive selection
 });
 ```
 
-If some versions fail to stop or delete, returns a `DestroyAggregateError` with details on which succeeded and which failed.
+**Returns** `PromoteResult`:
+
+| Field                | Type      | Description                                     |
+| -------------------- | --------- | ------------------------------------------------ |
+| `appId`              | `string`  | App ID                                            |
+| `deploymentId`       | `string`  | The promoted deployment ID                        |
+| `appEndpointDomain`  | `string`  | The app's live URL after promotion                |
+| `deploymentStarted`  | `boolean` | Whether the deployment had to be started first    |
+
+---
+
+#### `createProject(options): Promise<Result<CreateProjectResult, ApiRequestError>>`
+
+Creates a new project, optionally provisioning a database alongside it.
+
+```ts
+const result = await compute.createProject({
+  name: "my-project",
+  createDatabase: true,
+  region: "us-east-1",
+});
+
+if (result.isOk()) {
+  console.log(`Project: ${result.value.id}`);
+  if (result.value.database) {
+    console.log(`Database: ${result.value.database.connectionString}`);
+  }
+}
+```
+
+**Returns** `CreateProjectResult` (`ProjectInfo & { database?: DatabaseInfo }`):
+
+| Field           | Type           | Description                                          |
+| --------------- | -------------- | ------------------------------------------------------ |
+| `id`             | `string`       | Project ID                                              |
+| `name`           | `string`       | Project name                                             |
+| `defaultRegion`  | `string \| undefined` | Default region, if set                            |
+| `database`       | `DatabaseInfo \| undefined` | Provisioned database, present when `createDatabase` is true |
 
 ---
 
@@ -216,59 +278,59 @@ if (result.isOk()) {
 
 ---
 
-#### `listServices(options): Promise<Result<ServiceInfo[], ApiRequestError>>`
+#### `listApps(options): Promise<Result<AppInfo[], ApiRequestError>>`
 
 ```ts
-const result = await compute.listServices({ projectId: "proj_abc" });
+const result = await compute.listApps({ projectId: "proj_abc" });
 ```
 
 ---
 
-#### `createService(options): Promise<Result<ServiceInfo, ApiRequestError>>`
+#### `createApp(options): Promise<Result<AppInfo, ApiRequestError>>`
 
 ```ts
-const result = await compute.createService({
+const result = await compute.createApp({
   projectId: "proj_abc",
-  serviceName: "my-new-service",
+  appName: "my-new-app",
   region: "eu-west-3",
 });
 ```
 
 ---
 
-#### `showService(options): Promise<Result<ServiceDetail, ApiRequestError>>`
+#### `showApp(options): Promise<Result<AppDetail, ApiRequestError>>`
 
 ```ts
-const result = await compute.showService({ serviceId: "svc_xyz" });
+const result = await compute.showApp({ appId: "app_xyz" });
 if (result.isOk()) {
-  console.log(`Latest version: ${result.value.latestVersionId}`);
+  console.log(`Latest deployment: ${result.value.latestDeploymentId}`);
 }
 ```
 
 ---
 
-#### `deleteService(options): Promise<Result<void, ApiRequestError>>`
+#### `deleteApp(options): Promise<Result<void, ApiRequestError>>`
 
-Deletes a service record. The service should have no versions (use `destroyService` to clean up versions first).
+Deletes an app record. The app should have no deployments (use `destroyApp` to clean up deployments first).
 
 ```ts
-await compute.deleteService({ serviceId: "svc_xyz" });
+await compute.deleteApp({ appId: "app_xyz" });
 ```
 
 ---
 
-#### `listVersions(options): Promise<Result<VersionInfo[], ApiRequestError>>`
+#### `listDeployments(options): Promise<Result<DeploymentInfo[], ApiRequestError>>`
 
 ```ts
-const result = await compute.listVersions({ serviceId: "svc_xyz" });
+const result = await compute.listDeployments({ appId: "app_xyz" });
 ```
 
 ---
 
-#### `showVersion(options): Promise<Result<VersionDetail, ApiRequestError>>`
+#### `showDeployment(options): Promise<Result<DeploymentDetail, ApiRequestError>>`
 
 ```ts
-const result = await compute.showVersion({ versionId: "ver_abc" });
+const result = await compute.showDeployment({ deploymentId: "dep_abc" });
 if (result.isOk()) {
   console.log(`Status: ${result.value.status}`);
   console.log(`URL: https://${result.value.previewDomain}`);
@@ -277,31 +339,31 @@ if (result.isOk()) {
 
 ---
 
-#### `startVersion(options): Promise<Result<void, ApiRequestError>>`
+#### `startDeployment(options): Promise<Result<void, ApiRequestError>>`
 
 ```ts
-await compute.startVersion({ versionId: "ver_abc" });
+await compute.startDeployment({ deploymentId: "dep_abc" });
 ```
 
 ---
 
-#### `stopVersion(options): Promise<Result<void, ApiRequestError>>`
+#### `stopDeployment(options): Promise<Result<void, ApiRequestError>>`
 
 ```ts
-await compute.stopVersion({ versionId: "ver_abc" });
+await compute.stopDeployment({ deploymentId: "dep_abc" });
 ```
 
 ---
 
-#### `deleteVersion(options): Promise<Result<void, ApiRequestError>>`
+#### `deleteDeployment(options): Promise<Result<void, ApiRequestError>>`
 
 ```ts
-await compute.deleteVersion({ versionId: "ver_abc" });
+await compute.deleteDeployment({ deploymentId: "dep_abc" });
 ```
 
 ## Build strategies
 
-A build strategy produces a deployable artifact (a directory with an entrypoint file). The SDK ships with two built-in strategies:
+A build strategy produces a deployable artifact (a directory with an entrypoint file). The SDK ships with two built-in general-purpose strategies (plus framework-specific ones used internally by `AutoBuild`):
 
 ### `PreBuilt`
 
@@ -368,14 +430,14 @@ const result = await compute.deploy({
 
 // Pattern 1: isOk / isErr
 if (result.isOk()) {
-  console.log(result.value.deploymentUrl);
+  console.log(result.value.deploymentEndpointDomain);
 } else {
   console.error(result.error.message);
 }
 
 // Pattern 2: match
 result.match({
-  Ok: (value) => console.log(value.deploymentUrl),
+  Ok: (value) => console.log(value.deploymentEndpointDomain),
   Err: (error) => console.error(error.message),
 });
 ```
@@ -384,18 +446,20 @@ result.match({
 
 Every error extends `TaggedError` and has a `_tag` discriminant for pattern matching:
 
-| Error class              | `_tag`                     | Description                                               |
-| ------------------------ | -------------------------- | --------------------------------------------------------- |
-| `AuthenticationError`    | `"AuthenticationError"`    | API returned HTTP 401                                     |
-| `ApiError`               | `"ApiError"`               | API returned a non-401 error                              |
-| `MissingArgumentError`   | `"MissingArgumentError"`   | A required argument was not provided                      |
-| `BuildError`             | `"BuildError"`             | Build strategy failed                                     |
-| `ArtifactError`          | `"ArtifactError"`          | Archive creation or upload failed                         |
-| `TimeoutError`           | `"TimeoutError"`           | Version didn't reach target status in time                |
-| `VersionFailedError`     | `"VersionFailedError"`     | Version transitioned to `"failed"` status                 |
-| `NoExistingVersionError` | `"NoExistingVersionError"` | `updateEnv` called on a service with no prior deployments |
-| `CancelledError`         | `"CancelledError"`         | Operation cancelled via `AbortSignal`                     |
-| `DestroyAggregateError`  | `"DestroyAggregateError"`  | Some versions failed during `destroyService`              |
+| Error class                | `_tag`                       | Description                                              |
+| --------------------------- | ----------------------------- | ----------------------------------------------------------- |
+| `AuthenticationError`        | `"AuthenticationError"`        | API returned HTTP 401                                        |
+| `ApiError`                   | `"ApiError"`                   | API returned a non-401 error                                  |
+| `MissingArgumentError`       | `"MissingArgumentError"`       | A required argument was not provided                           |
+| `InvalidOptionsError`        | `"InvalidOptionsError"`        | A conflicting or invalid combination of options was provided    |
+| `BuildError`                 | `"BuildError"`                 | Build strategy failed                                            |
+| `ArtifactError`              | `"ArtifactError"`              | Archive creation or upload failed                                 |
+| `TimeoutError`               | `"TimeoutError"`               | Deployment didn't reach target status in time                      |
+| `DeploymentFailedError`      | `"DeploymentFailedError"`      | Deployment transitioned to `"failed"` status                        |
+| `NoExistingDeploymentError`  | `"NoExistingDeploymentError"`  | `updateEnv` called on an app with no prior deployments                |
+| `NoDeploymentsFoundError`    | `"NoDeploymentsFoundError"`    | App has no deployments to select from                                   |
+| `CancelledError`             | `"CancelledError"`             | Operation cancelled via `AbortSignal`                                     |
+| `DestroyAggregateError`      | `"DestroyAggregateError"`      | Some deployments failed during `destroyApp`                                |
 
 ### Matching specific errors
 
@@ -432,11 +496,12 @@ if (result.isErr()) {
 
 The SDK exports narrowed error unions for each operation:
 
-- **`DeployError`** — errors from `deploy()`: `CancelledError | MissingArgumentError | AuthenticationError | ApiError | BuildError | ArtifactError | TimeoutError | VersionFailedError`
-- **`UpdateEnvError`** — errors from `updateEnv()`: `CancelledError | MissingArgumentError | AuthenticationError | ApiError | NoExistingVersionError | TimeoutError | VersionFailedError`
-- **`DestroyVersionError`** — errors from `destroyVersion()`: `CancelledError | MissingArgumentError | AuthenticationError | ApiError | TimeoutError | VersionFailedError`
-- **`DestroyServiceError`** — errors from `destroyService()`: `CancelledError | AuthenticationError | ApiError | DestroyAggregateError`
-- **`ApiRequestError`** — errors from simple CRUD methods (`listProjects`, `listServices`, `createService`, etc.): `CancelledError | AuthenticationError | ApiError`
+- **`DeployError`** — errors from `deploy()`: `CancelledError | MissingArgumentError | InvalidOptionsError | AuthenticationError | ApiError | BuildError | ArtifactError | TimeoutError | DeploymentFailedError`
+- **`UpdateEnvError`** — errors from `updateEnv()`: `CancelledError | MissingArgumentError | InvalidOptionsError | AuthenticationError | ApiError | NoExistingDeploymentError | TimeoutError | DeploymentFailedError`
+- **`DestroyDeploymentError`** — errors from `destroyDeployment()`: `CancelledError | MissingArgumentError | NoDeploymentsFoundError | AuthenticationError | ApiError | TimeoutError | DeploymentFailedError`
+- **`DestroyAppError`** — errors from `destroyApp()`: `CancelledError | AuthenticationError | ApiError | DestroyAggregateError`
+- **`PromoteError`** — errors from `promote()`: `AuthenticationError | ApiError | MissingArgumentError | NoDeploymentsFoundError | TimeoutError | DeploymentFailedError | CancelledError`
+- **`ApiRequestError`** — errors from single-request methods (`createProject`, `listProjects`, `listApps`, `createApp`, `startDeployment`, `stopDeployment`, `deleteDeployment`, etc.): `CancelledError | AuthenticationError | ApiError`
 
 ## Progress and interaction callbacks
 
@@ -444,11 +509,13 @@ Long-running operations accept `progress` and `interaction` callbacks for UI int
 
 ### Deploy progress
 
+`deploy()` promotes the new deployment and stops (optionally destroys) the previous one by default, so `DeployProgress` also reports promotion and old-deployment cleanup progress alongside the build/upload/start steps:
+
 ```ts
 await compute.deploy({
   strategy,
   projectId: "proj_abc",
-  serviceName: "my-app",
+  appName: "my-app",
   region: "us-east-1",
   progress: {
     onBuildStart() {
@@ -463,8 +530,8 @@ await compute.deploy({
     onArchiveReady(sizeBytes) {
       console.log(`Archive: ${(sizeBytes / 1024).toFixed(1)} KB`);
     },
-    onVersionCreated(versionId) {
-      console.log(`Version: ${versionId}`);
+    onDeploymentCreated(deploymentId) {
+      console.log(`Deployment: ${deploymentId}`);
     },
     onUploadStart() {
       console.log("Uploading...");
@@ -481,13 +548,25 @@ await compute.deploy({
     onRunning(deploymentUrl) {
       console.log(`Live at ${deploymentUrl}`);
     },
+    onPromoteStart() {
+      console.log("Promoting...");
+    },
+    onPromoted(appEndpointDomain) {
+      console.log(`Promoted: ${appEndpointDomain}`);
+    },
+    onOldDeploymentStopping(deploymentId) {
+      console.log(`Stopping previous deployment ${deploymentId}...`);
+    },
+    onOldDeploymentStopped(deploymentId) {
+      console.log(`Stopped previous deployment ${deploymentId}.`);
+    },
   },
 });
 ```
 
 ### Deploy interaction
 
-When `projectId`, `serviceId`, or `region` are not provided, the SDK calls interaction callbacks to let the consumer resolve them (e.g., by prompting the user):
+When `projectId`, `appId`/`appName`, or `region` aren't provided, the SDK calls interaction callbacks so the caller can resolve them (e.g., by prompting the user):
 
 ```ts
 await compute.deploy({
@@ -497,16 +576,16 @@ await compute.deploy({
       // projects: ProjectInfo[] — return the chosen project ID
       return projects[0].id;
     },
-    async selectService(services) {
-      // services: ServiceInfo[] — return a service ID, or null to create a new one
+    async selectApp(apps) {
+      // apps: AppInfo[] — return an app ID, or null to create a new one
       return null;
     },
-    async provideServiceName() {
-      // return a name for the new service
-      return "my-new-service";
+    async provideAppName() {
+      // return a name for the new app
+      return "my-new-app";
     },
     async selectRegion(regions) {
-      // regions: RegionInfo[] — return the chosen region ID
+      // regions: RegionInfo[] — used to resolve a region when one wasn't supplied
       return "us-east-1";
     },
   },
@@ -516,28 +595,28 @@ await compute.deploy({
 ### Destroy progress
 
 ```ts
-await compute.destroyService({
-  serviceId: "svc_xyz",
+await compute.destroyApp({
+  appId: "app_xyz",
   progress: {
-    onStoppingVersions(versionIds) {
+    onStoppingDeployments(deploymentIds) {
       /* ... */
     },
-    onVersionStopped(versionId) {
+    onDeploymentStopped(deploymentId) {
       /* ... */
     },
-    onAllVersionsStopped() {
+    onAllDeploymentsStopped() {
       /* ... */
     },
-    onDeletingVersions(versionIds) {
+    onDeletingDeployments(deploymentIds) {
       /* ... */
     },
-    onVersionDeleted(versionId) {
+    onDeploymentDeleted(deploymentId) {
       /* ... */
     },
-    onAllVersionsDeleted() {
+    onAllDeploymentsDeleted() {
       /* ... */
     },
-    onServiceDeleted(serviceId) {
+    onAppDeleted(appId) {
       /* ... */
     },
   },
@@ -556,7 +635,7 @@ setTimeout(() => controller.abort(), 30_000);
 
 const result = await compute.deploy({
   strategy,
-  serviceId: "svc_xyz",
+  appId: "app_xyz",
   signal: controller.signal,
 });
 
@@ -570,12 +649,12 @@ if (result.isErr() && result.error._tag === "CancelledError") {
 ```ts
 import type {
   ProjectInfo, // { id, name, defaultRegion? }
-  ServiceInfo, // { id, name, region, projectId, createdAt? }
-  ServiceDetail, // ServiceInfo & { latestVersionId? }
-  VersionInfo, // { id, status, createdAt, previewDomain? }
-  VersionDetail, // VersionInfo & { envVars? }
+  AppInfo, // { id, name, region, projectId, createdAt? }
+  AppDetail, // AppInfo & { latestDeploymentId?, appEndpointDomain? }
+  DeploymentInfo, // { id, status, createdAt, previewDomain? }
+  DeploymentDetail, // DeploymentInfo & { envVars?, foundryVersionId? }
   RegionInfo, // { id, displayName }
-  ResolvedConfig, // { projectId, serviceId, serviceName, region, portMapping? }
+  ResolvedConfig, // { projectId, appId, appName, region, portMapping? }
   PortMapping, // { http?: number | null }
 } from "@prisma/compute-sdk";
 ```
@@ -609,7 +688,7 @@ async function main() {
       entrypoint: "server.js",
     }),
     projectId: process.env.PROJECT_ID!,
-    serviceName: "my-api",
+    appName: "my-api",
     region: "us-east-1",
     envVars: {
       DATABASE_URL: process.env.DATABASE_URL!,
@@ -637,7 +716,7 @@ async function main() {
       },
       TimeoutError: (e) => {
         console.error(`Deploy timed out (${Math.round(e.elapsedMs / 1000)}s).`);
-        console.error(`Version ${e.versionId} may still be starting.`);
+        console.error(`Deployment ${e.deploymentId} may still be starting.`);
         process.exit(1);
       },
       _: (e) => {
@@ -648,17 +727,17 @@ async function main() {
     return;
   }
 
-  const { serviceId, versionId, deploymentUrl } = deployResult.value;
-  console.log(`\nService: ${serviceId}`);
-  console.log(`Version: ${versionId}`);
-  console.log(`URL:     ${deploymentUrl}`);
-
-  // List versions
-  const versionsResult = await compute.listVersions({ serviceId });
-  if (versionsResult.isOk()) {
-    console.log(`\nVersions (${versionsResult.value.length}):`);
-    for (const v of versionsResult.value) {
-      console.log(`  ${v.id} — ${v.status} (${v.createdAt})`);
+  const { appId, deploymentId, deploymentEndpointDomain } = deployResult.value;
+  console.log(`\nApp:        ${appId}`);
+  console.log(`Deployment: ${deploymentId}`);
+  console.log(`URL:        ${deploymentEndpointDomain}`);
+
+  // List deployments
+  const deploymentsResult = await compute.listDeployments({ appId });
+  if (deploymentsResult.isOk()) {
+    console.log(`\nDeployments (${deploymentsResult.value.length}):`);
+    for (const d of deploymentsResult.value) {
+      console.log(`  ${d.id} — ${d.status} (${d.createdAt})`);
     }
   }
 }
@@ -669,7 +748,7 @@ main();
 ## Requirements
 
 - Node.js >= 18.0.0
-- `@prisma/management-api-sdk` >= 1.20.1
+- `@prisma/management-api-sdk` ^1.44.0
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/compute-sdk",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "TypeScript SDK for deploying and managing applications on Prisma Compute",
   "license": "Apache-2.0",
   "repository": "prisma/project-compute",