@libredb/studio 0.9.7

package/tests/api/db/test-connection.test.ts

@@ -0,0 +1,185 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { createMockRequest, parseResponseJSON } from '../../helpers/mock-next';
+import { createMockProvider } from '../../helpers/mock-provider';
+import { DatabaseConfigError } from '@/lib/db/errors';
+
+// ─── Create mock objects ────────────────────────────────────────────────────
+const mockProvider = createMockProvider();
+const mockCreateDatabaseProvider = mock(async () => mockProvider);
+
+// ─── Mock auth + seed resolution BEFORE importing route ─────────────────────
+mock.module('@/lib/auth', () => ({
+  getSession: mock(async () => ({ role: 'admin', username: 'admin' })),
+  signJWT: mock(async () => 'mock-token'),
+  verifyJWT: mock(async () => null),
+  login: mock(async () => {}),
+  logout: mock(async () => {}),
+}));
+
+mock.module('@/lib/seed/resolve-connection', () => {
+  class SeedConnectionError extends Error {
+    constructor(message: string, public statusCode: number) {
+      super(message);
+      this.name = 'SeedConnectionError';
+    }
+  }
+  return {
+    resolveConnection: mock(async (body: Record<string, unknown>) => {
+      if (!body.connection && !body.connectionId) {
+        throw new SeedConnectionError('Either connection or connectionId is required', 400);
+      }
+      return body.connection;
+    }),
+    SeedConnectionError,
+  };
+});
+
+// ─── Mock dependencies BEFORE importing route ───────────────────────────────
+mock.module('@/lib/db/factory', () => ({
+  createDatabaseProvider: mockCreateDatabaseProvider,
+  getOrCreateProvider: mock(async () => mockProvider),
+  removeProvider: mock(async () => {}),
+  clearProviderCache: mock(async () => {}),
+  getProviderCacheStats: mock(() => ({ size: 0, connections: [] })),
+}));
+
+// ─── Import route handler AFTER mocking ─────────────────────────────────────
+const { POST } = await import('@/app/api/db/test-connection/route');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const validConnection = {
+  id: 'test-1',
+  name: 'Test DB',
+  type: 'postgres',
+  host: 'localhost',
+  port: 5432,
+  database: 'testdb',
+};
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+describe('POST /api/db/test-connection', () => {
+  beforeEach(() => {
+    mockCreateDatabaseProvider.mockClear();
+    (mockProvider.connect as ReturnType<typeof mock>).mockClear();
+    (mockProvider.disconnect as ReturnType<typeof mock>).mockClear();
+    (mockProvider.getHealth as ReturnType<typeof mock>).mockClear();
+
+    // Reset implementations to defaults
+    mockCreateDatabaseProvider.mockImplementation(async () => mockProvider);
+    (mockProvider.connect as ReturnType<typeof mock>).mockImplementation(async () => {});
+    (mockProvider.disconnect as ReturnType<typeof mock>).mockImplementation(async () => {});
+    (mockProvider.getHealth as ReturnType<typeof mock>).mockImplementation(async () => ({
+      activeConnections: 5,
+      databaseSize: '256 MB',
+      cacheHitRatio: '99.2%',
+      slowQueries: [],
+      activeSessions: [],
+    }));
+  });
+
+  test('returns success with latency for valid connection', async () => {
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: validConnection,
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ success: boolean; message: string; latency: number }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.success).toBe(true);
+    expect(data.message).toBe('Connection successful');
+    expect(typeof data.latency).toBe('number');
+  });
+
+  test('returns 400 when connection type is missing', async () => {
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: { host: 'localhost' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ success: boolean; error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.success).toBe(false);
+  });
+
+  test('returns 400 when body is empty object', async () => {
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: {},
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ success: boolean; error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.success).toBe(false);
+  });
+
+  test('returns 400 when DatabaseConfigError is thrown', async () => {
+    mockCreateDatabaseProvider.mockImplementation(async () => {
+      throw new DatabaseConfigError('Invalid database configuration');
+    });
+
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: validConnection,
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string; code: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toBe('Invalid database configuration');
+    expect(data.code).toBe('CONFIG_ERROR');
+  });
+
+  test('returns 500 when connection error occurs', async () => {
+    (mockProvider.connect as ReturnType<typeof mock>).mockImplementation(async () => {
+      throw new Error('ECONNREFUSED');
+    });
+
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: validConnection,
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string; code: string }>(res);
+
+    expect(res.status).toBe(500);
+    expect(data.error).toBe('ECONNREFUSED');
+    expect(data.code).toBe('INTERNAL_ERROR');
+  });
+
+  test('calls connect and disconnect on successful test', async () => {
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: validConnection,
+    });
+
+    await POST(req as never);
+
+    expect(mockProvider.connect).toHaveBeenCalledTimes(1);
+    expect(mockProvider.getHealth).toHaveBeenCalledTimes(1);
+    expect(mockProvider.disconnect).toHaveBeenCalledTimes(1);
+  });
+
+  test('calls disconnect on error', async () => {
+    (mockProvider.getHealth as ReturnType<typeof mock>).mockImplementation(async () => {
+      throw new Error('Health check failed');
+    });
+
+    const req = createMockRequest('/api/db/test-connection', {
+      method: 'POST',
+      body: validConnection,
+    });
+
+    await POST(req as never);
+
+    expect(mockProvider.connect).toHaveBeenCalledTimes(1);
+    expect(mockProvider.disconnect).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/api/db/transaction.test.ts

@@ -0,0 +1,314 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { createMockRequest, parseResponseJSON } from '../../helpers/mock-next';
+import { createMockProvider } from '../../helpers/mock-provider';
+import {
+  QueryError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  TimeoutError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+} from '@/lib/db/errors';
+
+// ─── Create mock provider with transaction methods ──────────────────────────
+const baseMockProvider = createMockProvider();
+
+const mockTxProvider = {
+  ...baseMockProvider,
+  beginTransaction: mock(async () => {}),
+  commitTransaction: mock(async () => {}),
+  rollbackTransaction: mock(async () => {}),
+  isInTransaction: mock(() => true),
+  queryInTransaction: mock(async () => ({
+    rows: [{ id: 1, name: 'Alice' }],
+    fields: ['id', 'name'],
+    rowCount: 1,
+    executionTime: 10,
+  })),
+};
+
+// Non-transaction provider (no transaction methods)
+const mockNonTxProvider = createMockProvider();
+
+const mockGetOrCreateProvider = mock(async () => mockTxProvider as never);
+
+// ─── Mock auth + seed resolution BEFORE importing route ─────────────────────
+mock.module('@/lib/auth', () => ({
+  getSession: mock(async () => ({ role: 'admin', username: 'admin' })),
+  signJWT: mock(async () => 'mock-token'),
+  verifyJWT: mock(async () => null),
+  login: mock(async () => {}),
+  logout: mock(async () => {}),
+}));
+
+mock.module('@/lib/seed/resolve-connection', () => {
+  class SeedConnectionError extends Error {
+    constructor(message: string, public statusCode: number) {
+      super(message);
+      this.name = 'SeedConnectionError';
+    }
+  }
+  return {
+    resolveConnection: mock(async (body: Record<string, unknown>) => {
+      if (!body.connection && !body.connectionId) {
+        throw new SeedConnectionError('Either connection or connectionId is required', 400);
+      }
+      return body.connection;
+    }),
+    SeedConnectionError,
+  };
+});
+
+// ─── Mock dependencies BEFORE importing route ───────────────────────────────
+mock.module('@/lib/db', () => ({
+  getOrCreateProvider: mockGetOrCreateProvider,
+  createDatabaseProvider: mock(async () => mockTxProvider),
+  removeProvider: mock(async () => {}),
+  clearProviderCache: mock(async () => {}),
+  getProviderCacheStats: mock(() => ({ size: 0, connections: [] })),
+  QueryError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  TimeoutError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+}));
+
+// ─── Import route handler AFTER mocking ─────────────────────────────────────
+const { POST } = await import('@/app/api/db/transaction/route');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const validConnection = {
+  id: 'test-1',
+  name: 'Test DB',
+  type: 'postgres',
+  host: 'localhost',
+  port: 5432,
+  database: 'testdb',
+};
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+describe('POST /api/db/transaction', () => {
+  beforeEach(() => {
+    mockGetOrCreateProvider.mockClear();
+    mockTxProvider.beginTransaction.mockClear();
+    mockTxProvider.commitTransaction.mockClear();
+    mockTxProvider.rollbackTransaction.mockClear();
+    mockTxProvider.isInTransaction.mockClear();
+    mockTxProvider.queryInTransaction.mockClear();
+    (mockTxProvider.prepareQuery as ReturnType<typeof mock>).mockClear();
+
+    // Reset to default implementations
+    mockGetOrCreateProvider.mockImplementation(async () => mockTxProvider as never);
+    mockTxProvider.beginTransaction.mockImplementation(async () => {});
+    mockTxProvider.commitTransaction.mockImplementation(async () => {});
+    mockTxProvider.rollbackTransaction.mockImplementation(async () => {});
+    mockTxProvider.isInTransaction.mockImplementation(() => true);
+    mockTxProvider.queryInTransaction.mockImplementation(async () => ({
+      rows: [{ id: 1, name: 'Alice' }],
+      fields: ['id', 'name'],
+      rowCount: 1,
+      executionTime: 10,
+    }));
+  });
+
+  test('begin action returns status active', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'begin' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ status: string; message: string }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.status).toBe('active');
+    expect(data.message).toBe('Transaction started');
+    expect(mockTxProvider.beginTransaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('commit action returns status committed', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'commit' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ status: string; message: string }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.status).toBe('committed');
+    expect(data.message).toBe('Transaction committed');
+    expect(mockTxProvider.commitTransaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('rollback action returns status rolled_back', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'rollback' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ status: string; message: string }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.status).toBe('rolled_back');
+    expect(data.message).toBe('Transaction rolled back');
+    expect(mockTxProvider.rollbackTransaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('query action with sql returns result with pagination', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'query', sql: 'SELECT * FROM users' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{
+      rows: unknown[];
+      fields: string[];
+      rowCount: number;
+      inTransaction: boolean;
+      pagination: { limit: number; offset: number; hasMore: boolean; totalReturned: number; wasLimited: boolean };
+    }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.inTransaction).toBe(true);
+    expect(data.rows).toBeDefined();
+    expect(data.fields).toBeDefined();
+    expect(data.pagination).toBeDefined();
+    expect(data.pagination.wasLimited).toBeDefined();
+  });
+
+  test('query action without sql returns 400', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'query' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toContain('SQL query is required');
+  });
+
+  test('status action returns inTransaction boolean', async () => {
+    mockTxProvider.isInTransaction.mockImplementation(() => false);
+
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'status' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ inTransaction: boolean }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.inTransaction).toBe(false);
+  });
+
+  test('unknown action returns 400', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'invalid-action' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toContain('Unknown transaction action');
+  });
+
+  test('missing connection returns 400', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { action: 'begin' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toContain('required');
+  });
+
+  test('missing action returns 400', async () => {
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toContain('Connection and action are required');
+  });
+
+  test('provider without transaction support returns 400', async () => {
+    mockGetOrCreateProvider.mockImplementation(async () => mockNonTxProvider as never);
+
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'begin' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toContain('not supported');
+  });
+
+  test('QueryError returns 400', async () => {
+    mockTxProvider.beginTransaction.mockImplementation(async () => {
+      throw new QueryError('Syntax error near BEGIN', 'postgres');
+    });
+
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'begin' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.error).toContain('Syntax error');
+  });
+
+  test('DatabaseError returns 500', async () => {
+    mockTxProvider.beginTransaction.mockImplementation(async () => {
+      throw new DatabaseError('Internal database error', 'postgres', 'DATABASE_ERROR');
+    });
+
+    const req = createMockRequest('/api/db/transaction', {
+      method: 'POST',
+      body: { connection: validConnection, action: 'begin' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(500);
+    expect(data.error).toContain('Internal database error');
+  });
+});

package/tests/api/proxy.test.ts

@@ -0,0 +1,191 @@
+import { describe, test, expect } from 'bun:test';
+import { NextRequest } from 'next/server';
+import { SignJWT } from 'jose';
+import { proxy } from '@/proxy';
+
+// ─── JWT helpers ────────────────────────────────────────────────────────────
+
+const JWT_SECRET = new TextEncoder().encode('test-jwt-secret-for-unit-tests-32ch');
+
+async function createToken(role: string, expiresIn = '1h') {
+  return await new SignJWT({ role, username: role })
+    .setProtectedHeader({ alg: 'HS256' })
+    .setIssuedAt()
+    .setExpirationTime(expiresIn)
+    .sign(JWT_SECRET);
+}
+
+function createNextRequest(pathname: string, token?: string): NextRequest {
+  const url = `http://localhost:3000${pathname}`;
+  const headers = new Headers();
+  if (token) {
+    headers.set('cookie', `auth-token=${token}`);
+  }
+  return new NextRequest(url, { headers });
+}
+
+function isRedirect(response: Response): boolean {
+  return response.status === 307 || response.status === 308 || response.status === 302 || response.status === 301;
+}
+
+function getRedirectLocation(response: Response): string | null {
+  return response.headers.get('location');
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('proxy', () => {
+  // ───────────────────────────────────────────────────────────────────────────
+  // Public routes
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('public routes', () => {
+    test('/api/auth/login passes through without redirect', async () => {
+      const req = createNextRequest('/api/auth/login');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('/api/db/health passes through without redirect', async () => {
+      const req = createNextRequest('/api/db/health');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('/_next/static/chunk.js passes through without redirect', async () => {
+      const req = createNextRequest('/_next/static/chunk.js');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('/favicon.ico passes through without redirect', async () => {
+      const req = createNextRequest('/favicon.ico');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // Login page
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('/login page', () => {
+    test('allows access without token', async () => {
+      const req = createNextRequest('/login');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('redirects to /admin with valid admin token', async () => {
+      const token = await createToken('admin');
+      const req = createNextRequest('/login', token);
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(true);
+      expect(getRedirectLocation(res)).toContain('/admin');
+    });
+
+    test('redirects to / with valid user token', async () => {
+      const token = await createToken('user');
+      const req = createNextRequest('/login', token);
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(true);
+      const location = getRedirectLocation(res)!;
+      // Should redirect to root, not /admin
+      expect(location).toContain('http://localhost:3000');
+      expect(location).not.toContain('/admin');
+      expect(location).not.toContain('/login');
+    });
+
+    test('allows access with invalid token', async () => {
+      const req = createNextRequest('/login', 'invalid-token-garbage');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // Protected routes
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('protected routes', () => {
+    test('redirects to /login without token', async () => {
+      const req = createNextRequest('/');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(true);
+      expect(getRedirectLocation(res)).toContain('/login');
+    });
+
+    test('allows access with valid token', async () => {
+      const token = await createToken('user');
+      const req = createNextRequest('/', token);
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('redirects to /login with expired/invalid token', async () => {
+      const req = createNextRequest('/', 'expired-or-invalid-token');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(true);
+      expect(getRedirectLocation(res)).toContain('/login');
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // RBAC: /admin routes
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('/admin RBAC', () => {
+    test('allows admin role to access /admin', async () => {
+      const token = await createToken('admin');
+      const req = createNextRequest('/admin', token);
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('redirects user role from /admin to /', async () => {
+      const token = await createToken('user');
+      const req = createNextRequest('/admin', token);
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(true);
+      const location = getRedirectLocation(res)!;
+      expect(location).toContain('http://localhost:3000');
+      expect(location).not.toContain('/admin');
+      expect(location).not.toContain('/login');
+    });
+  });
+
+  // ───────────────────────────────────────────────────────────────────────────
+  // API routes with auth
+  // ───────────────────────────────────────────────────────────────────────────
+
+  describe('API routes', () => {
+    test('/api/db/query with valid token passes through', async () => {
+      const token = await createToken('user');
+      const req = createNextRequest('/api/db/query', token);
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(false);
+    });
+
+    test('/api/db/query without token redirects to /login', async () => {
+      const req = createNextRequest('/api/db/query');
+      const res = await proxy(req);
+
+      expect(isRedirect(res)).toBe(true);
+      expect(getRedirectLocation(res)).toContain('/login');
+    });
+  });
+});