@axiom-lattice/pg-stores 5.0.0 → 5.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,8 +25,8 @@
     "@langchain/core": "1.3.2",
     "pg": "^8.16.3",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "12.0.0",
-    "@axiom-lattice/protocols": "7.0.0"
+    "@axiom-lattice/core": "12.0.1",
+    "@axiom-lattice/protocols": "7.0.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/__tests__/PostgreSQLAssistantStore.integration.test.ts

@@ -0,0 +1,225 @@
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+
+import { PostgreSQLAssistantStore } from "../stores/PostgreSQLAssistantStore";
+
+const TEST_DATABASE_URL = process.env.TEST_DATABASE_URL;
+const describeIfDatabase = TEST_DATABASE_URL ? describe : describe.skip;
+
+describeIfDatabase("PostgreSQLAssistantStore integration", () => {
+  let store: PostgreSQLAssistantStore;
+  let pool: Pool;
+  const tenants = new Set<string>();
+
+  beforeAll(async () => {
+    store = new PostgreSQLAssistantStore({
+      poolConfig: TEST_DATABASE_URL!,
+      autoMigrate: true,
+    });
+    await store.initialize();
+    pool = new Pool({ connectionString: TEST_DATABASE_URL });
+  });
+
+  afterEach(async () => {
+    if (tenants.size === 0) {
+      return;
+    }
+    await pool.query("DELETE FROM lattice_assistants WHERE tenant_id = ANY($1::text[])", [
+      [...tenants],
+    ]);
+    tenants.clear();
+  });
+
+  afterAll(async () => {
+    await pool.end();
+    await store.dispose();
+  });
+
+  function tenantId(): string {
+    const id = `assistant-${randomUUID()}`;
+    tenants.add(id);
+    return id;
+  }
+
+  function graphDefinition(label: string) {
+    return {
+      entryPoint: "orchestrator",
+      nodes: [
+        { id: "orchestrator", type: "agent", metadata: { tags: ["a", "b"], nested: { level: 2 } } },
+        { id: "worker", type: "tool", metadata: { disabled: false, note: null } },
+      ],
+      edges: [{ from: "orchestrator", to: "worker", condition: null }],
+      metadata: { label, flags: { beta: true } },
+    };
+  }
+
+  it("creates an assistant and reads it back by id", async () => {
+    const tenant = tenantId();
+    const id = randomUUID();
+
+    const created = await store.createAssistant(tenant, id, {
+      name: "Planner",
+      description: "Plans work",
+      ownerUserId: "user-1",
+      graphDefinition: graphDefinition("v1"),
+    });
+
+    expect(created).toMatchObject({
+      id,
+      tenantId: tenant,
+      name: "Planner",
+      description: "Plans work",
+      ownerUserId: "user-1",
+    });
+    expect(created.graphDefinition).toEqual(graphDefinition("v1"));
+    expect(created.createdAt).toBeInstanceOf(Date);
+    expect(created.updatedAt).toBeInstanceOf(Date);
+
+    const read = await store.getAssistantById(tenant, id);
+    expect(read).toMatchObject({
+      id,
+      tenantId: tenant,
+      name: "Planner",
+      description: "Plans work",
+      ownerUserId: "user-1",
+    });
+    expect(read!.graphDefinition.metadata).toEqual({ label: "v1", flags: { beta: true } });
+  });
+
+  it("lists only the requested tenant's assistants", async () => {
+    const tenantA = tenantId();
+    const tenantB = tenantId();
+    const a1 = randomUUID();
+    const a2 = randomUUID();
+    const b1 = randomUUID();
+    await store.createAssistant(tenantA, a1, { name: "A1", graphDefinition: graphDefinition("a1") });
+    await store.createAssistant(tenantA, a2, { name: "A2", graphDefinition: graphDefinition("a2") });
+    await store.createAssistant(tenantB, b1, { name: "B1", graphDefinition: graphDefinition("b1") });
+
+    const listedA = await store.getAllAssistants(tenantA);
+    expect(listedA.map((a) => a.id).sort()).toEqual([a1, a2].sort());
+    expect(listedA.every((a) => a.tenantId === tenantA)).toBe(true);
+
+    const listedB = await store.getAllAssistants(tenantB);
+    expect(listedB.map((a) => a.id)).toEqual([b1]);
+  });
+
+  it("updates only the provided fields", async () => {
+    const tenant = tenantId();
+    const id = randomUUID();
+    await store.createAssistant(tenant, id, {
+      name: "Before",
+      description: "keep me",
+      graphDefinition: graphDefinition("before"),
+    });
+
+    const updated = await store.updateAssistant(tenant, id, {
+      name: "After",
+      ownerUserId: "user-2",
+      graphDefinition: graphDefinition("after"),
+    });
+
+    expect(updated).toMatchObject({
+      id,
+      name: "After",
+      description: "keep me",
+      ownerUserId: "user-2",
+    });
+    expect(updated!.graphDefinition.metadata).toEqual({ label: "after", flags: { beta: true } });
+  });
+
+  it("returns null / false for an absent assistant id", async () => {
+    const tenant = tenantId();
+    const missing = randomUUID();
+
+    expect(await store.getAssistantById(tenant, missing)).toBeNull();
+    expect(await store.hasAssistant(tenant, missing)).toBe(false);
+    expect(await store.updateAssistant(tenant, missing, { name: "nope" })).toBeNull();
+    expect(await store.deleteAssistant(tenant, missing)).toBe(false);
+  });
+
+  it("deletes an assistant and reports existence", async () => {
+    const tenant = tenantId();
+    const id = randomUUID();
+    await store.createAssistant(tenant, id, { name: "Temp", graphDefinition: graphDefinition("temp") });
+
+    expect(await store.hasAssistant(tenant, id)).toBe(true);
+    expect(await store.deleteAssistant(tenant, id)).toBe(true);
+    expect(await store.hasAssistant(tenant, id)).toBe(false);
+    expect(await store.getAssistantById(tenant, id)).toBeNull();
+  });
+
+  it("maps absent optional description and owner to undefined", async () => {
+    const tenant = tenantId();
+    const id = randomUUID();
+    await store.createAssistant(tenant, id, {
+      name: "Shared",
+      graphDefinition: { nested: { withNull: null }, list: [1, "two", false] },
+    });
+
+    const read = await store.getAssistantById(tenant, id);
+    expect(read).toMatchObject({ id, name: "Shared" });
+    expect(read!.description).toBeUndefined();
+    expect(read!.ownerUserId).toBeUndefined();
+    expect(read!.graphDefinition).toEqual({ nested: { withNull: null }, list: [1, "two", false] });
+  });
+
+  it("finds a personal assistant by owner, scoped to the tenant", async () => {
+    const tenant = tenantId();
+    const otherTenant = tenantId();
+    const personal = randomUUID();
+    const shared = randomUUID();
+    await store.createAssistant(tenant, personal, {
+      name: "Personal",
+      ownerUserId: "user-1",
+      graphDefinition: graphDefinition("personal"),
+    });
+    await store.createAssistant(tenant, shared, {
+      name: "Shared",
+      graphDefinition: graphDefinition("shared"),
+    });
+    await store.createAssistant(otherTenant, randomUUID(), {
+      name: "Other tenant personal",
+      ownerUserId: "user-1",
+      graphDefinition: graphDefinition("other"),
+    });
+
+    const found = await store.getByOwner(tenant, "user-1");
+    expect(found).toMatchObject({ id: personal, tenantId: tenant, ownerUserId: "user-1" });
+
+    expect(await store.getByOwner(tenant, "user-2")).toBeNull();
+    expect(await store.getByOwner(otherTenant, "user-2")).toBeNull();
+  });
+
+  it("keeps the same assistant id independent across tenants", async () => {
+    const tenantA = tenantId();
+    const tenantB = tenantId();
+    const id = randomUUID();
+    await store.createAssistant(tenantA, id, { name: "A", graphDefinition: graphDefinition("a") });
+    await store.createAssistant(tenantB, id, { name: "B", graphDefinition: graphDefinition("b") });
+
+    expect((await store.getAssistantById(tenantA, id))?.name).toBe("A");
+    expect((await store.getAssistantById(tenantB, id))?.name).toBe("B");
+    expect((await store.getAllAssistants(tenantA)).map((a) => a.id)).toEqual([id]);
+
+    expect(await store.deleteAssistant(tenantA, id)).toBe(true);
+    expect(await store.hasAssistant(tenantA, id)).toBe(false);
+    expect(await store.hasAssistant(tenantB, id)).toBe(true);
+  });
+
+  it("upserts when create is called again for the same id and tenant", async () => {
+    const tenant = tenantId();
+    const id = randomUUID();
+    await store.createAssistant(tenant, id, { name: "First", graphDefinition: graphDefinition("first") });
+    const second = await store.createAssistant(tenant, id, {
+      name: "Second",
+      description: "replaced",
+      graphDefinition: graphDefinition("second"),
+    });
+
+    expect(second.name).toBe("Second");
+    const read = await store.getAssistantById(tenant, id);
+    expect(read).toMatchObject({ id, name: "Second", description: "replaced" });
+    expect(await store.getAllAssistants(tenant)).toHaveLength(1);
+  });
+});

package/src/__tests__/PostgreSQLDatabaseConfigStore.integration.test.ts

@@ -0,0 +1,210 @@
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+
+// The @axiom-lattice/core barrel cannot load under jest in this package (ESM-only
+// transitive deps), so mock it with the real encryption module — node:crypto only.
+jest.mock("@axiom-lattice/core", () => ({
+  ...jest.requireActual("../../../core/src/util/encryption"),
+}));
+
+import type { DatabaseConfig } from "@axiom-lattice/protocols";
+import { decrypt } from "@axiom-lattice/core";
+import { PostgreSQLDatabaseConfigStore } from "../stores/PostgreSQLDatabaseConfigStore";
+
+const TEST_DATABASE_URL = process.env.TEST_DATABASE_URL;
+const describeIfDatabase = TEST_DATABASE_URL ? describe : describe.skip;
+
+describeIfDatabase("PostgreSQLDatabaseConfigStore integration", () => {
+  let store: PostgreSQLDatabaseConfigStore;
+  let pool: Pool;
+
+  beforeAll(async () => {
+    store = new PostgreSQLDatabaseConfigStore({
+      poolConfig: TEST_DATABASE_URL!,
+      autoMigrate: true,
+    });
+    await store.initialize();
+    pool = new Pool({ connectionString: TEST_DATABASE_URL });
+  });
+
+  const tenants = new Set<string>();
+
+  afterEach(async () => {
+    if (tenants.size === 0) {
+      return;
+    }
+    await pool.query(
+      "DELETE FROM lattice_database_configs WHERE tenant_id = ANY($1::text[])",
+      [[...tenants]],
+    );
+    tenants.clear();
+  });
+
+  afterAll(async () => {
+    await pool.end();
+    await store.dispose();
+  });
+
+  function tenantId(): string {
+    const id = `db-config-${randomUUID()}`;
+    tenants.add(id);
+    return id;
+  }
+
+  function config(overrides: Partial<DatabaseConfig> = {}): DatabaseConfig {
+    return {
+      type: "postgres",
+      host: "db.example.com",
+      port: 5432,
+      database: "app",
+      user: "app_user",
+      password: "super-secret",
+      ssl: true,
+      ...overrides,
+    };
+  }
+
+  async function createConfig(tenant: string) {
+    const id = randomUUID();
+    const key = `key-${randomUUID()}`;
+    const entry = await store.createConfig(tenant, id, {
+      key,
+      name: "Primary",
+      description: "Primary database",
+      config: config(),
+    });
+    return { id, key, entry };
+  }
+
+  it("creates and reads a config by id and by key", async () => {
+    const tenant = tenantId();
+    const { id, key, entry } = await createConfig(tenant);
+
+    expect(entry).toMatchObject({
+      id,
+      tenantId: tenant,
+      key,
+      name: "Primary",
+      description: "Primary database",
+    });
+    expect(entry.config.database).toBe("app");
+
+    const byId = await store.getConfigById(tenant, id);
+    expect(byId?.id).toBe(id);
+    expect(byId?.config.host).toBe("db.example.com");
+
+    const byKey = await store.getConfigByKey(tenant, key);
+    expect(byKey?.id).toBe(id);
+  });
+
+  it("encrypts the password at rest and decrypts it on read", async () => {
+    const tenant = tenantId();
+    const { id } = await createConfig(tenant);
+
+    const raw = await pool.query<{ config: { password: string } }>(
+      "SELECT config FROM lattice_database_configs WHERE tenant_id = $1 AND id = $2",
+      [tenant, id],
+    );
+
+    expect(raw.rows[0].config.password).not.toBe("super-secret");
+    expect(decrypt(raw.rows[0].config.password)).toBe("super-secret");
+
+    const read = await store.getConfigById(tenant, id);
+    expect(read?.config.password).toBe("super-secret");
+  });
+
+  it("lists a tenant's configs and includes them in the cross-tenant listing", async () => {
+    const tenant = tenantId();
+    const first = await createConfig(tenant);
+    const second = await createConfig(tenant);
+
+    const listed = await store.getAllConfigs(tenant);
+    expect(listed.map((entry) => entry.id).sort()).toEqual([first.id, second.id].sort());
+
+    const all = await store.getAllConfigsWithoutTenant();
+    const ids = all.map((entry) => entry.id);
+    expect(ids).toContain(first.id);
+    expect(ids).toContain(second.id);
+    expect(all.find((entry) => entry.id === first.id)?.config.password).toBe("super-secret");
+  });
+
+  it("updates fields and re-encrypts a new password", async () => {
+    const tenant = tenantId();
+    const { id, key } = await createConfig(tenant);
+
+    const updated = await store.updateConfig(tenant, id, {
+      name: "Renamed",
+      description: "Updated description",
+      config: config({ host: "new.example.com", password: "rotated-secret" }),
+    });
+
+    expect(updated).toMatchObject({
+      id,
+      key,
+      name: "Renamed",
+      description: "Updated description",
+    });
+    expect(updated?.config.host).toBe("new.example.com");
+    expect(updated?.config.password).toBe("rotated-secret");
+
+    const raw = await pool.query<{ config: { password: string } }>(
+      "SELECT config FROM lattice_database_configs WHERE tenant_id = $1 AND id = $2",
+      [tenant, id],
+    );
+    expect(decrypt(raw.rows[0].config.password)).toBe("rotated-secret");
+  });
+
+  it("keeps the encrypted password when a partial update omits config", async () => {
+    const tenant = tenantId();
+    const { id } = await createConfig(tenant);
+
+    const updated = await store.updateConfig(tenant, id, { name: "Only renamed" });
+
+    expect(updated?.name).toBe("Only renamed");
+    expect(updated?.config.password).toBe("super-secret");
+
+    const raw = await pool.query<{ config: { password: string } }>(
+      "SELECT config FROM lattice_database_configs WHERE tenant_id = $1 AND id = $2",
+      [tenant, id],
+    );
+    expect(raw.rows[0].config.password).not.toBe("super-secret");
+    expect(decrypt(raw.rows[0].config.password)).toBe("super-secret");
+  });
+
+  it("reports has and deletes a config", async () => {
+    const tenant = tenantId();
+    const { id } = await createConfig(tenant);
+
+    expect(await store.hasConfig(tenant, id)).toBe(true);
+    expect(await store.deleteConfig(tenant, id)).toBe(true);
+    expect(await store.hasConfig(tenant, id)).toBe(false);
+    expect(await store.getConfigById(tenant, id)).toBeNull();
+    expect(await store.deleteConfig(tenant, id)).toBe(false);
+  });
+
+  it("isolates configs by tenant", async () => {
+    const tenantA = tenantId();
+    const tenantB = tenantId();
+    const key = `shared-${randomUUID()}`;
+    const idA = randomUUID();
+    const idB = randomUUID();
+
+    await store.createConfig(tenantA, idA, { key, config: config() });
+    await store.createConfig(tenantB, idB, { key, config: config() });
+
+    expect(await store.getConfigById(tenantA, idB)).toBeNull();
+    expect((await store.getConfigByKey(tenantA, key))?.id).toBe(idA);
+    expect((await store.getAllConfigs(tenantA)).map((entry) => entry.id)).toEqual([idA]);
+  });
+
+  it("returns absent results for an unknown config", async () => {
+    const tenant = tenantId();
+    const missing = randomUUID();
+
+    expect(await store.getConfigById(tenant, missing)).toBeNull();
+    expect(await store.getConfigByKey(tenant, "missing")).toBeNull();
+    expect(await store.updateConfig(tenant, missing, { name: "x" })).toBeNull();
+    expect(await store.hasConfig(tenant, missing)).toBe(false);
+    expect(await store.deleteConfig(tenant, missing)).toBe(false);
+  });
+});