@libredb/studio 0.9.7

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

@@ -0,0 +1,198 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { createMockRequest, parseResponseJSON } from '../../helpers/mock-next';
+import { createMockProvider } from '../../helpers/mock-provider';
+import {
+  QueryError,
+  TimeoutError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+} from '@/lib/db/errors';
+
+// ─── Create mock objects ────────────────────────────────────────────────────
+const baseMockProvider = createMockProvider();
+
+// Provider with cancelQuery support
+const mockCancelProvider = {
+  ...baseMockProvider,
+  cancelQuery: mock(async () => true),
+};
+
+// Provider without cancelQuery support
+const mockNoCancelProvider = createMockProvider();
+
+const mockGetOrCreateProvider = mock(async () => mockCancelProvider 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 () => mockCancelProvider),
+  removeProvider: mock(async () => {}),
+  clearProviderCache: mock(async () => {}),
+  getProviderCacheStats: mock(() => ({ size: 0, connections: [] })),
+  QueryError,
+  TimeoutError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+  BaseDatabaseProvider: class {},
+}));
+
+// ─── Import route handler AFTER mocking ─────────────────────────────────────
+const { POST } = await import('@/app/api/db/cancel/route');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const validConnection = {
+  id: 'test-1',
+  name: 'Test DB',
+  type: 'postgres',
+  host: 'localhost',
+  port: 5432,
+  database: 'testdb',
+};
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+describe('POST /api/db/cancel', () => {
+  beforeEach(() => {
+    mockGetOrCreateProvider.mockClear();
+    mockCancelProvider.cancelQuery.mockClear();
+
+    // Reset implementations
+    mockGetOrCreateProvider.mockImplementation(async () => mockCancelProvider as never);
+    mockCancelProvider.cancelQuery.mockImplementation(async () => true);
+  });
+
+  test('returns cancelled:true with valid connection and queryId', async () => {
+    const req = createMockRequest('/api/db/cancel', {
+      method: 'POST',
+      body: { connection: validConnection, queryId: 'query-123' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ cancelled: boolean }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.cancelled).toBe(true);
+    expect(mockCancelProvider.cancelQuery).toHaveBeenCalledWith('query-123');
+  });
+
+  test('missing connection returns 400', async () => {
+    const req = createMockRequest('/api/db/cancel', {
+      method: 'POST',
+      body: { queryId: 'query-123' },
+    });
+
+    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 queryId returns 400', async () => {
+    const req = createMockRequest('/api/db/cancel', {
+      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 queryId are required');
+  });
+
+  test('provider without cancelQuery returns 400', async () => {
+    mockGetOrCreateProvider.mockImplementation(async () => mockNoCancelProvider as never);
+
+    const req = createMockRequest('/api/db/cancel', {
+      method: 'POST',
+      body: { connection: validConnection, queryId: 'query-123' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string; cancelled: boolean }>(res);
+
+    expect(res.status).toBe(400);
+    expect(data.cancelled).toBe(false);
+    expect(data.error).toContain('not supported');
+  });
+
+  test('cancelQuery returning false returns cancelled:false', async () => {
+    mockCancelProvider.cancelQuery.mockImplementation(async () => false);
+
+    const req = createMockRequest('/api/db/cancel', {
+      method: 'POST',
+      body: { connection: validConnection, queryId: 'query-999' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ cancelled: boolean }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.cancelled).toBe(false);
+  });
+
+  test('error in cancelQuery returns 500', async () => {
+    mockCancelProvider.cancelQuery.mockImplementation(async () => {
+      throw new Error('Failed to cancel query');
+    });
+
+    const req = createMockRequest('/api/db/cancel', {
+      method: 'POST',
+      body: { connection: validConnection, queryId: 'query-123' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string; code: string }>(res);
+
+    expect(res.status).toBe(500);
+    expect(data.error).toContain('Failed to cancel query');
+    expect(data.code).toBe('INTERNAL_ERROR');
+  });
+});

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

@@ -0,0 +1,124 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { createMockRequest, parseResponseJSON } from '../../helpers/mock-next';
+import {
+  QueryError,
+  TimeoutError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+} from '@/lib/db/errors';
+
+const mockRemoveProvider = mock(async () => {});
+
+mock.module('@/lib/db/factory', () => ({
+  createDatabaseProvider: mock(async () => ({})),
+  getOrCreateProvider: mock(async () => ({})),
+  removeProvider: mockRemoveProvider,
+  clearProviderCache: mock(async () => {}),
+  getProviderCacheStats: mock(() => ({ size: 0, connections: [] })),
+  registerShutdownHandlers: mock(() => {}),
+}));
+
+mock.module('@/lib/db', () => ({
+  createDatabaseProvider: mock(async () => ({})),
+  getOrCreateProvider: mock(async () => ({})),
+  removeProvider: mockRemoveProvider,
+  clearProviderCache: mock(async () => {}),
+  getProviderCacheStats: mock(() => ({ size: 0, connections: [] })),
+  registerShutdownHandlers: mock(() => {}),
+  QueryError,
+  TimeoutError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+}));
+
+mock.module('@/lib/logger', () => ({
+  logger: {
+    info: mock(() => {}),
+    warn: mock(() => {}),
+    error: mock(() => {}),
+    debug: mock(() => {}),
+  },
+}));
+
+const { POST } = await import('@/app/api/db/disconnect/route');
+
+beforeEach(() => {
+  mockRemoveProvider.mockClear();
+});
+
+describe('POST /api/db/disconnect', () => {
+  test('returns 400 when connectionId is missing', async () => {
+    const req = createMockRequest('/api/db/disconnect', {
+      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);
+    expect(data.error).toBe('connectionId is required');
+  });
+
+  test('returns 400 when connectionId is not a string', async () => {
+    const req = createMockRequest('/api/db/disconnect', {
+      method: 'POST',
+      body: { connectionId: 123 },
+    });
+
+    const res = await POST(req as never);
+    expect(res.status).toBe(400);
+  });
+
+  test('calls removeProvider and returns success', async () => {
+    const req = createMockRequest('/api/db/disconnect', {
+      method: 'POST',
+      body: { connectionId: 'conn-123' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ success: boolean }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.success).toBe(true);
+    expect(mockRemoveProvider).toHaveBeenCalledWith('conn-123');
+  });
+
+  test('returns 500 when removeProvider throws', async () => {
+    mockRemoveProvider.mockImplementationOnce(async () => {
+      throw new Error('disconnect failed');
+    });
+
+    const req = createMockRequest('/api/db/disconnect', {
+      method: 'POST',
+      body: { connectionId: 'conn-fail' },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ success: boolean; error: string }>(res);
+
+    expect(res.status).toBe(500);
+    expect(data.success).toBe(false);
+  });
+});

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

@@ -0,0 +1,222 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { createMockRequest, parseResponseJSON } from '../../helpers/mock-next';
+import { createMockProvider } from '../../helpers/mock-provider';
+import {
+  QueryError,
+  TimeoutError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+} from '@/lib/db/errors';
+
+// ─── Mock provider ──────────────────────────────────────────────────────────
+const mockProvider = createMockProvider();
+const mockGetOrCreateProvider = mock(async () => mockProvider);
+
+// ─── Mock auth + seed resolution BEFORE importing the 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 @/lib/db BEFORE importing the route ───────────────────────────────
+mock.module('@/lib/db', () => ({
+  getOrCreateProvider: mockGetOrCreateProvider,
+  createDatabaseProvider: mock(),
+  removeProvider: mock(),
+  clearProviderCache: mock(),
+  getProviderCacheStats: mock(),
+  QueryError,
+  TimeoutError,
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  isDatabaseError,
+  isConnectionError,
+  isQueryError,
+  isTimeoutError,
+  isAuthenticationError,
+  isRetryableError,
+  mapDatabaseError,
+  BaseDatabaseProvider: class {},
+}));
+
+// ─── Import route handlers AFTER mocking ────────────────────────────────────
+const { GET, POST } = await import('@/app/api/db/health/route');
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+const validConnection = {
+  id: 'test-1',
+  name: 'Test DB',
+  type: 'postgres',
+  host: 'localhost',
+  port: 5432,
+  database: 'testdb',
+};
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+describe('GET /api/db/health', () => {
+  test('returns 200 with healthy status', async () => {
+    const res = await GET();
+    const data = await parseResponseJSON<{
+      status: string;
+      timestamp: string;
+      service: string;
+    }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.status).toBe('healthy');
+    expect(data.service).toBe('libredb-studio');
+    expect(data.timestamp).toBeDefined();
+  });
+});
+
+describe('POST /api/db/health', () => {
+  beforeEach(() => {
+    mockGetOrCreateProvider.mockClear();
+    (mockProvider.getHealth as ReturnType<typeof mock>).mockClear();
+  });
+
+  test('returns 200 with health info for valid connection', async () => {
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: { connection: validConnection },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{
+      activeConnections: number;
+      databaseSize: string;
+      cacheHitRatio: string;
+    }>(res);
+
+    expect(res.status).toBe(200);
+    expect(data.activeConnections).toBeDefined();
+    expect(data.databaseSize).toBeDefined();
+    expect(data.cacheHitRatio).toBeDefined();
+  });
+
+  test('returns 400 when connection is missing', async () => {
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: {},
+    });
+
+    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('returns 503 for ConnectionError', async () => {
+    mockGetOrCreateProvider.mockRejectedValueOnce(
+      new ConnectionError('Connection refused')
+    );
+
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: { connection: validConnection },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string; code: string }>(res);
+
+    expect(res.status).toBe(503);
+    expect(data.error).toContain('Connection refused');
+    expect(data.code).toBe('CONNECTION_ERROR');
+  });
+
+  test('returns 500 for DatabaseError', async () => {
+    const dbError = new DatabaseError('Database internal error', 'postgres', 'INTERNAL_ERROR');
+    mockGetOrCreateProvider.mockResolvedValueOnce(mockProvider);
+    (mockProvider.getHealth as ReturnType<typeof mock>).mockRejectedValueOnce(dbError);
+
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: { connection: 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('Database internal error');
+    expect(data.code).toBe('INTERNAL_ERROR');
+  });
+
+  test('returns 401 when no session', async () => {
+    const { getSession } = await import('@/lib/auth');
+    (getSession as ReturnType<typeof mock>).mockResolvedValueOnce(null);
+
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: { connection: validConnection },
+    });
+
+    const res = await POST(req as never);
+    expect(res.status).toBe(401);
+  });
+
+  test('returns 400 when connection has no type', async () => {
+    const { resolveConnection } = await import('@/lib/seed/resolve-connection');
+    (resolveConnection as ReturnType<typeof mock>).mockResolvedValueOnce({ id: 'x', name: 'X' });
+
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: { connection: { id: 'x', name: 'X' } },
+    });
+
+    const res = await POST(req as never);
+    expect(res.status).toBe(400);
+  });
+
+  test('returns 500 for generic error', async () => {
+    (mockProvider.getHealth as ReturnType<typeof mock>).mockRejectedValueOnce(
+      new Error('Unexpected failure')
+    );
+
+    const req = createMockRequest('/api/db/health', {
+      method: 'POST',
+      body: { connection: validConnection },
+    });
+
+    const res = await POST(req as never);
+    const data = await parseResponseJSON<{ error: string }>(res);
+
+    expect(res.status).toBe(500);
+    expect(data.error).toBe('Unexpected failure');
+  });
+});