@axiom-lattice/local-stores 3.1.6 → 3.1.9

package/src/stores/LocalOpenAuditStore.ts

@@ -0,0 +1,110 @@
+/**
+ * Local SQLite implementation of the Open audit store (append-only).
+ */
+
+import { DatabaseWrapper, ensureTable, nowISO, parseISO } from "../database";
+import type {
+  OpenAuditStore,
+  OpenAuditAppendInput,
+  OpenAuditQuery,
+  OpenAuditRecord,
+} from "@axiom-lattice/protocols";
+import { randomUUID } from "crypto";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_open_audit (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  credential_id TEXT NOT NULL,
+  credential_kind TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  domain TEXT NOT NULL,
+  action TEXT NOT NULL,
+  args TEXT,
+  status TEXT NOT NULL,
+  error_code TEXT,
+  duration_ms INTEGER NOT NULL,
+  created_at TEXT NOT NULL
+);
+`;
+
+/** SQLite-backed append-only audit store for the Open API surface. */
+export class LocalOpenAuditStore implements OpenAuditStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async query(params: OpenAuditQuery): Promise<OpenAuditRecord[]> {
+    const clauses = ["tenant_id = ?"];
+    const values: unknown[] = [params.tenantId];
+    if (params.credentialId) {
+      clauses.push("credential_id = ?");
+      values.push(params.credentialId);
+    }
+    if (params.domain) {
+      clauses.push("domain = ?");
+      values.push(params.domain);
+    }
+    if (params.status) {
+      clauses.push("status = ?");
+      values.push(params.status);
+    }
+    if (params.from) {
+      clauses.push("created_at >= ?");
+      values.push(params.from);
+    }
+    if (params.to) {
+      clauses.push("created_at < ?");
+      values.push(params.to);
+    }
+    const limit = params.limit ?? 100;
+    const offset = params.offset ?? 0;
+    values.push(limit, offset);
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM lt_open_audit WHERE ${clauses.join(" AND ")}
+         ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+      )
+      .all(...values) as unknown as Array<Record<string, unknown>>;
+    return rows.map((row) => ({
+      id: row.id as string,
+      tenantId: row.tenant_id as string,
+      credentialId: row.credential_id as string,
+      credentialKind: row.credential_kind as OpenAuditRecord["credentialKind"],
+      projectId: row.project_id as string,
+      domain: row.domain as string,
+      action: row.action as string,
+      args: row.args ? JSON.parse(row.args as string) : undefined,
+      status: row.status as "ok" | "error",
+      errorCode: (row.error_code as string) ?? undefined,
+      durationMs: row.duration_ms as number,
+      createdAt: parseISO(row.created_at as string),
+    }));
+  }
+
+  async append(record: OpenAuditAppendInput): Promise<void> {
+    this.db
+      .prepare(
+        `INSERT INTO lt_open_audit
+          (id, tenant_id, credential_id, credential_kind, project_id, domain, action, args, status, error_code, duration_ms, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        randomUUID(),
+        record.tenantId,
+        record.credentialId,
+        record.credentialKind,
+        record.projectId,
+        record.domain,
+        record.action,
+        record.args === undefined ? null : JSON.stringify(record.args),
+        record.status,
+        record.errorCode ?? null,
+        Math.max(0, Math.round(record.durationMs)),
+        nowISO(),
+      );
+  }
+}

package/src/stores/LocalProjectRoomMessageStore.ts

@@ -26,6 +26,26 @@ function mapRow(row: Row): ProjectRoomMessage {
     ...(row.source_id === null ? {} : { sourceId: row.source_id }), ...(row.idempotency_key === null ? {} : { idempotencyKey: row.idempotency_key }), createdAt };
 }
 
+function mapRowsTolerant(
+  rows: Row[],
+  scope: { tenantId: string; roomId: string },
+): ProjectRoomMessage[] {
+  const messages: ProjectRoomMessage[] = [];
+  for (const row of rows) {
+    try {
+      messages.push(mapRow(row));
+    } catch (error) {
+      console.warn("[ProjectRoomMessageStore] Skipping invalid message row", {
+        tenantId: scope.tenantId,
+        roomId: scope.roomId,
+        rowId: typeof row.id === "string" ? row.id : undefined,
+        reason: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return messages;
+}
+
 /** Persists validated project room messages in local SQLite. */
 export class LocalProjectRoomMessageStore implements ProjectRoomMessageStore {
   constructor(private readonly db: DatabaseWrapper) { ensureProjectRoomSchema(db); }
@@ -37,9 +57,23 @@ export class LocalProjectRoomMessageStore implements ProjectRoomMessageStore {
     const rows = input.before
       ? this.db.prepare(`SELECT ${columns} FROM lt_project_room_messages WHERE tenant_id = ? AND room_id = ? AND (created_at < ? OR (created_at = ? AND id < ?)) ORDER BY created_at DESC, id DESC LIMIT ?`).all(input.tenantId, input.roomId, input.before.createdAt.toISOString(), input.before.createdAt.toISOString(), input.before.id, limit)
       : this.db.prepare(`SELECT ${columns} FROM lt_project_room_messages WHERE tenant_id = ? AND room_id = ? ORDER BY created_at DESC, id DESC LIMIT ?`).all(input.tenantId, input.roomId, limit);
-    return (rows as Row[]).map(mapRow);
+    return mapRowsTolerant(rows as Row[], { tenantId: input.tenantId, roomId: input.roomId });
   }
   async findById(tenantId: string, id: string): Promise<ProjectRoomMessage | null> { const row = this.byId(tenantId, id); return row ? mapRow(row) : null; }
+  async countAfter(input: {
+    tenantId: string; roomId: string; after: Date; excludeAuthorUserId?: string;
+  }): Promise<number> {
+    if (!validDate(input.after)) throw new RangeError("Project room message count horizon date is invalid");
+    const rows = this.db.prepare(
+      `SELECT author FROM lt_project_room_messages
+       WHERE tenant_id = ? AND room_id = ? AND created_at > ?`,
+    ).all(input.tenantId, input.roomId, input.after.toISOString()) as Array<{ author: string }>;
+    return rows.filter((row) => {
+      if (input.excludeAuthorUserId === undefined) return true;
+      const parsed = parseJson(row.author);
+      return !(record(parsed) && parsed.type === "human" && parsed.userId === input.excludeAuthorUserId);
+    }).length;
+  }
   private insert(input: Omit<ProjectRoomMessage, "createdAt">, idempotent: boolean): ProjectRoomMessage {
     return transaction(this.db, () => {
       if (idempotent && input.idempotencyKey) { const canonical = this.byKey(input.tenantId, input.roomId, input.idempotencyKey); if (canonical) return mapRow(canonical); }

package/src/stores/LocalProjectRoomReadStateStore.ts

@@ -0,0 +1,50 @@
+import type { ProjectRoomReadState, ProjectRoomReadStateStore } from "@axiom-lattice/protocols";
+import type { DatabaseWrapper } from "../database";
+import { ensureProjectRoomSchema, timestamp, transaction, validDate, write } from "./project-room-schema";
+
+type ReadStateRow = { tenant_id: string; room_id: string; user_id: string; last_read_at: string; updated_at: string };
+const columns = "tenant_id, room_id, user_id, last_read_at, updated_at";
+
+function mapRow(row: ReadStateRow): ProjectRoomReadState {
+  const lastReadAt = new Date(row.last_read_at);
+  const updatedAt = new Date(row.updated_at);
+  if (Number.isNaN(lastReadAt.getTime()) || Number.isNaN(updatedAt.getTime())) throw new Error("Invalid project room read state row");
+  return { tenantId: row.tenant_id, roomId: row.room_id, userId: row.user_id, lastReadAt, updatedAt };
+}
+
+/** Persists per-user project room read markers in the local SQLite store. */
+export class LocalProjectRoomReadStateStore implements ProjectRoomReadStateStore {
+  /** Creates a store over a managed local database wrapper. */
+  constructor(private readonly db: DatabaseWrapper) { ensureProjectRoomSchema(db); }
+
+  /** Returns the user's read marker for a room, or null when never reported. */
+  async get(tenantId: string, roomId: string, userId: string): Promise<ProjectRoomReadState | null> {
+    const row = this.byKey(tenantId, roomId, userId);
+    return row ? mapRow(row) : null;
+  }
+
+  /** Upserts the marker monotonically (an older report never regresses the horizon). */
+  async markRead(input: { tenantId: string; roomId: string; userId: string; lastReadAt: Date }): Promise<ProjectRoomReadState> {
+    if (!validDate(input.lastReadAt)) throw new RangeError("Project room read state lastReadAt is invalid");
+    return transaction(this.db, () => {
+      const existing = this.byKey(input.tenantId, input.roomId, input.userId);
+      const lastReadAt = existing !== undefined && new Date(existing.last_read_at).getTime() > input.lastReadAt.getTime()
+        ? new Date(existing.last_read_at)
+        : input.lastReadAt;
+      write(this.db,
+        `INSERT INTO lt_project_room_read_states (${columns})
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT (tenant_id, room_id, user_id) DO UPDATE
+           SET last_read_at = excluded.last_read_at, updated_at = excluded.updated_at`,
+        [input.tenantId, input.roomId, input.userId, lastReadAt.toISOString(), timestamp()]);
+      const row = this.byKey(input.tenantId, input.roomId, input.userId) as ReadStateRow;
+      return mapRow(row);
+    });
+  }
+
+  private byKey(tenantId: string, roomId: string, userId: string): ReadStateRow | undefined {
+    return this.db.prepare(
+      `SELECT ${columns} FROM lt_project_room_read_states WHERE tenant_id = ? AND room_id = ? AND user_id = ?`,
+    ).get(tenantId, roomId, userId) as ReadStateRow | undefined;
+  }
+}

package/src/stores/project-room-schema.ts

@@ -49,6 +49,13 @@ CREATE UNIQUE INDEX IF NOT EXISTS uq_lt_project_room_messages_idempotency
   ON lt_project_room_messages (tenant_id, room_id, idempotency_key) WHERE idempotency_key IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_lt_project_room_messages_room_created
   ON lt_project_room_messages (tenant_id, room_id, created_at DESC, id DESC);
+CREATE TABLE IF NOT EXISTS lt_project_room_read_states (
+  tenant_id TEXT NOT NULL, room_id TEXT NOT NULL, user_id TEXT NOT NULL,
+  last_read_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, room_id, user_id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_project_room_read_states_user
+  ON lt_project_room_read_states (tenant_id, user_id);
 `;
 
 const tableColumns: Record<string, string[]> = {
@@ -56,6 +63,7 @@ const tableColumns: Record<string, string[]> = {
   lt_project_memberships: ["id", "tenant_id", "project_id", "user_id", "role", "status", "joined_at", "updated_at"],
   lt_project_bot_memberships: ["id", "tenant_id", "workspace_id", "project_id", "room_id", "assistant_id", "role", "title", "responsibility", "mention_name", "status", "room_thread_id", "joined_at", "updated_at"],
   lt_project_room_messages: ["id", "tenant_id", "workspace_id", "project_id", "room_id", "author", "content", "mentions", "reply_to_message_id", "source", "source_id", "idempotency_key", "created_at"],
+  lt_project_room_read_states: ["tenant_id", "room_id", "user_id", "last_read_at", "updated_at"],
 };
 const indexes: Record<string, { table: string; columns: string[]; unique: boolean; partial: boolean; sql?: string[] }> = {
   idx_lt_project_memberships_project: { table: "lt_project_memberships", columns: ["tenant_id", "project_id"], unique: false, partial: false },
@@ -65,12 +73,14 @@ const indexes: Record<string, { table: string; columns: string[]; unique: boolea
   idx_lt_project_bot_memberships_room: { table: "lt_project_bot_memberships", columns: ["tenant_id", "room_id"], unique: false, partial: false },
   uq_lt_project_room_messages_idempotency: { table: "lt_project_room_messages", columns: ["tenant_id", "room_id", "idempotency_key"], unique: true, partial: true, sql: ["idempotency_key is not null"] },
   idx_lt_project_room_messages_room_created: { table: "lt_project_room_messages", columns: ["tenant_id", "room_id", "created_at", "id"], unique: false, partial: false, sql: ["created_at desc", "id desc"] },
+  idx_lt_project_room_read_states_user: { table: "lt_project_room_read_states", columns: ["tenant_id", "user_id"], unique: false, partial: false },
 };
 const uniqueConstraints: Record<string, string[][]> = {
   lt_project_rooms: [["tenant_id", "id"], ["tenant_id", "project_id", "type"]],
   lt_project_memberships: [["tenant_id", "id"], ["tenant_id", "project_id", "user_id"]],
   lt_project_bot_memberships: [["tenant_id", "id"], ["tenant_id", "project_id", "assistant_id"]],
   lt_project_room_messages: [["tenant_id", "id"]],
+  lt_project_room_read_states: [["tenant_id", "room_id", "user_id"]],
 };
 const checkConstraints: Record<string, Array<{ name: string; fragment: string }>> = {
   lt_project_rooms: [{ name: "type", fragment: "type='main'" }],
@@ -83,6 +93,7 @@ const checkConstraints: Record<string, Array<{ name: string; fragment: string }>
     { name: "status", fragment: "status in ('active','paused','removed')" },
   ],
   lt_project_room_messages: [{ name: "source", fragment: "source in ('user','agent','task','routine','system')" }],
+  lt_project_room_read_states: [],
 };
 
 function rows(db: DatabaseWrapper, sql: string): Record<string, unknown>[] {
@@ -179,6 +190,25 @@ export function ensureProjectRoomSchema(db: DatabaseWrapper): void {
   const applied = hasMigrationTable ? rows(db, `SELECT name, version FROM lattice_schema_migrations WHERE store_name = 'project_room' AND name = '${migrationName}'`)[0] : undefined;
   if (applied) {
     if (applied.version !== 1) throw new Error(`Invalid project room schema migration version: ${String(applied.version)}`);
+    const hasReadStates = rows(db, "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'lt_project_room_read_states'").length > 0;
+    if (!hasReadStates) {
+      raw.exec("BEGIN IMMEDIATE");
+      try {
+        raw.exec(`CREATE TABLE IF NOT EXISTS lt_project_room_read_states (
+          tenant_id TEXT NOT NULL, room_id TEXT NOT NULL, user_id TEXT NOT NULL,
+          last_read_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+          PRIMARY KEY (tenant_id, room_id, user_id)
+        ); CREATE INDEX IF NOT EXISTS idx_lt_project_room_read_states_user
+          ON lt_project_room_read_states (tenant_id, user_id);`);
+        raw.run("INSERT INTO lattice_schema_migrations (store_name, name, version, applied_at) VALUES (?, ?, ?, ?)",
+          ["project_room", "create_project_room_read_states", 2, new Date().toISOString()]);
+        raw.exec("COMMIT");
+        db.save();
+      } catch (error) {
+        try { raw.exec("ROLLBACK"); } catch { /* preserve the schema failure */ }
+        throw error;
+      }
+    }
     validateProjectRoomSchema(db);
     marked[schemaMarker] = true;
     return;