@libredb/studio 0.9.7

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

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

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

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

@@ -0,0 +1,312 @@
+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');
+  });
+});