@axiom-lattice/local-stores 1.0.1

package/src/stores/LocalThreadMessageQueueStore.ts

@@ -0,0 +1,172 @@
+/**
+ * Local SQLite implementation of IMessageQueueStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  IMessageQueueStore,
+  PendingMessage,
+  AddMessageParams,
+  ThreadInfo,
+} from "@axiom-lattice/core";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { randomUUID } from "crypto";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_thread_message_queue (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL,
+  message_content TEXT NOT NULL,
+  message_type TEXT NOT NULL DEFAULT 'human',
+  sequence_order INTEGER NOT NULL DEFAULT 0,
+  priority INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'pending',
+  command TEXT,
+  custom_run_config TEXT,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_tmq_thread ON lt_thread_message_queue(thread_id, status);
+CREATE INDEX IF NOT EXISTS idx_lt_tmq_pending ON lt_thread_message_queue(status, priority DESC, sequence_order ASC);
+`;
+
+interface QueueRow {
+  id: string;
+  thread_id: string;
+  tenant_id: string;
+  assistant_id: string;
+  message_content: string;
+  message_type: string;
+  sequence_order: number;
+  priority: number;
+  status: string;
+  command: string | null;
+  custom_run_config: string | null;
+  created_at: string;
+}
+
+export class LocalThreadMessageQueueStore implements IMessageQueueStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async addMessage(params: AddMessageParams): Promise<PendingMessage> {
+    const now = nowISO();
+    const id = params.id || randomUUID();
+
+    const seqRow = this.db.prepare(
+      `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq FROM lt_thread_message_queue WHERE thread_id = ?`,
+    ).get(params.threadId) as { next_seq: number };
+    const nextSeq = seqRow.next_seq;
+
+    this.db.prepare(
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id, params.threadId, params.tenantId, params.assistantId,
+      JSON.stringify(params.content), params.type || "human", nextSeq,
+      params.priority || 0,
+      params.command ? JSON.stringify(params.command) : null,
+      params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+      now,
+    );
+
+    return this.getById(id);
+  }
+
+  async addMessageAtHead(params: AddMessageParams): Promise<PendingMessage> {
+    const now = nowISO();
+    const id = params.id || randomUUID();
+
+    const seqRow = this.db.prepare(
+      `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq FROM lt_thread_message_queue WHERE thread_id = ?`,
+    ).get(params.threadId) as { next_seq: number };
+
+    this.db.prepare(
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?)`,
+    ).run(
+      id, params.threadId, params.tenantId!, params.assistantId!,
+      JSON.stringify(params.content), params.type || "human", seqRow.next_seq,
+      params.command ? JSON.stringify(params.command) : null,
+      params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+      now,
+    );
+
+    return this.getById(id);
+  }
+
+  async getPendingMessages(threadId: string): Promise<PendingMessage[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending' ORDER BY priority DESC, sequence_order ASC`,
+    ).all(threadId) as unknown as QueueRow[];
+    return rows.map(rowToMessage);
+  }
+
+  async getProcessingMessages(threadId: string): Promise<PendingMessage[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'processing' ORDER BY priority DESC, sequence_order ASC`,
+    ).all(threadId) as unknown as QueueRow[];
+    return rows.map(rowToMessage);
+  }
+
+  async getQueueSize(threadId: string): Promise<number> {
+    const row = this.db.prepare(
+      `SELECT COUNT(*) as count FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'`,
+    ).get(threadId) as { count: number };
+    return row.count;
+  }
+
+  async getThreadsWithPendingMessages(): Promise<ThreadInfo[]> {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT tenant_id, assistant_id, thread_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') ORDER BY thread_id`,
+    ).all() as { tenant_id: string; assistant_id: string; thread_id: string }[];
+    return rows.map((r) => ({
+      tenantId: r.tenant_id,
+      assistantId: r.assistant_id,
+      threadId: r.thread_id,
+    }));
+  }
+
+  async removeMessage(messageId: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE id = ?`).run(messageId);
+    return result.changes > 0;
+  }
+
+  async clearMessages(threadId: string): Promise<void> {
+    this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE thread_id = ?`).run(threadId);
+  }
+
+  async markProcessing(messageId: string): Promise<void> {
+    this.db.prepare(`UPDATE lt_thread_message_queue SET status = 'processing' WHERE id = ?`).run(messageId);
+  }
+
+  async resetProcessingToPending(threadId: string): Promise<number> {
+    const result = this.db.prepare(
+      `UPDATE lt_thread_message_queue SET status = 'pending' WHERE thread_id = ? AND status = 'processing'`,
+    ).run(threadId);
+    return result.changes;
+  }
+
+  private getById(id: string): PendingMessage {
+    const row = this.db.prepare(`SELECT * FROM lt_thread_message_queue WHERE id = ?`).get(id) as unknown as QueueRow;
+    return rowToMessage(row);
+  }
+}
+
+function rowToMessage(row: QueueRow): PendingMessage {
+  return {
+    id: row.id,
+    content: JSON.parse(row.message_content),
+    type: row.message_type as "human" | "system",
+    sequence: row.sequence_order,
+    createdAt: parseISO(row.created_at),
+    priority: row.priority || 0,
+    command: row.command ? JSON.parse(row.command) : undefined,
+    custom_run_config: row.custom_run_config ? JSON.parse(row.custom_run_config) : undefined,
+  };
+}

package/src/stores/LocalThreadStore.ts

@@ -0,0 +1,149 @@
+/**
+ * Local SQLite implementation of ThreadStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  ThreadStore,
+  Thread,
+  CreateThreadRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_threads (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_threads_assistant ON lt_threads(tenant_id, assistant_id);
+`;
+
+interface ThreadRow {
+  id: string;
+  tenant_id: string;
+  assistant_id: string;
+  metadata: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalThreadStore implements ThreadStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getThreadsByAssistantId(
+    tenantId: string,
+    assistantId: string,
+    metadataFilter?: Record<string, string>,
+  ): Promise<Thread[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_threads WHERE tenant_id = ? AND assistant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId, assistantId) as unknown as ThreadRow[];
+
+    let threads = rows.map(mapRowToThread);
+
+    if (metadataFilter && Object.keys(metadataFilter).length > 0) {
+      threads = threads.filter((t) =>
+        Object.entries(metadataFilter).every(
+          ([key, value]) => t.metadata?.[key] === value,
+        ),
+      );
+    }
+
+    return threads;
+  }
+
+  async getThreadById(tenantId: string, threadId: string): Promise<Thread | undefined> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_threads WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, threadId) as unknown as ThreadRow | undefined;
+    return row ? mapRowToThread(row) : undefined;
+  }
+
+  async createThread(
+    tenantId: string,
+    assistantId: string,
+    threadId: string,
+    data: CreateThreadRequest,
+  ): Promise<Thread> {
+    const now = nowISO();
+    const metadata = JSON.stringify(data.metadata || {});
+
+    this.db.prepare(
+      `INSERT INTO lt_threads (id, tenant_id, assistant_id, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         assistant_id = excluded.assistant_id,
+         metadata = excluded.metadata,
+         updated_at = excluded.updated_at`,
+    ).run(threadId, tenantId, assistantId, metadata, now, now);
+
+    return {
+      id: threadId,
+      tenantId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateThread(
+    tenantId: string,
+    threadId: string,
+    updates: Partial<CreateThreadRequest>,
+  ): Promise<Thread | null> {
+    const existing = await this.getThreadById(tenantId, threadId);
+    if (!existing) return null;
+
+    const updatedMetadata = {
+      ...existing.metadata,
+      ...(updates.metadata || {}),
+    };
+    const now = nowISO();
+
+    this.db.prepare(
+      `UPDATE lt_threads SET metadata = ?, updated_at = ? WHERE tenant_id = ? AND id = ?`,
+    ).run(JSON.stringify(updatedMetadata), now, tenantId, threadId);
+
+    return {
+      ...existing,
+      metadata: updatedMetadata,
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async deleteThread(tenantId: string, threadId: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_threads WHERE tenant_id = ? AND id = ?`,
+    ).run(tenantId, threadId);
+    return result.changes > 0;
+  }
+
+  async hasThread(tenantId: string, threadId: string): Promise<boolean> {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_threads WHERE tenant_id = ? AND id = ? LIMIT 1`,
+    ).get(tenantId, threadId);
+    return row !== undefined;
+  }
+}
+
+function mapRowToThread(row: ThreadRow): Thread {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    metadata: JSON.parse(row.metadata || "{}"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalUserStore.ts

@@ -0,0 +1,136 @@
+/**
+ * Local SQLite implementation of UserStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  UserStore,
+  User,
+  UserStatus,
+  CreateUserRequest,
+  UpdateUserRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_users (
+  id TEXT PRIMARY KEY,
+  email TEXT NOT NULL,
+  name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_users_email ON lt_users(email);
+`;
+
+interface UserRow {
+  id: string;
+  email: string;
+  name: string;
+  status: string;
+  metadata: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalUserStore implements UserStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllUsers(): Promise<User[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_users ORDER BY created_at DESC`,
+    ).all() as unknown as UserRow[];
+    return rows.map(mapRowToUser);
+  }
+
+  async getUserById(id: string): Promise<User | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_users WHERE id = ?`,
+    ).get(id) as unknown as UserRow | undefined;
+    return row ? mapRowToUser(row) : null;
+  }
+
+  async getUserByEmail(email: string): Promise<User | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_users WHERE email = ?`,
+    ).get(email) as unknown as UserRow | undefined;
+    return row ? mapRowToUser(row) : null;
+  }
+
+  async createUser(id: string, data: CreateUserRequest): Promise<User> {
+    const now = nowISO();
+    const status = data.status || "pending";
+    const metadata = JSON.stringify(data.metadata || {});
+
+    this.db.prepare(
+      `INSERT INTO lt_users (id, email, name, status, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         email = excluded.email,
+         name = excluded.name,
+         status = excluded.status,
+         metadata = excluded.metadata,
+         updated_at = excluded.updated_at`,
+    ).run(id, data.email, data.name, status, metadata, now, now);
+
+    return {
+      id,
+      email: data.email,
+      name: data.name,
+      status,
+      metadata: data.metadata,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateUser(id: string, updates: UpdateUserRequest): Promise<User | null> {
+    const existing = await this.getUserById(id);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.email !== undefined) { setClauses.push("email = ?"); values.push(updates.email); }
+    if (updates.name !== undefined) { setClauses.push("name = ?"); values.push(updates.name); }
+    if (updates.status !== undefined) { setClauses.push("status = ?"); values.push(updates.status); }
+    if (updates.metadata !== undefined) { setClauses.push("metadata = ?"); values.push(JSON.stringify(updates.metadata)); }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(id);
+
+    this.db.prepare(
+      `UPDATE lt_users SET ${setClauses.join(", ")} WHERE id = ?`,
+    ).run(...values);
+
+    return this.getUserById(id);
+  }
+
+  async deleteUser(id: string): Promise<boolean> {
+    const result = this.db.prepare(`DELETE FROM lt_users WHERE id = ?`).run(id);
+    return result.changes > 0;
+  }
+}
+
+function mapRowToUser(row: UserRow): User {
+  return {
+    id: row.id,
+    email: row.email,
+    name: row.name,
+    status: row.status as UserStatus,
+    metadata: JSON.parse(row.metadata || "{}"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalUserTenantLinkStore.ts

@@ -0,0 +1,135 @@
+/**
+ * Local SQLite implementation of UserTenantLinkStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  UserTenantLinkStore,
+  UserTenantLink,
+  UserTenantRole,
+  CreateUserTenantLinkRequest,
+  UpdateUserTenantLinkRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_user_tenant_links (
+  user_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'member',
+  joined_at TEXT NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  PRIMARY KEY (user_id, tenant_id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_utl_user ON lt_user_tenant_links(user_id);
+CREATE INDEX IF NOT EXISTS idx_lt_utl_tenant ON lt_user_tenant_links(tenant_id);
+`;
+
+interface LinkRow {
+  user_id: string;
+  tenant_id: string;
+  role: string;
+  joined_at: string;
+  metadata: string;
+}
+
+export class LocalUserTenantLinkStore implements UserTenantLinkStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getTenantsByUser(userId: string): Promise<UserTenantLink[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_user_tenant_links WHERE user_id = ? ORDER BY joined_at DESC`,
+    ).all(userId) as unknown as LinkRow[];
+    return rows.map(mapRowToLink);
+  }
+
+  async getUsersByTenant(tenantId: string): Promise<UserTenantLink[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_user_tenant_links WHERE tenant_id = ? ORDER BY joined_at DESC`,
+    ).all(tenantId) as unknown as LinkRow[];
+    return rows.map(mapRowToLink);
+  }
+
+  async getLink(userId: string, tenantId: string): Promise<UserTenantLink | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_user_tenant_links WHERE user_id = ? AND tenant_id = ?`,
+    ).get(userId, tenantId) as unknown as LinkRow | undefined;
+    return row ? mapRowToLink(row) : null;
+  }
+
+  async createLink(data: CreateUserTenantLinkRequest): Promise<UserTenantLink> {
+    const now = nowISO();
+    const role = data.role || "member";
+    const metadata = JSON.stringify(data.metadata || {});
+
+    this.db.prepare(
+      `INSERT INTO lt_user_tenant_links (user_id, tenant_id, role, joined_at, metadata)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(user_id, tenant_id) DO UPDATE SET
+         role = excluded.role,
+         metadata = excluded.metadata`,
+    ).run(data.userId, data.tenantId, role, now, metadata);
+
+    return {
+      userId: data.userId,
+      tenantId: data.tenantId,
+      role,
+      joinedAt: parseISO(now),
+      metadata: data.metadata,
+    };
+  }
+
+  async updateLink(
+    userId: string,
+    tenantId: string,
+    updates: UpdateUserTenantLinkRequest,
+  ): Promise<UserTenantLink | null> {
+    const existing = await this.getLink(userId, tenantId);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.role !== undefined) { setClauses.push("role = ?"); values.push(updates.role); }
+    if (updates.metadata !== undefined) { setClauses.push("metadata = ?"); values.push(JSON.stringify(updates.metadata)); }
+
+    if (setClauses.length === 0) return existing;
+
+    values.push(userId, tenantId);
+
+    this.db.prepare(
+      `UPDATE lt_user_tenant_links SET ${setClauses.join(", ")} WHERE user_id = ? AND tenant_id = ?`,
+    ).run(...values);
+
+    return this.getLink(userId, tenantId);
+  }
+
+  async deleteLink(userId: string, tenantId: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_user_tenant_links WHERE user_id = ? AND tenant_id = ?`,
+    ).run(userId, tenantId);
+    return result.changes > 0;
+  }
+
+  async hasLink(userId: string, tenantId: string): Promise<boolean> {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_user_tenant_links WHERE user_id = ? AND tenant_id = ? LIMIT 1`,
+    ).get(userId, tenantId);
+    return row !== undefined;
+  }
+}
+
+function mapRowToLink(row: LinkRow): UserTenantLink {
+  return {
+    userId: row.user_id,
+    tenantId: row.tenant_id,
+    role: row.role as UserTenantRole,
+    joinedAt: parseISO(row.joined_at),
+    metadata: JSON.parse(row.metadata || "{}"),
+  };
+}