@prisma/compute-sdk 0.4.0 → 0.6.0

package/src/compute-client.ts

@@ -14,6 +14,7 @@ import type {
   DestroyServiceProgress,
   DestroyVersionInteraction,
   DestroyVersionProgress,
+  PromoteProgress,
   UpdateEnvProgress,
 } from "./callbacks.ts";
 import {
@@ -27,9 +28,11 @@ import {
   DestroyAggregateError,
   type DestroyServiceError,
   type DestroyVersionError,
+  InvalidOptionsError,
   MissingArgumentError,
   NoExistingVersionError,
   NoVersionsFoundError,
+  type PromoteError,
   type UpdateEnvError,
   type VersionOperationError,
 } from "./errors.ts";
@@ -56,19 +59,21 @@ export interface DeployOptions {
   serviceId?: string;
   serviceName?: string;
   region?: string;
-  envVars?: Record<string, string>;
+  envVars?: Record<string, string | null>;
   portMapping?: PortMapping;
   timeoutSeconds?: number;
   pollIntervalMs?: number;
   signal?: AbortSignal;
   interaction?: DeployInteraction;
   progress?: DeployProgress;
+  skipPromote?: boolean;
+  destroyOldVersion?: boolean;
 }
 
 export interface UpdateEnvOptions {
   projectId?: string;
   serviceId?: string;
-  envVars?: Record<string, string>;
+  envVars?: Record<string, string | null>;
   portMapping?: PortMapping;
   timeoutSeconds?: number;
   pollIntervalMs?: number;
@@ -155,16 +160,37 @@ export interface DeleteVersionOptions {
   signal?: AbortSignal;
 }
 
+export interface PromoteOptions {
+  serviceId: string;
+  versionId?: string;
+  timeoutSeconds?: number;
+  pollIntervalMs?: number;
+  signal?: AbortSignal;
+  interaction?: DestroyVersionInteraction;
+  progress?: PromoteProgress;
+}
+
 export interface DeployResult {
   projectId: string;
   serviceId: string;
   serviceName: string;
   region: string;
   versionId: string;
-  deploymentUrl: string;
+  versionEndpointDomain: string;
+  serviceEndpointDomain: string | null;
+  promoted: boolean;
+  previousVersionId: string | null;
+  previousVersionAction: "stopped" | "destroyed" | "still-active" | null;
   resolvedConfig: ResolvedConfig;
 }
 
+export interface PromoteResult {
+  serviceId: string;
+  versionId: string;
+  serviceEndpointDomain: string;
+  versionStarted: boolean;
+}
+
 export interface UpdateEnvResult {
   projectId: string;
   serviceId: string;
@@ -199,6 +225,15 @@ export class ComputeClient {
   async deploy(
     options: DeployOptions,
   ): Promise<Result<DeployResult, DeployError>> {
+    if (options.skipPromote && options.destroyOldVersion) {
+      return Result.err(
+        new InvalidOptionsError({
+          message:
+            "destroyOldVersion cannot be combined with skipPromote — the old version stays active when promotion is skipped",
+        }),
+      );
+    }
+
     const self = this;
     return Result.gen(async function* () {
       yield* self.#checkAborted(options.signal);
@@ -284,23 +319,63 @@ export class ComputeClient {
           }),
         );
 
-        const deploymentUrl = toDeploymentUrl(pollResult.previewDomain);
-        options.progress?.onRunning?.(deploymentUrl);
+        const versionEndpointDomain = toDeploymentUrl(pollResult.previewDomain);
+        options.progress?.onRunning?.(versionEndpointDomain);
 
-        return Result.ok({
+        const service = yield* Result.await(
+          self.#api.getService(target.serviceId, options.signal),
+        );
+        const previousVersionId = service.latestVersionId ?? null;
+
+        const resolvedConfig: ResolvedConfig = {
           projectId: target.projectId,
           serviceId: target.serviceId,
           serviceName: target.serviceName,
           region: target.region,
-          versionId: createResponse.id,
-          deploymentUrl,
-          resolvedConfig: {
+          portMapping: options.portMapping,
+        };
+
+        if (options.skipPromote) {
+          return Result.ok({
             projectId: target.projectId,
             serviceId: target.serviceId,
             serviceName: target.serviceName,
             region: target.region,
-            portMapping: options.portMapping,
-          },
+            versionId: createResponse.id,
+            versionEndpointDomain,
+            serviceEndpointDomain: null,
+            promoted: false,
+            previousVersionId,
+            previousVersionAction: previousVersionId
+              ? ("still-active" as const)
+              : null,
+            resolvedConfig,
+          });
+        }
+
+        const switchoverResult = yield* Result.await(
+          self.#promoteAndSwitchover(
+            target.serviceId,
+            createResponse.id,
+            previousVersionId,
+            options.destroyOldVersion ?? false,
+            options.signal,
+            options.progress,
+          ),
+        );
+
+        return Result.ok({
+          projectId: target.projectId,
+          serviceId: target.serviceId,
+          serviceName: target.serviceName,
+          region: target.region,
+          versionId: createResponse.id,
+          versionEndpointDomain,
+          serviceEndpointDomain: switchoverResult.serviceEndpointDomain,
+          promoted: true,
+          previousVersionId: switchoverResult.previousVersionId,
+          previousVersionAction: switchoverResult.previousVersionAction,
+          resolvedConfig,
         });
       } finally {
         await artifact.cleanup?.();
@@ -737,6 +812,7 @@ export class ComputeClient {
         region: s.region.id,
         projectId: s.projectId,
         latestVersionId: s.latestVersionId,
+        serviceEndpointDomain: s.serviceEndpointDomain,
       });
     });
   }
@@ -848,6 +924,227 @@ export class ComputeClient {
     });
   }
 
+  async promote(
+    options: PromoteOptions,
+  ): Promise<Result<PromoteResult, PromoteError>> {
+    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)),
+        );
+        const details: VersionDetailData[] = [];
+        for (const result of detailResults) {
+          if (result.isErr()) {
+            if (ApiError.is(result.error) && result.error.statusCode === 404)
+              continue;
+            return result;
+          }
+          details.push(result.value);
+        }
+
+        const versionInfos = details
+          .map(
+            (v): VersionInfo => ({
+              id: v.id,
+              status: v.status,
+              createdAt: v.createdAt,
+              previewDomain: v.previewDomain,
+            }),
+          )
+          .sort(versionSortComparator);
+
+        if (versionInfos.length === 0) {
+          return Result.err(
+            new NoVersionsFoundError({ serviceId: options.serviceId }),
+          );
+        }
+
+        if (!options.interaction?.selectVersion) {
+          return Result.err(new MissingArgumentError({ field: "versionId" }));
+        }
+
+        versionId = await options.interaction.selectVersion(versionInfos);
+      }
+
+      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,
+          );
+          if (startResult.isErr()) {
+            options.progress?.onPromoteFailed?.(startResult.error);
+            return startResult;
+          }
+        }
+
+        const pollResult = await pollVersionStatus(self.#api, versionId, {
+          targetStatus: "running",
+          timeoutSeconds: options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
+          pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+          signal: options.signal,
+          onStatusChange: options.progress?.onStatusChange,
+        });
+        if (pollResult.isErr()) {
+          options.progress?.onPromoteFailed?.(pollResult.error);
+          return pollResult;
+        }
+        versionStarted = true;
+        options.progress?.onVersionRunning?.();
+      }
+
+      options.progress?.onPromoteStart?.();
+      const promoteResult = await self.#api.promoteService(
+        options.serviceId,
+        { versionId },
+        options.signal,
+      );
+      if (promoteResult.isErr()) {
+        options.progress?.onPromoteFailed?.(promoteResult.error);
+        return promoteResult;
+      }
+      options.progress?.onPromoted?.(promoteResult.value.serviceEndpointDomain);
+
+      return Result.ok({
+        serviceId: options.serviceId,
+        versionId,
+        serviceEndpointDomain: promoteResult.value.serviceEndpointDomain,
+        versionStarted,
+      });
+    });
+  }
+
+  async #promoteAndSwitchover(
+    serviceId: string,
+    newVersionId: string,
+    previousVersionId: string | null,
+    destroyOldVersion: boolean,
+    signal?: AbortSignal,
+    progress?: DeployProgress,
+  ): Promise<
+    Result<
+      {
+        serviceEndpointDomain: string;
+        previousVersionId: string | null;
+        previousVersionAction: "stopped" | "destroyed" | null;
+      },
+      DeployError
+    >
+  > {
+    progress?.onPromoteStart?.();
+    const promoteResult = await this.#api.promoteService(
+      serviceId,
+      { versionId: newVersionId },
+      signal,
+    );
+
+    if (promoteResult.isErr()) {
+      progress?.onPromoteFailed?.(promoteResult.error);
+      progress?.onCleanupDanglingVersion?.(newVersionId);
+      await this.#cleanupDanglingVersion(newVersionId, undefined, progress);
+      return promoteResult;
+    }
+
+    const serviceEndpointDomain = promoteResult.value.serviceEndpointDomain;
+    progress?.onPromoted?.(serviceEndpointDomain);
+
+    let previousVersionAction: "stopped" | "destroyed" | null = null;
+
+    if (previousVersionId && previousVersionId !== newVersionId) {
+      progress?.onOldVersionStopping?.(previousVersionId);
+      const stopResult = await this.#api.stopVersion(previousVersionId, signal);
+
+      if (stopResult.isOk()) {
+        const pollResult = await pollVersionStatus(
+          this.#api,
+          previousVersionId,
+          {
+            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,
+            );
+            if (deleteResult.isOk()) {
+              previousVersionAction = "destroyed";
+              progress?.onOldVersionDeleted?.(previousVersionId);
+            } else {
+              progress?.onOldVersionDeleteFailed?.(previousVersionId);
+            }
+          }
+        } else {
+          progress?.onOldVersionStopFailed?.(previousVersionId);
+        }
+      } else {
+        progress?.onOldVersionStopFailed?.(previousVersionId);
+      }
+    }
+
+    return Result.ok({
+      serviceEndpointDomain,
+      previousVersionId,
+      previousVersionAction,
+    });
+  }
+
+  async #cleanupDanglingVersion(
+    versionId: string,
+    signal?: AbortSignal,
+    progress?: DeployProgress,
+  ): Promise<void> {
+    const stopResult = await this.#api.stopVersion(versionId, signal);
+    if (stopResult.isErr()) {
+      progress?.onCleanupDanglingVersionFailed?.(versionId);
+      return;
+    }
+
+    const pollResult = await pollVersionStatus(this.#api, versionId, {
+      targetStatus: "stopped",
+      timeoutSeconds: 30,
+      pollIntervalMs: 1000,
+      signal,
+    });
+    if (pollResult.isErr()) {
+      progress?.onCleanupDanglingVersionFailed?.(versionId);
+      return;
+    }
+
+    const deleteResult = await this.#api.deleteVersion(versionId, signal);
+    if (deleteResult.isErr()) {
+      progress?.onCleanupDanglingVersionFailed?.(versionId);
+      return;
+    }
+
+    progress?.onCleanupDanglingVersionComplete?.(versionId);
+  }
+
   #checkAborted(signal?: AbortSignal): Result<void, CancelledError> {
     if (signal?.aborted) {
       return Result.err(new CancelledError());

package/src/errors.ts

@@ -87,7 +87,7 @@ export class NoVersionsFoundError extends TaggedError("NoVersionsFoundError")<{
   constructor(args: { serviceId: string }) {
     super({
       serviceId: args.serviceId,
-      message: `Service ${args.serviceId} has no versions to destroy`,
+      message: `Service ${args.serviceId} has no versions`,
     });
   }
 }
@@ -121,10 +121,15 @@ export class DestroyAggregateError extends TaggedError(
   }
 }
 
+export class InvalidOptionsError extends TaggedError("InvalidOptionsError")<{
+  message: string;
+}>() {}
+
 export type DeployError =
   | AuthenticationError
   | ApiError
   | MissingArgumentError
+  | InvalidOptionsError
   | BuildError
   | ArtifactError
   | TimeoutError
@@ -155,6 +160,15 @@ export type DestroyServiceError =
   | ApiError
   | DestroyAggregateError;
 
+export type PromoteError =
+  | AuthenticationError
+  | ApiError
+  | MissingArgumentError
+  | NoVersionsFoundError
+  | TimeoutError
+  | VersionFailedError
+  | CancelledError;
+
 export type ApiRequestError = CancelledError | AuthenticationError | ApiError;
 
 export type VersionOperationError =

package/src/index.ts

@@ -18,6 +18,7 @@ export type {
   DestroyServiceProgress,
   DestroyVersionInteraction,
   DestroyVersionProgress,
+  PromoteProgress,
   UpdateEnvProgress,
 } from "./callbacks.ts";
 export type {
@@ -34,6 +35,8 @@ export type {
   ListProjectsOptions,
   ListServicesOptions,
   ListVersionsOptions,
+  PromoteOptions,
+  PromoteResult,
   ShowServiceOptions,
   ShowVersionOptions,
   StartVersionOptions,
@@ -48,6 +51,7 @@ export type {
   DeployError,
   DestroyServiceError,
   DestroyVersionError,
+  PromoteError,
   UpdateEnvError,
   VersionOperationError,
 } from "./errors.ts";
@@ -59,6 +63,7 @@ export {
   BuildError,
   CancelledError,
   DestroyAggregateError,
+  InvalidOptionsError,
   MissingArgumentError,
   NoExistingVersionError,
   NoVersionsFoundError,

package/src/types.ts

@@ -33,6 +33,7 @@ export interface ServiceInfo {
 
 export interface ServiceDetail extends ServiceInfo {
   latestVersionId?: string | null;
+  serviceEndpointDomain?: string;
 }
 
 export interface VersionInfo {