@checkstack/catalog-backend 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @checkstack/catalog-backend
 
+## 0.4.0
+
+### Minor Changes
+
+- b01078f: Added GitOps System kind extension for managing system group associations
+
 ## 0.3.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/catalog-backend",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {

package/src/catalog-gitops-kinds.test.ts

@@ -85,6 +85,11 @@ function createMockEntityService() {
       const idx = groups.findIndex((g) => g.id === id);
       if (idx >= 0) groups.splice(idx, 1);
     }),
+    addSystemToGroup: mock(async (props: { groupId: string; systemId: string }) => {}),
+    removeSystemFromGroup: mock(async (props: { groupId: string; systemId: string }) => {}),
+    getGroupsForSystem: mock(async (systemId: string) => {
+      return [] as { groupId: string, systemId: string }[];
+    }),
   };
 }
 
@@ -271,6 +276,74 @@ describe("Catalog GitOps Kind: System", () => {
   });
 });
 
+describe("Catalog GitOps Kind Extension: System -> groups", () => {
+  let mockService: ReturnType<typeof createMockEntityService>;
+
+  beforeEach(() => {
+    mockService = createMockEntityService();
+  });
+
+  it("associates system with groups and removes stale ones", async () => {
+    // We mock getGroupsForSystem to return one existing association
+    mockService.getGroupsForSystem.mockResolvedValueOnce([
+      { groupId: "grp-stale", systemId: "sys-1" }
+    ]);
+
+    const mockExtContext: ReconcileContext = {
+      ...mockContext,
+      resolveEntityRef: mock(async ({ entityName }) => {
+        if (entityName === "new-group") return "grp-new";
+        return undefined;
+      }),
+    };
+
+    // Simulate the inline reconcile logic from index.ts
+    const reconcileExt = async ({ extensionSpec, entityId, context }: any) => {
+      if (!extensionSpec || extensionSpec.length === 0) return;
+
+      const desiredGroupIds = new Set<string>();
+
+      for (const entry of extensionSpec) {
+        const groupId = await context.resolveEntityRef({
+          kind: entry.kind,
+          entityName: entry.name,
+        });
+        if (groupId) {
+          desiredGroupIds.add(groupId);
+          await mockService.addSystemToGroup({ groupId, systemId: entityId });
+        }
+      }
+
+      const currentAssociations = await mockService.getGroupsForSystem(entityId);
+      for (const existing of currentAssociations) {
+        if (!desiredGroupIds.has(existing.groupId)) {
+          await mockService.removeSystemFromGroup({
+            groupId: existing.groupId,
+            systemId: entityId,
+          });
+        }
+      }
+    };
+
+    await reconcileExt({
+      entity: { metadata: { name: "my-system" } },
+      extensionSpec: [{ kind: "Group", name: "new-group" }],
+      entityId: "sys-1",
+      context: mockExtContext,
+    });
+
+    expect(mockService.addSystemToGroup).toHaveBeenCalledWith({
+      groupId: "grp-new",
+      systemId: "sys-1",
+    });
+
+    expect(mockService.removeSystemFromGroup).toHaveBeenCalledWith({
+      groupId: "grp-stale",
+      systemId: "sys-1",
+    });
+  });
+});
+
 describe("Catalog GitOps Kind: Group", () => {
   let mockService: ReturnType<typeof createMockEntityService>;
 

package/src/index.ts

@@ -18,7 +18,7 @@ import { resolveRoute, type InferClient, extractErrorMessage} from "@checkstack/
 import { registerSearchProvider } from "@checkstack/command-backend";
 import { EntityService } from "./services/entity-service";
 import { entityKindExtensionPoint } from "@checkstack/gitops-backend";
-import { CHECKSTACK_API_VERSION } from "@checkstack/gitops-common";
+import { CHECKSTACK_API_VERSION, entityRefSchema } from "@checkstack/gitops-common";
 import { z } from "zod";
 
 // Database schema is still needed for types in creating the router
@@ -82,6 +82,61 @@ export default createBackendPlugin({
       },
     });
 
+    // Register kind extension: System -> groups
+    kindRegistry.registerKindExtension({
+      apiVersion: CHECKSTACK_API_VERSION,
+      kind: "System",
+      namespace: "groups",
+      specSchema: z.array(entityRefSchema).optional(),
+      reconcile: async ({ entity, extensionSpec, entityId, context }) => {
+        if (!gitopsDb) throw new Error("Catalog database not initialized");
+        if (!extensionSpec || extensionSpec.length === 0) return;
+
+        const entityService = new EntityService(gitopsDb);
+        const systemEntityId = entityId;
+
+        const desiredGroupIds = new Set<string>();
+
+        for (const entry of extensionSpec) {
+          const groupId = await context.resolveEntityRef({
+            kind: entry.kind,
+            entityName: entry.name,
+          });
+
+          if (!groupId) {
+            throw new Error(
+              `Cannot resolve ${entry.kind} ref "${entry.name}" — ensure the entity exists`
+            );
+          }
+
+          desiredGroupIds.add(groupId);
+
+          await entityService.addSystemToGroup({
+            groupId: groupId,
+            systemId: systemEntityId,
+          });
+
+          context.logger.info(
+            `GitOps: associated System "${entity.metadata.name}" with Group "${entry.name}" (${groupId})`
+          );
+        }
+
+        // Remove stale associations not in the spec
+        const currentAssociations = await entityService.getGroupsForSystem(systemEntityId);
+        for (const existing of currentAssociations) {
+          if (!desiredGroupIds.has(existing.groupId)) {
+            await entityService.removeSystemFromGroup({
+              groupId: existing.groupId,
+              systemId: systemEntityId,
+            });
+            context.logger.info(
+              `GitOps: removed stale association ${existing.groupId} from System "${entity.metadata.name}"`
+            );
+          }
+        }
+      },
+    });
+
     // Register kind: Group
     kindRegistry.registerKind({
       apiVersion: CHECKSTACK_API_VERSION,

package/src/services/entity-service.ts

@@ -144,6 +144,15 @@ export class EntityService {
     await this.database.delete(schema.groups).where(eq(schema.groups.id, id));
   }
 
+  async getGroupsForSystem(systemId: string) {
+    const associations = await this.database
+      .select()
+      .from(schema.systemsGroups)
+      .where(eq(schema.systemsGroups.systemId, systemId));
+
+    return associations;
+  }
+
   async addSystemToGroup(props: { groupId: string; systemId: string }) {
     const { groupId, systemId } = props;
     await this.database