@libredb/studio 0.9.7

package/src/lib/storage/providers/sqlite.ts

@@ -0,0 +1,153 @@
+/**
+ * SQLite Server Storage Provider
+ * Uses better-sqlite3 (Node.js compatible, works in production runner).
+ * WAL mode enabled for concurrent read performance.
+ */
+
+import type { ServerStorageProvider, StorageCollection, StorageData } from '../types';
+import { STORAGE_COLLECTIONS } from '../types';
+import type BetterSqlite3 from 'better-sqlite3';
+import { logger } from '@/lib/logger';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let Database: any;
+
+export class SQLiteStorageProvider implements ServerStorageProvider {
+  private db: BetterSqlite3.Database | null = null;
+  private dbPath: string;
+
+  constructor(dbPath?: string) {
+    this.dbPath = dbPath || process.env.STORAGE_SQLITE_PATH || './data/libredb-storage.db';
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      // Dynamic import to avoid requiring better-sqlite3 when not needed
+      if (!Database) {
+        const mod = await import('better-sqlite3');
+        Database = mod.default;
+      }
+
+      // Ensure directory exists
+      const path = await import('path');
+      const fs = await import('fs');
+      const dir = path.dirname(this.dbPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      this.db = new Database(this.dbPath) as BetterSqlite3.Database;
+
+      // Enable WAL mode for better concurrent read performance
+      this.db!.pragma('journal_mode = WAL');
+
+      // Create table
+      this.db!.exec(`
+        CREATE TABLE IF NOT EXISTS user_storage (
+          user_id    TEXT NOT NULL,
+          collection TEXT NOT NULL,
+          data       TEXT NOT NULL,
+          updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+          PRIMARY KEY (user_id, collection)
+        )
+      `);
+    } catch (error) {
+      logger.error('SQLite storage initialization failed', error, { provider: 'sqlite', path: this.dbPath });
+      throw error;
+    }
+  }
+
+  async getAllData(userId: string): Promise<Partial<StorageData>> {
+    this.ensureDb();
+    const stmt = this.db!.prepare(
+      'SELECT collection, data FROM user_storage WHERE user_id = ?'
+    );
+    const rows = stmt.all(userId) as { collection: string; data: string }[];
+
+    const result: Partial<StorageData> = {};
+    for (const row of rows) {
+      try {
+        (result as Record<string, unknown>)[row.collection] = JSON.parse(row.data);
+      } catch {
+        logger.warn('Skipping corrupted storage data', { provider: 'sqlite', collection: row.collection });
+      }
+    }
+    return result;
+  }
+
+  async getCollection<K extends StorageCollection>(
+    userId: string,
+    collection: K
+  ): Promise<StorageData[K] | null> {
+    this.ensureDb();
+    const stmt = this.db!.prepare(
+      'SELECT data FROM user_storage WHERE user_id = ? AND collection = ?'
+    );
+    const row = stmt.get(userId, collection) as { data: string } | undefined;
+    if (!row) return null;
+    try {
+      return JSON.parse(row.data) as StorageData[K];
+    } catch {
+      logger.warn('Corrupted data in storage collection', { provider: 'sqlite', collection });
+      return null;
+    }
+  }
+
+  async setCollection<K extends StorageCollection>(
+    userId: string,
+    collection: K,
+    data: StorageData[K]
+  ): Promise<void> {
+    this.ensureDb();
+    const stmt = this.db!.prepare(`
+      INSERT INTO user_storage (user_id, collection, data, updated_at)
+      VALUES (?, ?, ?, datetime('now'))
+      ON CONFLICT (user_id, collection)
+      DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+    stmt.run(userId, collection, JSON.stringify(data));
+  }
+
+  async mergeData(userId: string, data: Partial<StorageData>): Promise<void> {
+    this.ensureDb();
+    const stmt = this.db!.prepare(`
+      INSERT INTO user_storage (user_id, collection, data, updated_at)
+      VALUES (?, ?, ?, datetime('now'))
+      ON CONFLICT (user_id, collection)
+      DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+    `);
+
+    const tx = this.db!.transaction(() => {
+      for (const collection of STORAGE_COLLECTIONS) {
+        const collectionData = (data as Record<string, unknown>)[collection];
+        if (collectionData !== undefined) {
+          stmt.run(userId, collection, JSON.stringify(collectionData));
+        }
+      }
+    });
+    tx();
+  }
+
+  async isHealthy(): Promise<boolean> {
+    try {
+      this.ensureDb();
+      const result = this.db!.prepare('SELECT 1 as ok').get() as { ok: number };
+      return result?.ok === 1;
+    } catch {
+      return false;
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  private ensureDb(): void {
+    if (!this.db) {
+      throw new Error('SQLite storage not initialized. Call initialize() first.');
+    }
+  }
+}

package/src/lib/storage/storage-facade.ts

@@ -0,0 +1,272 @@
+/**
+ * Storage Facade — public API for all storage operations.
+ * Maintains the same sync interface as the original storage.ts.
+ * Dispatches CustomEvent on every mutation for the sync hook.
+ */
+
+import {
+  DatabaseConnection,
+  QueryHistoryItem,
+  SavedQuery,
+  SchemaSnapshot,
+  SavedChartConfig,
+} from '../types';
+import { type AuditEvent } from '../audit';
+import { DEFAULT_MASKING_CONFIG, type MaskingConfig } from '../data-masking';
+import { DEFAULT_THRESHOLDS, type ThresholdConfig } from '../monitoring-thresholds';
+import { readJSON, writeJSON, readString, writeString, remove } from './local-storage';
+import type { StorageCollection } from './types';
+
+const MAX_HISTORY_ITEMS = 500;
+const MAX_SNAPSHOTS = 50;
+const MAX_AUDIT_EVENTS = 1000;
+
+/** Dispatch a custom event to notify the sync hook of a mutation */
+function dispatchChange(collection: StorageCollection, data: unknown): void {
+  if (typeof window === 'undefined') return;
+  window.dispatchEvent(
+    new CustomEvent('libredb-storage-change', {
+      detail: { collection, data },
+    })
+  );
+}
+
+/** Revive Date fields from JSON-parsed objects */
+function reviveDates<T>(items: T[], ...dateFields: string[]): T[] {
+  return items.map((item) => {
+    const revived = { ...item } as Record<string, unknown>;
+    for (const field of dateFields) {
+      if (revived[field]) {
+        revived[field] = new Date(revived[field] as string);
+      }
+    }
+    return revived as unknown as T;
+  });
+}
+
+export const storage = {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Connections
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getConnections: (): DatabaseConnection[] => {
+    const data = readJSON<DatabaseConnection[]>('connections');
+    if (!data) return [];
+    return reviveDates(data, 'createdAt');
+  },
+
+  saveConnection: (connection: DatabaseConnection) => {
+    const connections = storage.getConnections();
+    const existingIndex = connections.findIndex((c) => c.id === connection.id);
+
+    if (existingIndex > -1) {
+      connections[existingIndex] = connection;
+    } else {
+      connections.push(connection);
+    }
+
+    writeJSON('connections', connections);
+    dispatchChange('connections', connections);
+  },
+
+  deleteConnection: (id: string) => {
+    const connections = storage.getConnections();
+    const filtered = connections.filter((c) => c.id !== id);
+    writeJSON('connections', filtered);
+    dispatchChange('connections', filtered);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // History
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getHistory: (): QueryHistoryItem[] => {
+    const data = readJSON<QueryHistoryItem[]>('history');
+    if (!data) return [];
+    return reviveDates(data, 'executedAt');
+  },
+
+  addToHistory: (item: QueryHistoryItem) => {
+    const history = storage.getHistory();
+    const newHistory = [item, ...history].slice(0, MAX_HISTORY_ITEMS);
+    writeJSON('history', newHistory);
+    dispatchChange('history', newHistory);
+  },
+
+  clearHistory: () => {
+    writeJSON('history', []);
+    dispatchChange('history', []);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Saved Queries
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getSavedQueries: (): SavedQuery[] => {
+    const data = readJSON<SavedQuery[]>('saved_queries');
+    if (!data) return [];
+    return reviveDates(data, 'createdAt', 'updatedAt');
+  },
+
+  saveQuery: (query: SavedQuery) => {
+    const queries = storage.getSavedQueries();
+    const existingIndex = queries.findIndex((q) => q.id === query.id);
+
+    if (existingIndex > -1) {
+      queries[existingIndex] = { ...query, updatedAt: new Date() };
+    } else {
+      queries.push({ ...query, createdAt: new Date(), updatedAt: new Date() });
+    }
+
+    writeJSON('saved_queries', queries);
+    dispatchChange('saved_queries', queries);
+  },
+
+  deleteSavedQuery: (id: string) => {
+    const queries = storage.getSavedQueries();
+    const filtered = queries.filter((q) => q.id !== id);
+    writeJSON('saved_queries', filtered);
+    dispatchChange('saved_queries', filtered);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Schema Snapshots
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getSchemaSnapshots: (connectionId?: string): SchemaSnapshot[] => {
+    const data = readJSON<SchemaSnapshot[]>('schema_snapshots');
+    if (!data) return [];
+    const snapshots = reviveDates(data, 'createdAt');
+    if (connectionId) {
+      return snapshots.filter((s) => s.connectionId === connectionId);
+    }
+    return snapshots;
+  },
+
+  saveSchemaSnapshot: (snapshot: SchemaSnapshot) => {
+    const snapshots = storage.getSchemaSnapshots();
+    snapshots.push({ ...snapshot, createdAt: new Date() });
+    const trimmed = snapshots.slice(-MAX_SNAPSHOTS);
+    writeJSON('schema_snapshots', trimmed);
+    dispatchChange('schema_snapshots', trimmed);
+  },
+
+  deleteSchemaSnapshot: (id: string) => {
+    const snapshots = storage.getSchemaSnapshots();
+    const filtered = snapshots.filter((s) => s.id !== id);
+    writeJSON('schema_snapshots', filtered);
+    dispatchChange('schema_snapshots', filtered);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Saved Charts
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getSavedCharts: (): SavedChartConfig[] => {
+    const data = readJSON<SavedChartConfig[]>('saved_charts');
+    if (!data) return [];
+    return reviveDates(data, 'createdAt');
+  },
+
+  saveChart: (chart: SavedChartConfig) => {
+    const charts = storage.getSavedCharts();
+    const existingIndex = charts.findIndex((c) => c.id === chart.id);
+    if (existingIndex > -1) {
+      charts[existingIndex] = chart;
+    } else {
+      charts.push({ ...chart, createdAt: new Date() });
+    }
+    writeJSON('saved_charts', charts);
+    dispatchChange('saved_charts', charts);
+  },
+
+  deleteChart: (id: string) => {
+    const charts = storage.getSavedCharts();
+    const filtered = charts.filter((c) => c.id !== id);
+    writeJSON('saved_charts', filtered);
+    dispatchChange('saved_charts', filtered);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Active Connection ID
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getActiveConnectionId: (): string | null => {
+    return readString('active_connection_id');
+  },
+
+  setActiveConnectionId: (id: string | null) => {
+    if (typeof window === 'undefined') return;
+    if (id) {
+      writeString('active_connection_id', id);
+    } else {
+      remove('active_connection_id');
+    }
+    dispatchChange('active_connection_id', id);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Audit Log (consolidated from audit.ts)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getAuditLog: (): AuditEvent[] => {
+    const data = readJSON<AuditEvent[]>('audit_log');
+    return data ?? [];
+  },
+
+  saveAuditLog: (events: AuditEvent[]) => {
+    const trimmed = events.slice(-MAX_AUDIT_EVENTS);
+    writeJSON('audit_log', trimmed);
+    dispatchChange('audit_log', trimmed);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Masking Config (consolidated from data-masking.ts)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getMaskingConfig: (): MaskingConfig => {
+    const data = readJSON<MaskingConfig>('masking_config');
+    if (!data) return DEFAULT_MASKING_CONFIG;
+
+    // Merge with defaults to ensure new builtin patterns are included
+    const builtinIds = new Set(
+      DEFAULT_MASKING_CONFIG.patterns.filter((p) => p.isBuiltin).map((p) => p.id)
+    );
+    const storedIds = new Set(data.patterns.map((p) => p.id));
+
+    for (const defaultPattern of DEFAULT_MASKING_CONFIG.patterns) {
+      if (defaultPattern.isBuiltin && !storedIds.has(defaultPattern.id)) {
+        data.patterns.push(defaultPattern);
+      }
+    }
+
+    if (!data.roleSettings) {
+      data.roleSettings = DEFAULT_MASKING_CONFIG.roleSettings;
+    }
+
+    data.patterns = data.patterns.filter(
+      (p) => !p.isBuiltin || builtinIds.has(p.id) || !p.id.startsWith('builtin-')
+    );
+
+    return data;
+  },
+
+  saveMaskingConfig: (config: MaskingConfig) => {
+    writeJSON('masking_config', config);
+    dispatchChange('masking_config', config);
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Threshold Config (consolidated from SecurityTab.tsx)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  getThresholdConfig: (): ThresholdConfig[] => {
+    const data = readJSON<ThresholdConfig[]>('threshold_config');
+    return data ?? DEFAULT_THRESHOLDS;
+  },
+
+  saveThresholdConfig: (thresholds: ThresholdConfig[]) => {
+    writeJSON('threshold_config', thresholds);
+    dispatchChange('threshold_config', thresholds);
+  },
+};

package/src/lib/storage/types.ts

@@ -0,0 +1,75 @@
+import type {
+  DatabaseConnection,
+  QueryHistoryItem,
+  SavedQuery,
+  SchemaSnapshot,
+  SavedChartConfig,
+} from '../types';
+import type { AuditEvent } from '../audit';
+import type { MaskingConfig } from '../data-masking';
+import type { ThresholdConfig } from '../monitoring-thresholds';
+
+/**
+ * All persistable collections and their data types.
+ * Maps 1:1 with localStorage keys (minus the `libredb_` prefix).
+ */
+export interface StorageData {
+  connections: DatabaseConnection[];
+  history: QueryHistoryItem[];
+  saved_queries: SavedQuery[];
+  schema_snapshots: SchemaSnapshot[];
+  saved_charts: SavedChartConfig[];
+  active_connection_id: string | null;
+  audit_log: AuditEvent[];
+  masking_config: MaskingConfig;
+  threshold_config: ThresholdConfig[];
+}
+
+/** Collection names that can be synced to server storage */
+export type StorageCollection = keyof StorageData;
+
+/** All persistable collection names */
+export const STORAGE_COLLECTIONS: StorageCollection[] = [
+  'connections',
+  'history',
+  'saved_queries',
+  'schema_snapshots',
+  'saved_charts',
+  'active_connection_id',
+  'audit_log',
+  'masking_config',
+  'threshold_config',
+];
+
+/**
+ * Server-side storage provider interface.
+ * Implements the Strategy Pattern — SQLite and PostgreSQL both implement this.
+ */
+export interface ServerStorageProvider {
+  /** Create tables if they don't exist */
+  initialize(): Promise<void>;
+  /** Get all collections for a user */
+  getAllData(userId: string): Promise<Partial<StorageData>>;
+  /** Get a single collection for a user */
+  getCollection<K extends StorageCollection>(userId: string, collection: K): Promise<StorageData[K] | null>;
+  /** Set a single collection for a user */
+  setCollection<K extends StorageCollection>(userId: string, collection: K, data: StorageData[K]): Promise<void>;
+  /** Merge multiple collections (used for migration) */
+  mergeData(userId: string, data: Partial<StorageData>): Promise<void>;
+  /** Health check */
+  isHealthy(): Promise<boolean>;
+  /** Cleanup resources */
+  close(): Promise<void>;
+}
+
+/** Storage config returned by /api/storage/config */
+export interface StorageConfigResponse {
+  provider: 'local' | 'sqlite' | 'postgres';
+  serverMode: boolean;
+}
+
+/** Event dispatched on storage mutations */
+export interface StorageChangeDetail {
+  collection: StorageCollection;
+  data: unknown;
+}

package/src/lib/time-series-buffer.ts

@@ -0,0 +1,58 @@
+export interface TimeSeriesPoint<T> {
+  timestamp: number;
+  data: T;
+}
+
+export class TimeSeriesBuffer<T> {
+  private buffer: TimeSeriesPoint<T>[];
+  private head: number = 0;
+  private count: number = 0;
+  private readonly maxSize: number;
+
+  constructor(maxSize: number = 120) {
+    this.maxSize = maxSize;
+    this.buffer = new Array(maxSize);
+  }
+
+  push(data: T): void {
+    const point: TimeSeriesPoint<T> = {
+      timestamp: Date.now(),
+      data,
+    };
+    this.buffer[this.head] = point;
+    this.head = (this.head + 1) % this.maxSize;
+    if (this.count < this.maxSize) {
+      this.count++;
+    }
+  }
+
+  getAll(): TimeSeriesPoint<T>[] {
+    if (this.count === 0) return [];
+    const result: TimeSeriesPoint<T>[] = [];
+    const start = this.count < this.maxSize ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      const idx = (start + i) % this.maxSize;
+      result.push(this.buffer[idx]);
+    }
+    return result;
+  }
+
+  getRange(from: number, to: number): TimeSeriesPoint<T>[] {
+    return this.getAll().filter(p => p.timestamp >= from && p.timestamp <= to);
+  }
+
+  getLast(n: number): TimeSeriesPoint<T>[] {
+    const all = this.getAll();
+    return all.slice(Math.max(0, all.length - n));
+  }
+
+  clear(): void {
+    this.buffer = new Array(this.maxSize);
+    this.head = 0;
+    this.count = 0;
+  }
+
+  get size(): number {
+    return this.count;
+  }
+}