@libredb/studio 0.9.7 → 0.9.12

package/tests/unit/lib/query-generators.test.ts

@@ -1,127 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { generateTableQuery, generateSelectQuery, shouldRefreshSchema } from '@/lib/query-generators';
-import type { ProviderCapabilities } from '@/lib/db/types';
-import type { ColumnSchema } from '@/lib/types';
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function makeCaps(overrides: Partial<ProviderCapabilities> = {}): ProviderCapabilities {
-  return {
-    queryLanguage: 'sql',
-    supportsExplain: true,
-    supportsExternalQueryLimiting: true,
-    supportsCreateTable: true,
-    supportsMaintenance: true,
-    maintenanceOperations: [],
-    supportsConnectionString: true,
-    defaultPort: 5432,
-    schemaRefreshPattern: 'CREATE|ALTER|DROP|TRUNCATE',
-    ...overrides,
-  };
-}
-
-const sampleColumns: ColumnSchema[] = [
-  { name: 'id', type: 'integer', nullable: false, isPrimary: true },
-  { name: 'name', type: 'varchar(255)', nullable: false, isPrimary: false },
-];
-
-// ============================================================================
-// generateTableQuery
-// ============================================================================
-
-describe('generateTableQuery', () => {
-  test('SQL (postgres/mysql/sqlite) uses LIMIT 50', () => {
-    const result = generateTableQuery('users', makeCaps({ defaultPort: 5432 }));
-    expect(result).toBe('SELECT * FROM users LIMIT 50;');
-  });
-
-  test('JSON (MongoDB) generates JSON find query', () => {
-    const result = generateTableQuery('users', makeCaps({ queryLanguage: 'json', defaultPort: null }));
-    const parsed = JSON.parse(result);
-    expect(parsed.collection).toBe('users');
-    expect(parsed.operation).toBe('find');
-    expect(parsed.options.limit).toBe(50);
-  });
-
-  test('Oracle (port 1521) uses FETCH FIRST 50 ROWS ONLY', () => {
-    const result = generateTableQuery('users', makeCaps({ defaultPort: 1521 }));
-    expect(result).toContain('FETCH FIRST 50 ROWS ONLY');
-    expect(result).toContain('SELECT * FROM users');
-  });
-
-  test('MSSQL (port 1433) uses TOP 50', () => {
-    const result = generateTableQuery('users', makeCaps({ defaultPort: 1433 }));
-    expect(result).toBe('SELECT TOP 50 * FROM users;');
-  });
-});
-
-// ============================================================================
-// generateSelectQuery
-// ============================================================================
-
-describe('generateSelectQuery', () => {
-  test('SQL with columns generates column list and LIMIT 100', () => {
-    const result = generateSelectQuery('users', sampleColumns, makeCaps({ defaultPort: 5432 }));
-    expect(result).toContain('id');
-    expect(result).toContain('name');
-    expect(result).toContain('LIMIT 100');
-    expect(result).toContain('WHERE 1=1');
-  });
-
-  test('JSON (MongoDB) generates projection', () => {
-    const result = generateSelectQuery('users', sampleColumns, makeCaps({ queryLanguage: 'json', defaultPort: null }));
-    const parsed = JSON.parse(result);
-    expect(parsed.collection).toBe('users');
-    expect(parsed.options.projection.id).toBe(1);
-    expect(parsed.options.projection.name).toBe(1);
-    expect(parsed.options.limit).toBe(100);
-  });
-
-  test('Oracle uses FETCH FIRST 100 ROWS ONLY', () => {
-    const result = generateSelectQuery('users', sampleColumns, makeCaps({ defaultPort: 1521 }));
-    expect(result).toContain('FETCH FIRST 100 ROWS ONLY');
-    expect(result).toContain('id');
-    expect(result).toContain('name');
-  });
-
-  test('MSSQL uses TOP 100', () => {
-    const result = generateSelectQuery('users', sampleColumns, makeCaps({ defaultPort: 1433 }));
-    expect(result).toContain('SELECT TOP 100');
-    expect(result).toContain('id');
-    expect(result).toContain('name');
-  });
-});
-
-// ============================================================================
-// shouldRefreshSchema
-// ============================================================================
-
-describe('shouldRefreshSchema', () => {
-  const pattern = 'CREATE|ALTER|DROP|TRUNCATE';
-
-  test('CREATE TABLE triggers refresh', () => {
-    expect(shouldRefreshSchema('CREATE TABLE users (id INT)', pattern)).toBe(true);
-  });
-
-  test('ALTER TABLE triggers refresh', () => {
-    expect(shouldRefreshSchema('ALTER TABLE users ADD COLUMN email TEXT', pattern)).toBe(true);
-  });
-
-  test('DROP TABLE triggers refresh', () => {
-    expect(shouldRefreshSchema('DROP TABLE users', pattern)).toBe(true);
-  });
-
-  test('TRUNCATE triggers refresh', () => {
-    expect(shouldRefreshSchema('TRUNCATE TABLE users', pattern)).toBe(true);
-  });
-
-  test('SELECT does NOT trigger refresh', () => {
-    expect(shouldRefreshSchema('SELECT * FROM users', pattern)).toBe(false);
-  });
-
-  test('INSERT does NOT trigger refresh', () => {
-    expect(shouldRefreshSchema('INSERT INTO users VALUES (1)', pattern)).toBe(false);
-  });
-});

package/tests/unit/lib/storage/factory.test.ts

@@ -1,71 +0,0 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-import {
-  getStorageProviderType,
-  isServerStorageEnabled,
-  getStorageConfig,
-} from '@/lib/storage/factory';
-
-// Clean env before every test to prevent leakage
-beforeEach(() => {
-  delete process.env.STORAGE_PROVIDER;
-});
-
-describe('storage factory: getStorageProviderType', () => {
-  test('returns "local" when STORAGE_PROVIDER not set', () => {
-    expect(getStorageProviderType()).toBe('local');
-  });
-
-  test('returns "local" for empty string', () => {
-    process.env.STORAGE_PROVIDER = '';
-    expect(getStorageProviderType()).toBe('local');
-  });
-
-  test('returns "sqlite" when STORAGE_PROVIDER=sqlite', () => {
-    process.env.STORAGE_PROVIDER = 'sqlite';
-    expect(getStorageProviderType()).toBe('sqlite');
-  });
-
-  test('returns "postgres" when STORAGE_PROVIDER=postgres', () => {
-    process.env.STORAGE_PROVIDER = 'postgres';
-    expect(getStorageProviderType()).toBe('postgres');
-  });
-
-  test('returns "local" for unknown values', () => {
-    process.env.STORAGE_PROVIDER = 'redis';
-    expect(getStorageProviderType()).toBe('local');
-  });
-
-  test('is case-insensitive', () => {
-    process.env.STORAGE_PROVIDER = 'SQLite';
-    expect(getStorageProviderType()).toBe('sqlite');
-  });
-});
-
-describe('storage factory: isServerStorageEnabled', () => {
-  test('returns false when local', () => {
-    expect(isServerStorageEnabled()).toBe(false);
-  });
-
-  test('returns true for sqlite', () => {
-    process.env.STORAGE_PROVIDER = 'sqlite';
-    expect(isServerStorageEnabled()).toBe(true);
-  });
-
-  test('returns true for postgres', () => {
-    process.env.STORAGE_PROVIDER = 'postgres';
-    expect(isServerStorageEnabled()).toBe(true);
-  });
-});
-
-describe('storage factory: getStorageConfig', () => {
-  test('returns correct shape for local', () => {
-    const config = getStorageConfig();
-    expect(config).toEqual({ provider: 'local', serverMode: false });
-  });
-
-  test('returns correct shape for sqlite', () => {
-    process.env.STORAGE_PROVIDER = 'sqlite';
-    const config = getStorageConfig();
-    expect(config).toEqual({ provider: 'sqlite', serverMode: true });
-  });
-});

package/tests/unit/lib/storage/local-storage.test.ts

@@ -1,114 +0,0 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-
-if (typeof globalThis.window === 'undefined') {
-  // @ts-expect-error — minimal window stub
-  globalThis.window = globalThis;
-}
-
-import { readJSON, writeJSON, readString, writeString, remove, getKey } from '@/lib/storage/local-storage';
-
-describe('local-storage: getKey', () => {
-  test('maps known collection names to libredb_ prefix keys', () => {
-    expect(getKey('connections')).toBe('libredb_connections');
-    expect(getKey('history')).toBe('libredb_history');
-    expect(getKey('saved_queries')).toBe('libredb_saved_queries');
-    expect(getKey('audit_log')).toBe('libredb_audit_log');
-    expect(getKey('masking_config')).toBe('libredb_masking_config');
-    expect(getKey('threshold_config')).toBe('libredb_threshold_config');
-  });
-
-  test('falls back to libredb_ prefix for unknown collections', () => {
-    expect(getKey('unknown')).toBe('libredb_unknown');
-  });
-});
-
-describe('local-storage: readJSON / writeJSON', () => {
-  beforeEach(() => {
-    localStorage.clear();
-  });
-
-  test('writeJSON / readJSON round-trip', () => {
-    writeJSON('connections', [{ id: 1 }]);
-    expect(readJSON<{ id: number }[]>('connections')).toEqual([{ id: 1 }]);
-  });
-
-  test('readJSON returns null for non-existent key', () => {
-    expect(readJSON('nonexistent')).toBeNull();
-  });
-
-  test('readJSON returns null for invalid JSON', () => {
-    localStorage.setItem('libredb_connections', 'not-json{{{');
-    expect(readJSON('connections')).toBeNull();
-  });
-});
-
-describe('local-storage: readString / writeString', () => {
-  beforeEach(() => {
-    localStorage.clear();
-  });
-
-  test('writeString / readString round-trip', () => {
-    writeString('active_connection_id', 'conn-42');
-    expect(readString('active_connection_id')).toBe('conn-42');
-  });
-
-  test('readString returns null for non-existent key', () => {
-    expect(readString('active_connection_id')).toBeNull();
-  });
-});
-
-describe('local-storage: writeJSON quota handling', () => {
-  beforeEach(() => {
-    localStorage.clear();
-  });
-
-  test('returns true on success', () => {
-    const result = writeJSON('test-key', { data: 'value' });
-    expect(result).toBe(true);
-  });
-
-  test('returns false on QuotaExceededError', () => {
-    const originalSetItem = localStorage.setItem;
-    localStorage.setItem = () => { throw new DOMException('quota exceeded', 'QuotaExceededError'); };
-    try {
-      const result = writeJSON('test-key', { data: 'value' });
-      expect(result).toBe(false);
-    } finally {
-      localStorage.setItem = originalSetItem;
-    }
-  });
-});
-
-describe('local-storage: writeString quota handling', () => {
-  beforeEach(() => {
-    localStorage.clear();
-  });
-
-  test('returns true on success', () => {
-    const result = writeString('active_connection_id', 'conn-42');
-    expect(result).toBe(true);
-  });
-
-  test('returns false on QuotaExceededError', () => {
-    const originalSetItem = localStorage.setItem;
-    localStorage.setItem = () => { throw new DOMException('quota exceeded', 'QuotaExceededError'); };
-    try {
-      const result = writeString('active_connection_id', 'conn-42');
-      expect(result).toBe(false);
-    } finally {
-      localStorage.setItem = originalSetItem;
-    }
-  });
-});
-
-describe('local-storage: remove', () => {
-  beforeEach(() => {
-    localStorage.clear();
-  });
-
-  test('remove deletes the key', () => {
-    writeString('active_connection_id', 'conn-42');
-    remove('active_connection_id');
-    expect(readString('active_connection_id')).toBeNull();
-  });
-});

package/tests/unit/lib/storage/providers/postgres.test.ts

@@ -1,312 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
-import type { ServerStorageProvider } from '@/lib/storage/types';
-
-// ── Mock pg ──────────────────────────────────────────────────────────────────
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const mockQuery = mock(async (..._args: any[]): Promise<any> => ({ rows: [] }));
-const mockRelease = mock(() => {});
-const mockEnd = mock(async () => {});
-
-const mockClient = {
-  query: mockQuery,
-  release: mockRelease,
-};
-
-const mockPool: Record<string, any> = {
-  query: mockQuery,
-  connect: mock(async () => mockClient),
-  end: mockEnd,
-};
-
-const mockPoolConstructor = mock(() => mockPool);
-
-mock.module('pg', () => ({
-  Pool: mockPoolConstructor,
-}));
-/* eslint-enable @typescript-eslint/no-explicit-any */
-
-import { PostgresStorageProvider } from '@/lib/storage/providers/postgres';
-
-describe('PostgresStorageProvider', () => {
-  let provider: ServerStorageProvider;
-
-  beforeEach(() => {
-    mockQuery.mockClear();
-    mockEnd.mockClear();
-    mockRelease.mockClear();
-    mockPoolConstructor.mockClear();
-    provider = new PostgresStorageProvider('postgresql://localhost:5432/test');
-  });
-
-  afterEach(async () => {
-    await provider.close();
-  });
-
-  test('initialize creates table', async () => {
-    await provider.initialize();
-    expect(mockQuery).toHaveBeenCalledTimes(1);
-    const sql = (mockQuery.mock.calls as unknown[][])[0][0] as string;
-    expect(sql).toContain('CREATE TABLE IF NOT EXISTS user_storage');
-  });
-
-  test('initialize disables SSL for localhost when no ssl params', async () => {
-    const localProvider = new PostgresStorageProvider(
-      'postgresql://localhost:5432/test'
-    );
-    await localProvider.initialize();
-
-    const poolConfig = (mockPoolConstructor.mock.calls as unknown[][])[0]?.[0] as {
-      ssl?: unknown;
-    };
-    expect(poolConfig.ssl).toBe(false);
-    await localProvider.close();
-  });
-
-  test('initialize disables SSL when sslmode=disable', async () => {
-    const localProvider = new PostgresStorageProvider(
-      'postgresql://localhost:5432/test?sslmode=disable'
-    );
-    await localProvider.initialize();
-
-    const poolConfig = (mockPoolConstructor.mock.calls as unknown[][])[0]?.[0] as {
-      ssl?: unknown;
-    };
-    expect(poolConfig.ssl).toBe(false);
-    await localProvider.close();
-  });
-
-  test('initialize disables SSL for docker local host aliases', async () => {
-    const localProvider = new PostgresStorageProvider(
-      'postgresql://host.docker.internal:5432/test'
-    );
-    await localProvider.initialize();
-
-    const poolConfig = (mockPoolConstructor.mock.calls as unknown[][])[0]?.[0] as {
-      ssl?: unknown;
-    };
-    expect(poolConfig.ssl).toBe(false);
-    await localProvider.close();
-  });
-
-  test('initialize enables SSL when sslmode=require', async () => {
-    const cloudProvider = new PostgresStorageProvider(
-      'postgresql://db.example.com:5432/test?sslmode=require'
-    );
-    await cloudProvider.initialize();
-
-    const poolConfig = (mockPoolConstructor.mock.calls as unknown[][])[0]?.[0] as {
-      ssl?: unknown;
-    };
-    expect(poolConfig.ssl).toEqual({ rejectUnauthorized: false });
-    await cloudProvider.close();
-  });
-
-  test('initialize enables SSL for non-local hosts by default', async () => {
-    const cloudProvider = new PostgresStorageProvider(
-      'postgresql://db.internal.example:5432/test'
-    );
-    await cloudProvider.initialize();
-
-    const poolConfig = (mockPoolConstructor.mock.calls as unknown[][])[0]?.[0] as {
-      ssl?: unknown;
-    };
-    expect(poolConfig.ssl).toEqual({ rejectUnauthorized: false });
-    await cloudProvider.close();
-  });
-
-  test('initialize disables SSL for all loopback 127.x.x.x addresses', async () => {
-    const localProvider = new PostgresStorageProvider(
-      'postgresql://127.0.0.42:5432/test'
-    );
-    await localProvider.initialize();
-
-    const poolConfig = (mockPoolConstructor.mock.calls as unknown[][])[0]?.[0] as {
-      ssl?: unknown;
-    };
-    expect(poolConfig.ssl).toBe(false);
-    await localProvider.close();
-  });
-
-  test('getAllData returns parsed collections', async () => {
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({
-      rows: [
-        { collection: 'connections', data: JSON.stringify([{ id: 'c1' }]) },
-        { collection: 'history', data: JSON.stringify([{ id: 'h1' }]) },
-      ],
-    });
-
-    const result = await provider.getAllData('admin@test.com');
-    expect(result.connections as unknown).toEqual([{ id: 'c1' }]);
-    expect(result.history as unknown).toEqual([{ id: 'h1' }]);
-  });
-
-  test('getCollection returns null when not found', async () => {
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({ rows: [] });
-
-    const result = await provider.getCollection('admin@test.com', 'connections');
-    expect(result).toBeNull();
-  });
-
-  test('getCollection returns parsed data', async () => {
-    const data = [{ id: 'c1', name: 'Test' }];
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({
-      rows: [{ data: JSON.stringify(data) }],
-    });
-
-    const result = await provider.getCollection('admin@test.com', 'connections');
-    expect(result as unknown).toEqual(data);
-  });
-
-  test('setCollection calls INSERT with ON CONFLICT', async () => {
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({ rows: [] });
-
-    await provider.setCollection('admin@test.com', 'connections', []);
-
-    const calls = mockQuery.mock.calls as unknown[][];
-    const lastCall = calls[calls.length - 1];
-    const sql = lastCall[0] as string;
-    expect(sql).toContain('INSERT INTO user_storage');
-    expect(sql).toContain('ON CONFLICT');
-  });
-
-  test('isHealthy returns true on success', async () => {
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({ rows: [{ ok: 1 }] });
-
-    expect(await provider.isHealthy()).toBe(true);
-  });
-
-  test('isHealthy returns false on error', async () => {
-    await provider.initialize();
-    mockQuery.mockRejectedValueOnce(new Error('Connection lost'));
-
-    expect(await provider.isHealthy()).toBe(false);
-  });
-
-  test('close calls pool.end()', async () => {
-    await provider.initialize();
-    await provider.close();
-    expect(mockEnd).toHaveBeenCalledTimes(1);
-  });
-
-  test('mergeData uses transaction', async () => {
-    await provider.initialize();
-
-    const mockClientQuery = mock(async (): Promise<{ rows: unknown[] }> => ({ rows: [] }));
-    const client = {
-      query: mockClientQuery,
-      release: mock(() => {}),
-    };
-    mockPool.connect = mock(async () => client);
-
-    await provider.mergeData('admin@test.com', {
-      connections: [{ id: 'c1', name: 'Test', type: 'postgres', createdAt: new Date() } as import('@/lib/types').DatabaseConnection],
-    });
-
-    const queries = (mockClientQuery.mock.calls as unknown[][]).map((c) => c[0] as string);
-    expect(queries[0]).toBe('BEGIN');
-    expect(queries[queries.length - 1]).toBe('COMMIT');
-  });
-
-  test('mergeData rolls back on error and releases client', async () => {
-    await provider.initialize();
-
-    let callCount = 0;
-    const mockClientQuery = mock(async (sql: string): Promise<{ rows: unknown[] }> => {
-      callCount++;
-      // Fail on the INSERT (3rd call: BEGIN, then INSERT fails)
-      if (callCount === 2) throw new Error('Insert failed');
-      return { rows: [] };
-    });
-    const mockClientRelease = mock(() => {});
-    const client = {
-      query: mockClientQuery,
-      release: mockClientRelease,
-    };
-    mockPool.connect = mock(async () => client);
-
-    await expect(
-      provider.mergeData('admin@test.com', {
-        connections: [{ id: 'c1', name: 'Test', type: 'postgres', createdAt: new Date() } as import('@/lib/types').DatabaseConnection],
-      })
-    ).rejects.toThrow('Insert failed');
-
-    // ROLLBACK should have been called
-    const queries = (mockClientQuery.mock.calls as unknown[][]).map((c) => c[0] as string);
-    expect(queries).toContain('ROLLBACK');
-    // Client always released (finally block)
-    expect(mockClientRelease).toHaveBeenCalledTimes(1);
-  });
-
-  test('mergeData only writes provided collections', async () => {
-    await provider.initialize();
-
-    const mockClientQuery = mock(async (): Promise<{ rows: unknown[] }> => ({ rows: [] }));
-    const client = {
-      query: mockClientQuery,
-      release: mock(() => {}),
-    };
-    mockPool.connect = mock(async () => client);
-
-    await provider.mergeData('admin@test.com', {
-      connections: [{ id: 'c1', name: 'Test', type: 'postgres', createdAt: new Date() } as import('@/lib/types').DatabaseConnection],
-    });
-
-    const queries = (mockClientQuery.mock.calls as unknown[][]).map((c) => c[0] as string);
-    // BEGIN + 1 INSERT + COMMIT = 3 queries
-    expect(queries.length).toBe(3);
-    expect(queries[0]).toBe('BEGIN');
-    expect(queries[1]).toContain('INSERT INTO user_storage');
-    expect(queries[2]).toBe('COMMIT');
-  });
-
-  test('getCollection returns null for corrupted JSON', async () => {
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({
-      rows: [{ data: 'invalid-json{{{' }],
-    });
-
-    const result = await provider.getCollection('admin@test.com', 'connections');
-    expect(result).toBeNull();
-  });
-
-  test('getAllData skips corrupted JSON rows', async () => {
-    await provider.initialize();
-    mockQuery.mockResolvedValueOnce({
-      rows: [
-        { collection: 'connections', data: JSON.stringify([{ id: 'c1' }]) },
-        { collection: 'history', data: 'corrupted{{{' },
-      ],
-    });
-
-    const result = await provider.getAllData('admin@test.com');
-    expect(result.connections as unknown).toEqual([{ id: 'c1' }]);
-    expect(result.history).toBeUndefined();
-  });
-
-  test('initialize throws when no connection string', async () => {
-    const origEnv = process.env.STORAGE_POSTGRES_URL;
-    delete process.env.STORAGE_POSTGRES_URL;
-    try {
-      const noUrlProvider = new PostgresStorageProvider('');
-      await expect(noUrlProvider.initialize()).rejects.toThrow('STORAGE_POSTGRES_URL is required');
-    } finally {
-      if (origEnv !== undefined) process.env.STORAGE_POSTGRES_URL = origEnv;
-    }
-  });
-
-  test('close on uninitialized provider does not throw', async () => {
-    const freshProvider = new PostgresStorageProvider('postgresql://localhost/test');
-    await expect(freshProvider.close()).resolves.toBeUndefined();
-  });
-
-  test('ensurePool throws when not initialized', async () => {
-    const freshProvider = new PostgresStorageProvider('postgresql://localhost/test');
-    await expect(freshProvider.getAllData('test@test.com')).rejects.toThrow('not initialized');
-  });
-});