@libredb/studio 0.9.7 → 0.9.12

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

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

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

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