@lobehub/lobehub 2.0.0-next.196 → 2.0.0-next.198

package/packages/database/src/models/__tests__/_util.ts

@@ -1,30 +0,0 @@
-import { PGlite } from '@electric-sql/pglite';
-import { vector } from '@electric-sql/pglite/vector';
-import { drizzle } from 'drizzle-orm/pglite';
-
-import migrations from '../../core/migrations.json';
-import * as schema from '../../schemas';
-import { LobeChatDatabase } from '../../type';
-
-const isServerDBMode = process.env.TEST_SERVER_DB === '1';
-
-let testClientDB: ReturnType<typeof drizzle<typeof schema>> | null = null;
-
-export const getTestDB = async () => {
-  if (isServerDBMode) {
-    const { getTestDBInstance } = await import('../../core/dbForTest');
-    return await getTestDBInstance();
-  }
-
-  if (testClientDB) return testClientDB as unknown as LobeChatDatabase;
-
-  // 直接使用 pglite 内置资源，不需要从 CDN 下载
-  const pglite = new PGlite({ extensions: { vector } });
-
-  testClientDB = drizzle({ client: pglite, schema });
-
-  // @ts-expect-error - migrate internal API
-  await testClientDB.dialect.migrate(migrations, testClientDB.session, {});
-
-  return testClientDB as unknown as LobeChatDatabase;
-};

package/packages/database/src/repositories/tableViewer/index.test.ts

@@ -1,255 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { getTestDB } from '../../models/__tests__/_util';
-import { LobeChatDatabase } from '../../type';
-import { TableViewerRepo } from './index';
-
-const userId = 'user-table-viewer';
-
-// Mock database execution
-const mockExecute = vi.fn();
-const mockDB = {
-  execute: mockExecute,
-};
-
-let serverDB: LobeChatDatabase;
-let repo: TableViewerRepo;
-
-beforeAll(async () => {
-  serverDB = await getTestDB();
-  repo = new TableViewerRepo(serverDB, userId);
-}, 30000);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('TableViewerRepo', () => {
-  describe('getAllTables', () => {
-    it('should handle custom schema', async () => {
-      const result = await repo.getAllTables('custom_schema');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('getTableDetails', () => {
-    it('should return table column details', async () => {
-      const tableName = 'test_table';
-      const mockColumns = {
-        rows: [
-          {
-            column_name: 'id',
-            data_type: 'uuid',
-            is_nullable: 'NO',
-            column_default: null,
-            is_primary_key: true,
-            foreign_key: null,
-          },
-        ],
-      };
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce(mockColumns);
-
-      const result = await testRepo.getTableDetails(tableName);
-
-      expect(result).toEqual([
-        {
-          name: 'id',
-          type: 'uuid',
-          nullable: false,
-          defaultValue: null,
-          isPrimaryKey: true,
-          foreignKey: null,
-        },
-      ]);
-    });
-  });
-
-  describe('getTableData', () => {
-    it('should return paginated data with filters', async () => {
-      const tableName = 'test_table';
-      const pagination = {
-        page: 1,
-        pageSize: 10,
-        sortBy: 'id',
-        sortOrder: 'desc' as const,
-      };
-      const filters = [
-        {
-          column: 'name',
-          operator: 'contains' as const,
-          value: 'test',
-        },
-      ];
-
-      const mockData = {
-        rows: [{ id: 1, name: 'test' }],
-      };
-      const mockCount = {
-        rows: [{ total: 1 }],
-      };
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce(mockData).mockResolvedValueOnce(mockCount);
-
-      const result = await testRepo.getTableData(tableName, pagination, filters);
-
-      expect(result).toEqual({
-        data: mockData.rows,
-        pagination: {
-          page: 1,
-          pageSize: 10,
-          total: 1,
-        },
-      });
-    });
-  });
-
-  describe('updateRow', () => {
-    it('should update and return row data', async () => {
-      const tableName = 'test_table';
-      const id = '123';
-      const primaryKeyColumn = 'id';
-      const data = { name: 'updated' };
-
-      const mockResult = {
-        rows: [{ id: '123', name: 'updated' }],
-      };
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce(mockResult);
-
-      const result = await testRepo.updateRow(tableName, id, primaryKeyColumn, data);
-
-      expect(result).toEqual(mockResult.rows[0]);
-      expect(mockExecute).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('deleteRow', () => {
-    it('should delete a row', async () => {
-      const tableName = 'test_table';
-      const id = '123';
-      const primaryKeyColumn = 'id';
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce({ rows: [] });
-
-      await testRepo.deleteRow(tableName, id, primaryKeyColumn);
-
-      expect(mockExecute).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('insertRow', () => {
-    it('should insert and return new row data', async () => {
-      const tableName = 'test_table';
-      const data = { name: 'new row' };
-
-      const mockResult = {
-        rows: [{ id: '123', name: 'new row' }],
-      };
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce(mockResult);
-
-      const result = await testRepo.insertRow(tableName, data);
-
-      expect(result).toEqual(mockResult.rows[0]);
-      expect(mockExecute).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('getTableCount', () => {
-    it('should return table count', async () => {
-      const tableName = 'test_table';
-      const mockResult = {
-        rows: [{ total: 42 }],
-      };
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce(mockResult);
-
-      const result = await testRepo.getTableCount(tableName);
-
-      expect(result).toBe(42);
-      expect(mockExecute).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('batchDelete', () => {
-    it('should delete multiple rows', async () => {
-      const tableName = 'test_table';
-      const ids = ['1', '2', '3'];
-      const primaryKeyColumn = 'id';
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce({ rows: [] });
-
-      await testRepo.batchDelete(tableName, ids, primaryKeyColumn);
-
-      expect(mockExecute).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('exportTableData', () => {
-    it('should export table data with default pagination', async () => {
-      const tableName = 'test_table';
-      const mockData = {
-        rows: [{ id: 1, name: 'test' }],
-      };
-      const mockCount = {
-        rows: [{ total: 1 }],
-      };
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-      mockExecute.mockResolvedValueOnce(mockData).mockResolvedValueOnce(mockCount);
-
-      const result = await testRepo.exportTableData(tableName);
-
-      expect(result).toEqual({
-        data: mockData.rows,
-        pagination: {
-          page: 1,
-          pageSize: 1000,
-          total: 1,
-        },
-      });
-    });
-
-    it('should export table data with custom pagination and filters', async () => {
-      const tableName = 'test_table';
-      const pagination = { page: 2, pageSize: 50 };
-      const filters = [
-        {
-          column: 'status',
-          operator: 'equals' as const,
-          value: 'active',
-        },
-      ];
-
-      const mockData = {
-        rows: [{ id: 1, status: 'active' }],
-      };
-      const mockCount = {
-        rows: [{ total: 1 }],
-      };
-
-      mockExecute.mockResolvedValueOnce(mockData).mockResolvedValueOnce(mockCount);
-
-      const testRepo = new TableViewerRepo(mockDB as any, userId);
-
-      const result = await testRepo.exportTableData(tableName, pagination, filters);
-
-      expect(result).toEqual({
-        data: mockData.rows,
-        pagination: {
-          page: 2,
-          pageSize: 50,
-          total: 1,
-        },
-      });
-    });
-  });
-});

package/packages/database/src/repositories/tableViewer/index.ts

@@ -1,251 +0,0 @@
-import type {
-  FilterCondition,
-  PaginationParams,
-  TableBasicInfo,
-  TableColumnInfo,
-} from '@lobechat/types';
-import { sql } from 'drizzle-orm';
-import pMap from 'p-map';
-
-import { LobeChatDatabase } from '../../type';
-
-export class TableViewerRepo {
-  private userId: string;
-  private db: LobeChatDatabase;
-
-  constructor(db: LobeChatDatabase, userId: string) {
-    this.userId = userId;
-    this.db = db;
-  }
-
-  /**
-   * Get all tables in the database
-   */
-  async getAllTables(schema = 'public'): Promise<TableBasicInfo[]> {
-    const query = sql`
-      SELECT
-        table_name as name,
-        table_type as type
-      FROM information_schema.tables
-      WHERE table_schema = ${schema}
-      ORDER BY table_name;
-    `;
-
-    const tables = await this.db.execute(query);
-
-    const tableNames = tables.rows.map((row) => row.name) as string[];
-
-    const counts = await pMap(tableNames, async (name) => this.getTableCount(name), {
-      concurrency: 10,
-    });
-
-    return tables.rows.map((row, index) => ({
-      count: counts[index],
-      name: row.name,
-      type: row.type,
-    })) as TableBasicInfo[];
-  }
-
-  /**
-   * Get detailed structure information for a specified table
-   */
-  async getTableDetails(tableName: string): Promise<TableColumnInfo[]> {
-    const query = sql`
-      SELECT
-        c.column_name,
-        c.data_type,
-        c.is_nullable,
-        c.column_default,
-        -- Primary key information
-        (
-          SELECT true
-          FROM information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-          WHERE tc.table_name = c.table_name
-            AND kcu.column_name = c.column_name
-            AND tc.constraint_type = 'PRIMARY KEY'
-        ) is_primary_key,
-        -- Foreign key information
-        (
-          SELECT json_build_object(
-            'table', ccu.table_name,
-            'column', ccu.column_name
-          )
-          FROM information_schema.table_constraints tc
-          JOIN information_schema.key_column_usage kcu
-            ON tc.constraint_name = kcu.constraint_name
-          JOIN information_schema.constraint_column_usage ccu
-            ON ccu.constraint_name = tc.constraint_name
-          WHERE tc.table_name = c.table_name
-            AND kcu.column_name = c.column_name
-            AND tc.constraint_type = 'FOREIGN KEY'
-        ) foreign_key
-      FROM information_schema.columns c
-      WHERE c.table_name = ${tableName}
-      AND c.table_schema = 'public'
-      ORDER BY c.ordinal_position;
-    `;
-
-    const columns = await this.db.execute(query);
-
-    return columns.rows.map((col: any) => ({
-      defaultValue: col.column_default,
-      foreignKey: col.foreign_key,
-      isPrimaryKey: !!col.is_primary_key,
-      name: col.column_name,
-      nullable: col.is_nullable === 'YES',
-      type: col.data_type,
-    }));
-  }
-
-  /**
-   * Get table data with support for pagination, sorting, and filtering
-   */
-  async getTableData(tableName: string, pagination: PaginationParams, filters?: FilterCondition[]) {
-    const offset = (pagination.page - 1) * pagination.pageSize;
-
-    // Build base query
-    let baseQuery = sql`SELECT * FROM ${sql.identifier(tableName)}`;
-
-    // Add filter conditions
-    if (filters && filters.length > 0) {
-      const whereConditions = filters.map((filter) => {
-        const column = sql.identifier(filter.column);
-
-        switch (filter.operator) {
-          case 'equals': {
-            return sql`${column} = ${filter.value}`;
-          }
-          case 'contains': {
-            return sql`${column} ILIKE ${`%${filter.value}%`}`;
-          }
-          case 'startsWith': {
-            return sql`${column} ILIKE ${`${filter.value}%`}`;
-          }
-          case 'endsWith': {
-            return sql`${column} ILIKE ${`%${filter.value}`}`;
-          }
-          default: {
-            return sql`1=1`;
-          }
-        }
-      });
-
-      baseQuery = sql`${baseQuery} WHERE ${sql.join(whereConditions, sql` AND `)}`;
-    }
-
-    // Add sorting
-    if (pagination.sortBy) {
-      const direction = pagination.sortOrder === 'desc' ? sql`DESC` : sql`ASC`;
-      baseQuery = sql`${baseQuery} ORDER BY ${sql.identifier(pagination.sortBy)} ${direction}`;
-    }
-
-    // Add pagination
-    const query = sql`${baseQuery} LIMIT ${pagination.pageSize} OFFSET ${offset}`;
-
-    // Get total count
-    const countQuery = sql`SELECT COUNT(*) as total FROM ${sql.identifier(tableName)}`;
-
-    // Execute queries in parallel
-    const [data, count] = await Promise.all([this.db.execute(query), this.db.execute(countQuery)]);
-
-    return {
-      data: data.rows,
-      pagination: {
-        page: pagination.page,
-        pageSize: pagination.pageSize,
-        total: Number(count.rows[0].total),
-      },
-    };
-  }
-
-  /**
-   * Update a row in the table
-   */
-  async updateRow(
-    tableName: string,
-    id: string,
-    primaryKeyColumn: string,
-    data: Record<string, any>,
-  ) {
-    const setColumns = Object.entries(data).map(([key, value]) => {
-      return sql`${sql.identifier(key)} = ${value}`;
-    });
-
-    const query = sql`
-      UPDATE ${sql.identifier(tableName)}
-      SET ${sql.join(setColumns, sql`, `)}
-      WHERE ${sql.identifier(primaryKeyColumn)} = ${id}
-      RETURNING *
-    `;
-
-    const result = await this.db.execute(query);
-    return result.rows[0];
-  }
-
-  /**
-   * Delete a row from the table
-   */
-  async deleteRow(tableName: string, id: string, primaryKeyColumn: string) {
-    const query = sql`
-      DELETE FROM ${sql.identifier(tableName)}
-      WHERE ${sql.identifier(primaryKeyColumn)} = ${id}
-    `;
-
-    await this.db.execute(query);
-  }
-
-  /**
-   * Insert new row data
-   */
-  async insertRow(tableName: string, data: Record<string, any>) {
-    const columns = Object.keys(data).map((key) => sql.identifier(key));
-    const values = Object.values(data);
-
-    const query = sql`
-      INSERT INTO ${sql.identifier(tableName)}
-      (${sql.join(columns, sql`, `)})
-      VALUES (${sql.join(
-        values.map((v) => sql`${v}`),
-        sql`, `,
-      )})
-      RETURNING *
-    `;
-
-    const result = await this.db.execute(query);
-    return result.rows[0];
-  }
-
-  /**
-   * Get total record count of a table
-   */
-  async getTableCount(tableName: string): Promise<number> {
-    const query = sql`SELECT COUNT(*) as total FROM ${sql.identifier(tableName)}`;
-    const result = await this.db.execute(query);
-    return Number(result.rows[0].total);
-  }
-
-  /**
-   * Batch delete data
-   */
-  async batchDelete(tableName: string, ids: string[], primaryKeyColumn: string) {
-    const query = sql`
-      DELETE FROM ${sql.identifier(tableName)}
-      WHERE ${sql.identifier(primaryKeyColumn)} = ANY(${ids})
-    `;
-
-    await this.db.execute(query);
-  }
-
-  /**
-   * Export table data (supports paginated export)
-   */
-  async exportTableData(
-    tableName: string,
-    pagination?: PaginationParams,
-    filters?: FilterCondition[],
-  ) {
-    return this.getTableData(tableName, pagination || { page: 1, pageSize: 1000 }, filters);
-  }
-}

package/packages/types/src/tableViewer.ts

@@ -1,30 +0,0 @@
-export interface TableBasicInfo {
-  count: number;
-  name: string;
-  type: 'BASE TABLE' | 'VIEW';
-}
-
-export interface TableColumnInfo {
-  defaultValue?: string;
-  foreignKey?: {
-    column: string;
-    table: string;
-  };
-  isPrimaryKey: boolean;
-  name: string;
-  nullable: boolean;
-  type: string;
-}
-
-export interface PaginationParams {
-  page: number;
-  pageSize: number;
-  sortBy?: string;
-  sortOrder?: 'asc' | 'desc';
-}
-
-export interface FilterCondition {
-  column: string;
-  operator: 'equals' | 'contains' | 'startsWith' | 'endsWith';
-  value: any;
-}

package/scripts/migrateClientDB/compile-migrations.ts

@@ -1,14 +0,0 @@
-import { readMigrationFiles } from 'drizzle-orm/migrator';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const dbBase = join(__dirname, '../../packages/database');
-const migrationsFolder = join(dbBase, './migrations');
-const migrations = readMigrationFiles({ migrationsFolder: migrationsFolder });
-
-writeFileSync(
-  join(dbBase, './src/core/migrations.json'),
-  JSON.stringify(migrations, null, 2), // null, 2 adds indentation for better readability
-);
-
-console.log('🏁 client migrations.json compiled!');