@samebase/alchemy-convex 0.11.0 → 0.13.0

package/src/store/component/state.ts

@@ -0,0 +1,289 @@
+// The data functions of the alchemyState component: the Alchemy state of
+// every stack and stage, in the tables `resources` and `outputs`. Only the app
+// that mounts the component calls them. The store app (src/store/convex)
+// forwards its internal `state:*` functions here with the same results.
+//
+// A stage holds one row for each resource of its stack, so the reads of one
+// stage collect all rows.
+import { v, type Infer } from "convex/values";
+import type { MutationCtx, QueryCtx } from "./_generated/server.js";
+import { mutation, query } from "./_generated/server.js";
+import { runRecord } from "./runRecord.ts";
+
+const stage = { stack: v.string(), stage: v.string() };
+const resource = { ...stage, fqn: v.string() };
+
+const rowOf = (ctx: QueryCtx, args: { stack: string; stage: string; fqn: string }) =>
+  ctx.db
+    .query("resources")
+    .withIndex("by_fqn", (q) =>
+      q.eq("stack", args.stack).eq("stage", args.stage).eq("fqn", args.fqn),
+    )
+    .unique();
+
+const rowsOf = (ctx: QueryCtx, args: { stack: string; stage: string }) =>
+  ctx.db
+    .query("resources")
+    .withIndex("by_fqn", (q) => q.eq("stack", args.stack).eq("stage", args.stage))
+    .collect();
+
+const outputOf = (ctx: QueryCtx, args: { stack: string; stage: string }) =>
+  ctx.db
+    .query("outputs")
+    .withIndex("by_stage", (q) => q.eq("stack", args.stack).eq("stage", args.stage))
+    .unique();
+
+/**
+ * The run record of a write, or null for a write without one. The app's
+ * functions take it as an optional field; across the component boundary it is
+ * a required field, because the generated component API types an optional
+ * field without `undefined`.
+ */
+const run = v.union(runRecord, v.null());
+
+/** A resource write and its current run become visible in one transaction. */
+const writeCurrentRun = async (
+  ctx: MutationCtx,
+  args: { stack: string; stage: string; run: Infer<typeof run> },
+) => {
+  const output = await outputOf(ctx, args);
+  // A write without a run record clears the record of the previous run.
+  if (output !== null)
+    await ctx.db.patch("outputs", output._id, { currentRun: args.run ?? undefined });
+  else if (args.run !== null)
+    await ctx.db.insert("outputs", { stack: args.stack, stage: args.stage, currentRun: args.run });
+};
+
+/** The sorted union of two lists of names. */
+const union = (a: readonly string[], b: readonly string[]) => [...new Set([...a, ...b])].sort();
+
+/**
+ * The distinct names of one table in index order, with one index read for
+ * each name: `first(after)` is the first row whose name is above `after`.
+ */
+const distinct = async (first: (after: string | undefined) => Promise<string | null>) => {
+  const names: string[] = [];
+  for (;;) {
+    const next = await first(names.at(-1));
+    if (next === null) return names;
+    names.push(next);
+  }
+};
+
+/** Stacks with at least one resource or one output, sorted. */
+export const stacks = query({
+  args: {},
+  returns: v.array(v.string()),
+  handler: async (ctx) =>
+    union(
+      await distinct(
+        async (after) =>
+          (
+            await ctx.db
+              .query("resources")
+              .withIndex("by_fqn", (q) => (after === undefined ? q : q.gt("stack", after)))
+              .first()
+          )?.stack ?? null,
+      ),
+      await distinct(
+        async (after) =>
+          (
+            await ctx.db
+              .query("outputs")
+              .withIndex("by_stage", (q) => (after === undefined ? q : q.gt("stack", after)))
+              .first()
+          )?.stack ?? null,
+      ),
+    ),
+});
+
+/** Stages of a stack with at least one resource or one output, sorted. */
+export const stages = query({
+  args: { stack: v.string() },
+  returns: v.array(v.string()),
+  handler: async (ctx, args) =>
+    union(
+      await distinct(
+        async (after) =>
+          (
+            await ctx.db
+              .query("resources")
+              .withIndex("by_fqn", (q) =>
+                after === undefined
+                  ? q.eq("stack", args.stack)
+                  : q.eq("stack", args.stack).gt("stage", after),
+              )
+              .first()
+          )?.stage ?? null,
+      ),
+      await distinct(
+        async (after) =>
+          (
+            await ctx.db
+              .query("outputs")
+              .withIndex("by_stage", (q) =>
+                after === undefined
+                  ? q.eq("stack", args.stack)
+                  : q.eq("stack", args.stack).gt("stage", after),
+              )
+              .first()
+          )?.stage ?? null,
+      ),
+    ),
+});
+
+export const list = query({
+  args: stage,
+  returns: v.array(v.string()),
+  handler: async (ctx, args) => (await rowsOf(ctx, args)).map((row) => row.fqn),
+});
+
+export const get = query({
+  args: resource,
+  returns: v.union(v.string(), v.null()),
+  handler: async (ctx, args) => (await rowOf(ctx, args))?.value ?? null,
+});
+
+/** Resources whose state has `status: "replaced"`. */
+export const replaced = query({
+  args: stage,
+  returns: v.array(v.string()),
+  handler: async (ctx, args) =>
+    (await rowsOf(ctx, args))
+      .map((row) => row.value)
+      .filter((value) => {
+        const parsed: unknown = JSON.parse(value);
+        return (
+          typeof parsed === "object" &&
+          parsed !== null &&
+          "status" in parsed &&
+          parsed.status === "replaced"
+        );
+      }),
+});
+
+export const set = mutation({
+  args: { ...resource, value: v.string(), run },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const row = await rowOf(ctx, args);
+    if (row === null)
+      await ctx.db.insert("resources", {
+        stack: args.stack,
+        stage: args.stage,
+        fqn: args.fqn,
+        value: args.value,
+      });
+    else await ctx.db.patch("resources", row._id, { value: args.value });
+    await writeCurrentRun(ctx, args);
+    return null;
+  },
+});
+
+export const remove = mutation({
+  args: { ...resource, run },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const row = await rowOf(ctx, args);
+    if (row !== null) await ctx.db.delete("resources", row._id);
+    await writeCurrentRun(ctx, args);
+    return null;
+  },
+});
+
+/** Deletes the resources and outputs of one stage, or of every stage of the stack (`stage: null`). */
+export const removeStack = mutation({
+  args: { stack: v.string(), stage: v.union(v.string(), v.null()) },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const { stack } = args;
+    const resources = await ctx.db
+      .query("resources")
+      .withIndex("by_fqn", (q) =>
+        args.stage === null ? q.eq("stack", stack) : q.eq("stack", stack).eq("stage", args.stage),
+      )
+      .collect();
+    const outputs = await ctx.db
+      .query("outputs")
+      .withIndex("by_stage", (q) =>
+        args.stage === null ? q.eq("stack", stack) : q.eq("stack", stack).eq("stage", args.stage),
+      )
+      .collect();
+    for (const row of resources) await ctx.db.delete("resources", row._id);
+    for (const row of outputs) await ctx.db.delete("outputs", row._id);
+    return null;
+  },
+});
+
+export const getOutput = query({
+  args: stage,
+  returns: v.union(v.string(), v.null()),
+  handler: async (ctx, args) => (await outputOf(ctx, args))?.value ?? null,
+});
+
+export const setOutput = mutation({
+  args: { ...stage, value: v.string(), run },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const row = await outputOf(ctx, args);
+    if (row === null)
+      await ctx.db.insert("outputs", { stack: args.stack, stage: args.stage, value: args.value });
+    else await ctx.db.patch("outputs", row._id, { value: args.value });
+    await writeCurrentRun(ctx, args);
+    return null;
+  },
+});
+
+/** The reply of {@link readStack}. */
+export const stackReply = v.object({
+  stages: v.array(
+    v.object({
+      stage: v.string(),
+      resources: v.array(v.object({ fqn: v.string(), value: v.string() })),
+      output: v.union(v.string(), v.null()),
+      record: v.union(runRecord, v.null()),
+    }),
+  ),
+});
+
+/**
+ * One call for a reader: every stage of a stack in name order, each with its
+ * resources in fqn order and its output, as the JSON texts that the rows
+ * hold. A stage with an output and no resource is listed with an empty
+ * resource list; a stage with resources and no output with `output: null`.
+ * One function reads at most 16 MiB (Convex limit): a stack whose rows go
+ * beyond that fails here and is read with `stages`, `list`, `get`, and
+ * `getOutput` instead.
+ */
+export const readStack = query({
+  args: { stack: v.string() },
+  returns: stackReply,
+  handler: async (ctx, args) => {
+    // Both indexes order by stack, then stage, then (for resources) fqn.
+    const resources = await ctx.db
+      .query("resources")
+      .withIndex("by_fqn", (q) => q.eq("stack", args.stack))
+      .collect();
+    const outputs = await ctx.db
+      .query("outputs")
+      .withIndex("by_stage", (q) => q.eq("stack", args.stack))
+      .collect();
+    const stages = union(
+      [...new Set(resources.map((row) => row.stage))],
+      [...new Set(outputs.map((row) => row.stage))],
+    );
+    return {
+      stages: stages.map((stage) => {
+        const output = outputs.find((row) => row.stage === stage);
+        return {
+          stage,
+          resources: resources
+            .filter((row) => row.stage === stage)
+            .map((row) => ({ fqn: row.fqn, value: row.value })),
+          output: output?.value ?? null,
+          record: output?.currentRun ?? null,
+        };
+      }),
+    };
+  },
+});

package/src/store/convex/_generated/api.d.ts

@@ -9,7 +9,6 @@
  */
 
 import type * as reader from "../reader.js";
-import type * as runRecord from "../runRecord.js";
 import type * as state from "../state.js";
 import type * as version from "../version.js";
 
@@ -21,7 +20,6 @@ import type {
 
 declare const fullApi: ApiFromModules<{
   reader: typeof reader;
-  runRecord: typeof runRecord;
   state: typeof state;
   version: typeof version;
 }>;
@@ -52,4 +50,6 @@ export declare const internal: FilterApi<
   FunctionReference<any, "internal">
 >;
 
-export declare const components: {};
+export declare const components: {
+  alchemyState: import("../../component/_generated/component.js").ComponentApi<"alchemyState">;
+};

package/src/store/convex/_generated/dataModel.d.ts

@@ -8,29 +8,29 @@
  * @module
  */
 
-import type {
-  DataModelFromSchemaDefinition,
-  DocumentByName,
-  TableNamesInDataModel,
-  SystemTableNames,
-} from "convex/server";
+import { AnyDataModel } from "convex/server";
 import type { GenericId } from "convex/values";
-import schema from "../schema.js";
+
+/**
+ * No `schema.ts` file found!
+ *
+ * This generated code has permissive types like `Doc = any` because
+ * Convex doesn't know your schema. If you'd like more type safety, see
+ * https://docs.convex.dev/using/schemas for instructions on how to add a
+ * schema file.
+ *
+ * After you change a schema, rerun codegen with `npx convex dev`.
+ */
 
 /**
  * The names of all of your Convex tables.
  */
-export type TableNames = TableNamesInDataModel<DataModel>;
+export type TableNames = string;
 
 /**
  * The type of a document stored in Convex.
- *
- * @typeParam TableName - A string literal type of the table name (like "users").
  */
-export type Doc<TableName extends TableNames> = DocumentByName<
-  DataModel,
-  TableName
->;
+export type Doc = any;
 
 /**
  * An identifier for a document in Convex.
@@ -42,10 +42,8 @@ export type Doc<TableName extends TableNames> = DocumentByName<
  *
  * IDs are just strings at runtime, but this type can be used to distinguish them from other
  * strings when type checking.
- *
- * @typeParam TableName - A string literal type of the table name (like "users").
  */
-export type Id<TableName extends TableNames | SystemTableNames> =
+export type Id<TableName extends TableNames = TableNames> =
   GenericId<TableName>;
 
 /**
@@ -57,4 +55,4 @@ export type Id<TableName extends TableNames | SystemTableNames> =
  * This type is used to parameterize methods like `queryGeneric` and
  * `mutationGeneric` to make them type-safe.
  */
-export type DataModel = DataModelFromSchemaDefinition<typeof schema>;
+export type DataModel = AnyDataModel;

package/src/store/convex/convex.config.ts

@@ -0,0 +1,7 @@
+import { defineApp } from "convex/server";
+import alchemyState from "../component/convex.config.ts";
+
+const app = defineApp();
+app.use(alchemyState);
+
+export default app;

package/src/store/convex/reader.ts

@@ -1,6 +1,10 @@
-import { v, type Infer } from "convex/values";
+// Authenticated reads stay in the app: `authorize` signs and `repository`
+// verifies with `ctx.auth`, which a component does not have. The rows and the
+// redaction are in the alchemyState component.
+import { v } from "convex/values";
+import { repositoryReply } from "../component/reader.ts";
+import { components } from "./_generated/api.js";
 import { env, internalMutation, query } from "./_generated/server.js";
-import { runRecord, validate } from "./runRecord.ts";
 
 const repositoryName = /^[^/]+\/[^/]+$/;
 
@@ -26,30 +30,10 @@ export const authorize = internalMutation({
   },
 });
 
-const stage = v.object({
-  name: v.string(),
-  record: runRecord,
-  deployedHeadCommit: v.union(v.string(), v.null()),
-  resources: v.array(v.object({ fqn: v.string(), value: v.string() })),
-  output: v.string(),
-});
-
-/** Alchemy encodes a secret as an object with __redacted__; discard that whole object's contents. */
-function withoutSecrets(text: string): unknown {
-  return JSON.parse(text, (_key, value: unknown) =>
-    typeof value === "object" && value !== null && "__redacted__" in value
-      ? { __redacted__: null }
-      : value,
-  );
-}
-
 /** A native subscription reads only the repository named in its verified capability. */
 export const repository = query({
   args: {},
-  returns: v.object({
-    store: v.literal("found"),
-    stacks: v.array(v.object({ name: v.string(), stages: v.array(stage) })),
-  }),
+  returns: repositoryReply,
   handler: async (ctx) => {
     const identity = await ctx.auth.getUserIdentity();
     if (
@@ -60,72 +44,8 @@ export const repository = query({
     ) {
       throw new Error("Alchemy repository read access is required.");
     }
-    const name = identity.repository;
-    // The exact name and its slash-prefixed children exclude names such as owner/app-other.
-    // All four reads share the query transaction, including writes made while provisioning.
-    const [rootResources, childResources, rootOutputs, childOutputs] = await Promise.all([
-      ctx.db
-        .query("resources")
-        .withIndex("by_fqn", (q) => q.eq("stack", name))
-        .collect(),
-      ctx.db
-        .query("resources")
-        .withIndex("by_fqn", (q) => q.gte("stack", `${name}/`).lt("stack", `${name}0`))
-        .collect(),
-      ctx.db
-        .query("outputs")
-        .withIndex("by_stage", (q) => q.eq("stack", name))
-        .collect(),
-      ctx.db
-        .query("outputs")
-        .withIndex("by_stage", (q) => q.gte("stack", `${name}/`).lt("stack", `${name}0`))
-        .collect(),
-    ]);
-    const stacks = new Map<string, Map<string, Infer<typeof stage>>>();
-    for (const row of [...rootOutputs, ...childOutputs]) {
-      const record = row.currentRun;
-      if (record === undefined || record.repository !== name) continue;
-      // The output keeps the record of the last completed deploy under `samebase.run`.
-      let output = row.value === undefined ? null : withoutSecrets(row.value);
-      let deployed: unknown = null;
-      if (typeof output === "object" && output !== null && "samebase.run" in output) {
-        ({ "samebase.run": deployed, ...output } = output);
-      }
-      let stages = stacks.get(row.stack);
-      if (stages === undefined) {
-        stages = new Map();
-        stacks.set(row.stack, stages);
-      }
-      stages.set(row.stage, {
-        name: row.stage,
-        record,
-        deployedHeadCommit:
-          validate(runRecord, deployed) && deployed.repository === name
-            ? deployed.headCommit
-            : null,
-        resources: [],
-        output: JSON.stringify(output),
-      });
-    }
-    for (const row of [...rootResources, ...childResources]) {
-      stacks
-        .get(row.stack)
-        ?.get(row.stage)
-        ?.resources.push({
-          fqn: row.fqn,
-          value: JSON.stringify(withoutSecrets(row.value)),
-        });
-    }
-    return {
-      store: "found" as const,
-      stacks: [...stacks]
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-        .map(([name, stages]) => ({
-          name,
-          stages: [...stages.values()].sort((a, b) =>
-            a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
-          ),
-        })),
-    };
+    return await ctx.runQuery(components.alchemyState.reader.repository, {
+      repository: identity.repository,
+    });
   },
 });