agent-inbox 0.1.3 → 0.1.5

package/test/sqlite-prefix.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import Database from "better-sqlite3";
+import { SqliteStorage } from "../src/storage/sqlite.js";
+import type { Agent, Message } from "../src/types.js";
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    agent_id: "agent-1",
+    scope: "default",
+    status: "active",
+    metadata: {},
+    registered_at: "2025-01-01T00:00:00Z",
+    last_active_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "msg-1",
+    scope: "default",
+    sender_id: "agent-1",
+    recipients: [{ agent_id: "agent-2", kind: "to" }],
+    content: { type: "text", text: "hello" },
+    importance: "normal",
+    metadata: {},
+    created_at: "2025-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("SqliteStorage with prefix", () => {
+  let storage: SqliteStorage;
+
+  beforeEach(() => {
+    storage = new SqliteStorage({ path: ":memory:", prefix: "inbox_" });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it("should create prefixed tables", () => {
+    storage.putAgent(makeAgent());
+    const agent = storage.getAgent("agent-1");
+    expect(agent).toBeDefined();
+    expect(agent!.agent_id).toBe("agent-1");
+  });
+
+  it("should store and retrieve messages with prefix", () => {
+    storage.putMessage(makeMessage());
+    const msg = storage.getMessage("msg-1");
+    expect(msg).toBeDefined();
+    expect(msg!.recipients).toHaveLength(1);
+  });
+
+  it("should support full-text search with prefix", () => {
+    storage.putMessage(
+      makeMessage({ id: "m1", content: { type: "text", text: "fix the auth bug" } })
+    );
+    storage.putMessage(
+      makeMessage({ id: "m2", content: { type: "text", text: "deploy the app" } })
+    );
+    const results = storage.searchMessages("auth");
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe("m1");
+  });
+
+  it("should support conversations and turns with prefix", () => {
+    storage.putConversation({
+      id: "conv-1",
+      scope: "default",
+      status: "active",
+      participants: [{ agent_id: "alice", joined_at: "2025-01-01T00:00:00Z" }],
+      metadata: {},
+      created_at: "2025-01-01T00:00:00Z",
+      updated_at: "2025-01-01T00:00:00Z",
+    });
+    storage.addTurn({
+      id: "turn-1",
+      conversation_id: "conv-1",
+      participant_id: "alice",
+      content_type: "text",
+      content: { type: "text", text: "hello" },
+      created_at: "2025-01-01T00:00:00Z",
+    });
+    const turns = storage.getTurns("conv-1");
+    expect(turns).toHaveLength(1);
+  });
+});
+
+describe("SqliteStorage with external DB handle", () => {
+  let externalDb: Database.Database;
+  let storage: SqliteStorage;
+
+  beforeEach(() => {
+    externalDb = new Database(":memory:");
+    externalDb.pragma("journal_mode = WAL");
+    externalDb.pragma("foreign_keys = ON");
+    storage = new SqliteStorage({ db: externalDb, prefix: "inbox_" });
+  });
+
+  afterEach(() => {
+    storage.close(); // should NOT close the external DB
+    // Verify external DB is still usable
+    expect(() => externalDb.pragma("journal_mode")).not.toThrow();
+    externalDb.close();
+  });
+
+  it("should use the external DB handle", () => {
+    storage.putAgent(makeAgent());
+    const agent = storage.getAgent("agent-1");
+    expect(agent).toBeDefined();
+  });
+
+  it("should create prefixed tables in external DB", () => {
+    storage.putAgent(makeAgent());
+    // Query the external DB directly to verify prefixed table exists
+    const rows = externalDb
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'inbox_%'")
+      .all() as { name: string }[];
+    const tableNames = rows.map((r) => r.name);
+    expect(tableNames).toContain("inbox_agents");
+    expect(tableNames).toContain("inbox_messages");
+    expect(tableNames).toContain("inbox_recipients");
+  });
+
+  it("should not close external DB on storage.close()", () => {
+    storage.close();
+    // External DB should still work
+    const result = externalDb.prepare("SELECT 1 as val").get() as { val: number };
+    expect(result.val).toBe(1);
+  });
+
+  it("should coexist with other tables in the same DB", () => {
+    // Create a non-inbox table in the same DB
+    externalDb.exec("CREATE TABLE IF NOT EXISTS hive_posts (id TEXT PRIMARY KEY, title TEXT)");
+    externalDb.prepare("INSERT INTO hive_posts (id, title) VALUES (?, ?)").run("p1", "Hello World");
+
+    // Inbox operations should work independently
+    storage.putAgent(makeAgent());
+    storage.putMessage(makeMessage());
+
+    // Both should be accessible
+    const agent = storage.getAgent("agent-1");
+    expect(agent).toBeDefined();
+    const post = externalDb.prepare("SELECT title FROM hive_posts WHERE id = ?").get("p1") as { title: string };
+    expect(post.title).toBe("Hello World");
+  });
+});
+
+describe("Two SqliteStorage instances sharing one DB", () => {
+  let sharedDb: Database.Database;
+  let storageA: SqliteStorage;
+  let storageB: SqliteStorage;
+
+  beforeEach(() => {
+    sharedDb = new Database(":memory:");
+    sharedDb.pragma("journal_mode = WAL");
+    sharedDb.pragma("foreign_keys = ON");
+    storageA = new SqliteStorage({ db: sharedDb, prefix: "inbox_a_" });
+    storageB = new SqliteStorage({ db: sharedDb, prefix: "inbox_b_" });
+  });
+
+  afterEach(() => {
+    storageA.close();
+    storageB.close();
+    sharedDb.close();
+  });
+
+  it("should isolate data between prefixes", () => {
+    storageA.putAgent(makeAgent({ agent_id: "alice" }));
+    storageB.putAgent(makeAgent({ agent_id: "bob" }));
+
+    expect(storageA.getAgent("alice")).toBeDefined();
+    expect(storageA.getAgent("bob")).toBeUndefined();
+
+    expect(storageB.getAgent("bob")).toBeDefined();
+    expect(storageB.getAgent("alice")).toBeUndefined();
+  });
+
+  it("should isolate messages between prefixes", () => {
+    storageA.putMessage(makeMessage({ id: "m1", sender_id: "alice" }));
+    storageB.putMessage(makeMessage({ id: "m2", sender_id: "bob" }));
+
+    expect(storageA.getMessage("m1")).toBeDefined();
+    expect(storageA.getMessage("m2")).toBeUndefined();
+
+    expect(storageB.getMessage("m2")).toBeDefined();
+    expect(storageB.getMessage("m1")).toBeUndefined();
+  });
+});