@checkstack/catalog-backend 1.3.1 → 1.4.0

package/src/services/environment-membership.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "bun:test";
+import { diffSystemEnvironments } from "./environment-membership";
+
+describe("diffSystemEnvironments", () => {
+  it("adds desired ids that are not currently linked", () => {
+    const diff = diffSystemEnvironments({
+      current: ["a"],
+      desired: ["a", "b", "c"],
+    });
+    expect(diff.toAdd.sort()).toEqual(["b", "c"]);
+    expect(diff.toRemove).toEqual([]);
+  });
+
+  it("removes current ids no longer desired", () => {
+    const diff = diffSystemEnvironments({
+      current: ["a", "b", "c"],
+      desired: ["a"],
+    });
+    expect(diff.toAdd).toEqual([]);
+    expect(diff.toRemove.sort()).toEqual(["b", "c"]);
+  });
+
+  it("computes add and remove together", () => {
+    const diff = diffSystemEnvironments({
+      current: ["a", "b"],
+      desired: ["b", "c"],
+    });
+    expect(diff.toAdd).toEqual(["c"]);
+    expect(diff.toRemove).toEqual(["a"]);
+  });
+
+  it("is a no-op when the sets match (order-independent)", () => {
+    const diff = diffSystemEnvironments({
+      current: ["a", "b"],
+      desired: ["b", "a"],
+    });
+    expect(diff.toAdd).toEqual([]);
+    expect(diff.toRemove).toEqual([]);
+  });
+
+  it("clears all membership when desired is empty", () => {
+    const diff = diffSystemEnvironments({
+      current: ["a", "b"],
+      desired: [],
+    });
+    expect(diff.toAdd).toEqual([]);
+    expect(diff.toRemove.sort()).toEqual(["a", "b"]);
+  });
+
+  it("adds all when current is empty", () => {
+    const diff = diffSystemEnvironments({
+      current: [],
+      desired: ["a", "b"],
+    });
+    expect(diff.toAdd.sort()).toEqual(["a", "b"]);
+    expect(diff.toRemove).toEqual([]);
+  });
+
+  it("de-duplicates the desired set", () => {
+    const diff = diffSystemEnvironments({
+      current: [],
+      desired: ["a", "a", "b"],
+    });
+    expect(diff.toAdd.sort()).toEqual(["a", "b"]);
+  });
+});

package/src/services/environment-membership.ts

@@ -0,0 +1,40 @@
+/**
+ * Pure desired-set membership diff for systems <-> environments.
+ *
+ * Both the `setSystemEnvironments` RPC and the GitOps
+ * `System -> environments` reconcile compute the same add/prune diff
+ * against current membership. Keeping it pure (no DB) makes it
+ * straightforward to unit-test without a database harness.
+ */
+
+export interface MembershipDiff {
+  /** Environment ids to associate that are not currently linked. */
+  toAdd: string[];
+  /** Currently-linked environment ids no longer in the desired set. */
+  toRemove: string[];
+}
+
+/**
+ * Diff a desired environment-id set against the current set.
+ * Order-independent; de-duplicates the desired set.
+ */
+export function diffSystemEnvironments(props: {
+  current: ReadonlyArray<string>;
+  desired: ReadonlyArray<string>;
+}): MembershipDiff {
+  const { current, desired } = props;
+  const currentSet = new Set(current);
+  const desiredSet = new Set(desired);
+
+  const toAdd: string[] = [];
+  for (const id of desiredSet) {
+    if (!currentSet.has(id)) toAdd.push(id);
+  }
+
+  const toRemove: string[] = [];
+  for (const id of currentSet) {
+    if (!desiredSet.has(id)) toRemove.push(id);
+  }
+
+  return { toAdd, toRemove };
+}

package/src/services/pg-errors.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "bun:test";
+import { isUniqueViolation } from "./pg-errors";
+
+describe("isUniqueViolation", () => {
+  it("detects a direct unique violation (code 23505)", () => {
+    expect(isUniqueViolation({ code: "23505" })).toBe(true);
+  });
+
+  it("detects a wrapped unique violation (on cause)", () => {
+    expect(isUniqueViolation({ cause: { code: "23505" } })).toBe(true);
+  });
+
+  it("ignores other Postgres errors (e.g. FK violation 23503)", () => {
+    expect(isUniqueViolation({ code: "23503" })).toBe(false);
+    expect(isUniqueViolation({ cause: { code: "23503" } })).toBe(false);
+  });
+
+  it("ignores non-pg-shaped errors", () => {
+    expect(isUniqueViolation(null)).toBe(false);
+    expect(isUniqueViolation("23505")).toBe(false);
+    expect(isUniqueViolation(new Error("boom"))).toBe(false);
+    expect(isUniqueViolation({})).toBe(false);
+  });
+});

package/src/services/pg-errors.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+/** Postgres SQLSTATE for a unique-constraint violation. */
+const UNIQUE_VIOLATION = "23505";
+
+// A Postgres driver error carries a SQLSTATE string in `code`. Drizzle may
+// rethrow it wrapped, exposing the original on `cause`, so we check both shapes.
+const pgErrorSchema = z.object({ code: z.string() });
+const wrappedPgErrorSchema = z.object({ cause: pgErrorSchema });
+
+/**
+ * True when `error` is (or wraps) a Postgres unique-constraint violation. Used
+ * to turn a race-induced duplicate insert into a clean `CONFLICT` instead of a
+ * 500, mirroring the pre-insert name check.
+ */
+export function isUniqueViolation(error: unknown): boolean {
+  const direct = pgErrorSchema.safeParse(error);
+  if (direct.success && direct.data.code === UNIQUE_VIOLATION) return true;
+  const wrapped = wrappedPgErrorSchema.safeParse(error);
+  return wrapped.success && wrapped.data.cause.code === UNIQUE_VIOLATION;
+}

package/tsconfig.json

@@ -4,6 +4,12 @@
     "src"
   ],
   "references": [
+    {
+      "path": "../ai-backend"
+    },
+    {
+      "path": "../ai-common"
+    },
     {
       "path": "../auth-backend"
     },