@prisma/compute-sdk 0.1.0

package/src/errors.ts

@@ -0,0 +1,148 @@
+import { TaggedError } from "better-result";
+
+export class AuthenticationError extends TaggedError("AuthenticationError")<{
+  statusCode: 401;
+  message: string;
+}>() {}
+
+export class ApiError extends TaggedError("ApiError")<{
+  statusCode: number;
+  statusText: string;
+  code?: string;
+  message: string;
+  hint?: string;
+  traceHeaders: Record<string, string>;
+}>() {}
+
+export class MissingArgumentError extends TaggedError("MissingArgumentError")<{
+  field: string;
+  message: string;
+}>() {
+  constructor(args: { field: string }) {
+    super({
+      field: args.field,
+      message: `Missing required argument: ${args.field}`,
+    });
+  }
+}
+
+export class BuildError extends TaggedError("BuildError")<{
+  message: string;
+  logs?: string[];
+}>() {}
+
+export class ArtifactError extends TaggedError("ArtifactError")<{
+  message: string;
+  cause?: unknown;
+}>() {}
+
+export class TimeoutError extends TaggedError("TimeoutError")<{
+  versionId: string;
+  elapsedMs: number;
+  lastStatus: string;
+  message: string;
+}>() {
+  constructor(args: {
+    versionId: string;
+    elapsedMs: number;
+    lastStatus: string;
+  }) {
+    super({
+      ...args,
+      message: `Timed out waiting for version ${args.versionId} to reach target state (last status: ${args.lastStatus}, elapsed: ${Math.round(args.elapsedMs / 1000)}s)`,
+    });
+  }
+}
+
+export class VersionFailedError extends TaggedError("VersionFailedError")<{
+  versionId: string;
+  message: string;
+}>() {
+  constructor(args: { versionId: string }) {
+    super({
+      versionId: args.versionId,
+      message: `Version ${args.versionId} transitioned to failed status`,
+    });
+  }
+}
+
+export class NoExistingVersionError extends TaggedError(
+  "NoExistingVersionError",
+)<{
+  serviceId: string;
+  message: string;
+}>() {
+  constructor(args: { serviceId: string }) {
+    super({
+      serviceId: args.serviceId,
+      message: `Service ${args.serviceId} has no existing versions. Environment-only updates require at least one prior deployment.`,
+    });
+  }
+}
+
+export class CancelledError extends TaggedError("CancelledError")<{
+  message: string;
+}>() {
+  constructor(args?: { message?: string }) {
+    super({ message: args?.message ?? "Operation cancelled" });
+  }
+}
+
+export class DestroyAggregateError extends TaggedError(
+  "DestroyAggregateError",
+)<{
+  message: string;
+  succeededVersionIds: string[];
+  failures: Array<{ versionId: string; error: ComputeError }>;
+  serviceDeleted: boolean;
+}>() {
+  constructor(args: {
+    succeededVersionIds: string[];
+    failures: Array<{ versionId: string; error: ComputeError }>;
+    serviceDeleted: boolean;
+  }) {
+    const failedIds = args.failures.map((f) => f.versionId).join(", ");
+    super({
+      ...args,
+      message: `Failed to destroy ${args.failures.length} version(s): ${failedIds}`,
+    });
+  }
+}
+
+export type ComputeError =
+  | AuthenticationError
+  | ApiError
+  | MissingArgumentError
+  | BuildError
+  | ArtifactError
+  | TimeoutError
+  | VersionFailedError
+  | NoExistingVersionError
+  | CancelledError
+  | DestroyAggregateError;
+
+export type DeployError =
+  | AuthenticationError
+  | ApiError
+  | MissingArgumentError
+  | BuildError
+  | ArtifactError
+  | TimeoutError
+  | VersionFailedError
+  | CancelledError;
+
+export type UpdateEnvError =
+  | AuthenticationError
+  | ApiError
+  | MissingArgumentError
+  | NoExistingVersionError
+  | TimeoutError
+  | VersionFailedError
+  | CancelledError;
+
+export type DestroyError =
+  | AuthenticationError
+  | ApiError
+  | MissingArgumentError
+  | CancelledError
+  | DestroyAggregateError;

package/src/index.ts

@@ -0,0 +1,75 @@
+// Re-export Result utilities so consumers don't need a direct better-result dependency
+export {
+  Err,
+  matchError,
+  matchErrorPartial,
+  Ok,
+  type Result,
+  TaggedError,
+} from "better-result";
+// Build strategy
+export type { BuildArtifact, BuildStrategy } from "./build-strategy.ts";
+export { PreBuilt } from "./build-strategy.ts";
+export { BunBuild } from "./bun-build.ts";
+// Callbacks
+export type {
+  DeployInteraction,
+  DeployProgress,
+  DestroyServiceProgress,
+  DestroyVersionInteraction,
+  DestroyVersionProgress,
+  UpdateEnvProgress,
+} from "./callbacks.ts";
+export type {
+  CreateServiceOptions,
+  DeleteServiceOptions,
+  DeleteVersionOptions,
+  DeployOptions,
+  DeployResult,
+  DestroyServiceOptions,
+  DestroyServiceResult,
+  DestroyVersionOptions,
+  DestroyVersionResult,
+  ListProjectsOptions,
+  ListServicesOptions,
+  ListVersionsOptions,
+  ShowServiceOptions,
+  ShowVersionOptions,
+  StartVersionOptions,
+  StopVersionOptions,
+  UpdateEnvOptions,
+  UpdateEnvResult,
+} from "./compute-client.ts";
+// Core client
+export { ComputeClient } from "./compute-client.ts";
+export type {
+  ComputeError,
+  DeployError,
+  DestroyError,
+  UpdateEnvError,
+} from "./errors.ts";
+// Errors
+export {
+  ApiError,
+  ArtifactError,
+  AuthenticationError,
+  BuildError,
+  CancelledError,
+  DestroyAggregateError,
+  MissingArgumentError,
+  NoExistingVersionError,
+  TimeoutError,
+  VersionFailedError,
+} from "./errors.ts";
+// Domain types
+export type {
+  PortMapping,
+  ProjectInfo,
+  RegionInfo,
+  ResolvedConfig,
+  ServiceDetail,
+  ServiceInfo,
+  VersionDetail,
+  VersionInfo,
+} from "./types.ts";
+export { KNOWN_REGION_IDS, REGIONS } from "./types.ts";

package/src/polling.ts

@@ -0,0 +1,108 @@
+import { Result } from "better-result";
+import type { ApiClientError, InternalApiClient } from "./api-client.ts";
+import {
+  ApiError,
+  CancelledError,
+  TimeoutError,
+  VersionFailedError,
+} from "./errors.ts";
+
+export type PollOptions = {
+  targetStatus: "running" | "stopped";
+  timeoutSeconds: number;
+  pollIntervalMs: number;
+  signal?: AbortSignal;
+  onStatusChange?(status: string): void;
+};
+
+export type PollResult = {
+  previewDomain: string;
+  lastStatus: string;
+};
+
+export type PollError =
+  | CancelledError
+  | TimeoutError
+  | VersionFailedError
+  | ApiClientError;
+
+/**
+ * Polls a compute version until it reaches the target status, fails, or times out.
+ *
+ * Returns a Result with the preview domain on success or a typed error.
+ */
+export async function pollVersionStatus(
+  api: InternalApiClient,
+  versionId: string,
+  options: PollOptions,
+): Promise<Result<PollResult, PollError>> {
+  return Result.gen(async function* () {
+    const deadline = Date.now() + options.timeoutSeconds * 1_000;
+    let lastStatus = "";
+
+    while (Date.now() <= deadline) {
+      if (options.signal?.aborted) {
+        return Result.err(new CancelledError());
+      }
+
+      const version = yield* Result.await(api.getVersion(versionId));
+
+      if (version.status !== lastStatus) {
+        lastStatus = version.status;
+        options.onStatusChange?.(version.status);
+      }
+
+      if (version.status === options.targetStatus) {
+        if (options.targetStatus === "running" && !version.previewDomain) {
+          return Result.err(
+            new ApiError({
+              statusCode: 0,
+              statusText: "",
+              message: "Version reached running state without a previewDomain",
+              traceHeaders: {},
+            }),
+          );
+        }
+        return Result.ok({
+          previewDomain: version.previewDomain ?? "",
+          lastStatus: version.status,
+        });
+      }
+
+      if (version.status === "failed") {
+        return Result.err(new VersionFailedError({ versionId }));
+      }
+
+      await sleep(options.pollIntervalMs, options.signal);
+    }
+
+    return Result.err(
+      new TimeoutError({
+        versionId,
+        elapsedMs: Date.now() - (deadline - options.timeoutSeconds * 1_000),
+        lastStatus,
+      }),
+    );
+  });
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}

package/src/types.ts

@@ -0,0 +1,65 @@
+/**
+ * Domain types for the Compute SDK.
+ */
+
+export interface PortMapping {
+  http?: number | null;
+}
+
+export interface ProjectInfo {
+  id: string;
+  name: string;
+  defaultRegion?: string;
+}
+
+export interface ServiceInfo {
+  id: string;
+  name: string;
+  region: string;
+  projectId: string;
+  createdAt?: string;
+}
+
+export interface ServiceDetail extends ServiceInfo {
+  latestVersionId?: string | null;
+}
+
+export interface VersionInfo {
+  id: string;
+  status: string;
+  createdAt: string;
+  previewDomain?: string | null;
+}
+
+export interface VersionDetail extends VersionInfo {
+  envVars?: Record<string, string | null>;
+  foundryVersionId?: string;
+}
+
+export interface RegionInfo {
+  id: string;
+  displayName: string;
+}
+
+export interface ResolvedConfig {
+  projectId: string;
+  serviceId: string;
+  serviceName: string;
+  region: string;
+  portMapping?: PortMapping;
+}
+
+/** Known compute region identifiers, used by the CLI for interactive prompts. */
+export const KNOWN_REGION_IDS = [
+  "us-east-1",
+  "us-west-1",
+  "eu-west-3",
+  "eu-central-1",
+  "ap-northeast-1",
+  "ap-southeast-1",
+] as const;
+
+export const REGIONS: RegionInfo[] = KNOWN_REGION_IDS.map((id) => ({
+  id,
+  displayName: id,
+}));