@libredb/studio 0.9.7 → 0.9.12

package/src/lib/sql/types.ts

@@ -1,40 +0,0 @@
-/**
- * SQL Alias Extraction Types
- *
- * Type definitions for the SQL alias extraction module used by Monaco Editor
- * completion provider.
- */
-
-/**
- * Represents a table alias mapping in a SQL query
- */
-export interface TableAlias {
-  /** The alias name (e.g., 'c' in 'customer AS c') */
-  alias: string;
-  /** The original table name (e.g., 'customer') */
-  tableName: string;
-  /** Optional schema prefix (e.g., 'public' in 'public.customer') */
-  schema?: string;
-  /** Source of the alias definition */
-  source: 'from' | 'join' | 'cte';
-}
-
-/**
- * Result of alias extraction from a SQL query
- */
-export interface AliasExtractionResult {
-  /** Map of alias (lowercase) -> TableAlias */
-  aliases: Map<string, TableAlias>;
-  /** Whether the query contains extractable table references */
-  hasTableReferences: boolean;
-}
-
-/**
- * Options for alias extraction
- */
-export interface AliasExtractorOptions {
-  /** Include CTE aliases (WITH clause) - default: true */
-  includeCTEs?: boolean;
-  /** Case-insensitive alias matching - default: true */
-  caseInsensitive?: boolean;
-}

package/src/lib/ssh/tunnel.ts

@@ -1,142 +0,0 @@
-/**
- * SSH Tunnel Manager
- * Creates SSH tunnels for database connections behind firewalls/bastion hosts.
- * Uses ssh2 library for tunnel creation.
- */
-
-import { Client } from 'ssh2';
-import net from 'net';
-import type { SSHTunnelConfig } from '@/lib/types';
-import { logger } from '@/lib/logger';
-
-export interface TunnelInfo {
-  localHost: string;
-  localPort: number;
-  close: () => Promise<void>;
-}
-
-// Cache active tunnels by connection ID
-const activeTunnels = new Map<string, TunnelInfo>();
-
-/**
- * Create an SSH tunnel for a database connection.
- * Returns the local host/port to connect the database client to.
- */
-export async function createSSHTunnel(
-  connectionId: string,
-  sshConfig: SSHTunnelConfig,
-  remoteHost: string,
-  remotePort: number
-): Promise<TunnelInfo> {
-  // Return existing tunnel if already active
-  // Note: cached tunnel may be stale if the SSH connection dropped silently.
-  // Callers should handle connection errors and call closeSSHTunnel() to evict stale entries.
-  const existing = activeTunnels.get(connectionId);
-  if (existing) {
-    return existing;
-  }
-
-  return new Promise((resolve, reject) => {
-    const sshClient = new Client();
-    let localServer: net.Server | null = null;
-
-    const cleanup = async () => {
-      activeTunnels.delete(connectionId);
-      if (localServer) {
-        localServer.close();
-        localServer = null;
-      }
-      sshClient.end();
-    };
-
-    sshClient.on('ready', () => {
-      // Create a local TCP server that forwards to the remote host through SSH
-      localServer = net.createServer((socket) => {
-        sshClient.forwardOut(
-          '127.0.0.1',
-          0,
-          remoteHost,
-          remotePort,
-          (err, stream) => {
-            if (err) {
-              socket.end();
-              return;
-            }
-            // Prevent unhandled stream errors from crashing the process
-            stream.on('error', () => { socket.destroy(); });
-            socket.on('error', () => { stream.close(); });
-            socket.pipe(stream).pipe(socket);
-          }
-        );
-      });
-
-      // Attach error handler before listen to catch bind/listen errors
-      localServer.on('error', (err) => {
-        cleanup();
-        reject(new Error(`SSH tunnel local server error: ${err.message}`));
-      });
-
-      // Listen on a random available port
-      localServer.listen(0, '127.0.0.1', () => {
-        const address = localServer!.address() as net.AddressInfo;
-        const tunnelInfo: TunnelInfo = {
-          localHost: '127.0.0.1',
-          localPort: address.port,
-          close: cleanup,
-        };
-        activeTunnels.set(connectionId, tunnelInfo);
-        logger.info(`Tunnel created for ${connectionId}: 127.0.0.1:${address.port} -> ${remoteHost}:${remotePort}`, { connectionId });
-        resolve(tunnelInfo);
-      });
-    });
-
-    sshClient.on('error', (err) => {
-      // Ensure SSH file descriptors are released before rejecting
-      sshClient.end();
-      cleanup();
-      reject(new Error(`SSH connection error: ${err.message}`));
-    });
-
-    // Build SSH connection options
-    const connectOptions: Parameters<Client['connect']>[0] = {
-      host: sshConfig.host,
-      port: sshConfig.port || 22,
-      username: sshConfig.username,
-    };
-
-    if (sshConfig.authMethod === 'password') {
-      connectOptions.password = sshConfig.password;
-    } else if (sshConfig.authMethod === 'privateKey') {
-      connectOptions.privateKey = sshConfig.privateKey;
-      if (sshConfig.passphrase) {
-        connectOptions.passphrase = sshConfig.passphrase;
-      }
-    }
-
-    sshClient.connect(connectOptions);
-  });
-}
-
-/**
- * Close an SSH tunnel by connection ID
- */
-export async function closeSSHTunnel(connectionId: string): Promise<void> {
-  const tunnel = activeTunnels.get(connectionId);
-  if (tunnel) {
-    await tunnel.close();
-  }
-}
-
-/**
- * Check if a tunnel exists for a connection
- */
-export function hasTunnel(connectionId: string): boolean {
-  return activeTunnels.has(connectionId);
-}
-
-/**
- * Get tunnel info for a connection
- */
-export function getTunnelInfo(connectionId: string): TunnelInfo | undefined {
-  return activeTunnels.get(connectionId);
-}

package/src/lib/storage/factory.ts

@@ -1,84 +0,0 @@
-/**
- * Storage Provider Factory
- * Creates the appropriate server storage provider based on STORAGE_PROVIDER env var.
- * Uses singleton pattern — one provider instance per process.
- */
-
-import type { ServerStorageProvider, StorageConfigResponse } from './types';
-
-let _provider: ServerStorageProvider | null = null;
-let _initialized = false;
-
-export type StorageProviderType = 'local' | 'sqlite' | 'postgres';
-
-/**
- * Get the configured storage provider type from environment.
- * Returns 'local' if not set or invalid.
- */
-export function getStorageProviderType(): StorageProviderType {
-  const env = process.env.STORAGE_PROVIDER?.toLowerCase();
-  if (env === 'sqlite' || env === 'postgres') return env;
-  return 'local';
-}
-
-/**
- * Check if server-side storage is enabled.
- */
-export function isServerStorageEnabled(): boolean {
-  return getStorageProviderType() !== 'local';
-}
-
-/**
- * Get the storage configuration for the /api/storage/config endpoint.
- */
-export function getStorageConfig(): StorageConfigResponse {
-  const provider = getStorageProviderType();
-  return {
-    provider,
-    serverMode: provider !== 'local',
-  };
-}
-
-/**
- * Get or create the singleton server storage provider.
- * Returns null if STORAGE_PROVIDER is 'local' or not set.
- * The provider is automatically initialized on first call.
- */
-export async function getStorageProvider(): Promise<ServerStorageProvider | null> {
-  const providerType = getStorageProviderType();
-
-  if (providerType === 'local') return null;
-
-  if (_provider && _initialized) return _provider;
-
-  switch (providerType) {
-    case 'sqlite': {
-      const { SQLiteStorageProvider } = await import('./providers/sqlite');
-      _provider = new SQLiteStorageProvider();
-      break;
-    }
-    case 'postgres': {
-      const { PostgresStorageProvider } = await import('./providers/postgres');
-      _provider = new PostgresStorageProvider();
-      break;
-    }
-  }
-
-  if (_provider && !_initialized) {
-    await _provider.initialize();
-    _initialized = true;
-  }
-
-  return _provider;
-}
-
-/**
- * Close and reset the singleton provider. Used for testing/cleanup.
- */
-export async function closeStorageProvider(): Promise<void> {
-  if (_provider) {
-    await _provider.close();
-    _provider = null;
-    _initialized = false;
-  }
-}

package/src/lib/storage/index.ts

@@ -1,14 +0,0 @@
-/**
- * Storage module — barrel export.
- * Import path `@/lib/storage` is preserved for all consumers.
- */
-
-export { storage } from './storage-facade';
-export type {
-  StorageData,
-  StorageCollection,
-  ServerStorageProvider,
-  StorageConfigResponse,
-  StorageChangeDetail,
-} from './types';
-export { STORAGE_COLLECTIONS } from './types';

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

@@ -1,99 +0,0 @@
-/**
- * Pure localStorage CRUD operations.
- * All reads/writes go through these functions.
- * No event dispatching — that's the facade's responsibility.
- */
-
-import { logger } from '@/lib/logger';
-
-const KEY_PREFIX = 'libredb_';
-
-/** Map collection names to localStorage keys */
-const COLLECTION_KEYS: Record<string, string> = {
-  connections: `${KEY_PREFIX}connections`,
-  history: `${KEY_PREFIX}history`,
-  saved_queries: `${KEY_PREFIX}saved_queries`,
-  schema_snapshots: `${KEY_PREFIX}schema_snapshots`,
-  saved_charts: `${KEY_PREFIX}saved_charts`,
-  active_connection_id: `${KEY_PREFIX}active_connection_id`,
-  audit_log: `${KEY_PREFIX}audit_log`,
-  masking_config: `${KEY_PREFIX}masking_config`,
-  threshold_config: `${KEY_PREFIX}threshold_config`,
-};
-
-function isClient(): boolean {
-  return typeof window !== 'undefined';
-}
-
-export function getKey(collection: string): string {
-  return COLLECTION_KEYS[collection] || `${KEY_PREFIX}${collection}`;
-}
-
-/**
- * Read raw JSON from localStorage.
- * Returns null if not found or parse fails.
- */
-export function readJSON<T>(collection: string): T | null {
-  if (!isClient()) return null;
-  try {
-    const key = getKey(collection);
-    const raw = localStorage.getItem(key);
-    if (raw === null) return null;
-    return JSON.parse(raw) as T;
-  } catch {
-    logger.warn('Failed to parse JSON from localStorage', { key: getKey(collection) });
-    return null;
-  }
-}
-
-/**
- * Read raw string from localStorage.
- */
-export function readString(collection: string): string | null {
-  if (!isClient()) return null;
-  return localStorage.getItem(getKey(collection));
-}
-
-/**
- * Write JSON to localStorage.
- * Returns true on success, false on failure (e.g. QuotaExceededError).
- */
-export function writeJSON(collection: string, data: unknown): boolean {
-  if (!isClient()) return false;
-  try {
-    localStorage.setItem(getKey(collection), JSON.stringify(data));
-    return true;
-  } catch (error) {
-    logger.warn('Failed to write to localStorage', {
-      key: getKey(collection),
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return false;
-  }
-}
-
-/**
- * Write raw string to localStorage.
- * Returns true on success, false on failure (e.g. QuotaExceededError).
- */
-export function writeString(collection: string, value: string): boolean {
-  if (!isClient()) return false;
-  try {
-    localStorage.setItem(getKey(collection), value);
-    return true;
-  } catch (error) {
-    logger.warn('Failed to write to localStorage', {
-      key: getKey(collection),
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return false;
-  }
-}
-
-/**
- * Remove a key from localStorage.
- */
-export function remove(collection: string): void {
-  if (!isClient()) return;
-  localStorage.removeItem(getKey(collection));
-}

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

@@ -1,225 +0,0 @@
-/**
- * PostgreSQL Server Storage Provider
- * Uses the existing `pg` package (already a project dependency).
- */
-
-import type { ServerStorageProvider, StorageCollection, StorageData } from '../types';
-import { STORAGE_COLLECTIONS } from '../types';
-import { logger } from '@/lib/logger';
-
-let Pool: typeof import('pg').Pool;
-
-export class PostgresStorageProvider implements ServerStorageProvider {
-  private pool: InstanceType<typeof import('pg').Pool> | null = null;
-  private connectionString: string;
-
-  constructor(connectionString?: string) {
-    this.connectionString =
-      connectionString || process.env.STORAGE_POSTGRES_URL || '';
-  }
-
-  async initialize(): Promise<void> {
-    if (!this.connectionString) {
-      throw new Error(
-        'STORAGE_POSTGRES_URL is required when STORAGE_PROVIDER=postgres'
-      );
-    }
-
-    // Dynamic import to avoid requiring pg when not needed
-    if (!Pool) {
-      const pg = await import('pg');
-      Pool = pg.Pool;
-    }
-
-    this.pool = new Pool({
-      connectionString: this.connectionString,
-      max: 5,
-      idleTimeoutMillis: 30000,
-      ssl: this.buildSSLConfig(),
-    });
-
-    // Create table
-    try {
-      await this.pool.query(`
-        CREATE TABLE IF NOT EXISTS user_storage (
-          user_id    TEXT NOT NULL,
-          collection TEXT NOT NULL,
-          data       TEXT NOT NULL,
-          updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-          PRIMARY KEY (user_id, collection)
-        )
-      `);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes('does not support SSL')) {
-        throw new Error(
-          'PostgreSQL storage connection failed: server does not support SSL. Add ?sslmode=disable to STORAGE_POSTGRES_URL for local PostgreSQL.',
-          { cause: error }
-        );
-      }
-      logger.error('PostgreSQL storage initialization failed', error, { provider: 'postgres' });
-      throw error;
-    }
-  }
-
-  async getAllData(userId: string): Promise<Partial<StorageData>> {
-    this.ensurePool();
-    const { rows } = await this.pool!.query(
-      'SELECT collection, data FROM user_storage WHERE user_id = $1',
-      [userId]
-    );
-
-    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: 'postgres', collection: row.collection });
-      }
-    }
-    return result;
-  }
-
-  async getCollection<K extends StorageCollection>(
-    userId: string,
-    collection: K
-  ): Promise<StorageData[K] | null> {
-    this.ensurePool();
-    const { rows } = await this.pool!.query(
-      'SELECT data FROM user_storage WHERE user_id = $1 AND collection = $2',
-      [userId, collection]
-    );
-    if (rows.length === 0) return null;
-    try {
-      return JSON.parse(rows[0].data) as StorageData[K];
-    } catch {
-      logger.warn('Corrupted data in storage collection', { provider: 'postgres', collection });
-      return null;
-    }
-  }
-
-  async setCollection<K extends StorageCollection>(
-    userId: string,
-    collection: K,
-    data: StorageData[K]
-  ): Promise<void> {
-    this.ensurePool();
-    await this.pool!.query(
-      `INSERT INTO user_storage (user_id, collection, data, updated_at)
-       VALUES ($1, $2, $3, NOW())
-       ON CONFLICT (user_id, collection)
-       DO UPDATE SET data = EXCLUDED.data, updated_at = NOW()`,
-      [userId, collection, JSON.stringify(data)]
-    );
-  }
-
-  async mergeData(userId: string, data: Partial<StorageData>): Promise<void> {
-    this.ensurePool();
-    const client = await this.pool!.connect();
-    try {
-      await client.query('BEGIN');
-      for (const collection of STORAGE_COLLECTIONS) {
-        const collectionData = (data as Record<string, unknown>)[collection];
-        if (collectionData !== undefined) {
-          await client.query(
-            `INSERT INTO user_storage (user_id, collection, data, updated_at)
-             VALUES ($1, $2, $3, NOW())
-             ON CONFLICT (user_id, collection)
-             DO UPDATE SET data = EXCLUDED.data, updated_at = NOW()`,
-            [userId, collection, JSON.stringify(collectionData)]
-          );
-        }
-      }
-      await client.query('COMMIT');
-    } catch (err) {
-      await client.query('ROLLBACK');
-      throw err;
-    } finally {
-      client.release();
-    }
-  }
-
-  async isHealthy(): Promise<boolean> {
-    try {
-      this.ensurePool();
-      const { rows } = await this.pool!.query('SELECT 1 as ok');
-      return rows[0]?.ok === 1;
-    } catch {
-      return false;
-    }
-  }
-
-  async close(): Promise<void> {
-    if (this.pool) {
-      await this.pool.end();
-      this.pool = null;
-    }
-  }
-
-  private ensurePool(): void {
-    if (!this.pool) {
-      throw new Error(
-        'PostgreSQL storage not initialized. Call initialize() first.'
-      );
-    }
-  }
-
-  private buildSSLConfig(): boolean | { rejectUnauthorized: boolean } {
-    const { host, searchParams } = this.parseConnectionString(this.connectionString);
-
-    const sslMode = searchParams.get('sslmode')?.toLowerCase();
-    if (sslMode === 'disable') return false;
-    if (
-      sslMode === 'require' ||
-      sslMode === 'prefer' ||
-      sslMode === 'verify-ca' ||
-      sslMode === 'verify-full'
-    ) {
-      return { rejectUnauthorized: false };
-    }
-
-    const sslParam = searchParams.get('ssl')?.toLowerCase();
-    if (sslParam === 'false' || sslParam === '0' || sslParam === 'no') {
-      return false;
-    }
-    if (sslParam === 'true' || sslParam === '1' || sslParam === 'yes') {
-      return { rejectUnauthorized: false };
-    }
-
-    if (this.isLocalHost(host)) return false;
-    return { rejectUnauthorized: false };
-  }
-
-  private parseConnectionString(connectionString: string): {
-    host: string;
-    searchParams: URLSearchParams;
-  } {
-    try {
-      const parsed = new URL(connectionString);
-      return {
-        host: parsed.hostname.toLowerCase(),
-        searchParams: parsed.searchParams,
-      };
-    } catch {
-      return {
-        host: '',
-        searchParams: new URLSearchParams(),
-      };
-    }
-  }
-
-  private isLocalHost(host: string): boolean {
-    const localHosts = new Set([
-      'localhost',
-      '::1',
-      'host.docker.internal',
-      'docker.for.mac.localhost',
-      'docker.for.win.localhost',
-      'gateway.docker.internal',
-    ]);
-    if (localHosts.has(host)) return true;
-    if (host.startsWith('127.')) return true;
-    return false;
-  }
-}