@libredb/studio 0.9.7

package/tests/fixtures/masking-configs.ts

@@ -0,0 +1,86 @@
+import type { MaskingConfig } from '@/lib/data-masking';
+
+export const mockMaskingConfigEnabled: MaskingConfig = {
+  enabled: true,
+  patterns: [
+    {
+      id: 'builtin-email',
+      name: 'Email',
+      columnPatterns: ['email', 'e_mail', 'user_email'],
+      maskType: 'email',
+      enabled: true,
+      isBuiltin: true,
+    },
+    {
+      id: 'builtin-ssn',
+      name: 'SSN',
+      columnPatterns: ['ssn', 'social_security'],
+      maskType: 'ssn',
+      enabled: true,
+      isBuiltin: true,
+    },
+    {
+      id: 'builtin-card',
+      name: 'Credit Card',
+      columnPatterns: ['credit_card', 'card_number'],
+      maskType: 'card',
+      enabled: true,
+      isBuiltin: true,
+    },
+    {
+      id: 'builtin-phone',
+      name: 'Phone',
+      columnPatterns: ['phone', 'mobile'],
+      maskType: 'phone',
+      enabled: true,
+      isBuiltin: true,
+    },
+    {
+      id: 'builtin-financial',
+      name: 'Financial',
+      columnPatterns: ['salary', 'income', 'balance'],
+      maskType: 'financial',
+      enabled: true,
+      isBuiltin: true,
+    },
+  ],
+  roleSettings: {
+    admin: { canToggle: true, canReveal: true },
+    user: { canToggle: false, canReveal: false },
+  },
+};
+
+export const mockMaskingConfigDisabled: MaskingConfig = {
+  ...mockMaskingConfigEnabled,
+  enabled: false,
+};
+
+export const mockMaskingConfigUserCanToggle: MaskingConfig = {
+  ...mockMaskingConfigEnabled,
+  roleSettings: {
+    admin: { canToggle: true, canReveal: true },
+    user: { canToggle: true, canReveal: true },
+  },
+};
+
+export const mockMaskingConfigAllDisabledPatterns: MaskingConfig = {
+  enabled: true,
+  patterns: mockMaskingConfigEnabled.patterns.map(p => ({ ...p, enabled: false })),
+  roleSettings: mockMaskingConfigEnabled.roleSettings,
+};
+
+export const mockMaskingConfigWithCustom: MaskingConfig = {
+  ...mockMaskingConfigEnabled,
+  patterns: [
+    ...mockMaskingConfigEnabled.patterns,
+    {
+      id: 'custom-1',
+      name: 'Custom Secret',
+      columnPatterns: ['secret_field', 'internal_.*'],
+      maskType: 'custom',
+      enabled: true,
+      isBuiltin: false,
+      customMask: '[REDACTED]',
+    },
+  ],
+};

package/tests/fixtures/query-results.ts

@@ -0,0 +1,71 @@
+import type { QueryResult } from '@/lib/types';
+
+export const mockSelectResult: QueryResult = {
+  rows: [
+    { id: 1, name: 'Alice', email: 'alice@example.com' },
+    { id: 2, name: 'Bob', email: 'bob@example.com' },
+    { id: 3, name: 'Charlie', email: 'charlie@example.com' },
+  ],
+  fields: ['id', 'name', 'email'],
+  rowCount: 3,
+  executionTime: 12,
+};
+
+export const mockEmptyResult: QueryResult = {
+  rows: [],
+  fields: [],
+  rowCount: 0,
+  executionTime: 1,
+};
+
+export const mockInsertResult: QueryResult = {
+  rows: [],
+  fields: [],
+  rowCount: 1,
+  executionTime: 5,
+};
+
+export const mockPaginatedResult: QueryResult = {
+  rows: Array.from({ length: 50 }, (_, i) => ({
+    id: i + 1,
+    name: `User ${i + 1}`,
+    email: `user${i + 1}@example.com`,
+  })),
+  fields: ['id', 'name', 'email'],
+  rowCount: 50,
+  executionTime: 25,
+  pagination: {
+    limit: 50,
+    offset: 0,
+    hasMore: true,
+    totalReturned: 50,
+    wasLimited: true,
+  },
+};
+
+export const mockExplainResult: QueryResult = {
+  rows: [
+    { 'QUERY PLAN': 'Seq Scan on users  (cost=0.00..10.00 rows=100 width=540)' },
+  ],
+  fields: ['QUERY PLAN'],
+  rowCount: 1,
+  executionTime: 2,
+  explainPlan: {
+    Plan: {
+      'Node Type': 'Seq Scan',
+      'Relation Name': 'users',
+      'Total Cost': 10.0,
+      'Plan Rows': 100,
+    },
+  },
+};
+
+export const mockSensitiveDataResult: QueryResult = {
+  rows: [
+    { id: 1, name: 'Alice', email: 'alice@example.com', ssn: '123-45-6789', salary: '85000.00' },
+    { id: 2, name: 'Bob', email: 'bob@test.com', ssn: '987-65-4321', salary: '92000.00' },
+  ],
+  fields: ['id', 'name', 'email', 'ssn', 'salary'],
+  rowCount: 2,
+  executionTime: 8,
+};

package/tests/fixtures/schemas.ts

@@ -0,0 +1,64 @@
+import type { TableSchema } from '@/lib/types';
+
+export const mockUsersTable: TableSchema = {
+  name: 'users',
+  columns: [
+    { name: 'id', type: 'integer', nullable: false, isPrimary: true, defaultValue: 'nextval(\'users_id_seq\')' },
+    { name: 'name', type: 'varchar(255)', nullable: false, isPrimary: false },
+    { name: 'email', type: 'varchar(255)', nullable: false, isPrimary: false },
+    { name: 'password', type: 'varchar(255)', nullable: false, isPrimary: false },
+    { name: 'created_at', type: 'timestamp', nullable: false, isPrimary: false, defaultValue: 'now()' },
+    { name: 'is_active', type: 'boolean', nullable: false, isPrimary: false, defaultValue: 'true' },
+  ],
+  indexes: [
+    { name: 'users_pkey', columns: ['id'], unique: true },
+    { name: 'users_email_key', columns: ['email'], unique: true },
+  ],
+  foreignKeys: [],
+  rowCount: 100,
+  size: '64 kB',
+};
+
+export const mockOrdersTable: TableSchema = {
+  name: 'orders',
+  columns: [
+    { name: 'id', type: 'integer', nullable: false, isPrimary: true },
+    { name: 'user_id', type: 'integer', nullable: false, isPrimary: false },
+    { name: 'total', type: 'numeric(10,2)', nullable: false, isPrimary: false },
+    { name: 'status', type: 'varchar(50)', nullable: false, isPrimary: false, defaultValue: '\'pending\'' },
+    { name: 'created_at', type: 'timestamp', nullable: false, isPrimary: false },
+  ],
+  indexes: [
+    { name: 'orders_pkey', columns: ['id'], unique: true },
+    { name: 'orders_user_id_idx', columns: ['user_id'], unique: false },
+  ],
+  foreignKeys: [
+    { columnName: 'user_id', referencedTable: 'users', referencedColumn: 'id' },
+  ],
+  rowCount: 500,
+  size: '128 kB',
+};
+
+export const mockProductsTable: TableSchema = {
+  name: 'products',
+  columns: [
+    { name: 'id', type: 'integer', nullable: false, isPrimary: true },
+    { name: 'name', type: 'varchar(255)', nullable: false, isPrimary: false },
+    { name: 'price', type: 'numeric(10,2)', nullable: false, isPrimary: false },
+    { name: 'category', type: 'varchar(100)', nullable: true, isPrimary: false },
+  ],
+  indexes: [
+    { name: 'products_pkey', columns: ['id'], unique: true },
+  ],
+  foreignKeys: [],
+  rowCount: 50,
+  size: '32 kB',
+};
+
+export const mockSchema: TableSchema[] = [
+  mockUsersTable,
+  mockOrdersTable,
+  mockProductsTable,
+];
+
+export const emptySchema: TableSchema[] = [];

package/tests/fixtures/seed-connections/invalid-config.yaml

@@ -0,0 +1,7 @@
+version: "2"
+
+connections:
+  - id: "INVALID_ID!"
+    name: ""
+    type: nosql
+    roles: []

package/tests/fixtures/seed-connections/minimal-config.yaml

@@ -0,0 +1,8 @@
+version: "1"
+
+connections:
+  - id: "minimal-pg"
+    name: "Minimal PG"
+    type: postgres
+    host: localhost
+    roles: ["*"]

package/tests/fixtures/seed-connections/mixed-credentials.yaml

@@ -0,0 +1,23 @@
+version: "1"
+
+connections:
+  - id: "env-var-creds"
+    name: "Env Var Creds"
+    type: postgres
+    host: pg.internal
+    password: "${GOOD_PASSWORD}"
+    roles: ["*"]
+
+  - id: "plaintext-creds"
+    name: "Plaintext Creds"
+    type: mysql
+    host: mysql.internal
+    password: "hardcoded_secret"
+    roles: ["*"]
+
+  - id: "missing-env"
+    name: "Missing Env"
+    type: postgres
+    host: pg.internal
+    password: "${NONEXISTENT_VAR}"
+    roles: ["*"]

package/tests/fixtures/seed-connections/multi-role-config.yaml

@@ -0,0 +1,30 @@
+version: "1"
+
+connections:
+  - id: "admin-only"
+    name: "Admin Only DB"
+    type: postgres
+    host: admin-pg.internal
+    password: "${ADMIN_PG_PASS}"
+    roles: ["admin"]
+
+  - id: "user-only"
+    name: "User Only DB"
+    type: mysql
+    host: user-mysql.internal
+    password: "${USER_MYSQL_PASS}"
+    roles: ["user"]
+
+  - id: "everyone"
+    name: "Everyone DB"
+    type: postgres
+    host: shared-pg.internal
+    password: "${SHARED_PG_PASS}"
+    roles: ["*"]
+
+  - id: "admin-and-user"
+    name: "Admin And User DB"
+    type: postgres
+    host: both-pg.internal
+    password: "${BOTH_PG_PASS}"
+    roles: ["admin", "user"]

package/tests/fixtures/seed-connections/valid-config.json

@@ -0,0 +1,15 @@
+{
+  "version": "1",
+  "defaults": { "managed": true, "environment": "production" },
+  "connections": [
+    {
+      "id": "test-postgres",
+      "name": "Test PostgreSQL",
+      "type": "postgres",
+      "host": "pg.internal",
+      "port": 5432,
+      "password": "${TEST_PG_PASSWORD}",
+      "roles": ["admin"]
+    }
+  ]
+}

package/tests/fixtures/seed-connections/valid-config.yaml

@@ -0,0 +1,51 @@
+version: "1"
+
+defaults:
+  managed: true
+  environment: production
+
+connections:
+  - id: "test-postgres"
+    name: "Test PostgreSQL"
+    type: postgres
+    host: pg.internal
+    port: 5432
+    database: testdb
+    user: "testuser"
+    password: "${TEST_PG_PASSWORD}"
+    environment: production
+    group: "Backend"
+    roles: ["admin"]
+    managed: true
+    color: "#10B981"
+
+  - id: "test-mysql"
+    name: "Test MySQL"
+    type: mysql
+    host: mysql.internal
+    port: 3306
+    database: appdb
+    user: "devuser"
+    password: "${TEST_MYSQL_PASSWORD}"
+    environment: staging
+    group: "Backend"
+    roles: ["*"]
+    managed: false
+
+  - id: "test-mongo"
+    name: "Test MongoDB"
+    type: mongodb
+    connectionString: "${TEST_MONGO_URI}"
+    group: "Platform"
+    roles: ["admin"]
+    managed: true
+
+  - id: "test-redis"
+    name: "Test Redis"
+    type: redis
+    host: redis.internal
+    port: 6379
+    database: "0"
+    password: "${TEST_REDIS_PASSWORD}"
+    roles: ["*"]
+    managed: true

package/tests/helpers/mock-fetch.ts

@@ -0,0 +1,59 @@
+/**
+ * Global fetch mock helper for hook and component tests
+ */
+import { mock } from 'bun:test';
+
+export interface MockFetchResponse {
+  status?: number;
+  ok?: boolean;
+  json?: unknown;
+  text?: string;
+  headers?: Record<string, string>;
+}
+
+type FetchMockFn = ReturnType<typeof mock<(input: RequestInfo | URL, init?: RequestInit) => Promise<Response>>>;
+
+/**
+ * Install a global fetch mock that matches URL patterns to responses.
+ * Returns the mock function for assertions.
+ */
+export function mockGlobalFetch(
+  routes: Record<string, MockFetchResponse | ((req: Request) => MockFetchResponse | Promise<MockFetchResponse>)>
+): FetchMockFn {
+  const fetchMock = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+    const pathname = new URL(url, 'http://localhost:3000').pathname;
+
+    for (const [pattern, handler] of Object.entries(routes)) {
+      if (pathname.includes(pattern)) {
+        const mockResponse = typeof handler === 'function'
+          ? await handler(new Request(url, init))
+          : handler;
+
+        return new Response(
+          mockResponse.json !== undefined ? JSON.stringify(mockResponse.json) : (mockResponse.text ?? ''),
+          {
+            status: mockResponse.status ?? 200,
+            headers: {
+              'content-type': 'application/json',
+              ...mockResponse.headers,
+            },
+          }
+        );
+      }
+    }
+
+    return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 });
+  });
+
+  globalThis.fetch = fetchMock as unknown as typeof fetch;
+  return fetchMock;
+}
+
+/**
+ * Restore original fetch (call in afterEach/afterAll)
+ */
+const _originalFetch = globalThis.fetch;
+export function restoreGlobalFetch() {
+  globalThis.fetch = _originalFetch;
+}

package/tests/helpers/mock-monaco.ts

@@ -0,0 +1,112 @@
+/**
+ * Monaco Editor mock for component tests
+ * Replaces the heavy Monaco Editor with a simple textarea
+ */
+import { mock } from 'bun:test';
+
+export function setupMonacoMock() {
+  mock.module('@monaco-editor/react', () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const React = require('react');
+    return {
+      default: function MockEditor(props: {
+        value?: string;
+        onChange?: (value: string | undefined) => void;
+        language?: string;
+        'data-testid'?: string;
+      }) {
+        return React.createElement('textarea', {
+          'data-testid': props['data-testid'] ?? 'mock-monaco-editor',
+          value: props.value ?? '',
+          onChange: (e: { target: { value: string } }) => props.onChange?.(e.target.value),
+          'aria-label': `${props.language ?? 'sql'} editor`,
+        });
+      },
+      Editor: function MockEditor(props: {
+        value?: string;
+        onChange?: (value: string | undefined) => void;
+        language?: string;
+      }) {
+        return React.createElement('textarea', {
+          'data-testid': 'mock-monaco-editor',
+          value: props.value ?? '',
+          onChange: (e: { target: { value: string } }) => props.onChange?.(e.target.value),
+        });
+      },
+      loader: {
+        init: mock(() => Promise.resolve()),
+        config: mock(() => {}),
+      },
+      useMonaco: mock(() => null),
+    };
+  });
+}
+
+export function setupRechartssMock() {
+  mock.module('recharts', () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const React = require('react');
+    return {
+      ResponsiveContainer: ({ children }: { children: unknown }) => children,
+      AreaChart: ({ children }: { children: unknown }) => React.createElement('div', { 'data-testid': 'mock-area-chart' }, children),
+      BarChart: ({ children }: { children: unknown }) => React.createElement('div', { 'data-testid': 'mock-bar-chart' }, children),
+      LineChart: ({ children }: { children: unknown }) => React.createElement('div', { 'data-testid': 'mock-line-chart' }, children),
+      RadialBarChart: ({ children }: { children: unknown }) => React.createElement('div', { 'data-testid': 'mock-radial-chart' }, children),
+      Area: () => null,
+      Bar: () => null,
+      Line: () => null,
+      RadialBar: () => null,
+      XAxis: () => null,
+      YAxis: () => null,
+      CartesianGrid: () => null,
+      Tooltip: () => null,
+      Legend: () => null,
+      PolarAngleAxis: () => null,
+    };
+  });
+}
+
+export function setupXYFlowMock() {
+  mock.module('@xyflow/react', () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const React = require('react');
+    return {
+      ReactFlow: ({ children }: { children: unknown }) => React.createElement('div', { 'data-testid': 'mock-react-flow' }, children),
+      ReactFlowProvider: ({ children }: { children: unknown }) => children,
+      MiniMap: () => React.createElement('div', { 'data-testid': 'mock-minimap' }),
+      Controls: () => null,
+      Background: () => null,
+      Handle: () => null,
+      useNodesState: () => [[], mock(() => {}), mock(() => {})],
+      useEdgesState: () => [[], mock(() => {}), mock(() => {})],
+      useReactFlow: () => ({ fitView: mock(() => {}), getNodes: mock(() => []), getEdges: mock(() => []) }),
+      Position: { Top: 'top', Bottom: 'bottom', Left: 'left', Right: 'right' },
+      MarkerType: { ArrowClosed: 'arrowclosed' },
+      Panel: ({ children, position }: { children: unknown; position?: string }) => React.createElement('div', { 'data-testid': `mock-panel-${position || 'default'}` }, children),
+    };
+  });
+}
+
+export function setupFramerMotionMock() {
+  mock.module('framer-motion', () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const React = require('react');
+    const motionPropKeys = ['initial', 'animate', 'exit', 'transition', 'variants', 'whileHover', 'whileTap', 'whileInView', 'layout', 'layoutId'];
+    const passthrough = ({ children, ...props }: Record<string, unknown>) => {
+      // Filter out framer-motion-specific props that React doesn't understand
+      const domProps = Object.fromEntries(
+        Object.entries(props).filter(([key]) => !motionPropKeys.includes(key))
+      );
+      return React.createElement('div', domProps, children);
+    };
+
+    return {
+      motion: new Proxy({}, {
+        get: () => passthrough,
+      }),
+      AnimatePresence: ({ children }: { children: unknown }) => children,
+      useAnimation: () => ({ start: mock(() => {}), stop: mock(() => {}) }),
+      useInView: () => true,
+    };
+  });
+}

package/tests/helpers/mock-navigation.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared next/navigation mock for all hook and component tests.
+ *
+ * IMPORTANT: Bun's mock.module() is process-wide — calling it from multiple files
+ * causes the LAST call to win. This shared module ensures mock.module('next/navigation')
+ * is called exactly once, and all test files can assert on the same mock functions.
+ *
+ * Usage:
+ *   import { mockRouterPush, mockRouterRefresh } from '../helpers/mock-navigation';
+ *   beforeEach(() => { mockRouterPush.mockClear(); mockRouterRefresh.mockClear(); });
+ */
+import { mock } from 'bun:test';
+
+export const mockRouterPush = mock(() => {});
+export const mockRouterRefresh = mock(() => {});
+export const mockRouterBack = mock(() => {});
+export const mockRouterForward = mock(() => {});
+
+mock.module('next/navigation', () => ({
+  useRouter: () => ({
+    push: mockRouterPush,
+    refresh: mockRouterRefresh,
+    back: mockRouterBack,
+    forward: mockRouterForward,
+  }),
+  usePathname: () => '/',
+  useSearchParams: () => new URLSearchParams(),
+}));

package/tests/helpers/mock-next.ts

@@ -0,0 +1,80 @@
+/**
+ * Next.js API Route test helpers
+ * Creates mock NextRequest objects and cookie helpers
+ */
+
+export function createMockRequest(
+  url: string,
+  options: {
+    method?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    cookies?: Record<string, string>;
+  } = {}
+): Request {
+  const { method = 'GET', body, headers = {}, cookies = {} } = options;
+
+  const cookieHeader = Object.entries(cookies)
+    .map(([k, v]) => `${k}=${v}`)
+    .join('; ');
+
+  const allHeaders: Record<string, string> = {
+    ...headers,
+    ...(cookieHeader ? { cookie: cookieHeader } : {}),
+    ...(body ? { 'content-type': 'application/json' } : {}),
+  };
+
+  const init: RequestInit = {
+    method,
+    headers: allHeaders,
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  };
+
+  return new Request(`http://localhost:3000${url}`, init);
+}
+
+export function createMockCookies() {
+  const store = new Map<string, { value: string; options?: Record<string, unknown> }>();
+
+  return {
+    get: (name: string) => {
+      const entry = store.get(name);
+      return entry ? { name, value: entry.value } : undefined;
+    },
+    set: (name: string, value: string, options?: Record<string, unknown>) => {
+      store.set(name, { value, options });
+    },
+    delete: (name: string) => {
+      store.delete(name);
+    },
+    has: (name: string) => store.has(name),
+    getAll: () => Array.from(store.entries()).map(([name, { value }]) => ({ name, value })),
+    _store: store,
+  };
+}
+
+/**
+ * Parse JSON from a Response object
+ */
+export async function parseResponseJSON<T = unknown>(response: Response): Promise<T> {
+  return response.json() as Promise<T>;
+}
+
+/**
+ * Read streaming response body as text
+ */
+export async function readStreamResponse(response: Response): Promise<string> {
+  const reader = response.body?.getReader();
+  if (!reader) return '';
+
+  const decoder = new TextDecoder();
+  let result = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result += decoder.decode(value, { stream: true });
+  }
+
+  return result;
+}