@prisma/compute-sdk 0.28.0 → 0.30.0

package/dist/compute-client.js

@@ -2,8 +2,8 @@ import { Result } from "better-result";
 import invariant from "tiny-invariant";
 import { InternalApiClient, readUploadUrl, toDeploymentUrl, } from "./api-client.js";
 import { createArchive } from "./archive.js";
-import { ApiError, ArtifactError, BuildError, CancelledError, DestroyAggregateError, InvalidOptionsError, MissingArgumentError, NoExistingVersionError, NoVersionsFoundError, } from "./errors.js";
-import { pollVersionStatus } from "./polling.js";
+import { ApiError, ArtifactError, BuildError, CancelledError, DestroyAggregateError, InvalidOptionsError, MissingArgumentError, NoDeploymentsFoundError, NoExistingDeploymentError, } from "./errors.js";
+import { pollDeploymentStatus } from "./polling.js";
 import { REGIONS } from "./types.js";
 import { uploadArtifact } from "./upload-artifact.js";
 const DEFAULT_TIMEOUT_SECONDS = 120;
@@ -14,9 +14,9 @@ export class ComputeClient {
         this.#api = new InternalApiClient(managementApiClient);
     }
     async deploy(options) {
-        if (options.skipPromote && options.destroyOldVersion) {
+        if (options.skipPromote && options.destroyOldDeployment) {
             return Result.err(new InvalidOptionsError({
-                message: "destroyOldVersion cannot be combined with skipPromote — the old version stays active when promotion is skipped",
+                message: "destroyOldDeployment cannot be combined with skipPromote — the old deployment stays active when promotion is skipped",
             }));
         }
         const self = this;
@@ -46,16 +46,16 @@ export class ComputeClient {
                 options.progress?.onArchiveReady?.(archiveBytes.byteLength);
                 yield* self.#checkAborted(options.signal);
                 const portMapping = options.portMapping ??
-                    (target.isNewService && artifact.defaultPortMapping
+                    (target.isNewApp && artifact.defaultPortMapping
                         ? artifact.defaultPortMapping
                         : undefined);
                 yield* Result.await(self.#applyEnvVars(target.projectId, target.branchId, options.envVars, options.signal));
-                const createResponse = yield* Result.await(self.#api.createServiceVersion(target.serviceId, portMapping ? { portMapping } : {}, options.signal));
-                options.progress?.onVersionCreated?.(createResponse.id);
+                const createResponse = yield* Result.await(self.#api.createAppDeployment(target.appId, portMapping ? { portMapping } : {}, options.signal));
+                options.progress?.onDeploymentCreated?.(createResponse.id);
                 const uploadUrl = readUploadUrl(createResponse);
                 if (!uploadUrl) {
                     return Result.err(new ArtifactError({
-                        message: "Version creation did not return an upload URL",
+                        message: "Deployment creation did not return an upload URL",
                     }));
                 }
                 yield* self.#checkAborted(options.signal);
@@ -63,55 +63,55 @@ export class ComputeClient {
                 yield* Result.await(self.#uploadArtifactResult(uploadUrl, archiveBytes, options.signal));
                 options.progress?.onUploadComplete?.();
                 yield* self.#checkAborted(options.signal);
-                const service = yield* Result.await(self.#api.getService(target.serviceId, options.signal));
-                const previousVersionId = service.latestVersionId ?? null;
+                const app = yield* Result.await(self.#api.getApp(target.appId, options.signal));
+                const previousDeploymentId = app.latestDeploymentId ?? null;
                 options.progress?.onStartRequested?.();
-                yield* Result.await(self.#api.startVersion(createResponse.id, options.signal));
-                const pollResult = yield* Result.await(pollVersionStatus(self.#api, createResponse.id, {
+                yield* Result.await(self.#api.startDeployment(createResponse.id, options.signal));
+                const pollResult = yield* Result.await(pollDeploymentStatus(self.#api, createResponse.id, {
                     targetStatus: "running",
                     timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
                     pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
                     signal: options.signal,
                     onStatusChange: options.progress?.onStatusChange,
                 }));
-                const versionEndpointDomain = toDeploymentUrl(pollResult.previewDomain);
-                options.progress?.onRunning?.(versionEndpointDomain);
+                const deploymentEndpointDomain = toDeploymentUrl(pollResult.previewDomain);
+                options.progress?.onRunning?.(deploymentEndpointDomain);
                 const resolvedConfig = {
                     projectId: target.projectId,
-                    serviceId: target.serviceId,
-                    serviceName: target.serviceName,
+                    appId: target.appId,
+                    appName: target.appName,
                     region: target.region,
-                    portMapping: options.portMapping,
+                    portMapping,
                 };
                 if (options.skipPromote) {
                     return Result.ok({
                         projectId: target.projectId,
-                        serviceId: target.serviceId,
-                        serviceName: target.serviceName,
+                        appId: target.appId,
+                        appName: target.appName,
                         region: target.region,
-                        versionId: createResponse.id,
-                        versionEndpointDomain,
-                        serviceEndpointDomain: null,
+                        deploymentId: createResponse.id,
+                        deploymentEndpointDomain,
+                        appEndpointDomain: null,
                         promoted: false,
-                        previousVersionId,
-                        previousVersionAction: previousVersionId
+                        previousDeploymentId,
+                        previousDeploymentAction: previousDeploymentId
                             ? "still-active"
                             : null,
                         resolvedConfig,
                     });
                 }
-                const switchoverResult = yield* Result.await(self.#promoteAndSwitchover(target.serviceId, createResponse.id, previousVersionId, options.destroyOldVersion ?? false, options.signal, options.progress));
+                const switchoverResult = yield* Result.await(self.#promoteAndSwitchover(target.appId, createResponse.id, previousDeploymentId, options.destroyOldDeployment ?? false, options.signal, options.progress));
                 return Result.ok({
                     projectId: target.projectId,
-                    serviceId: target.serviceId,
-                    serviceName: target.serviceName,
+                    appId: target.appId,
+                    appName: target.appName,
                     region: target.region,
-                    versionId: createResponse.id,
-                    versionEndpointDomain,
-                    serviceEndpointDomain: switchoverResult.serviceEndpointDomain,
+                    deploymentId: createResponse.id,
+                    deploymentEndpointDomain,
+                    appEndpointDomain: switchoverResult.appEndpointDomain,
                     promoted: true,
-                    previousVersionId: switchoverResult.previousVersionId,
-                    previousVersionAction: switchoverResult.previousVersionAction,
+                    previousDeploymentId: switchoverResult.previousDeploymentId,
+                    previousDeploymentAction: switchoverResult.previousDeploymentAction,
                     resolvedConfig,
                 });
             }
@@ -125,24 +125,24 @@ export class ComputeClient {
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
             const target = yield* Result.await(self.#resolveDeployTarget(options));
-            const versions = yield* Result.await(self.#api.listServiceVersions(target.serviceId, options.signal));
-            if (versions.length === 0) {
-                return Result.err(new NoExistingVersionError({ serviceId: target.serviceId }));
+            const deployments = yield* Result.await(self.#api.listAppDeployments(target.appId, options.signal));
+            if (deployments.length === 0) {
+                return Result.err(new NoExistingDeploymentError({ appId: target.appId }));
             }
             yield* self.#checkAborted(options.signal);
             yield* Result.await(self.#applyEnvVars(target.projectId, target.branchId, options.envVars, options.signal));
             yield* self.#checkAborted(options.signal);
-            const createResponse = yield* Result.await(self.#api.createServiceVersion(target.serviceId, {
+            const createResponse = yield* Result.await(self.#api.createAppDeployment(target.appId, {
                 ...(options.portMapping !== undefined
                     ? { portMapping: options.portMapping }
                     : {}),
                 skipCodeUpload: true,
             }, options.signal));
-            options.progress?.onVersionCreated?.(createResponse.id);
+            options.progress?.onDeploymentCreated?.(createResponse.id);
             yield* self.#checkAborted(options.signal);
             options.progress?.onStartRequested?.();
-            yield* Result.await(self.#api.startVersion(createResponse.id, options.signal));
-            const pollResult = yield* Result.await(pollVersionStatus(self.#api, createResponse.id, {
+            yield* Result.await(self.#api.startDeployment(createResponse.id, options.signal));
+            const pollResult = yield* Result.await(pollDeploymentStatus(self.#api, createResponse.id, {
                 targetStatus: "running",
                 timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
                 pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -153,119 +153,120 @@ export class ComputeClient {
             options.progress?.onRunning?.(deploymentUrl);
             return Result.ok({
                 projectId: target.projectId,
-                serviceId: target.serviceId,
-                versionId: createResponse.id,
+                appId: target.appId,
+                deploymentId: createResponse.id,
                 deploymentUrl,
                 resolvedConfig: {
                     projectId: target.projectId,
-                    serviceId: target.serviceId,
-                    serviceName: target.serviceName,
+                    appId: target.appId,
+                    appName: target.appName,
                     region: target.region,
                     portMapping: options.portMapping,
                 },
             });
         });
     }
-    async destroyVersion(options) {
+    async destroyDeployment(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            let versionId = options.versionId;
-            let versionDetailsCache;
-            if (!versionId) {
-                const serviceId = options.serviceId;
-                if (!serviceId) {
-                    return Result.err(new MissingArgumentError({ field: "versionId" }));
+            let deploymentId = options.deploymentId;
+            let deploymentDetailsCache;
+            if (!deploymentId) {
+                const appId = options.appId;
+                if (!appId) {
+                    return Result.err(new MissingArgumentError({ field: "deploymentId" }));
                 }
-                const versions = yield* Result.await(self.#api.listServiceVersions(serviceId, options.signal));
-                const versionDetailResults = await Promise.all(versions.map((v) => self.#api.getVersion(v.id, options.signal)));
+                const deployments = yield* Result.await(self.#api.listAppDeployments(appId, options.signal));
+                const deploymentDetailResults = await Promise.all(deployments.map((d) => self.#api.getDeployment(d.id, options.signal)));
                 const details = [];
-                for (const result of versionDetailResults) {
+                for (const result of deploymentDetailResults) {
                     if (result.isErr())
                         return result;
                     details.push(result.value);
                 }
-                versionDetailsCache = new Map(details.map((v) => [v.id, v]));
-                const versionInfos = details
-                    .map((v) => ({
-                    id: v.id,
-                    status: v.status,
-                    createdAt: v.createdAt,
-                    previewDomain: v.previewDomain,
+                deploymentDetailsCache = new Map(details.map((d) => [d.id, d]));
+                const deploymentInfos = details
+                    .map((d) => ({
+                    id: d.id,
+                    status: d.status,
+                    createdAt: d.createdAt,
+                    previewDomain: d.previewDomain,
                 }))
-                    .sort(versionSortComparator);
-                if (versionInfos.length === 0) {
-                    return Result.err(new NoVersionsFoundError({ serviceId }));
+                    .sort(deploymentSortComparator);
+                if (deploymentInfos.length === 0) {
+                    return Result.err(new NoDeploymentsFoundError({ appId }));
                 }
-                if (!options.interaction?.selectVersion) {
-                    return Result.err(new MissingArgumentError({ field: "versionId" }));
+                if (!options.interaction?.selectDeployment) {
+                    return Result.err(new MissingArgumentError({ field: "deploymentId" }));
                 }
-                versionId = await options.interaction.selectVersion(versionInfos);
+                deploymentId =
+                    await options.interaction.selectDeployment(deploymentInfos);
             }
-            const version = versionDetailsCache?.get(versionId) ??
-                (yield* Result.await(self.#api.getVersion(versionId, options.signal)));
-            const previousStatus = version.status ?? "unknown";
-            const shouldStop = version.status === "running" || version.status === "provisioning";
+            const deployment = deploymentDetailsCache?.get(deploymentId) ??
+                (yield* Result.await(self.#api.getDeployment(deploymentId, options.signal)));
+            const previousStatus = deployment.status ?? "unknown";
+            const shouldStop = deployment.status === "running" || deployment.status === "provisioning";
             let stopped = false;
             if (shouldStop) {
-                options.progress?.onStopRequested?.(versionId);
-                yield* Result.await(self.#api.stopVersion(versionId, options.signal));
-                yield* Result.await(pollVersionStatus(self.#api, versionId, {
+                options.progress?.onStopRequested?.(deploymentId);
+                yield* Result.await(self.#api.stopDeployment(deploymentId, options.signal));
+                yield* Result.await(pollDeploymentStatus(self.#api, deploymentId, {
                     targetStatus: "stopped",
                     timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
                     pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
                     signal: options.signal,
                 }));
                 stopped = true;
-                options.progress?.onStopped?.(versionId);
+                options.progress?.onStopped?.(deploymentId);
             }
-            yield* Result.await(self.#api.deleteVersion(versionId, options.signal));
-            options.progress?.onDeleted?.(versionId);
+            yield* Result.await(self.#api.deleteDeployment(deploymentId, options.signal));
+            options.progress?.onDeleted?.(deploymentId);
             return Result.ok({
-                versionId,
+                deploymentId,
                 previousStatus,
                 stopped,
                 deleted: true,
             });
         });
     }
-    async destroyService(options) {
+    async destroyApp(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
             const timeoutSeconds = options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
             const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-            const versions = yield* Result.await(self.#api.listServiceVersions(options.serviceId, options.signal));
-            const versionDetailResults = await Promise.all(versions.map((v) => self.#api.getVersion(v.id, options.signal)));
-            const versionDetails = [];
-            for (const result of versionDetailResults) {
+            const deployments = yield* Result.await(self.#api.listAppDeployments(options.appId, options.signal));
+            const deploymentDetailResults = await Promise.all(deployments.map((d) => self.#api.getDeployment(d.id, options.signal)));
+            const deploymentDetails = [];
+            for (const result of deploymentDetailResults) {
                 if (result.isErr())
                     return result;
-                versionDetails.push(result.value);
+                deploymentDetails.push(result.value);
             }
-            const activeVersions = versionDetails.filter((v) => v.status === "running" || v.status === "provisioning");
+            const activeDeployments = deploymentDetails.filter((d) => d.status === "running" || d.status === "provisioning");
             const succeededIds = [];
             const failures = [];
-            if (activeVersions.length > 0) {
-                const activeIds = activeVersions.map((v) => v.id);
-                options.progress?.onStoppingVersions?.(activeIds);
-                const stopResults = await Promise.all(activeVersions.map((v) => self.#api.stopVersion(v.id, options.signal)));
+            if (activeDeployments.length > 0) {
+                const activeIds = activeDeployments.map((d) => d.id);
+                options.progress?.onStoppingDeployments?.(activeIds);
+                const stopResults = await Promise.all(activeDeployments.map((d) => self.#api.stopDeployment(d.id, options.signal)));
                 const stoppedCandidates = [];
                 for (const [i, result] of stopResults.entries()) {
                     // biome-ignore lint/style/noNonNullAssertion: both lists have the same length
-                    const activeVersion = activeVersions[i];
+                    const activeDeployment = activeDeployments[i];
                     if (result.isErr()) {
                         failures.push({
-                            versionId: activeVersion.id,
+                            deploymentId: activeDeployment.id,
                             error: result.error,
                         });
                     }
                     else {
-                        stoppedCandidates.push(activeVersion);
+                        stoppedCandidates.push(activeDeployment);
                     }
                 }
                 if (stoppedCandidates.length > 0) {
-                    const pollResults = await Promise.all(stoppedCandidates.map((v) => pollVersionStatus(self.#api, v.id, {
+                    const pollResults = await Promise.all(stoppedCandidates.map((d) => pollDeploymentStatus(self.#api, d.id, {
                         targetStatus: "stopped",
                         timeoutSeconds,
                         pollIntervalMs,
@@ -273,64 +274,64 @@ export class ComputeClient {
                     })));
                     for (const [i, result] of pollResults.entries()) {
                         // biome-ignore lint/style/noNonNullAssertion: both lists have the same length
-                        const stoppedVersion = stoppedCandidates[i];
+                        const stoppedDeployment = stoppedCandidates[i];
                         if (result.isErr()) {
                             failures.push({
-                                versionId: stoppedVersion.id,
+                                deploymentId: stoppedDeployment.id,
                                 error: result.error,
                             });
                         }
                         else {
-                            options.progress?.onVersionStopped?.(stoppedVersion.id);
+                            options.progress?.onDeploymentStopped?.(stoppedDeployment.id);
                         }
                     }
                 }
                 if (failures.length > 0) {
                     return Result.err(new DestroyAggregateError({
-                        succeededVersionIds: succeededIds,
+                        succeededDeploymentIds: succeededIds,
                         failures,
-                        serviceDeleted: false,
+                        appDeleted: false,
                     }));
                 }
-                options.progress?.onAllVersionsStopped?.();
+                options.progress?.onAllDeploymentsStopped?.();
             }
-            if (versions.length > 0) {
-                const versionIds = versions.map((v) => v.id);
-                options.progress?.onDeletingVersions?.(versionIds);
-                const deleteResults = await Promise.all(versions.map((v) => self.#api.deleteVersion(v.id, options.signal)));
+            if (deployments.length > 0) {
+                const deploymentIds = deployments.map((d) => d.id);
+                options.progress?.onDeletingDeployments?.(deploymentIds);
+                const deleteResults = await Promise.all(deployments.map((d) => self.#api.deleteDeployment(d.id, options.signal)));
                 for (const [i, result] of deleteResults.entries()) {
                     // biome-ignore lint/style/noNonNullAssertion: both lists have the same length
-                    const version = versions[i];
+                    const deployment = deployments[i];
                     if (result.isErr()) {
                         failures.push({
-                            versionId: version.id,
+                            deploymentId: deployment.id,
                             error: result.error,
                         });
                     }
                     else {
-                        succeededIds.push(version.id);
-                        options.progress?.onVersionDeleted?.(version.id);
+                        succeededIds.push(deployment.id);
+                        options.progress?.onDeploymentDeleted?.(deployment.id);
                     }
                 }
                 if (failures.length > 0) {
                     return Result.err(new DestroyAggregateError({
-                        succeededVersionIds: succeededIds,
+                        succeededDeploymentIds: succeededIds,
                         failures,
-                        serviceDeleted: false,
+                        appDeleted: false,
                     }));
                 }
-                options.progress?.onAllVersionsDeleted?.();
+                options.progress?.onAllDeploymentsDeleted?.();
             }
-            let serviceDeleted = false;
-            if (!options.keepService) {
-                yield* Result.await(self.#api.deleteService(options.serviceId, options.signal));
-                serviceDeleted = true;
-                options.progress?.onServiceDeleted?.(options.serviceId);
+            let appDeleted = false;
+            if (!options.keepApp) {
+                yield* Result.await(self.#api.deleteApp(options.appId, options.signal));
+                appDeleted = true;
+                options.progress?.onAppDeleted?.(options.appId);
             }
             return Result.ok({
-                serviceId: options.serviceId,
-                deletedVersionIds: succeededIds,
-                serviceDeleted,
+                appId: options.appId,
+                deletedDeploymentIds: succeededIds,
+                appDeleted,
             });
         });
     }
@@ -373,25 +374,25 @@ export class ComputeClient {
             })));
         });
     }
-    async listServices(options) {
+    async listApps(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            const services = yield* Result.await(self.#api.listProjectServices(options.projectId, options.signal));
-            return Result.ok(services.map((s) => ({
-                id: s.id,
-                name: s.name,
-                region: s.region.id,
-                projectId: s.projectId,
+            const apps = yield* Result.await(self.#api.listProjectApps(options.projectId, options.signal));
+            return Result.ok(apps.map((a) => ({
+                id: a.id,
+                name: a.name,
+                region: a.region.id,
+                projectId: a.projectId,
             })));
         });
     }
-    async createService(options) {
+    async createApp(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            const response = yield* Result.await(self.#api.createProjectService(options.projectId, {
-                displayName: options.serviceName,
+            const response = yield* Result.await(self.#api.createProjectApp(options.projectId, {
+                displayName: options.appName,
                 regionId: options.region,
             }, options.signal));
             return Result.ok({
@@ -402,89 +403,89 @@ export class ComputeClient {
             });
         });
     }
-    async showService(options) {
+    async showApp(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            const s = yield* Result.await(self.#api.getService(options.serviceId, options.signal));
+            const a = yield* Result.await(self.#api.getApp(options.appId, options.signal));
             return Result.ok({
-                id: s.id,
-                name: s.name,
-                region: s.region.id,
-                projectId: s.projectId,
-                latestVersionId: s.latestVersionId,
-                serviceEndpointDomain: s.serviceEndpointDomain,
+                id: a.id,
+                name: a.name,
+                region: a.region.id,
+                projectId: a.projectId,
+                latestDeploymentId: a.latestDeploymentId,
+                appEndpointDomain: a.appEndpointDomain,
             });
         });
     }
-    async deleteService(options) {
+    async deleteApp(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            yield* Result.await(self.#api.deleteService(options.serviceId, options.signal));
+            yield* Result.await(self.#api.deleteApp(options.appId, options.signal));
             return Result.ok();
         });
     }
-    async listVersions(options) {
+    async listDeployments(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            const versions = yield* Result.await(self.#api.listServiceVersions(options.serviceId, options.signal));
-            const detailResults = await Promise.all(versions.map((v) => self.#api.getVersion(v.id, options.signal)));
+            const deployments = yield* Result.await(self.#api.listAppDeployments(options.appId, options.signal));
+            const detailResults = await Promise.all(deployments.map((d) => self.#api.getDeployment(d.id, options.signal)));
             const details = [];
             for (const result of detailResults) {
                 if (result.isErr()) {
-                    // listServiceVersions returns versions that have previously been deleted
-                    // and can't be fetched using getVersion so we need to filter those out.
+                    // listAppDeployments returns deployments that have previously been deleted
+                    // and can't be fetched using getDeployment so we need to filter those out.
                     if (ApiError.is(result.error) && result.error.statusCode === 404)
                         continue;
                     return result;
                 }
                 details.push(result.value);
             }
-            return Result.ok(details.map((v) => ({
-                id: v.id,
-                status: v.status,
-                createdAt: v.createdAt,
-                previewDomain: v.previewDomain,
+            return Result.ok(details.map((d) => ({
+                id: d.id,
+                status: d.status,
+                createdAt: d.createdAt,
+                previewDomain: d.previewDomain,
             })));
         });
     }
-    async showVersion(options) {
+    async showDeployment(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            const v = yield* Result.await(self.#api.getVersion(options.versionId, options.signal));
+            const d = yield* Result.await(self.#api.getDeployment(options.deploymentId, options.signal));
             return Result.ok({
-                id: v.id,
-                status: v.status,
-                createdAt: v.createdAt,
-                previewDomain: v.previewDomain,
-                envVars: v.envVars ?? undefined,
+                id: d.id,
+                status: d.status,
+                createdAt: d.createdAt,
+                previewDomain: d.previewDomain,
+                envVars: d.envVars ?? undefined,
             });
         });
     }
-    async startVersion(options) {
+    async startDeployment(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            yield* Result.await(self.#api.startVersion(options.versionId, options.signal));
+            yield* Result.await(self.#api.startDeployment(options.deploymentId, options.signal));
             return Result.ok();
         });
     }
-    async stopVersion(options) {
+    async stopDeployment(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            yield* Result.await(self.#api.stopVersion(options.versionId, options.signal));
+            yield* Result.await(self.#api.stopDeployment(options.deploymentId, options.signal));
             return Result.ok();
         });
     }
-    async deleteVersion(options) {
+    async deleteDeployment(options) {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            yield* Result.await(self.#api.deleteVersion(options.versionId, options.signal));
+            yield* Result.await(self.#api.deleteDeployment(options.deploymentId, options.signal));
             return Result.ok();
         });
     }
@@ -492,10 +493,10 @@ export class ComputeClient {
         const self = this;
         return Result.gen(async function* () {
             yield* self.#checkAborted(options.signal);
-            let versionId = options.versionId;
-            if (!versionId) {
-                const versions = yield* Result.await(self.#api.listServiceVersions(options.serviceId, options.signal));
-                const detailResults = await Promise.all(versions.map((v) => self.#api.getVersion(v.id, options.signal)));
+            let deploymentId = options.deploymentId;
+            if (!deploymentId) {
+                const deployments = yield* Result.await(self.#api.listAppDeployments(options.appId, options.signal));
+                const detailResults = await Promise.all(deployments.map((d) => self.#api.getDeployment(d.id, options.signal)));
                 const details = [];
                 for (const result of detailResults) {
                     if (result.isErr()) {
@@ -505,35 +506,36 @@ export class ComputeClient {
                     }
                     details.push(result.value);
                 }
-                const versionInfos = details
-                    .map((v) => ({
-                    id: v.id,
-                    status: v.status,
-                    createdAt: v.createdAt,
-                    previewDomain: v.previewDomain,
+                const deploymentInfos = details
+                    .map((d) => ({
+                    id: d.id,
+                    status: d.status,
+                    createdAt: d.createdAt,
+                    previewDomain: d.previewDomain,
                 }))
-                    .sort(versionSortComparator);
-                if (versionInfos.length === 0) {
-                    return Result.err(new NoVersionsFoundError({ serviceId: options.serviceId }));
+                    .sort(deploymentSortComparator);
+                if (deploymentInfos.length === 0) {
+                    return Result.err(new NoDeploymentsFoundError({ appId: options.appId }));
                 }
-                if (!options.interaction?.selectVersion) {
-                    return Result.err(new MissingArgumentError({ field: "versionId" }));
+                if (!options.interaction?.selectDeployment) {
+                    return Result.err(new MissingArgumentError({ field: "deploymentId" }));
                 }
-                versionId = await options.interaction.selectVersion(versionInfos);
+                deploymentId =
+                    await options.interaction.selectDeployment(deploymentInfos);
             }
-            const version = yield* Result.await(self.#api.getVersion(versionId, options.signal));
-            let versionStarted = false;
-            if (version.status !== "running") {
-                options.progress?.onVersionStarting?.(versionId);
-                if (version.status !== "provisioning") {
-                    options.progress?.onVersionStartRequested?.();
-                    const startResult = await self.#api.startVersion(versionId, options.signal);
+            const deployment = yield* Result.await(self.#api.getDeployment(deploymentId, options.signal));
+            let deploymentStarted = false;
+            if (deployment.status !== "running") {
+                options.progress?.onDeploymentStarting?.(deploymentId);
+                if (deployment.status !== "provisioning") {
+                    options.progress?.onDeploymentStartRequested?.();
+                    const startResult = await self.#api.startDeployment(deploymentId, options.signal);
                     if (startResult.isErr()) {
                         options.progress?.onPromoteFailed?.(startResult.error);
                         return startResult;
                     }
                 }
-                const pollResult = await pollVersionStatus(self.#api, versionId, {
+                const pollResult = await pollDeploymentStatus(self.#api, deploymentId, {
                     targetStatus: "running",
                     timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
                     pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
@@ -544,97 +546,97 @@ export class ComputeClient {
                     options.progress?.onPromoteFailed?.(pollResult.error);
                     return pollResult;
                 }
-                versionStarted = true;
-                options.progress?.onVersionRunning?.();
+                deploymentStarted = true;
+                options.progress?.onDeploymentRunning?.();
             }
             options.progress?.onPromoteStart?.();
-            const promoteResult = await self.#api.promoteService(options.serviceId, { versionId }, options.signal);
+            const promoteResult = await self.#api.promoteApp(options.appId, { deploymentId }, options.signal);
             if (promoteResult.isErr()) {
                 options.progress?.onPromoteFailed?.(promoteResult.error);
                 return promoteResult;
             }
-            options.progress?.onPromoted?.(promoteResult.value.serviceEndpointDomain);
+            options.progress?.onPromoted?.(promoteResult.value.appEndpointDomain);
             return Result.ok({
-                serviceId: options.serviceId,
-                versionId,
-                serviceEndpointDomain: promoteResult.value.serviceEndpointDomain,
-                versionStarted,
+                appId: options.appId,
+                deploymentId,
+                appEndpointDomain: promoteResult.value.appEndpointDomain,
+                deploymentStarted,
             });
         });
     }
-    async #promoteAndSwitchover(serviceId, newVersionId, previousVersionId, destroyOldVersion, signal, progress) {
+    async #promoteAndSwitchover(appId, newDeploymentId, previousDeploymentId, destroyOldDeployment, signal, progress) {
         progress?.onPromoteStart?.();
-        const promoteResult = await this.#api.promoteService(serviceId, { versionId: newVersionId }, signal);
+        const promoteResult = await this.#api.promoteApp(appId, { deploymentId: newDeploymentId }, signal);
         if (promoteResult.isErr()) {
             progress?.onPromoteFailed?.(promoteResult.error);
-            progress?.onCleanupDanglingVersion?.(newVersionId);
-            await this.#cleanupDanglingVersion(newVersionId, undefined, progress);
+            progress?.onCleanupDanglingDeployment?.(newDeploymentId);
+            await this.#cleanupDanglingDeployment(newDeploymentId, undefined, progress);
             return promoteResult;
         }
-        const serviceEndpointDomain = promoteResult.value.serviceEndpointDomain;
-        progress?.onPromoted?.(serviceEndpointDomain);
-        let previousVersionAction = null;
-        if (previousVersionId && previousVersionId !== newVersionId) {
-            progress?.onOldVersionStopping?.(previousVersionId);
-            const stopResult = await this.#api.stopVersion(previousVersionId, signal);
+        const appEndpointDomain = promoteResult.value.appEndpointDomain;
+        progress?.onPromoted?.(appEndpointDomain);
+        let previousDeploymentAction = null;
+        if (previousDeploymentId && previousDeploymentId !== newDeploymentId) {
+            progress?.onOldDeploymentStopping?.(previousDeploymentId);
+            const stopResult = await this.#api.stopDeployment(previousDeploymentId, signal);
             if (stopResult.isOk()) {
-                const pollResult = await pollVersionStatus(this.#api, previousVersionId, {
+                const pollResult = await pollDeploymentStatus(this.#api, previousDeploymentId, {
                     targetStatus: "stopped",
                     timeoutSeconds: 30,
                     pollIntervalMs: 1000,
                     signal,
                 });
                 if (pollResult.isOk()) {
-                    previousVersionAction = "stopped";
-                    progress?.onOldVersionStopped?.(previousVersionId);
-                    if (destroyOldVersion) {
-                        progress?.onOldVersionDeleting?.(previousVersionId);
-                        const deleteResult = await this.#api.deleteVersion(previousVersionId, signal);
+                    previousDeploymentAction = "stopped";
+                    progress?.onOldDeploymentStopped?.(previousDeploymentId);
+                    if (destroyOldDeployment) {
+                        progress?.onOldDeploymentDeleting?.(previousDeploymentId);
+                        const deleteResult = await this.#api.deleteDeployment(previousDeploymentId, signal);
                         if (deleteResult.isOk()) {
-                            previousVersionAction = "destroyed";
-                            progress?.onOldVersionDeleted?.(previousVersionId);
+                            previousDeploymentAction = "destroyed";
+                            progress?.onOldDeploymentDeleted?.(previousDeploymentId);
                         }
                         else {
-                            progress?.onOldVersionDeleteFailed?.(previousVersionId);
+                            progress?.onOldDeploymentDeleteFailed?.(previousDeploymentId);
                         }
                     }
                 }
                 else {
-                    progress?.onOldVersionStopFailed?.(previousVersionId);
+                    progress?.onOldDeploymentStopFailed?.(previousDeploymentId);
                 }
             }
             else {
-                progress?.onOldVersionStopFailed?.(previousVersionId);
+                progress?.onOldDeploymentStopFailed?.(previousDeploymentId);
             }
         }
         return Result.ok({
-            serviceEndpointDomain,
-            previousVersionId,
-            previousVersionAction,
+            appEndpointDomain,
+            previousDeploymentId,
+            previousDeploymentAction,
         });
     }
-    async #cleanupDanglingVersion(versionId, signal, progress) {
-        const stopResult = await this.#api.stopVersion(versionId, signal);
+    async #cleanupDanglingDeployment(deploymentId, signal, progress) {
+        const stopResult = await this.#api.stopDeployment(deploymentId, signal);
         if (stopResult.isErr()) {
-            progress?.onCleanupDanglingVersionFailed?.(versionId);
+            progress?.onCleanupDanglingDeploymentFailed?.(deploymentId);
             return;
         }
-        const pollResult = await pollVersionStatus(this.#api, versionId, {
+        const pollResult = await pollDeploymentStatus(this.#api, deploymentId, {
             targetStatus: "stopped",
             timeoutSeconds: 30,
             pollIntervalMs: 1000,
             signal,
         });
         if (pollResult.isErr()) {
-            progress?.onCleanupDanglingVersionFailed?.(versionId);
+            progress?.onCleanupDanglingDeploymentFailed?.(deploymentId);
             return;
         }
-        const deleteResult = await this.#api.deleteVersion(versionId, signal);
+        const deleteResult = await this.#api.deleteDeployment(deploymentId, signal);
         if (deleteResult.isErr()) {
-            progress?.onCleanupDanglingVersionFailed?.(versionId);
+            progress?.onCleanupDanglingDeploymentFailed?.(deploymentId);
             return;
         }
-        progress?.onCleanupDanglingVersionComplete?.(versionId);
+        progress?.onCleanupDanglingDeploymentComplete?.(deploymentId);
     }
     #checkAborted(signal) {
         try {
@@ -648,26 +650,26 @@ export class ComputeClient {
     async #resolveDeployTarget(options) {
         const self = this;
         return Result.gen(async function* () {
-            if (options.serviceId) {
-                const service = yield* Result.await(self.#api.getService(options.serviceId, options.signal));
-                if (!service.projectId) {
+            if (options.appId) {
+                const app = yield* Result.await(self.#api.getApp(options.appId, options.signal));
+                if (!app.projectId) {
                     return Result.err(new MissingArgumentError({ field: "projectId" }));
                 }
                 const requestedProjectId = options.projectId?.replace(/^proj_/, "");
-                const serviceProjectId = service.projectId.replace(/^proj_/, "");
+                const appProjectId = app.projectId.replace(/^proj_/, "");
                 if (requestedProjectId !== undefined &&
-                    requestedProjectId !== serviceProjectId) {
+                    requestedProjectId !== appProjectId) {
                     return Result.err(new InvalidOptionsError({
-                        message: `Service ${service.id} belongs to project ${service.projectId}, but project ${options.projectId} was provided`,
+                        message: `App ${app.id} belongs to project ${app.projectId}, but project ${options.projectId} was provided`,
                     }));
                 }
                 return Result.ok({
-                    projectId: service.projectId,
-                    serviceId: service.id,
-                    serviceName: service.name ?? service.id,
-                    region: service.region.id,
-                    branchId: service.branchId ?? null,
-                    isNewService: false,
+                    projectId: app.projectId,
+                    appId: app.id,
+                    appName: app.name ?? app.id,
+                    region: app.region.id,
+                    branchId: app.branchId ?? null,
+                    isNewApp: false,
                 });
             }
             let projectId = options.projectId;
@@ -683,50 +685,50 @@ export class ComputeClient {
                 }
                 projectId = await options.interaction.selectProject(projectInfos);
             }
-            if (options.serviceName && options.region) {
-                const response = yield* Result.await(self.#api.createProjectService(projectId, {
-                    displayName: options.serviceName,
+            if (options.appName && options.region) {
+                const response = yield* Result.await(self.#api.createProjectApp(projectId, {
+                    displayName: options.appName,
                     regionId: options.region,
                 }, options.signal));
                 return Result.ok({
                     projectId,
-                    serviceId: response.id,
-                    serviceName: response.name,
+                    appId: response.id,
+                    appName: response.name,
                     region: response.region.id,
                     branchId: response.branchId ?? null,
-                    isNewService: true,
+                    isNewApp: true,
                 });
             }
-            const services = yield* Result.await(self.#api.listProjectServices(projectId, options.signal));
-            const serviceInfos = services.map((s) => ({
-                id: s.id,
-                name: s.name,
-                region: s.region.id,
-                projectId: s.projectId,
+            const apps = yield* Result.await(self.#api.listProjectApps(projectId, options.signal));
+            const appInfos = apps.map((a) => ({
+                id: a.id,
+                name: a.name,
+                region: a.region.id,
+                projectId: a.projectId,
             }));
-            if (!options.interaction?.selectService) {
-                return Result.err(new MissingArgumentError({ field: "serviceId" }));
+            if (!options.interaction?.selectApp) {
+                return Result.err(new MissingArgumentError({ field: "appId" }));
             }
-            const selectedServiceId = await options.interaction.selectService(serviceInfos);
-            if (selectedServiceId !== null) {
-                const selected = services.find((s) => s.id === selectedServiceId);
-                invariant(selected, "selectService returned service ID not in the list");
-                const service = yield* Result.await(self.#api.getService(selectedServiceId, options.signal));
+            const selectedAppId = await options.interaction.selectApp(appInfos);
+            if (selectedAppId !== null) {
+                const selected = apps.find((a) => a.id === selectedAppId);
+                invariant(selected, "selectApp returned app ID not in the list");
+                const app = yield* Result.await(self.#api.getApp(selectedAppId, options.signal));
                 return Result.ok({
                     projectId,
-                    serviceId: selectedServiceId,
-                    serviceName: service.name ?? selected.name,
-                    region: service.region.id,
-                    branchId: service.branchId ?? null,
-                    isNewService: false,
+                    appId: selectedAppId,
+                    appName: app.name ?? selected.name,
+                    region: app.region.id,
+                    branchId: app.branchId ?? null,
+                    isNewApp: false,
                 });
             }
-            let serviceName = options.serviceName;
-            if (!serviceName) {
-                if (!options.interaction?.provideServiceName) {
-                    return Result.err(new MissingArgumentError({ field: "serviceName" }));
+            let appName = options.appName;
+            if (!appName) {
+                if (!options.interaction?.provideAppName) {
+                    return Result.err(new MissingArgumentError({ field: "appName" }));
                 }
-                serviceName = await options.interaction.provideServiceName();
+                appName = await options.interaction.provideAppName();
             }
             let region = options.region;
             if (!region) {
@@ -735,17 +737,17 @@ export class ComputeClient {
                 }
                 region = await options.interaction.selectRegion(REGIONS);
             }
-            const response = yield* Result.await(self.#api.createProjectService(projectId, {
-                displayName: serviceName,
+            const response = yield* Result.await(self.#api.createProjectApp(projectId, {
+                displayName: appName,
                 regionId: region,
             }, options.signal));
             return Result.ok({
                 projectId,
-                serviceId: response.id,
-                serviceName: response.name,
+                appId: response.id,
+                appName: response.name,
                 region: response.region.id,
                 branchId: response.branchId ?? null,
-                isNewService: true,
+                isNewApp: true,
             });
         });
     }
@@ -810,9 +812,9 @@ export class ComputeClient {
     }
 }
 /**
- * Sort versions: running/provisioning first, then by createdAt descending.
+ * Sort deployments: running/provisioning first, then by createdAt descending.
  */
-function versionSortComparator(a, b) {
+function deploymentSortComparator(a, b) {
     const statusPriority = (s) => s === "running" ? 0 : s === "provisioning" ? 1 : 2;
     const aPriority = statusPriority(a.status);
     const bPriority = statusPriority(b.status);