@checkstack/automation-backend 0.2.0 → 0.3.0

package/src/gitops-kinds.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, mock } from "bun:test";
+import {
+  deleteAutomationEntity,
+  GITOPS_MANAGED_BY,
+  reconcileAutomation,
+} from "./gitops-kinds";
+
+const logger = { info: () => {} };
+
+const spec = {
+  name: "Notify on incident",
+  triggers: [{ event: "incident.created" }],
+  conditions: [],
+  actions: [{ action: "automation.log", config: { message: "hi" } }],
+  mode: "single",
+  max_runs: 10,
+};
+
+function insertMockDb(newId: string) {
+  const values = mock((_input: Record<string, unknown>) => ({
+    returning: mock(() => Promise.resolve([{ id: newId }])),
+  }));
+  return { db: { insert: mock(() => ({ values })) }, values };
+}
+
+function updateMockDb(rows: Array<{ id: string }>) {
+  const set = mock((_input: Record<string, unknown>) => ({
+    where: mock(() => ({ returning: mock(() => Promise.resolve(rows)) })),
+  }));
+  return { db: { update: mock(() => ({ set })) }, set };
+}
+
+describe("reconcileAutomation", () => {
+  it("creates a new automation on first reconcile, tagging managed_by=gitops", async () => {
+    const { db, values } = insertMockDb("auto-1");
+    const result = await reconcileAutomation(db as never, {
+      entity: { metadata: { name: "notify" }, spec: spec as never },
+      logger,
+    });
+    expect(result.entityId).toBe("auto-1");
+    const inserted = values.mock.calls[0]?.[0] as unknown as {
+      managedBy: string;
+      name: string;
+      status: string;
+    };
+    expect(inserted.managedBy).toBe(GITOPS_MANAGED_BY);
+    expect(inserted.status).toBe("enabled");
+  });
+
+  it("uses metadata.title for the name when present", async () => {
+    const { db, values } = insertMockDb("auto-1");
+    await reconcileAutomation(db as never, {
+      entity: {
+        metadata: { name: "notify", title: "Notify on incident" },
+        spec: spec as never,
+      },
+      logger,
+    });
+    const inserted = values.mock.calls[0]?.[0] as unknown as { name: string };
+    expect(inserted.name).toBe("Notify on incident");
+  });
+
+  it("updates in place when an existingEntityId is given", async () => {
+    const { db, set } = updateMockDb([{ id: "auto-1" }]);
+    const result = await reconcileAutomation(db as never, {
+      entity: { metadata: { name: "notify" }, spec: spec as never },
+      existingEntityId: "auto-1",
+      logger,
+    });
+    expect(result.entityId).toBe("auto-1");
+    const updated = set.mock.calls[0]?.[0] as unknown as { managedBy: string };
+    expect(updated.managedBy).toBe(GITOPS_MANAGED_BY);
+  });
+
+  it("falls back to insert when the existing row has vanished", async () => {
+    // update returns no rows → re-create
+    const set = mock(() => ({
+      where: mock(() => ({ returning: mock(() => Promise.resolve([])) })),
+    }));
+    const values = mock(() => ({
+      returning: mock(() => Promise.resolve([{ id: "auto-new" }])),
+    }));
+    const db = {
+      update: mock(() => ({ set })),
+      insert: mock(() => ({ values })),
+    };
+    const result = await reconcileAutomation(db as never, {
+      entity: { metadata: { name: "notify" }, spec: spec as never },
+      existingEntityId: "gone",
+      logger,
+    });
+    expect(result.entityId).toBe("auto-new");
+    expect(db.insert).toHaveBeenCalledTimes(1);
+  });
+
+  it("carries the group from metadata.labels.group on insert", async () => {
+    const { db, values } = insertMockDb("auto-1");
+    await reconcileAutomation(db as never, {
+      entity: {
+        metadata: { name: "notify", labels: { group: "Alerting" } },
+        spec: spec as never,
+      },
+      logger,
+    });
+    const inserted = values.mock.calls[0]?.[0] as unknown as { group: string };
+    expect(inserted.group).toBe("Alerting");
+  });
+
+  it("carries the group from metadata.labels.group on update", async () => {
+    const { db, set } = updateMockDb([{ id: "auto-1" }]);
+    await reconcileAutomation(db as never, {
+      entity: {
+        metadata: { name: "notify", labels: { group: "Networking" } },
+        spec: spec as never,
+      },
+      existingEntityId: "auto-1",
+      logger,
+    });
+    const updated = set.mock.calls[0]?.[0] as unknown as { group: string };
+    expect(updated.group).toBe("Networking");
+  });
+
+  it("sets group to null when the label is absent or blank", async () => {
+    const { db, values } = insertMockDb("auto-1");
+    await reconcileAutomation(db as never, {
+      entity: {
+        metadata: { name: "notify", labels: { group: "  " } },
+        spec: spec as never,
+      },
+      logger,
+    });
+    const inserted = values.mock.calls[0]?.[0] as unknown as {
+      group: string | null;
+    };
+    expect(inserted.group).toBeNull();
+  });
+
+  it("fills schema defaults (mode / concurrency_scope) from the spec", async () => {
+    const { db, values } = insertMockDb("auto-1");
+    await reconcileAutomation(db as never, {
+      // spec omits mode/concurrency_scope → defaults applied on parse.
+      entity: {
+        metadata: { name: "notify" },
+        spec: {
+          name: "x",
+          triggers: [{ event: "incident.created" }],
+          actions: [],
+        } as never,
+      },
+      logger,
+    });
+    const inserted = values.mock.calls[0]?.[0] as unknown as {
+      definition: { mode: string; concurrency_scope: string };
+    };
+    expect(inserted.definition.mode).toBe("single");
+    expect(inserted.definition.concurrency_scope).toBe("automation");
+  });
+});
+
+describe("deleteAutomationEntity", () => {
+  it("deletes the row (guarded to managed_by=gitops)", async () => {
+    const where = mock(() => Promise.resolve());
+    const db = { delete: mock(() => ({ where })) };
+    await deleteAutomationEntity(db as never, { entityId: "auto-1", logger });
+    expect(db.delete).toHaveBeenCalledTimes(1);
+    expect(where).toHaveBeenCalledTimes(1);
+  });
+
+  it("no-ops when no entityId is given", async () => {
+    const db = { delete: mock(() => ({ where: mock() })) };
+    await deleteAutomationEntity(db as never, { logger });
+    expect(db.delete).not.toHaveBeenCalled();
+  });
+});

package/src/gitops-kinds.ts

@@ -0,0 +1,137 @@
+/**
+ * GitOps `Automation` entity kind (Phase 21).
+ *
+ * Registers `Automation` with the GitOps entity-kind registry so an
+ * automation's full `AutomationDefinitionSchema` can be declared in YAML
+ * and reconciled into the `automations` table. Mirrors the System kind
+ * registration in `catalog-backend`.
+ *
+ * Reconcile is upsert-by-name (identity tracked by the GitOps engine via
+ * the returned `entityId` + provenance): first sight creates, later
+ * sights update in place. Reconciled rows carry `managed_by = "gitops"`
+ * so the UI can show them as declaratively managed and lock the editor
+ * (the provenance lock is what actually gates the UI; `managed_by` is the
+ * origin marker).
+ */
+import { and, eq } from "drizzle-orm";
+import type { SafeDatabase } from "@checkstack/backend-api";
+import {
+  AutomationDefinitionSchema,
+  type AutomationDefinition,
+} from "@checkstack/automation-common";
+
+import { automations } from "./schema";
+import * as schema from "./schema";
+
+type Db = SafeDatabase<typeof schema>;
+
+/** Origin marker stamped on GitOps-managed automations. */
+export const GITOPS_MANAGED_BY = "gitops";
+
+/**
+ * Metadata label key carrying the automation's grouping label. GitOps has no
+ * dedicated `group` metadata field, so a declaratively-managed automation
+ * expresses its group via `metadata.labels.group`. Mirrors how `name` /
+ * `description` come from `metadata`, keeping `group` out of the spec
+ * (definition) tier — consistent with it being a row column, not part of the
+ * definition YAML.
+ */
+export const GITOPS_GROUP_LABEL = "group";
+
+interface ReconcileArgs {
+  entity: {
+    metadata: {
+      name: string;
+      title?: string;
+      description?: string;
+      labels?: Record<string, string>;
+    };
+    spec: AutomationDefinition;
+  };
+  existingEntityId?: string;
+  logger: { info: (msg: string) => void };
+}
+
+/**
+ * Resolve the grouping label from GitOps metadata. Trims and treats a
+ * blank/whitespace value as "no group".
+ */
+function resolveGroup(labels?: Record<string, string>): string | null {
+  const raw = labels?.[GITOPS_GROUP_LABEL]?.trim();
+  return raw && raw.length > 0 ? raw : null;
+}
+
+/**
+ * Reconcile an `Automation` descriptor into the `automations` table.
+ * Pure of the GitOps registry shape so it can be unit-tested directly.
+ * Returns the persisted automation id.
+ */
+export async function reconcileAutomation(
+  db: Db,
+  args: ReconcileArgs,
+): Promise<{ entityId: string }> {
+  const { entity, existingEntityId, logger } = args;
+  // The spec IS the automation definition; re-validate defensively (the
+  // GitOps engine already validated against specSchema, but parsing here
+  // fills defaults like `mode` / `concurrency_scope`).
+  const definition = AutomationDefinitionSchema.parse(entity.spec);
+  const name = entity.metadata.title ?? entity.metadata.name;
+  const description = entity.metadata.description ?? definition.description;
+  const group = resolveGroup(entity.metadata.labels);
+
+  if (existingEntityId) {
+    const [row] = await db
+      .update(automations)
+      .set({
+        name,
+        description: description ?? null,
+        group,
+        definition: definition as unknown as Record<string, unknown>,
+        managedBy: GITOPS_MANAGED_BY,
+        updatedAt: new Date(),
+      })
+      .where(eq(automations.id, existingEntityId))
+      .returning({ id: automations.id });
+    if (row) {
+      logger.info(`GitOps: updated Automation "${name}" (id: ${row.id})`);
+      return { entityId: row.id };
+    }
+    // Row vanished (manual delete between syncs) - fall through to insert.
+  }
+
+  const [created] = await db
+    .insert(automations)
+    .values({
+      name,
+      description: description ?? null,
+      group,
+      status: "enabled",
+      definition: definition as unknown as Record<string, unknown>,
+      managedBy: GITOPS_MANAGED_BY,
+    })
+    .returning({ id: automations.id });
+  if (!created) throw new Error("reconcileAutomation: insert returned no rows");
+  logger.info(`GitOps: created Automation "${name}" (id: ${created.id})`);
+  return { entityId: created.id };
+}
+
+/**
+ * Delete a GitOps-managed automation. Idempotent + guarded: only deletes
+ * rows still tagged `managed_by = "gitops"` so a row an operator took
+ * over manually (clearing the marker) is left alone.
+ */
+export async function deleteAutomationEntity(
+  db: Db,
+  args: { entityId?: string; logger: { info: (msg: string) => void } },
+): Promise<void> {
+  if (!args.entityId) return;
+  await db
+    .delete(automations)
+    .where(
+      and(
+        eq(automations.id, args.entityId),
+        eq(automations.managedBy, GITOPS_MANAGED_BY),
+      ),
+    );
+  args.logger.info(`GitOps: deleted Automation (id: ${args.entityId})`);
+}