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

package/src/EnvironmentVariables.ts

@@ -0,0 +1,254 @@
+import { OwnedBySomeoneElse, Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+
+import * as ConvexClient from "./ConvexClient";
+import type { Providers } from "./Providers";
+import { checkpointCreate, shouldAdopt } from "./internal/Lifecycle";
+
+export interface EnvironmentVariablesProps {
+  readonly url: string;
+  readonly deployKey: Redacted.Redacted<string>;
+  readonly variables: Readonly<
+    Record<string, string | Redacted.Redacted<string>>
+  >;
+}
+
+export interface EnvironmentVariablesAttributes {
+  readonly url: string;
+  readonly deployKey: Redacted.Redacted<string>;
+  readonly ownedNames: ReadonlyArray<string>;
+  readonly variables: Readonly<Record<string, Redacted.Redacted<string>>>;
+  readonly originals: Readonly<Record<string, Redacted.Redacted<string>>>;
+}
+
+export type EnvironmentVariables = Resource<
+  "Convex.EnvironmentVariables",
+  EnvironmentVariablesProps,
+  EnvironmentVariablesAttributes,
+  never,
+  Providers
+>;
+export const EnvironmentVariables = Resource<EnvironmentVariables>(
+  "Convex.EnvironmentVariables",
+);
+
+export class EnvironmentTargetChange extends Schema.TaggedError<EnvironmentTargetChange>()(
+  "EnvironmentTargetChange",
+  { url: Schema.String },
+) {}
+
+export const provider = Effect.gen(function* () {
+  const client = yield* ConvexClient.ConvexClient;
+  const redacted = (value: string | Redacted.Redacted<string>) =>
+    typeof value === "string" ? Redacted.make(value) : value;
+  const valueAt = (
+    variables: Readonly<Record<string, Redacted.Redacted<string>>>,
+    name: string,
+  ) => (Object.hasOwn(variables, name) ? variables[name] : undefined);
+  const select = (
+    variables: Readonly<Record<string, Redacted.Redacted<string>>>,
+    names: ReadonlyArray<string>,
+  ) =>
+    Object.fromEntries(
+      names.flatMap((name) =>
+        !Object.hasOwn(variables, name) ? [] : [[name, variables[name]]],
+      ),
+    );
+  return {
+    diff: Effect.fn("EnvironmentVariables.diff")(function* ({ news, output }) {
+      if (!isResolved(news) || !output) return;
+      if (news.url !== output.url)
+        return yield* new EnvironmentTargetChange({
+          url: output.url,
+        });
+      const names = Object.keys(news.variables);
+      if (
+        names.length !== output.ownedNames.length ||
+        names.some((name) => !output.ownedNames.includes(name))
+      )
+        return { action: "update" };
+      const variables = yield* client.listEnvironmentVariables(
+        news.url,
+        news.deployKey,
+      );
+      for (const [name, value] of Object.entries(news.variables)) {
+        const observed = valueAt(variables, name);
+        if (
+          observed === undefined ||
+          Redacted.value(observed) !== Redacted.value(redacted(value))
+        )
+          return { action: "update" };
+      }
+    }),
+    read: Effect.fn("EnvironmentVariables.read")(function* ({ olds, output }) {
+      const url = output?.url ?? olds.url;
+      if (url === undefined || olds.deployKey === undefined) return;
+      const observed = yield* client.listEnvironmentVariables(
+        url,
+        olds.deployKey,
+      );
+      const ownedNames = output?.ownedNames ?? Object.keys(olds.variables);
+      const variables = select(observed, ownedNames);
+      if (output) return { ...output, deployKey: olds.deployKey, variables };
+      if (Object.keys(variables).length === 0) return undefined;
+      return Unowned({
+        url,
+        deployKey: olds.deployKey,
+        ownedNames,
+        variables,
+        originals: variables,
+      });
+    }),
+    reconcile: Effect.fn("EnvironmentVariables.reconcile")(function* ({
+      fqn,
+      instanceId,
+      news,
+      output,
+    }) {
+      if (!output) yield* checkpointCreate(fqn, instanceId, news);
+      if (output && output.url !== news.url)
+        return yield* new EnvironmentTargetChange({
+          url: output.url,
+        });
+      const observed = yield* client.listEnvironmentVariables(
+        news.url,
+        news.deployKey,
+      );
+      const ownedNames = Object.keys(news.variables);
+      if (!output && (yield* shouldAdopt(fqn))) {
+        const variables = select(observed, ownedNames);
+        output = {
+          url: news.url,
+          deployKey: news.deployKey,
+          ownedNames,
+          variables,
+          originals: variables,
+        };
+        yield* checkpointCreate(fqn, instanceId, news, output);
+      }
+      const previousNames = output?.ownedNames ?? [];
+      for (const name of ownedNames) {
+        if (
+          !previousNames.includes(name) &&
+          valueAt(observed, name) !== undefined
+        )
+          return yield* new OwnedBySomeoneElse({
+            message:
+              "An existing environment variable requires explicit adoption in a separate resource.",
+            resourceType: EnvironmentVariables.Type,
+            physicalName: name,
+          });
+      }
+      const desired = Object.fromEntries(
+        Object.entries(news.variables).map(([name, value]) => [
+          name,
+          redacted(value),
+        ]),
+      );
+      const changes: Array<{
+        name: string;
+        value?: Redacted.Redacted<string>;
+      }> = [];
+      for (const [name, value] of Object.entries(desired)) {
+        const current = valueAt(observed, name);
+        if (
+          current === undefined ||
+          Redacted.value(current) !== Redacted.value(value)
+        )
+          changes.push({ name, value });
+      }
+      for (const name of previousNames) {
+        if (Object.hasOwn(desired, name)) continue;
+        const original = output ? valueAt(output.originals, name) : undefined;
+        const current = valueAt(observed, name);
+        if (original !== undefined) {
+          if (
+            current === undefined ||
+            Redacted.value(current) !== Redacted.value(original)
+          )
+            changes.push({ name, value: original });
+        } else if (current !== undefined) changes.push({ name });
+      }
+      if (changes.length > 0)
+        yield* client.updateEnvironmentVariables(
+          news.url,
+          news.deployKey,
+          changes,
+        );
+      return {
+        url: news.url,
+        deployKey: news.deployKey,
+        ownedNames,
+        variables: desired,
+        originals: select(output?.originals ?? {}, ownedNames),
+      };
+    }),
+    delete: Effect.fn("EnvironmentVariables.delete")(function* ({ output }) {
+      const observed = yield* client
+        .listEnvironmentVariables(output.url, output.deployKey)
+        .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+      if (observed === undefined) return;
+      const changes: Array<{
+        name: string;
+        value?: Redacted.Redacted<string>;
+      }> = [];
+      for (const name of output.ownedNames) {
+        const original = valueAt(output.originals, name);
+        const current = valueAt(observed, name);
+        if (original !== undefined) {
+          if (
+            current === undefined ||
+            Redacted.value(current) !== Redacted.value(original)
+          )
+            changes.push({ name, value: original });
+        } else if (current !== undefined) changes.push({ name });
+      }
+      if (changes.length > 0)
+        yield* client
+          .updateEnvironmentVariables(output.url, output.deployKey, changes)
+          .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+    }),
+  } satisfies Provider.ProviderServiceInput<EnvironmentVariables>;
+});
+
+/**
+ * Under `alchemy dev` variables are managed on the local backend. A backend
+ * that is not running keeps its variables in its retained data, so removing
+ * them is skipped rather than failing the apply.
+ */
+export const localProvider = Effect.map(
+  provider,
+  (service) =>
+    ({
+      ...service,
+      delete: (input) =>
+        // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Alchemy's provider input type erases the delete error channel.
+        service.delete(input).pipe(
+          Effect.catchIf(
+            (error) =>
+              error._tag === "ConvexApiError" &&
+              error.code === "TransportError",
+            () => Effect.void,
+          ),
+        ),
+    }) satisfies Provider.ProviderServiceInput<EnvironmentVariables>,
+);
+
+export const layer = Provider.effect(EnvironmentVariables, provider);
+export const localLayer = Provider.effect(
+  EnvironmentVariables,
+  localProvider,
+).pipe(
+  Layer.provide(
+    ConvexClient.layer({ mode: "local" }).pipe(
+      Layer.provide(FetchHttpClient.layer),
+    ),
+  ),
+);

package/src/Project.ts

@@ -0,0 +1,205 @@
+import { OwnedBySomeoneElse, Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+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";
+
+export interface ProjectProps {
+  readonly teamId: number;
+  readonly name?: string;
+}
+
+export interface ProjectAttributes {
+  readonly projectId: number;
+  readonly teamId: number;
+  readonly name: string;
+  readonly slug: string;
+}
+
+export type Project = Resource<
+  "Convex.Project",
+  ProjectProps,
+  ProjectAttributes,
+  never,
+  Providers
+>;
+export const Project = Resource<Project>("Convex.Project", {
+  defaultRemovalPolicy: "retain",
+});
+
+export class ProjectTeamChange extends Schema.TaggedError<ProjectTeamChange>()(
+  "ProjectTeamChange",
+  {
+    projectId: Schema.Finite,
+    teamId: Schema.Finite,
+    requestedTeamId: Schema.Finite,
+  },
+) {}
+
+export class AmbiguousProject extends Schema.TaggedError<AmbiguousProject>()(
+  "AmbiguousProject",
+  {
+    teamId: Schema.Finite,
+    name: Schema.String,
+    projectIds: Schema.Array(Schema.Finite),
+  },
+) {}
+
+export const provider = Effect.gen(function* () {
+  const client = yield* ConvexClient;
+  const attributes = (project: {
+    id: number;
+    teamId: number;
+    name: string;
+    slug: string;
+  }): ProjectAttributes => ({
+    projectId: project.id,
+    teamId: project.teamId,
+    name: project.name,
+    slug: project.slug,
+  });
+  const find = Effect.fn("Project.find")(function* (
+    teamId: number,
+    name: string,
+  ) {
+    const matches = (yield* client.listProjects(teamId)).filter(
+      (project) => project.name === name,
+    );
+    if (matches.length > 1)
+      return yield* new AmbiguousProject({
+        teamId,
+        name,
+        projectIds: matches.map((project) => project.id),
+      });
+    return matches[0];
+  });
+  return {
+    diff: Effect.fn("Project.diff")(function* ({ news, output }) {
+      if (!isResolved(news) || !output) return;
+      if (output.teamId !== news.teamId)
+        return yield* new ProjectTeamChange({
+          projectId: output.projectId,
+          teamId: output.teamId,
+          requestedTeamId: news.teamId,
+        });
+      const project = yield* client
+        .getProject(output.projectId)
+        .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+      if (!project) return { action: "update" };
+      if (project.teamId !== news.teamId)
+        return yield* new ProjectTeamChange({
+          projectId: project.id,
+          teamId: project.teamId,
+          requestedTeamId: news.teamId,
+        });
+      if ((news.name ?? output.name) !== project.name)
+        return { action: "update" };
+    }),
+    read: Effect.fn("Project.read")(function* ({
+      fqn,
+      instanceId,
+      olds,
+      output,
+    }) {
+      if (output) {
+        const project = yield* client
+          .getProject(output.projectId)
+          .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+        return project ? attributes(project) : undefined;
+      }
+      if (olds.teamId === undefined) return;
+      const project = yield* find(
+        olds.teamId,
+        olds.name ?? (yield* resourceName("project", fqn, instanceId)),
+      );
+      return project ? Unowned(attributes(project)) : undefined;
+    }),
+    reconcile: Effect.fn("Project.reconcile")(function* ({
+      fqn,
+      instanceId,
+      news,
+      output,
+    }) {
+      if (!output) yield* checkpointCreate(fqn, instanceId, news);
+      if (output && output.teamId !== news.teamId)
+        return yield* new ProjectTeamChange({
+          projectId: output.projectId,
+          teamId: output.teamId,
+          requestedTeamId: news.teamId,
+        });
+      let project = output
+        ? yield* client
+            .getProject(output.projectId)
+            .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void))
+        : undefined;
+      const name =
+        news.name ??
+        output?.name ??
+        (yield* resourceName("project", fqn, instanceId));
+      if (!project) {
+        const existing = yield* find(news.teamId, name);
+        if (existing && !(yield* shouldAdopt(fqn)))
+          return yield* new OwnedBySomeoneElse({
+            message: "An existing project requires explicit adoption.",
+            resourceType: Project.Type,
+            physicalName: name,
+          });
+        if (existing) {
+          project = existing;
+          yield* checkpointCreate(fqn, instanceId, news, attributes(existing));
+        } else {
+          const created = yield* client.createProject(news.teamId, {
+            projectName: name,
+          });
+          project = yield* client.getProject(created.id);
+        }
+      }
+      if (project.teamId !== news.teamId)
+        return yield* new ProjectTeamChange({
+          projectId: project.id,
+          teamId: project.teamId,
+          requestedTeamId: news.teamId,
+        });
+      if (project.name !== name)
+        project = yield* client.updateProject(project.id, {
+          name,
+        });
+      return attributes(project);
+    }),
+    delete: Effect.fn("Project.delete")(function* ({ output }) {
+      yield* client
+        .deleteProject(output.projectId)
+        .pipe(Effect.catchTag("ConvexNotFound", () => Effect.void));
+    }),
+  } satisfies Provider.ProviderServiceInput<Project>;
+});
+
+/**
+ * Under `alchemy dev` a project needs no Convex account: it is a fixed local
+ * identity that local deployments ignore.
+ */
+export const localProvider = Effect.succeed({
+  reconcile: Effect.fn("Project.localReconcile")(function* ({
+    fqn,
+    instanceId,
+    news,
+  }) {
+    const name = news.name ?? (yield* resourceName("project", fqn, instanceId));
+    return {
+      projectId: 0,
+      teamId: news.teamId,
+      name,
+      slug: name,
+    } satisfies ProjectAttributes;
+  }),
+  delete: () => Effect.void,
+} satisfies Provider.ProviderServiceInput<Project>);
+
+export const layer = Provider.effect(Project, provider);
+export const localLayer = Provider.effect(Project, localProvider);

package/src/Providers.ts

@@ -0,0 +1,67 @@
+import * as ProviderLayer from "alchemy/Local/ProviderLayer";
+import * as Provider from "alchemy/Provider";
+import type * as Redacted from "effect/Redacted";
+import * as Layer from "effect/Layer";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Code from "./Code";
+import * as ConvexClient from "./ConvexClient";
+import * as Deployment from "./Deployment";
+import * as DeployKey from "./DeployKey";
+import * as EnvironmentVariables from "./EnvironmentVariables";
+import * as Project from "./Project";
+import * as CommandRunner from "./internal/CommandRunner";
+import * as PushLock from "./internal/PushLock";
+
+export class Providers extends Provider.ProviderCollection<Providers>()(
+  "@confect/alchemy/Providers",
+) {}
+
+/**
+ * Register Convex resources without eagerly resolving management credentials.
+ * `alchemy deploy` resolves each resource to its cloud provider; `alchemy dev`
+ * resolves the same resources to local providers backed by a local Convex
+ * backend, so one stack definition serves both.
+ */
+export const providers = (options?: {
+  readonly token?: Redacted.Redacted<string>;
+}) =>
+  Layer.effect(
+    Providers,
+    Provider.collection([
+      Project.Project,
+      Deployment.Deployment,
+      DeployKey.DeployKey,
+      EnvironmentVariables.EnvironmentVariables,
+      Code.Code,
+    ]),
+  ).pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        ProviderLayer.dual(Project.Project, {
+          live: () => Project.layer,
+          local: () => Project.localLayer,
+        }),
+        ProviderLayer.dual(Deployment.Deployment, {
+          live: () => Deployment.layer,
+          local: () => Deployment.localLayer,
+        }),
+        ProviderLayer.dual(DeployKey.DeployKey, {
+          live: () => DeployKey.layer,
+          local: () => DeployKey.localLayer,
+        }),
+        ProviderLayer.dual(EnvironmentVariables.EnvironmentVariables, {
+          live: () => EnvironmentVariables.layer,
+          local: () => EnvironmentVariables.localLayer,
+        }),
+        ProviderLayer.dual(Code.Code, {
+          live: () => Code.layer,
+          local: () => Code.localLayer,
+        }),
+      ),
+    ),
+    Layer.provide(
+      ConvexClient.layer(options).pipe(Layer.provide(FetchHttpClient.layer)),
+    ),
+    Layer.provide(CommandRunner.layer),
+    Layer.provide(PushLock.layer()),
+  );

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as Convex from "./Convex";
+export * as Confect from "./Confect";

package/src/internal/CodeDeployment.ts

@@ -0,0 +1,81 @@
+import type { ProviderMode } from "alchemy/ProviderMode";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import type { CodeProps } from "../Code";
+import { CommandRunner, type PushTarget } from "./CommandRunner";
+import * as Loopback from "./Loopback";
+import { PushLock } from "./PushLock";
+
+export class InvalidDeploymentTarget extends Schema.TaggedError<InvalidDeploymentTarget>()(
+  "InvalidDeploymentTarget",
+  { reason: Schema.Literals(["deployment", "deployKey"]) },
+) {}
+
+const deploymentName = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+const cloudTarget = (
+  props: CodeProps,
+): Result.Result<PushTarget, InvalidDeploymentTarget> => {
+  const { name, url } = props.deployment;
+  if (
+    !deploymentName.test(name) ||
+    !new RegExp(
+      `^https://${name}(?:\\.[a-z]{2}-[a-z]+-[0-9]+)?\\.convex\\.cloud$`,
+    ).test(url)
+  )
+    return Result.fail(new InvalidDeploymentTarget({ reason: "deployment" }));
+  const key =
+    /^(?:dev|prod|preview|custom):([a-z0-9]+(?:-[a-z0-9]+)*)\|[a-zA-Z0-9+/=_-]+$/.exec(
+      Redacted.value(props.deployKey),
+    );
+  if (!key || key[1] !== name)
+    return Result.fail(new InvalidDeploymentTarget({ reason: "deployKey" }));
+  return Result.succeed({
+    _tag: "Cloud",
+    deploymentName: name,
+    deployKey: props.deployKey,
+  });
+};
+
+const localTarget = (
+  props: CodeProps,
+): Result.Result<PushTarget, InvalidDeploymentTarget> => {
+  const { name, url } = props.deployment;
+  if (!deploymentName.test(name) || !Loopback.isOrigin(url))
+    return Result.fail(new InvalidDeploymentTarget({ reason: "deployment" }));
+  const key = /^([a-z0-9]+(?:-[a-z0-9]+)*)\|[0-9a-f]+$/.exec(
+    Redacted.value(props.deployKey),
+  );
+  if (!key || key[1] !== name)
+    return Result.fail(new InvalidDeploymentTarget({ reason: "deployKey" }));
+  return Result.succeed({
+    _tag: "SelfHosted",
+    deploymentName: name,
+    url,
+    adminKey: props.deployKey,
+  });
+};
+
+const targets = { live: cloudTarget, local: localTarget } satisfies Record<
+  ProviderMode,
+  (props: CodeProps) => Result.Result<PushTarget, InvalidDeploymentTarget>
+>;
+
+export const deploy = Effect.fn("Code.deploy")(function* (
+  props: CodeProps,
+  mode: ProviderMode = "live",
+) {
+  const target = yield* Effect.fromResult(targets[mode](props));
+  const runner = yield* CommandRunner;
+  const lock = yield* PushLock;
+  yield* lock.withLock(
+    target.deploymentName,
+    Effect.gen(function* () {
+      if (props.prepare) yield* runner.prepare(props.prepare, props.cwd);
+      yield* runner.deploy(target, props.cwd);
+    }),
+  );
+  return { name: props.deployment.name, url: props.deployment.url };
+});