@axiom-lattice/local-stores 1.0.1

package/src/stores/LocalMcpServerConfigStore.ts

@@ -0,0 +1,223 @@
+/**
+ * Local SQLite implementation of McpServerConfigStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  McpServerConfigStore,
+  McpServerConfigEntry,
+  CreateMcpServerConfigRequest,
+  UpdateMcpServerConfigRequest,
+  McpServerConfig,
+} 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_mcp_configs (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  name TEXT,
+  description TEXT,
+  config TEXT NOT NULL,
+  selected_tools TEXT DEFAULT '[]',
+  is_env_encrypted INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'disconnected',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_mcp_key ON lt_mcp_configs(tenant_id, key);
+`;
+
+interface ConfigRow {
+  id: string;
+  tenant_id: string;
+  key: string;
+  name: string | null;
+  description: string | null;
+  config: string;
+  selected_tools: string;
+  is_env_encrypted: number;
+  status: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalMcpServerConfigStore implements McpServerConfigStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllConfigs(tenantId: string): Promise<McpServerConfigEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_mcp_configs WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as ConfigRow[];
+    return rows.map(mapRowToEntry);
+  }
+
+  async getAllConfigsWithoutTenant(): Promise<McpServerConfigEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_mcp_configs ORDER BY created_at DESC`,
+    ).all() as unknown as ConfigRow[];
+    return rows.map(mapRowToEntry);
+  }
+
+  async getConfigById(tenantId: string, id: string): Promise<McpServerConfigEntry | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_mcp_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<McpServerConfigEntry | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_mcp_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: CreateMcpServerConfigRequest,
+  ): Promise<McpServerConfigEntry> {
+    const now = nowISO();
+    const { config: configWithEncryptedEnv, isEnvEncrypted } = encryptEnvInConfig(data.config);
+
+    this.db.prepare(
+      `INSERT INTO lt_mcp_configs (id, tenant_id, key, name, description, config, selected_tools, is_env_encrypted, status, 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,
+         selected_tools = excluded.selected_tools,
+         is_env_encrypted = excluded.is_env_encrypted,
+         status = excluded.status,
+         updated_at = excluded.updated_at`,
+    ).run(
+      id, tenantId, data.key, data.name || null, data.description || null,
+      JSON.stringify(configWithEncryptedEnv),
+      JSON.stringify(data.selectedTools || []),
+      isEnvEncrypted ? 1 : 0, "disconnected",
+      now, now,
+    );
+
+    return {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      selectedTools: data.selectedTools || [],
+      isEnvEncrypted,
+      status: "disconnected",
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateConfig(
+    tenantId: string,
+    id: string,
+    updates: Partial<UpdateMcpServerConfigRequest>,
+  ): Promise<McpServerConfigEntry | 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) {
+      const { config: configWithEncryptedEnv, isEnvEncrypted } = encryptEnvInConfig(updates.config);
+      setClauses.push("config = ?"); values.push(JSON.stringify(configWithEncryptedEnv));
+      setClauses.push("is_env_encrypted = ?"); values.push(isEnvEncrypted ? 1 : 0);
+    }
+    if (updates.selectedTools !== undefined) { setClauses.push("selected_tools = ?"); values.push(JSON.stringify(updates.selectedTools)); }
+    if (updates.status !== undefined) { setClauses.push("status = ?"); values.push(updates.status); }
+
+    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_mcp_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_mcp_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_mcp_configs WHERE tenant_id = ? AND id = ? LIMIT 1`,
+    ).get(tenantId, id);
+    return row !== undefined;
+  }
+}
+
+function mapRowToEntry(row: ConfigRow): McpServerConfigEntry {
+  const config: McpServerConfig = JSON.parse(row.config);
+
+  if (config.env && row.is_env_encrypted) {
+    try {
+      const decryptedEnv: Record<string, string> = {};
+      for (const [key, value] of Object.entries(config.env)) {
+        decryptedEnv[key] = decrypt(value);
+      }
+      config.env = decryptedEnv;
+    } catch (error) {
+      console.error("Failed to decrypt MCP server env:", error);
+      throw new Error("Failed to decrypt MCP server configuration");
+    }
+  }
+
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.key,
+    config,
+    name: row.name || undefined,
+    description: row.description || undefined,
+    selectedTools: JSON.parse(row.selected_tools || "[]"),
+    isEnvEncrypted: row.is_env_encrypted === 1,
+    status: row.status as McpServerConfigEntry["status"],
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}
+
+function encryptEnvInConfig(config: McpServerConfig): { config: McpServerConfig; isEnvEncrypted: boolean } {
+  const configCopy = { ...config };
+  let isEnvEncrypted = false;
+
+  if (configCopy.env && Object.keys(configCopy.env).length > 0) {
+    const encryptedEnv: Record<string, string> = {};
+    for (const [key, value] of Object.entries(configCopy.env)) {
+      encryptedEnv[key] = encrypt(value);
+    }
+    configCopy.env = encryptedEnv;
+    isEnvEncrypted = true;
+  }
+
+  return { config: configCopy, isEnvEncrypted };
+}

package/src/stores/LocalMetricsServerConfigStore.ts

@@ -0,0 +1,162 @@
+/**
+ * Local SQLite implementation of MetricsServerConfigStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  MetricsServerConfigStore,
+  MetricsServerConfigEntry,
+  CreateMetricsServerConfigRequest,
+  UpdateMetricsServerConfigRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_metrics_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_metrics_key ON lt_metrics_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 LocalMetricsServerConfigStore implements MetricsServerConfigStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getAllConfigs(tenantId: string): Promise<MetricsServerConfigEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_metrics_configs WHERE tenant_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId) as unknown as ConfigRow[];
+    return rows.map(mapRowToEntry);
+  }
+
+  async getAllConfigsWithoutTenant(): Promise<MetricsServerConfigEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_metrics_configs ORDER BY created_at DESC`,
+    ).all() as unknown as ConfigRow[];
+    return rows.map(mapRowToEntry);
+  }
+
+  async getConfigById(tenantId: string, id: string): Promise<MetricsServerConfigEntry | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_metrics_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<MetricsServerConfigEntry | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_metrics_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: CreateMetricsServerConfigRequest,
+  ): Promise<MetricsServerConfigEntry> {
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_metrics_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(data.config), 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<UpdateMetricsServerConfigRequest>,
+  ): Promise<MetricsServerConfigEntry | 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(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_metrics_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_metrics_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_metrics_configs WHERE tenant_id = ? AND id = ? LIMIT 1`,
+    ).get(tenantId, id);
+    return row !== undefined;
+  }
+}
+
+function mapRowToEntry(row: ConfigRow): MetricsServerConfigEntry {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.key,
+    config: JSON.parse(row.config),
+    name: row.name || undefined,
+    description: row.description || undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}

package/src/stores/LocalProjectStore.ts

@@ -0,0 +1,150 @@
+/**
+ * Local SQLite implementation of ProjectStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  ProjectStore,
+  Project,
+  CreateProjectRequest,
+  UpdateProjectRequest,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_projects (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  config TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_projects_workspace ON lt_projects(tenant_id, workspace_id);
+`;
+
+interface ProjectRow {
+  id: string;
+  tenant_id: string;
+  workspace_id: string;
+  name: string;
+  description: string | null;
+  config: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export class LocalProjectStore implements ProjectStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+
+  async getProjectsByWorkspace(tenantId: string, workspaceId: string): Promise<Project[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_projects WHERE tenant_id = ? AND workspace_id = ? ORDER BY created_at DESC`,
+    ).all(tenantId, workspaceId) as unknown as ProjectRow[];
+    return rows.map(mapRowToProject);
+  }
+
+  async getProjectById(tenantId: string, id: string): Promise<Project | null> {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_projects WHERE tenant_id = ? AND id = ?`,
+    ).get(tenantId, id) as unknown as ProjectRow | undefined;
+    return row ? mapRowToProject(row) : null;
+  }
+
+  async createProject(
+    tenantId: string,
+    workspaceId: string,
+    id: string,
+    data: CreateProjectRequest,
+  ): Promise<Project> {
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_projects (id, tenant_id, workspace_id, name, description, config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         workspace_id = excluded.workspace_id,
+         name = excluded.name,
+         description = excluded.description,
+         config = excluded.config,
+         updated_at = excluded.updated_at`,
+    ).run(id, tenantId, workspaceId, data.name, data.description || null, data.config ? JSON.stringify(data.config) : null, now, now);
+
+    return {
+      id,
+      tenantId,
+      workspaceId,
+      name: data.name,
+      description: data.description,
+      config: data.config,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now),
+    };
+  }
+
+  async updateProject(
+    tenantId: string,
+    id: string,
+    updates: UpdateProjectRequest,
+  ): Promise<Project | null> {
+    const existing = await this.getProjectById(tenantId, id);
+    if (!existing) return null;
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    if (updates.name !== undefined) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== undefined) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.config !== undefined) {
+      setClauses.push("config = ?");
+      values.push(updates.config ? JSON.stringify(updates.config) : null);
+    }
+
+    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_projects SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`,
+    ).run(...values);
+
+    return this.getProjectById(tenantId, id);
+  }
+
+  async deleteProject(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_projects WHERE tenant_id = ? AND id = ?`,
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+}
+
+function mapRowToProject(row: ProjectRow): Project {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    workspaceId: row.workspace_id,
+    name: row.name,
+    description: row.description || undefined,
+    config: row.config ? JSON.parse(row.config) as Record<string, unknown> : undefined,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at),
+  };
+}