@gaganref/confect-alchemy 0.0.0-stage → 10.3.1-fork.2

package/src/DeployKey.ts

@@ -0,0 +1,256 @@
+import type { PlatformCreateDeployKeyArgs } from "@convex-dev/platform/managementApi";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+
+import { ConvexClient } from "./ConvexClient";
+import type { Providers } from "./Providers";
+import { resourceName } from "./internal/ResourceIdentity";
+import { checkpointCreate } from "./internal/Lifecycle";
+import { adminKey, dataDirectories } from "./internal/LocalBackend";
+
+export interface DeployKeyProps {
+  readonly deploymentName: string;
+  readonly name?: string;
+  readonly allowedActions?: ReadonlyArray<
+    NonNullable<PlatformCreateDeployKeyArgs["allowedActions"]>[number]
+  >;
+}
+
+export interface DeployKeyAttributes {
+  readonly deploymentName: string;
+  readonly keyId: number;
+  readonly name: string;
+  readonly deployKey: Redacted.Redacted<string>;
+  readonly allowedActions: ReadonlyArray<string>;
+}
+
+export type DeployKey = Resource<
+  "Convex.DeployKey",
+  DeployKeyProps,
+  DeployKeyAttributes,
+  never,
+  Providers
+>;
+export const DeployKey = Resource<DeployKey>("Convex.DeployKey");
+
+export class DeployKeyRecoveryRequired extends Schema.TaggedError<DeployKeyRecoveryRequired>()(
+  "DeployKeyRecoveryRequired",
+  {
+    deploymentName: Schema.String,
+    name: Schema.String,
+    keyIds: Schema.Array(Schema.Finite),
+  },
+) {}
+
+export class DeployKeyChangeRequiresNewResource extends Schema.TaggedError<DeployKeyChangeRequiresNewResource>()(
+  "DeployKeyChangeRequiresNewResource",
+  { deploymentName: Schema.String, keyId: Schema.Finite, field: Schema.String },
+) {}
+
+export const provider = Effect.gen(function* () {
+  const client = yield* ConvexClient;
+  const hasName = (keyName: string, name: string) =>
+    keyName === name ||
+    (keyName.startsWith(`${name} (`) &&
+      /^[0-9a-f]{8}\)$/.test(keyName.slice(name.length + 2)));
+  const recover = (
+    deploymentName: string,
+    name: string,
+    keyIds: ReadonlyArray<number>,
+  ) => new DeployKeyRecoveryRequired({ deploymentName, name, keyIds });
+  return {
+    diff: Effect.fn("DeployKey.diff")(function* ({ news, output }) {
+      if (!isResolved(news) || !output) return;
+      for (const field of ["deploymentName", "name"] as const) {
+        if (news[field] !== undefined && news[field] !== output[field])
+          return yield* new DeployKeyChangeRequiresNewResource({
+            deploymentName: output.deploymentName,
+            keyId: output.keyId,
+            field,
+          });
+      }
+      const keys = yield* client.listDeployKeys(output.deploymentName);
+      const key = keys.find((candidate) => candidate.id === output.keyId);
+      if (!key || !Redacted.isRedacted(output.deployKey))
+        return yield* recover(output.deploymentName, output.name, [
+          output.keyId,
+        ]);
+      if (!hasName(key.name, news.name ?? output.name))
+        return yield* new DeployKeyChangeRequiresNewResource({
+          deploymentName: output.deploymentName,
+          keyId: output.keyId,
+          field: "name",
+        });
+      const allowedActions = news.allowedActions ?? output.allowedActions;
+      if (
+        new Set(allowedActions).size !== new Set(key.allowedActions).size ||
+        allowedActions.some((action) => !key.allowedActions.includes(action))
+      )
+        return yield* new DeployKeyChangeRequiresNewResource({
+          deploymentName: output.deploymentName,
+          keyId: output.keyId,
+          field: "allowedActions",
+        });
+    }),
+    read: Effect.fn("DeployKey.read")(function* ({
+      fqn,
+      instanceId,
+      olds,
+      output,
+    }) {
+      const deploymentName = output?.deploymentName ?? olds.deploymentName;
+      if (deploymentName === undefined) return;
+      const name =
+        output?.name ??
+        olds.name ??
+        (yield* resourceName("key", fqn, instanceId));
+      const keys = yield* client.listDeployKeys(deploymentName);
+      if (output) {
+        const key = keys.find((candidate) => candidate.id === output.keyId);
+        if (!key) return yield* recover(deploymentName, name, [output.keyId]);
+        if (!Redacted.isRedacted(output.deployKey))
+          return yield* recover(deploymentName, name, [key.id]);
+        return {
+          ...output,
+          allowedActions: key.allowedActions,
+        };
+      }
+      const matches = keys.filter((key) => hasName(key.name, name));
+      if (matches.length > 0)
+        return yield* recover(
+          deploymentName,
+          name,
+          matches.map((candidate) => candidate.id),
+        );
+      return undefined;
+    }),
+    reconcile: Effect.fn("DeployKey.reconcile")(function* ({
+      fqn,
+      instanceId,
+      news,
+      output,
+    }) {
+      if (!output) yield* checkpointCreate(fqn, instanceId, news);
+      const name =
+        news.name ??
+        output?.name ??
+        (yield* resourceName("key", fqn, instanceId));
+      if (output) {
+        for (const field of ["deploymentName", "name"] as const) {
+          if (news[field] !== undefined && news[field] !== output[field])
+            return yield* new DeployKeyChangeRequiresNewResource({
+              deploymentName: output.deploymentName,
+              keyId: output.keyId,
+              field,
+            });
+        }
+        const keys = yield* client.listDeployKeys(output.deploymentName);
+        const key = keys.find((candidate) => candidate.id === output.keyId);
+        if (!key || !Redacted.isRedacted(output.deployKey))
+          return yield* recover(output.deploymentName, name, [output.keyId]);
+        if (!hasName(key.name, name))
+          return yield* new DeployKeyChangeRequiresNewResource({
+            deploymentName: output.deploymentName,
+            keyId: output.keyId,
+            field: "name",
+          });
+        const allowedActions = news.allowedActions ?? output.allowedActions;
+        if (
+          new Set(allowedActions).size !== new Set(key.allowedActions).size ||
+          allowedActions.some((action) => !key.allowedActions.includes(action))
+        )
+          return yield* new DeployKeyChangeRequiresNewResource({
+            deploymentName: output.deploymentName,
+            keyId: output.keyId,
+            field: "allowedActions",
+          });
+        return {
+          ...output,
+          allowedActions: key.allowedActions,
+        };
+      }
+      const existing = (yield* client.listDeployKeys(
+        news.deploymentName,
+      )).filter((key) => hasName(key.name, name));
+      if (existing.length > 0)
+        return yield* recover(
+          news.deploymentName,
+          name,
+          existing.map((key) => key.id),
+        );
+      const created = yield* client.createDeployKey(news.deploymentName, {
+        name,
+        ...(news.allowedActions === undefined
+          ? {}
+          : { allowedActions: [...news.allowedActions] }),
+      });
+      const matches = (yield* client.listDeployKeys(
+        news.deploymentName,
+      )).filter((key) => hasName(key.name, name));
+      const key = matches[0];
+      if (matches.length !== 1 || !key)
+        return yield* recover(
+          news.deploymentName,
+          name,
+          matches.map((candidate) => candidate.id),
+        );
+      return {
+        deploymentName: news.deploymentName,
+        keyId: key.id,
+        name,
+        deployKey: created.deployKey,
+        allowedActions: key.allowedActions,
+      };
+    }),
+    delete: Effect.fn("DeployKey.delete")(function* ({ output }) {
+      yield* client
+        .deleteDeployKey(output.deploymentName, output.deployKey)
+        .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+    }),
+  } satisfies Provider.ProviderServiceInput<DeployKey>;
+});
+
+/**
+ * Under `alchemy dev` the deploy key is the admin key the local deployment
+ * generated. It is read on every apply, so a recreated backend's new key
+ * replaces the old one.
+ */
+export const localProvider = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const directory = yield* dataDirectories;
+  return {
+    diff: () => Effect.succeed({ action: "update" }),
+    reconcile: Effect.fn("DeployKey.localReconcile")(function* ({
+      fqn,
+      instanceId,
+      news,
+    }) {
+      const name = news.name ?? (yield* resourceName("key", fqn, instanceId));
+      const deployKey = yield* adminKey(
+        news.deploymentName,
+        directory(news.deploymentName),
+      ).pipe(
+        Effect.provideService(FileSystem.FileSystem, fs),
+        Effect.provideService(Path.Path, path),
+      );
+      return {
+        deploymentName: news.deploymentName,
+        keyId: 0,
+        name,
+        deployKey,
+        allowedActions: news.allowedActions ?? [],
+      } satisfies DeployKeyAttributes;
+    }),
+    delete: () => Effect.void,
+  } satisfies Provider.ProviderServiceInput<DeployKey>;
+});
+
+export const layer = Provider.effect(DeployKey, provider);
+export const localLayer = Provider.effect(DeployKey, localProvider);

package/src/Deployment.ts

@@ -0,0 +1,277 @@
+import type {
+  CreateDeploymentType,
+  PlatformDeploymentResponse,
+  RegionName,
+} from "@convex-dev/platform/managementApi";
+import { OwnedBySomeoneElse, Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as LocalProvider from "alchemy/Local/LocalProvider";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import { moduleExtension } from "alchemy/Util/Node";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Schema from "effect/Schema";
+
+import { ConvexClient } from "./ConvexClient";
+import type { Providers } from "./Providers";
+import { resourceName } from "./internal/ResourceIdentity";
+import { checkpointCreate, shouldAdopt } from "./internal/Lifecycle";
+import { boot, dataDirectories, remove } from "./internal/LocalBackend";
+
+export interface DeploymentProps {
+  readonly projectId: number;
+  readonly type: CreateDeploymentType;
+  readonly reference?: string;
+  readonly region?: RegionName;
+}
+
+export interface DeploymentAttributes {
+  readonly projectId: number;
+  readonly name: string;
+  readonly reference: string;
+  readonly type: CreateDeploymentType;
+  readonly url: string;
+  /**
+   * Always set in the cloud; a local deployment echoes the requested region.
+   */
+  readonly region?: RegionName;
+}
+
+export type Deployment = Resource<
+  "Convex.Deployment",
+  DeploymentProps,
+  DeploymentAttributes,
+  never,
+  Providers
+>;
+export const Deployment = Resource<Deployment>("Convex.Deployment", {
+  defaultRemovalPolicy: "retain",
+});
+
+export class DeploymentIdentityChange extends Schema.TaggedError<DeploymentIdentityChange>()(
+  "DeploymentIdentityChange",
+  {
+    deploymentName: Schema.String,
+    field: Schema.String,
+    current: Schema.String,
+    requested: Schema.String,
+  },
+) {}
+
+export class UnsupportedLocalDeployment extends Schema.TaggedError<UnsupportedLocalDeployment>()(
+  "UnsupportedLocalDeployment",
+  { deploymentName: Schema.String },
+) {}
+
+export class AmbiguousDeployment extends Schema.TaggedError<AmbiguousDeployment>()(
+  "AmbiguousDeployment",
+  { projectId: Schema.Finite, reference: Schema.String },
+) {}
+
+export const provider = Effect.gen(function* () {
+  const client = yield* ConvexClient;
+  const attributes = Effect.fn("Deployment.attributes")(function* (
+    deployment: PlatformDeploymentResponse,
+  ) {
+    if (deployment.kind !== "cloud")
+      return yield* new UnsupportedLocalDeployment({
+        deploymentName: deployment.name,
+      });
+    return {
+      projectId: deployment.projectId,
+      name: deployment.name,
+      reference: deployment.reference,
+      type: deployment.deploymentType,
+      url: deployment.deploymentUrl,
+      region: deployment.region,
+    } satisfies DeploymentAttributes;
+  });
+  const find = Effect.fn("Deployment.find")(function* (
+    projectId: number,
+    reference: string,
+  ) {
+    const matches = (yield* client.listDeployments(projectId)).filter(
+      (deployment) =>
+        deployment.kind === "cloud" && deployment.reference === reference,
+    );
+    if (matches.length > 1)
+      return yield* new AmbiguousDeployment({ projectId, reference });
+    return matches[0];
+  });
+  const validate = Effect.fn("Deployment.validate")(function* (
+    current: DeploymentAttributes,
+    news: DeploymentProps,
+  ) {
+    for (const field of ["projectId", "type", "region"] as const) {
+      if (news[field] !== undefined && current[field] !== news[field])
+        return yield* new DeploymentIdentityChange({
+          deploymentName: current.name,
+          field,
+          current: String(current[field]),
+          requested: String(news[field]),
+        });
+    }
+  });
+  return {
+    diff: Effect.fn("Deployment.diff")(function* ({ news, output }) {
+      if (!isResolved(news) || !output) return;
+      yield* validate(output, news);
+      const deployment = yield* client
+        .getDeployment(output.name)
+        .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+      if (!deployment) return { action: "update" };
+      const current = yield* attributes(deployment);
+      yield* validate(current, news);
+      if ((news.reference ?? output.reference) !== current.reference)
+        return { action: "update" };
+    }),
+    read: Effect.fn("Deployment.read")(function* ({
+      fqn,
+      instanceId,
+      olds,
+      output,
+    }) {
+      if (output) {
+        const deployment = yield* client
+          .getDeployment(output.name)
+          .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+        return deployment ? yield* attributes(deployment) : undefined;
+      }
+      if (olds.projectId === undefined) return;
+      const deployment = yield* find(
+        olds.projectId,
+        olds.reference ?? (yield* resourceName("deployment", fqn, instanceId)),
+      );
+      return deployment ? Unowned(yield* attributes(deployment)) : undefined;
+    }),
+    reconcile: Effect.fn("Deployment.reconcile")(function* ({
+      fqn,
+      instanceId,
+      news,
+      output,
+    }) {
+      if (!output) yield* checkpointCreate(fqn, instanceId, news);
+      if (output) yield* validate(output, news);
+      let deployment = output
+        ? yield* client
+            .getDeployment(output.name)
+            .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void))
+        : undefined;
+      const reference =
+        news.reference ??
+        output?.reference ??
+        (yield* resourceName("deployment", fqn, instanceId));
+      if (!deployment) {
+        const existing = yield* find(news.projectId, reference);
+        if (existing && !(yield* shouldAdopt(fqn)))
+          return yield* new OwnedBySomeoneElse({
+            message: "An existing deployment requires explicit adoption.",
+            resourceType: Deployment.Type,
+            physicalName: reference,
+          });
+        if (existing) {
+          const adopted = yield* attributes(existing);
+          yield* validate(adopted, news);
+          yield* checkpointCreate(fqn, instanceId, news, adopted);
+          deployment = existing;
+        } else {
+          deployment = yield* client.createDeployment(news.projectId, {
+            type: news.type,
+            reference,
+            ...(news.region === undefined ? {} : { region: news.region }),
+          });
+        }
+      }
+      const current = yield* attributes(deployment);
+      yield* validate(current, news);
+      if (current.reference !== reference) {
+        const existing = yield* find(news.projectId, reference);
+        if (existing && existing.name !== current.name)
+          return yield* new OwnedBySomeoneElse({
+            message: "The requested deployment reference is already in use.",
+            resourceType: Deployment.Type,
+            physicalName: reference,
+          });
+        yield* client.updateDeployment(current.name, {
+          reference,
+        });
+        deployment = yield* client.getDeployment(current.name);
+      }
+      return yield* attributes(deployment);
+    }),
+    delete: Effect.fn("Deployment.delete")(function* ({ output }) {
+      yield* client
+        .deleteDeployment(output.name)
+        .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+    }),
+  } satisfies Provider.ProviderServiceInput<Deployment>;
+});
+
+interface LocalConfig {
+  readonly name: string;
+  readonly props: DeploymentProps;
+}
+
+/**
+ * Under `alchemy dev` a deployment is a local Convex backend this provider
+ * owns. Alchemy's dev sidecar hosts it, so the backend keeps running across
+ * reloads of the stack and stops when the dev session ends. Its data lives in
+ * `.alchemy/convex/<stack>/<stage>/<name>` and is removed only when the
+ * deployment is destroyed.
+ */
+export const localLayer = LocalProvider.make(
+  Deployment,
+  new URL(
+    `./internal/LocalSidecar${moduleExtension(import.meta.url)}`,
+    import.meta.url,
+  ).href,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const directory = yield* dataDirectories;
+    return {
+      resolveConfig: Effect.fn("Deployment.localConfig")(function* ({
+        fqn,
+        instanceId,
+        news,
+      }) {
+        return {
+          name: yield* resourceName("deployment", fqn, instanceId),
+          props: news,
+        } satisfies LocalConfig;
+      }),
+      start: Effect.fn("Deployment.localStart")(function* ({
+        config,
+        invalidate,
+      }) {
+        const backend = yield* boot(config.name, directory(config.name));
+        yield* backend.exited.pipe(
+          Effect.andThen(invalidate),
+          Effect.forkScoped,
+        );
+        return {
+          projectId: config.props.projectId,
+          name: config.name,
+          reference: config.props.reference ?? config.name,
+          type: config.props.type,
+          url: backend.url,
+          ...(config.props.region === undefined
+            ? {}
+            : { region: config.props.region }),
+        } satisfies DeploymentAttributes;
+      }),
+      stop: Effect.fn("Deployment.localStop")(function* ({ fqn, instanceId }) {
+        const name = yield* resourceName("deployment", fqn, instanceId);
+        yield* remove(name, directory(name)).pipe(
+          Effect.provideService(FileSystem.FileSystem, fs),
+        );
+      }),
+    } satisfies LocalProvider.LocalProviderSpec<
+      Deployment,
+      LocalConfig,
+      Effect.Services<ReturnType<typeof boot>>
+    >;
+  }),
+);
+
+export const layer = Provider.effect(Deployment, provider);