@libredb/studio 0.9.7 → 0.9.12

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

@@ -1,153 +0,0 @@
-/**
- * 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

@@ -1,272 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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;
-  }
-}