@polpo-ai/drizzle 0.11.0 → 0.12.0

package/dist/__tests__/stores.test.js

@@ -7,6 +7,7 @@ import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { randomBytes } from "node:crypto";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrateSqliteSchema } from "../sqlite-migrator.js";
 import { createSqliteStores } from "../index.js";
 // Provide a deterministic vault key for tests (32 bytes hex-encoded)
 process.env.POLPO_VAULT_KEY = randomBytes(32).toString("hex");
@@ -14,228 +15,11 @@ process.env.POLPO_VAULT_KEY = randomBytes(32).toString("hex");
 let sqlite;
 let db;
 let stores;
-/** Create all SQLite tables via raw SQL (mirrors what ensurePgSchema does for PG). */
-function createTables(raw) {
-    raw.exec(`
-    CREATE TABLE IF NOT EXISTS tasks (
-      id TEXT PRIMARY KEY,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL,
-      assign_to TEXT NOT NULL,
-      "group" TEXT,
-      mission_id TEXT,
-      depends_on TEXT NOT NULL DEFAULT '[]',
-      status TEXT NOT NULL DEFAULT 'pending',
-      retries INTEGER NOT NULL DEFAULT 0,
-      max_retries INTEGER NOT NULL DEFAULT 2,
-      max_duration INTEGER,
-      retry_policy TEXT,
-      expectations TEXT NOT NULL DEFAULT '[]',
-      metrics TEXT NOT NULL DEFAULT '[]',
-      result TEXT,
-      phase TEXT,
-      fix_attempts INTEGER NOT NULL DEFAULT 0,
-      resolution_attempts INTEGER NOT NULL DEFAULT 0,
-      original_description TEXT,
-      session_id TEXT,
-      notifications TEXT,
-      outcomes TEXT,
-      expected_outcomes TEXT,
-      deadline TEXT,
-      priority TEXT,
-      side_effects INTEGER,
-      revision_count INTEGER,
-      "user" TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_tasks_user ON tasks("user");
-    CREATE TABLE IF NOT EXISTS missions (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL UNIQUE,
-      data TEXT NOT NULL,
-      prompt TEXT,
-      status TEXT NOT NULL DEFAULT 'draft',
-      schedule TEXT,
-      end_date TEXT,
-      quality_threshold TEXT,
-      deadline TEXT,
-      notifications TEXT,
-      execution_count INTEGER NOT NULL DEFAULT 0,
-      "user" TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_missions_user ON missions("user");
-    CREATE TABLE IF NOT EXISTS metadata (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS processes (
-      agent_name TEXT NOT NULL,
-      pid INTEGER NOT NULL,
-      task_id TEXT NOT NULL,
-      started_at TEXT NOT NULL,
-      alive INTEGER NOT NULL DEFAULT 1,
-      activity TEXT NOT NULL DEFAULT '{}'
-    );
-    CREATE TABLE IF NOT EXISTS runs (
-      id TEXT PRIMARY KEY,
-      task_id TEXT NOT NULL,
-      pid INTEGER NOT NULL DEFAULT 0,
-      agent_name TEXT NOT NULL,
-      adapter_type TEXT NOT NULL,
-      session_id TEXT,
-      status TEXT NOT NULL DEFAULT 'running',
-      started_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      activity TEXT NOT NULL DEFAULT '{}',
-      result TEXT,
-      outcomes TEXT,
-      config TEXT,
-      config_path TEXT NOT NULL,
-      "user" TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_runs_user ON runs("user");
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      title TEXT,
-      agent TEXT,
-      "user" TEXT,
-      metadata TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions("user");
-    CREATE TABLE IF NOT EXISTS messages (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-      role TEXT NOT NULL,
-      content TEXT NOT NULL,
-      ts TEXT NOT NULL,
-      tool_calls TEXT
-    );
-    CREATE TABLE IF NOT EXISTS notifications (
-      id TEXT PRIMARY KEY,
-      timestamp TEXT NOT NULL,
-      rule_id TEXT NOT NULL,
-      rule_name TEXT NOT NULL,
-      channel TEXT NOT NULL,
-      channel_type TEXT NOT NULL,
-      status TEXT NOT NULL,
-      error TEXT,
-      title TEXT NOT NULL,
-      body TEXT NOT NULL,
-      severity TEXT NOT NULL,
-      source_event TEXT NOT NULL,
-      attachment_count INTEGER NOT NULL DEFAULT 0,
-      attachment_types TEXT
-    );
-    CREATE TABLE IF NOT EXISTS log_sessions (
-      id TEXT PRIMARY KEY,
-      started_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS log_entries (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL REFERENCES log_sessions(id) ON DELETE CASCADE,
-      ts TEXT NOT NULL,
-      event TEXT NOT NULL,
-      data TEXT
-    );
-    CREATE TABLE IF NOT EXISTS approvals (
-      id TEXT PRIMARY KEY,
-      gate_id TEXT NOT NULL,
-      gate_name TEXT NOT NULL,
-      task_id TEXT,
-      mission_id TEXT,
-      status TEXT NOT NULL DEFAULT 'pending',
-      payload TEXT,
-      requested_at TEXT NOT NULL,
-      resolved_at TEXT,
-      resolved_by TEXT,
-      note TEXT
-    );
-    CREATE TABLE IF NOT EXISTS memory (
-      key TEXT PRIMARY KEY,
-      content TEXT NOT NULL DEFAULT ''
-    );
-    CREATE TABLE IF NOT EXISTS peers (
-      id TEXT PRIMARY KEY,
-      channel TEXT NOT NULL,
-      external_id TEXT NOT NULL,
-      display_name TEXT,
-      first_seen_at TEXT NOT NULL,
-      last_seen_at TEXT NOT NULL,
-      linked_to TEXT
-    );
-    CREATE TABLE IF NOT EXISTS peer_allowlist (
-      peer_id TEXT PRIMARY KEY
-    );
-    CREATE TABLE IF NOT EXISTS pairing_requests (
-      id TEXT PRIMARY KEY,
-      peer_id TEXT NOT NULL,
-      channel TEXT NOT NULL,
-      external_id TEXT NOT NULL,
-      display_name TEXT,
-      code TEXT NOT NULL UNIQUE,
-      created_at TEXT NOT NULL,
-      expires_at TEXT NOT NULL,
-      resolved INTEGER NOT NULL DEFAULT 0
-    );
-    CREATE TABLE IF NOT EXISTS peer_sessions (
-      peer_id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS teams (
-      name TEXT PRIMARY KEY,
-      description TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS agents (
-      name TEXT PRIMARY KEY,
-      team_name TEXT NOT NULL,
-      config TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS vault (
-      agent TEXT NOT NULL,
-      service TEXT NOT NULL,
-      type TEXT NOT NULL,
-      label TEXT,
-      credentials TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (agent, service)
-    );
-    CREATE TABLE IF NOT EXISTS playbooks (
-      name TEXT PRIMARY KEY,
-      description TEXT NOT NULL,
-      mission TEXT NOT NULL,
-      parameters TEXT,
-      version TEXT,
-      author TEXT,
-      tags TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS skills (
-      name TEXT PRIMARY KEY,
-      description TEXT NOT NULL DEFAULT '',
-      source TEXT,
-      installed_at TEXT NOT NULL,
-      allowed_tools TEXT,
-      tags TEXT,
-      category TEXT
-    );
-    PRAGMA foreign_keys = ON;
-  `);
-}
-beforeEach(() => {
+beforeEach(async () => {
     sqlite = new Database(":memory:");
-    createTables(sqlite);
+    sqlite.exec("PRAGMA foreign_keys = ON");
     db = drizzle(sqlite);
+    await migrateSqliteSchema(db);
     stores = createSqliteStores(db);
 });
 afterEach(() => {
@@ -245,8 +29,8 @@ afterEach(() => {
 // TaskStore
 // ═══════════════════════════════════════════════════════════════════════
 describe("DrizzleTaskStore", () => {
-    it("addTask + getTask round-trip", async () => {
-        const task = await stores.taskStore.addTask({
+    it("createTask + getTask round-trip", async () => {
+        const task = await stores.taskStore.createTask({
             title: "Fix bug",
             description: "Fix the login bug",
             assignTo: "claude",
@@ -264,8 +48,8 @@ describe("DrizzleTaskStore", () => {
         expect(fetched.title).toBe("Fix bug");
         expect(fetched.expectations).toEqual([{ type: "llm_review", criteria: "Login works" }]);
     });
-    it("addTask persists OpenAI-compat user identifier", async () => {
-        const task = await stores.taskStore.addTask({
+    it("createTask persists OpenAI-compat user identifier", async () => {
+        const task = await stores.taskStore.createTask({
             title: "Per-user task",
             description: "Scoped to end-user",
             assignTo: "claude",
@@ -279,20 +63,20 @@ describe("DrizzleTaskStore", () => {
         const fetched = await stores.taskStore.getTask(task.id);
         expect(fetched.user).toBe("u-42");
     });
-    it("getAllTasks returns ordered by createdAt", async () => {
-        await stores.taskStore.addTask({
+    it("listTasks returns ordered by createdAt", async () => {
+        await stores.taskStore.createTask({
             title: "A", description: "first", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
-        await stores.taskStore.addTask({
+        await stores.taskStore.createTask({
             title: "B", description: "second", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
-        const all = await stores.taskStore.getAllTasks();
+        const all = await stores.taskStore.listTasks();
         expect(all).toHaveLength(2);
         expect(all[0].title).toBe("A");
         expect(all[1].title).toBe("B");
     });
     it("updateTask merges fields", async () => {
-        const task = await stores.taskStore.addTask({
+        const task = await stores.taskStore.createTask({
             title: "Original", description: "desc", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
         const updated = await stores.taskStore.updateTask(task.id, { title: "Updated" });
@@ -301,30 +85,30 @@ describe("DrizzleTaskStore", () => {
         const fetched = await stores.taskStore.getTask(task.id);
         expect(fetched.title).toBe("Updated");
     });
-    it("removeTask deletes by ID", async () => {
-        const task = await stores.taskStore.addTask({
+    it("deleteTask deletes by ID", async () => {
+        const task = await stores.taskStore.createTask({
             title: "Delete me", description: "d", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
-        const removed = await stores.taskStore.removeTask(task.id);
+        const removed = await stores.taskStore.deleteTask(task.id);
         expect(removed).toBe(true);
         const fetched = await stores.taskStore.getTask(task.id);
         expect(fetched).toBeUndefined();
     });
-    it("removeTasks with filter", async () => {
-        await stores.taskStore.addTask({
+    it("deleteTasks with filter", async () => {
+        await stores.taskStore.createTask({
             title: "Keep", description: "d", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
-        await stores.taskStore.addTask({
+        await stores.taskStore.createTask({
             title: "Remove", description: "d", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [], group: "old",
         });
-        const count = await stores.taskStore.removeTasks((t) => t.group === "old");
+        const count = await stores.taskStore.deleteTasks((t) => t.group === "old");
         expect(count).toBe(1);
-        const all = await stores.taskStore.getAllTasks();
+        const all = await stores.taskStore.listTasks();
         expect(all).toHaveLength(1);
         expect(all[0].title).toBe("Keep");
     });
     it("transition validates state machine", async () => {
-        const task = await stores.taskStore.addTask({
+        const task = await stores.taskStore.createTask({
             title: "T", description: "d", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
         // pending → assigned is valid
@@ -334,7 +118,7 @@ describe("DrizzleTaskStore", () => {
         await expect(stores.taskStore.transition(task.id, "pending")).rejects.toThrow();
     });
     it("transition increments retries on failed→pending", async () => {
-        const task = await stores.taskStore.addTask({
+        const task = await stores.taskStore.createTask({
             title: "T", description: "d", assignTo: "claude", dependsOn: [], maxRetries: 3, expectations: [], metrics: [],
         });
         await stores.taskStore.transition(task.id, "assigned");
@@ -344,7 +128,7 @@ describe("DrizzleTaskStore", () => {
         expect(retried.retries).toBe(1);
     });
     it("unsafeSetStatus bypasses state machine", async () => {
-        const task = await stores.taskStore.addTask({
+        const task = await stores.taskStore.createTask({
             title: "T", description: "d", assignTo: "claude", dependsOn: [], maxRetries: 2, expectations: [], metrics: [],
         });
         // pending → done is not a valid transition, but unsafeSetStatus allows it
@@ -352,43 +136,43 @@ describe("DrizzleTaskStore", () => {
         expect(result.status).toBe("done");
     });
     // ── Missions ────────────────────────────────────────────────────────
-    it("saveMission + getMission round-trip", async () => {
-        const mission = await stores.taskStore.saveMission({
+    it("createMission + getMission round-trip", async () => {
+        const mission = await stores.missionStore.createMission({
             name: "mission-1",
             data: '{"tasks":[]}',
             status: "draft",
         });
         expect(mission.id).toBeDefined();
         expect(mission.name).toBe("mission-1");
-        const fetched = await stores.taskStore.getMission(mission.id);
+        const fetched = await stores.missionStore.getMission(mission.id);
         expect(fetched).toBeDefined();
         expect(fetched.name).toBe("mission-1");
     });
     it("getMissionByName finds by name", async () => {
-        await stores.taskStore.saveMission({ name: "deploy-v2", data: "{}", status: "draft" });
-        const found = await stores.taskStore.getMissionByName("deploy-v2");
+        await stores.missionStore.createMission({ name: "deploy-v2", data: "{}", status: "draft" });
+        const found = await stores.missionStore.getMissionByName("deploy-v2");
         expect(found).toBeDefined();
         expect(found.name).toBe("deploy-v2");
     });
     it("updateMission merges fields", async () => {
-        const m = await stores.taskStore.saveMission({ name: "m-1", data: "{}", status: "draft" });
-        const updated = await stores.taskStore.updateMission(m.id, { status: "active" });
+        const m = await stores.missionStore.createMission({ name: "m-1", data: "{}", status: "draft" });
+        const updated = await stores.missionStore.updateMission(m.id, { status: "active" });
         expect(updated.status).toBe("active");
         expect(updated.name).toBe("m-1");
     });
     it("deleteMission removes", async () => {
-        const m = await stores.taskStore.saveMission({ name: "m-del", data: "{}", status: "draft" });
-        const ok = await stores.taskStore.deleteMission(m.id);
+        const m = await stores.missionStore.createMission({ name: "m-del", data: "{}", status: "draft" });
+        const ok = await stores.missionStore.deleteMission(m.id);
         expect(ok).toBe(true);
-        const fetched = await stores.taskStore.getMission(m.id);
+        const fetched = await stores.missionStore.getMission(m.id);
         expect(fetched).toBeUndefined();
     });
     it("nextMissionName increments", async () => {
-        expect(await stores.taskStore.nextMissionName()).toBe("mission-1");
-        await stores.taskStore.saveMission({ name: "mission-1", data: "{}", status: "draft" });
-        expect(await stores.taskStore.nextMissionName()).toBe("mission-2");
-        await stores.taskStore.saveMission({ name: "mission-5", data: "{}", status: "draft" });
-        expect(await stores.taskStore.nextMissionName()).toBe("mission-6");
+        expect(await stores.missionStore.nextMissionName()).toBe("mission-1");
+        await stores.missionStore.createMission({ name: "mission-1", data: "{}", status: "draft" });
+        expect(await stores.missionStore.nextMissionName()).toBe("mission-2");
+        await stores.missionStore.createMission({ name: "mission-5", data: "{}", status: "draft" });
+        expect(await stores.missionStore.nextMissionName()).toBe("mission-6");
     });
     // ── State ────────────────────────────────────────────────────────────
     it("setState + getState round-trip", async () => {
@@ -511,7 +295,7 @@ describe("DrizzleRunStore", () => {
 // ═══════════════════════════════════════════════════════════════════════
 describe("DrizzleSessionStore", () => {
     it("create + getSession", async () => {
-        const id = await stores.sessionStore.create("My Session");
+        const id = await stores.sessionStore.create({ title: "My Session" });
         const session = await stores.sessionStore.getSession(id);
         expect(session).toBeDefined();
         expect(session.title).toBe("My Session");
@@ -539,10 +323,10 @@ describe("DrizzleSessionStore", () => {
         expect(recent[1].content).toBe("3");
     });
     it("listSessions includes messageCount", async () => {
-        const s1 = await stores.sessionStore.create("S1");
+        const s1 = await stores.sessionStore.create({ title: "S1" });
         await stores.sessionStore.addMessage(s1, "user", "msg1");
         await stores.sessionStore.addMessage(s1, "assistant", "msg2");
-        await stores.sessionStore.create("S2");
+        await stores.sessionStore.create({ title: "S2" });
         const list = await stores.sessionStore.listSessions();
         expect(list).toHaveLength(2);
         const withMessages = list.find((s) => s.title === "S1");
@@ -595,14 +379,14 @@ describe("DrizzleSessionStore", () => {
         expect(acmeProd[0].title).toBe("Acme-prod");
     });
     it("renameSession updates title", async () => {
-        const id = await stores.sessionStore.create("Old");
+        const id = await stores.sessionStore.create({ title: "Old" });
         const ok = await stores.sessionStore.renameSession(id, "New");
         expect(ok).toBe(true);
         const session = await stores.sessionStore.getSession(id);
         expect(session.title).toBe("New");
     });
     it("deleteSession cascade-deletes messages", async () => {
-        const id = await stores.sessionStore.create("Del");
+        const id = await stores.sessionStore.create({ title: "Del" });
         await stores.sessionStore.addMessage(id, "user", "msg");
         const ok = await stores.sessionStore.deleteSession(id);
         expect(ok).toBe(true);
@@ -610,17 +394,17 @@ describe("DrizzleSessionStore", () => {
         expect(await stores.sessionStore.getMessages(id)).toEqual([]);
     });
     it("prune keeps the N most recent sessions", async () => {
-        await stores.sessionStore.create("Old");
-        await stores.sessionStore.create("New");
+        await stores.sessionStore.create({ title: "Old" });
+        await stores.sessionStore.create({ title: "New" });
         const pruned = await stores.sessionStore.prune(1);
         expect(pruned).toBe(1);
         const list = await stores.sessionStore.listSessions();
         expect(list).toHaveLength(1);
     });
     it("getLatestSession returns most recently updated", async () => {
-        await stores.sessionStore.create("First");
+        await stores.sessionStore.create({ title: "First" });
         await new Promise((r) => setTimeout(r, 5));
-        const id2 = await stores.sessionStore.create("Second");
+        const id2 = await stores.sessionStore.create({ title: "Second" });
         const latest = await stores.sessionStore.getLatestSession();
         expect(latest).toBeDefined();
         expect(latest.id).toBe(id2);