@axiom-lattice/local-stores 1.0.1

package/src/stores/LocalChannelBindingStore.ts

@@ -0,0 +1,204 @@
+/**
+ * Local SQLite implementation of ChannelBindingStore (BindingRegistry).
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  Binding,
+  BindingRegistry,
+  CreateBindingInput,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { randomUUID } from "crypto";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_channel_bindings (
+  id TEXT PRIMARY KEY,
+  channel TEXT NOT NULL,
+  channel_installation_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  sender_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  thread_id TEXT,
+  workspace_id TEXT,
+  project_id TEXT,
+  thread_mode TEXT NOT NULL DEFAULT 'fixed',
+  sender_display_name TEXT,
+  sender_metadata TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_cb_resolve ON lt_channel_bindings(channel, sender_id, channel_installation_id, tenant_id);
+`;
+
+interface BindingRow {
+  id: string;
+  channel: string;
+  channel_installation_id: string;
+  tenant_id: string;
+  sender_id: string;
+  agent_id: string;
+  thread_id: string | null;
+  workspace_id: string | null;
+  project_id: string | null;
+  thread_mode: string;
+  sender_display_name: string | null;
+  sender_metadata: string | null;
+  enabled: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalChannelBindingStore implements BindingRegistry {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async resolve(params: {
+    channel: string;
+    senderId: string;
+    channelInstallationId: string;
+    tenantId: string;
+  }): Promise<Binding | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_channel_bindings
+       WHERE channel = ? AND sender_id = ? AND channel_installation_id = ? AND tenant_id = ? AND enabled = 1
+       LIMIT 1`,
+    ).get(params.channel, params.senderId, params.channelInstallationId, params.tenantId) as unknown as BindingRow | undefined;
+    return row ? mapRowToBinding(row) : null;
+  }
+
+  async create(input: CreateBindingInput): Promise<Binding> {
+    const id = randomUUID();
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_channel_bindings
+       (id, channel, channel_installation_id, tenant_id, sender_id, agent_id,
+        thread_mode, sender_display_name, sender_metadata, workspace_id, project_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id, input.channel, input.channelInstallationId, input.tenantId,
+      input.senderId, input.agentId, input.threadMode || "fixed",
+      input.senderDisplayName || null,
+      input.senderMetadata ? JSON.stringify(input.senderMetadata) : null,
+      input.workspaceId || null, input.projectId || null,
+      now, now,
+    );
+
+    return (await this.getById(id))!;
+  }
+
+  async update(id: string, patch: Partial<Binding>): Promise<Binding> {
+    const existing = await this.getById(id);
+    if (!existing) throw new Error(`Binding ${id} not found`);
+
+    const updated = {
+      channel: patch.channel ?? existing.channel,
+      channelInstallationId: patch.channelInstallationId ?? existing.channelInstallationId,
+      senderId: patch.senderId ?? existing.senderId,
+      agentId: patch.agentId ?? existing.agentId,
+      threadId: patch.threadId !== undefined ? patch.threadId : existing.threadId,
+      workspaceId: patch.workspaceId !== undefined ? patch.workspaceId : existing.workspaceId,
+      projectId: patch.projectId !== undefined ? patch.projectId : existing.projectId,
+      threadMode: patch.threadMode ?? existing.threadMode,
+      senderDisplayName: patch.senderDisplayName !== undefined ? patch.senderDisplayName : existing.senderDisplayName,
+      senderMetadata: patch.senderMetadata !== undefined ? patch.senderMetadata : existing.senderMetadata,
+      enabled: patch.enabled ?? existing.enabled,
+    };
+
+    const now = nowISO();
+
+    this.db.prepare(
+      `UPDATE lt_channel_bindings SET
+         channel = ?, channel_installation_id = ?, sender_id = ?, agent_id = ?,
+         thread_id = ?, workspace_id = ?, project_id = ?, thread_mode = ?,
+         sender_display_name = ?, sender_metadata = ?, enabled = ?, updated_at = ?
+       WHERE id = ?`,
+    ).run(
+      updated.channel, updated.channelInstallationId, updated.senderId,
+      updated.agentId, updated.threadId || null, updated.workspaceId || null,
+      updated.projectId || null, updated.threadMode, updated.senderDisplayName || null,
+      updated.senderMetadata ? JSON.stringify(updated.senderMetadata) : null,
+      updated.enabled ? 1 : 0, now, id,
+    );
+
+    return (await this.getById(id))!;
+  }
+
+  async delete(id: string): Promise<void> {
+    this.db.prepare(`DELETE FROM lt_channel_bindings WHERE id = ?`).run(id);
+  }
+
+  async list(params: {
+    channel?: string;
+    agentId?: string;
+    tenantId: string;
+    channelInstallationId?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<Binding[]> {
+    const conditions: string[] = ["tenant_id = ?"];
+    const values: unknown[] = [params.tenantId];
+
+    if (params.channel) { conditions.push("channel = ?"); values.push(params.channel); }
+    if (params.agentId) { conditions.push("agent_id = ?"); values.push(params.agentId); }
+    if (params.channelInstallationId) { conditions.push("channel_installation_id = ?"); values.push(params.channelInstallationId); }
+
+    const limit = params.limit ?? 50;
+    const offset = params.offset ?? 0;
+    values.push(limit, offset);
+
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_channel_bindings
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY created_at DESC
+       LIMIT ? OFFSET ?`,
+    ).all(...values) as unknown as BindingRow[];
+
+    return rows.map(mapRowToBinding);
+  }
+
+  async import(bindings: CreateBindingInput[]): Promise<Binding[]> {
+    const result: Binding[] = [];
+    for (const input of bindings) {
+      result.push(await this.create(input));
+    }
+    return result;
+  }
+
+  async export(params: { tenantId: string }): Promise<Binding[]> {
+    return this.list({ tenantId: params.tenantId, limit: 10000, offset: 0 });
+  }
+
+  private async getById(id: string): Promise<Binding | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_channel_bindings WHERE id = ?`,
+    ).get(id) as unknown as BindingRow | undefined;
+    return row ? mapRowToBinding(row) : null;
+  }
+}
+
+function mapRowToBinding(row: BindingRow): Binding {
+  return {
+    id: row.id,
+    channel: row.channel,
+    channelInstallationId: row.channel_installation_id,
+    tenantId: row.tenant_id,
+    senderId: row.sender_id,
+    agentId: row.agent_id,
+    threadId: row.thread_id || undefined,
+    workspaceId: row.workspace_id || undefined,
+    projectId: row.project_id || undefined,
+    threadMode: row.thread_mode as Binding["threadMode"],
+    senderDisplayName: row.sender_display_name || undefined,
+    senderMetadata: row.sender_metadata ? JSON.parse(row.sender_metadata) : undefined,
+    enabled: row.enabled === 1,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalChannelInstallationStore.ts

@@ -0,0 +1,170 @@
+/**
+ * Local SQLite implementation of ChannelInstallationStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  ChannelInstallationStore,
+  ChannelInstallation,
+  ChannelInstallationType,
+  CreateChannelInstallationRequest,
+  UpdateChannelInstallationRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_channel_installations (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  channel TEXT NOT NULL,
+  name TEXT,
+  config TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  fallback_agent_id TEXT,
+  reject_when_no_binding INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_ci_tenant ON lt_channel_installations(tenant_id);
+`;
+
+interface Row {
+  id: string;
+  tenant_id: string;
+  channel: string;
+  name: string | null;
+  config: string;
+  enabled: number;
+  fallback_agent_id: string | null;
+  reject_when_no_binding: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalChannelInstallationStore implements ChannelInstallationStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getInstallationById(installationId: string): Promise<ChannelInstallation | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_channel_installations WHERE id = ?`,
+    ).get(installationId) as Row | undefined;
+    return row ? mapRow(row) : null;
+  }
+
+  async getInstallationsByTenant(
+    tenantId: string,
+    channel?: ChannelInstallationType,
+  ): Promise<ChannelInstallation[]> {
+    let rows: Row[];
+    if (channel) {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_channel_installations WHERE tenant_id = ? AND channel = ? ORDER BY created_at DESC`,
+      ).all(tenantId, channel) as Row[];
+    } else {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_channel_installations WHERE tenant_id = ? ORDER BY created_at DESC`,
+      ).all(tenantId) as Row[];
+    }
+    return rows.map(mapRow);
+  }
+
+  async createInstallation(
+    tenantId: string,
+    installationId: string,
+    data: CreateChannelInstallationRequest,
+  ): Promise<ChannelInstallation> {
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_channel_installations
+       (id, tenant_id, channel, name, config, enabled, fallback_agent_id, reject_when_no_binding, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         channel = excluded.channel,
+         name = excluded.name,
+         config = excluded.config,
+         enabled = excluded.enabled,
+         fallback_agent_id = excluded.fallback_agent_id,
+         reject_when_no_binding = excluded.reject_when_no_binding,
+         updated_at = excluded.updated_at`,
+    ).run(
+      installationId, tenantId, data.channel,
+      data.name || null, JSON.stringify(data.config),
+      data.enabled !== false ? 1 : 0,
+      data.fallbackAgentId || null,
+      data.rejectWhenNoBinding ? 1 : 0,
+      now, now,
+    );
+
+    return {
+      id: installationId,
+      tenantId,
+      channel: data.channel,
+      name: data.name,
+      config: data.config,
+      enabled: data.enabled !== false,
+      fallbackAgentId: data.fallbackAgentId,
+      rejectWhenNoBinding: data.rejectWhenNoBinding ?? false,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateInstallation(
+    tenantId: string,
+    installationId: string,
+    updates: UpdateChannelInstallationRequest,
+  ): Promise<ChannelInstallation | null> {
+    const existing = await this.getInstallationById(installationId);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.name !== undefined) { setClauses.push("name = ?"); values.push(updates.name || null); }
+    if (updates.config !== undefined) { setClauses.push("config = ?"); values.push(JSON.stringify(updates.config)); }
+    if (updates.enabled !== undefined) { setClauses.push("enabled = ?"); values.push(updates.enabled ? 1 : 0); }
+    if (updates.fallbackAgentId !== undefined) { setClauses.push("fallback_agent_id = ?"); values.push(updates.fallbackAgentId || null); }
+    if (updates.rejectWhenNoBinding !== undefined) { setClauses.push("reject_when_no_binding = ?"); values.push(updates.rejectWhenNoBinding ? 1 : 0); }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(installationId);
+
+    this.db.prepare(
+      `UPDATE lt_channel_installations SET ${setClauses.join(", ")} WHERE id = ?`,
+    ).run(...values);
+
+    return this.getInstallationById(installationId);
+  }
+
+  async deleteInstallation(tenantId: string, installationId: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_channel_installations WHERE id = ? AND tenant_id = ?`,
+    ).run(installationId, tenantId);
+    return result.changes > 0;
+  }
+}
+
+function mapRow(row: Row): ChannelInstallation {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    channel: row.channel as ChannelInstallationType,
+    name: row.name || undefined,
+    config: JSON.parse(row.config),
+    enabled: row.enabled === 1,
+    fallbackAgentId: row.fallback_agent_id || undefined,
+    rejectWhenNoBinding: row.reject_when_no_binding === 1,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalDatabaseConfigStore.ts

@@ -0,0 +1,183 @@
+/**
+ * Local SQLite implementation of DatabaseConfigStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  DatabaseConfigStore,
+  DatabaseConfigEntry,
+  CreateDatabaseConfigRequest,
+  UpdateDatabaseConfigRequest,
+  DatabaseConfig,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { encrypt, decrypt } from "@axiom-lattice/core";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_database_configs (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  name TEXT,
+  description TEXT,
+  config TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_dbconfig_key ON lt_database_configs(tenant_id, key);
+`;
+
+interface ConfigRow {
+  id: string;
+  tenant_id: string;
+  key: string;
+  name: string | null;
+  description: string | null;
+  config: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalDatabaseConfigStore implements DatabaseConfigStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllConfigs(tenantId: string): Promise<DatabaseConfigEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_database_configs WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as ConfigRow[];
+    return rows.map((r) => mapRowToEntry(r));
+  }
+
+  async getAllConfigsWithoutTenant(): Promise<DatabaseConfigEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_database_configs ORDER BY created_at DESC`,
+    ).all() as unknown as ConfigRow[];
+    return rows.map((r) => mapRowToEntry(r));
+  }
+
+  async getConfigById(tenantId: string, id: string): Promise<DatabaseConfigEntry | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_database_configs WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as ConfigRow | undefined;
+    return row ? mapRowToEntry(row) : null;
+  }
+
+  async getConfigByKey(tenantId: string, key: string): Promise<DatabaseConfigEntry | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_database_configs WHERE tenant_id = ? AND key = ?`,
+    ).get(tenantId, key) as unknown as ConfigRow | undefined;
+    return row ? mapRowToEntry(row) : null;
+  }
+
+  async createConfig(
+    tenantId: string,
+    id: string,
+    data: CreateDatabaseConfigRequest,
+  ): Promise<DatabaseConfigEntry> {
+    const now = nowISO();
+    const configWithEncrypted = encryptPasswordInConfig(data.config);
+
+    this.db.prepare(
+      `INSERT INTO lt_database_configs (id, tenant_id, key, name, description, config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         key = excluded.key,
+         name = excluded.name,
+         description = excluded.description,
+         config = excluded.config,
+         updated_at = excluded.updated_at`,
+    ).run(id, tenantId, data.key, data.name || null, data.description || null, JSON.stringify(configWithEncrypted), now, now);
+
+    return {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateConfig(
+    tenantId: string,
+    id: string,
+    updates: Partial<UpdateDatabaseConfigRequest>,
+  ): Promise<DatabaseConfigEntry | null> {
+    const existing = await this.getConfigById(tenantId, id);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.key !== undefined) { setClauses.push("key = ?"); values.push(updates.key); }
+    if (updates.name !== undefined) { setClauses.push("name = ?"); values.push(updates.name || null); }
+    if (updates.description !== undefined) { setClauses.push("description = ?"); values.push(updates.description || null); }
+    if (updates.config !== undefined) {
+      setClauses.push("config = ?");
+      values.push(JSON.stringify(encryptPasswordInConfig(updates.config)));
+    }
+
+    if (setClauses.length === 0) return existing;
+
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+
+    this.db.prepare(
+      `UPDATE lt_database_configs SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...values);
+
+    return this.getConfigById(tenantId, id);
+  }
+
+  async deleteConfig(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_database_configs WHERE tenant_id = ? AND id = ?`,
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+
+  async hasConfig(tenantId: string, id: string): Promise<boolean> {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_database_configs WHERE tenant_id = ? AND id = ? LIMIT 1`,
+    ).get(tenantId, id);
+    return row !== undefined;
+  }
+}
+
+function mapRowToEntry(row: ConfigRow): DatabaseConfigEntry {
+  const config = JSON.parse(row.config) as DatabaseConfig;
+  if (config.password) {
+    try {
+      config.password = decrypt(config.password);
+    } catch {
+      // password might not be encrypted (legacy data)
+    }
+  }
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.key,
+    config,
+    name: row.name || undefined,
+    description: row.description || undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}
+
+function encryptPasswordInConfig(config: DatabaseConfig): DatabaseConfig {
+  if (config.password) {
+    return { ...config, password: encrypt(config.password) };
+  }
+  return config;
+}