@libredb/studio 0.9.7 → 0.9.12

package/tests/fixtures/masking-configs.ts

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

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

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

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

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

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

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

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

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

@@ -1,15 +0,0 @@
-{
-  "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

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

@@ -1,59 +0,0 @@
-/**
- * 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

@@ -1,112 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,80 +0,0 @@
-/**
- * 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;
-}