alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Prisma/ComputeLifecycle.ts

@@ -0,0 +1,391 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import {
+  isConflict,
+  isNotFound,
+  PrismaApiError,
+  type PrismaManagementClient,
+} from "./Client.ts";
+import { stopDeploymentIdempotent } from "./Internal/DeploymentActions.ts";
+import { observeDeployment } from "./Internal/DeploymentObserve.ts";
+import type { Deployment } from "./Types.ts";
+export { isConflict } from "./Client.ts";
+
+export interface WaitForDeploymentStatusOptions {
+  /**
+   * Maximum time to wait for a deployment to reach the requested status.
+   */
+  timeoutSeconds?: number;
+  /**
+   * Poll interval used while waiting for Prisma deployment status changes.
+   */
+  pollIntervalMs?: number;
+}
+
+/**
+ * Result returned after attempting to stop and delete a Prisma deployment.
+ */
+export interface DestroyDeploymentResult {
+  /**
+   * Prisma deployment ID that was targeted.
+   */
+  deploymentId: string;
+  /**
+   * Status observed before cleanup started, or undefined if the deployment was gone.
+   */
+  previousStatus: string | undefined;
+  /**
+   * True when Alchemy requested a stop before deletion.
+   */
+  stopped: boolean;
+  /**
+   * True when the delete call completed or the deployment vanished during cleanup.
+   */
+  deleted: boolean;
+}
+
+/** Result returned after deleting a Prisma App. */
+export interface DestroyAppResult {
+  /** Prisma App ID that was targeted. */
+  appId: string;
+  /** True when App deletion completed or the app was already gone. */
+  appDeleted: boolean;
+}
+
+/**
+ * Result returned after deleting Apps under a Prisma project.
+ */
+export interface DestroyProjectAppsResult {
+  /**
+   * Prisma project ID that was targeted.
+   */
+  projectId: string;
+  /**
+   * App IDs deleted by this cleanup pass.
+   */
+  deletedAppIds: string[];
+  /**
+   * True when the project delete call completed or the project vanished.
+   */
+  projectDeleted: boolean;
+}
+
+const DEFAULT_TIMEOUT_SECONDS = 120;
+const DEFAULT_POLL_INTERVAL_MS = 1_000;
+const DELETE_CONFLICT_RETRY_ATTEMPTS = 5;
+
+const deleteRetryDelay = (attempt: number) =>
+  Effect.sleep(Duration.millis(250 * 2 ** attempt));
+
+const ensureError = (error: unknown): Error =>
+  error instanceof Error
+    ? error
+    : new Error("Prisma deployment lifecycle operation failed.", {
+        cause: error,
+      });
+
+const isProjectDeleteBlocked = (error: unknown): boolean =>
+  isConflict(error) ||
+  (error instanceof PrismaApiError &&
+    error.method === "DELETE" &&
+    error.path.startsWith("/v1/projects/") &&
+    error.status === 400);
+
+const deploymentDeleteFailed = (
+  deploymentId: string,
+  statusAtDelete: string | undefined,
+  error: unknown,
+) => {
+  const format = (error: unknown) =>
+    error instanceof PrismaApiError
+      ? `Prisma API returned HTTP ${error.status}: ${error.message}`
+      : error instanceof Error
+        ? error.message
+        : String(error);
+  const detail = format(error);
+  const isKnownStoppedDeleteFailure =
+    statusAtDelete === "stopped" &&
+    error instanceof PrismaApiError &&
+    error.status >= 500;
+  return new Error(
+    [
+      `Failed to delete Prisma deployment '${deploymentId}' while it was in status '${statusAtDelete ?? "unknown"}'.`,
+      detail,
+      isKnownStoppedDeleteFailure
+        ? "Stopped Prisma deployments are expected to be deletable; the Management API returned a server error."
+        : undefined,
+      "The deployment may need platform cleanup before the App or project can be deleted.",
+      `Manual check: GET /v1/deployments/${deploymentId}; manual retry: DELETE /v1/deployments/${deploymentId}.`,
+    ]
+      .filter((line): line is string => line !== undefined)
+      .join(" "),
+    { cause: error },
+  );
+};
+
+const deploymentWaitTimedOut = (
+  deploymentId: string,
+  targetStatus: "running" | "stopped",
+  lastStatus: string | undefined,
+) =>
+  new Error(
+    `Timed out waiting for Prisma deployment '${deploymentId}' to reach '${targetStatus}' (last status: '${lastStatus ?? "unknown"}')`,
+  );
+
+export const waitForDeploymentStatus = Effect.fn(function* (
+  client: PrismaManagementClient,
+  deploymentId: string,
+  targetStatus: "running" | "stopped",
+  options: WaitForDeploymentStatusOptions = {},
+) {
+  const timeoutSeconds = options.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
+  const intervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+    return yield* Effect.fail(
+      new Error("timeoutSeconds must be a positive finite number."),
+    );
+  }
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    return yield* Effect.fail(
+      new Error("pollIntervalMs must be a positive finite number."),
+    );
+  }
+  const timeoutMs = timeoutSeconds * 1_000;
+  const startedAt = yield* Effect.sync(() => Date.now());
+  const deadline = startedAt + timeoutMs;
+  let lastStatus: string | undefined;
+
+  while (true) {
+    const remainingBeforeObservation = yield* Effect.sync(
+      () => deadline - Date.now(),
+    );
+    if (remainingBeforeObservation <= 0) {
+      return yield* Effect.fail(
+        deploymentWaitTimedOut(deploymentId, targetStatus, lastStatus),
+      );
+    }
+    const deploymentOption = yield* observeDeployment(
+      client,
+      deploymentId,
+    ).pipe(Effect.timeoutOption(Duration.millis(remainingBeforeObservation)));
+    if (Option.isNone(deploymentOption)) {
+      return yield* Effect.fail(
+        deploymentWaitTimedOut(deploymentId, targetStatus, lastStatus),
+      );
+    }
+    const deployment = deploymentOption.value;
+    lastStatus = deployment.status;
+    if (deployment.status === targetStatus) {
+      return deployment as Deployment;
+    }
+    if (deployment.status === "failed") {
+      return yield* Effect.fail(
+        new Error(`Prisma deployment '${deploymentId}' failed`),
+      );
+    }
+
+    const elapsed = yield* Effect.sync(() => Date.now() - startedAt);
+    if (elapsed >= timeoutMs) {
+      return yield* Effect.fail(
+        deploymentWaitTimedOut(deploymentId, targetStatus, lastStatus),
+      );
+    }
+
+    yield* Effect.sleep(
+      Duration.millis(Math.min(intervalMs, timeoutMs - elapsed)),
+    );
+  }
+});
+
+/**
+ * Stops a running or provisioning deployment, then deletes it.
+ *
+ * Uses the canonical deployment lifecycle routes. Errors include the observed
+ * status and exact manual route for cleanup.
+ */
+export const destroyDeployment: (
+  client: PrismaManagementClient,
+  deploymentId: string,
+  options?: WaitForDeploymentStatusOptions,
+) => Effect.Effect<DestroyDeploymentResult, Error, never> = Effect.fn(
+  function* (
+    client: PrismaManagementClient,
+    deploymentId: string,
+    options: WaitForDeploymentStatusOptions = {},
+  ) {
+    const deployment = yield* observeDeployment(client, deploymentId).pipe(
+      Effect.catchIf(isNotFound, () => Effect.succeed(undefined)),
+    );
+    if (!deployment) {
+      return {
+        deploymentId,
+        previousStatus: undefined,
+        stopped: false,
+        // The postcondition is already satisfied. Report this consistently
+        // with delete calls whose 404 is observed after cleanup starts.
+        deleted: true,
+      } satisfies DestroyDeploymentResult;
+    }
+
+    const previousStatus = deployment.status;
+    let statusAtDelete = previousStatus;
+    let stopped = false;
+    if (
+      deployment.status === "running" ||
+      deployment.status === "provisioning"
+    ) {
+      yield* stopDeploymentIdempotent(client, deploymentId).pipe(
+        Effect.catchIf(
+          (e) => isNotFound(e),
+          () => Effect.void,
+        ),
+        Effect.mapError(ensureError),
+      );
+      const stoppedVersion = yield* waitForDeploymentStatus(
+        client,
+        deploymentId,
+        "stopped",
+        options,
+      ).pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+      statusAtDelete = stoppedVersion?.status ?? "stopped";
+      stopped = true;
+    }
+
+    yield* client.deleteDeployment(deploymentId).pipe(
+      Effect.catchIf(isNotFound, () => Effect.void),
+      Effect.catch((error) =>
+        Effect.fail(
+          deploymentDeleteFailed(deploymentId, statusAtDelete, error),
+        ),
+      ),
+    );
+
+    return {
+      deploymentId,
+      previousStatus,
+      stopped,
+      deleted: true,
+    } satisfies DestroyDeploymentResult;
+  },
+);
+
+/**
+ * Deletes an App. The canonical App delete endpoint cascades its deployments.
+ */
+export const destroyApp: (
+  client: PrismaManagementClient,
+  appId: string,
+  options?: WaitForDeploymentStatusOptions & { keepApp?: boolean },
+) => Effect.Effect<DestroyAppResult, Error, never> = Effect.fn(function* (
+  client: PrismaManagementClient,
+  appId: string,
+  options: WaitForDeploymentStatusOptions & {
+    keepApp?: boolean;
+  } = {},
+) {
+  let appDeleted = false;
+  if (!options.keepApp) {
+    for (let attempt = 0; attempt < DELETE_CONFLICT_RETRY_ATTEMPTS; attempt++) {
+      const deleted = yield* client.deleteApp(appId).pipe(
+        Effect.as(true),
+        Effect.catchIf(isNotFound, () => Effect.succeed(true)),
+        Effect.catchIf(isConflict, (error) =>
+          attempt + 1 < DELETE_CONFLICT_RETRY_ATTEMPTS
+            ? deleteRetryDelay(attempt).pipe(Effect.as(false))
+            : Effect.fail(error),
+        ),
+      );
+      if (deleted) {
+        appDeleted = true;
+        break;
+      }
+    }
+  }
+
+  return {
+    appId,
+    appDeleted,
+  } satisfies DestroyAppResult;
+});
+
+/**
+ * Deletes every App under a project, then deletes the project.
+ *
+ * Callers can start from the project ID and let Alchemy discover the App IDs.
+ */
+export const destroyProjectApps: (
+  client: PrismaManagementClient,
+  projectId: string,
+  options?: WaitForDeploymentStatusOptions & {
+    keepProject?: boolean;
+    keepApp?: boolean;
+  },
+) => Effect.Effect<DestroyProjectAppsResult, Error, never> = Effect.fn(
+  function* (
+    client: PrismaManagementClient,
+    projectId: string,
+    options: WaitForDeploymentStatusOptions & {
+      keepProject?: boolean;
+      keepApp?: boolean;
+    } = {},
+  ) {
+    const deletedAppIds = new Set<string>();
+
+    const cleanupApps = Effect.fn(function* () {
+      const apps = yield* client
+        .listApps({
+          projectId,
+          limit: 100,
+        })
+        .pipe(Effect.catchIf(isNotFound, () => Effect.succeed(undefined)));
+      if (!apps) return false;
+      for (const app of apps) {
+        const result = yield* destroyApp(client, app.id, options);
+        if (result.appDeleted) deletedAppIds.add(app.id);
+      }
+      return true;
+    });
+
+    yield* cleanupApps();
+
+    let projectDeleted = false;
+    if (!options.keepProject) {
+      for (
+        let attempt = 0;
+        attempt < DELETE_CONFLICT_RETRY_ATTEMPTS;
+        attempt++
+      ) {
+        const deleted = yield* client.deleteProject(projectId).pipe(
+          Effect.as(true),
+          Effect.catchIf(isNotFound, () => Effect.succeed(true)),
+          Effect.catchIf(isProjectDeleteBlocked, (error) =>
+            attempt + 1 < DELETE_CONFLICT_RETRY_ATTEMPTS
+              ? cleanupApps().pipe(
+                  Effect.andThen(deleteRetryDelay(attempt)),
+                  Effect.as(false),
+                )
+              : Effect.fail(error),
+          ),
+        );
+        if (deleted) {
+          projectDeleted = true;
+          break;
+        }
+      }
+    }
+
+    return {
+      projectId,
+      deletedAppIds: Array.from(deletedAppIds),
+      projectDeleted,
+    } satisfies DestroyProjectAppsResult;
+  },
+);
+
+export const toDeploymentUrl = (domain: string | null | undefined) =>
+  domain
+    ? domain.startsWith("http://") || domain.startsWith("https://")
+      ? domain
+      : `https://${domain}`
+    : undefined;