@lobehub/lobehub 2.0.0-next.95 → 2.0.0-next.97

package/packages/conversation-flow/src/__tests__/structuring.test.ts

@@ -0,0 +1,600 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildHelperMaps } from '../indexing';
+import { buildIdTree } from '../structuring';
+import type { Message } from '../types';
+
+describe('buildIdTree', () => {
+  describe('basic tree building', () => {
+    it('should build tree from single root message', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        children: [],
+        id: 'msg-1',
+      });
+    });
+
+    it('should build tree with linear conversation', () => {
+      const messages: Message[] = [
+        {
+          content: 'Message 1',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Message 2',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Message 3',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 3000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[0].children).toHaveLength(1);
+      expect(result[0].children[0].id).toBe('msg-2');
+      expect(result[0].children[0].children).toHaveLength(1);
+      expect(result[0].children[0].children[0].id).toBe('msg-3');
+    });
+
+    it('should handle multiple root messages', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root 1',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Root 2',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          role: 'user',
+          updatedAt: 2000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[1].id).toBe('msg-2');
+    });
+  });
+
+  describe('branching conversations', () => {
+    it('should build tree with branches', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Branch 1',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Branch 2',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 3000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[0].children).toHaveLength(2);
+      expect(result[0].children[0].id).toBe('msg-2');
+      expect(result[0].children[1].id).toBe('msg-3');
+    });
+
+    it('should handle nested branches', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Branch 1',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Branch 1.1',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 3000,
+        },
+        {
+          content: 'Branch 1.2',
+          createdAt: 4000,
+          id: 'msg-4',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 4000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].children[0].id).toBe('msg-2');
+      expect(result[0].children[0].children).toHaveLength(2);
+      expect(result[0].children[0].children[0].id).toBe('msg-3');
+      expect(result[0].children[0].children[1].id).toBe('msg-4');
+    });
+
+    it('should handle deeply nested tree (4 levels)', () => {
+      const messages: Message[] = [
+        {
+          content: 'Level 0',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Level 1',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Level 2',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 3000,
+        },
+        {
+          content: 'Level 3',
+          createdAt: 4000,
+          id: 'msg-4',
+          meta: {},
+          parentId: 'msg-3',
+          role: 'assistant',
+          updatedAt: 4000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+
+      let current = result[0];
+      expect(current.id).toBe('msg-1');
+
+      current = current.children[0];
+      expect(current.id).toBe('msg-2');
+
+      current = current.children[0];
+      expect(current.id).toBe('msg-3');
+
+      current = current.children[0];
+      expect(current.id).toBe('msg-4');
+      expect(current.children).toHaveLength(0);
+    });
+  });
+
+  describe('thread handling', () => {
+    it('should exclude messages with threadId from main tree', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Main flow',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Thread message',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          threadId: 'thread-1',
+          updatedAt: 3000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[0].children).toHaveLength(1);
+      expect(result[0].children[0].id).toBe('msg-2');
+    });
+
+    it('should exclude root messages with threadId', () => {
+      const messages: Message[] = [
+        {
+          content: 'Main root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Thread root',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          role: 'assistant',
+          threadId: 'thread-1',
+          updatedAt: 2000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('msg-1');
+    });
+
+    it('should filter out thread children at any level', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Main child',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Main grandchild',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 3000,
+        },
+        {
+          content: 'Thread grandchild',
+          createdAt: 4000,
+          id: 'msg-4',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          threadId: 'thread-1',
+          updatedAt: 4000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].children[0].id).toBe('msg-2');
+      expect(result[0].children[0].children).toHaveLength(1);
+      expect(result[0].children[0].children[0].id).toBe('msg-3');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty messages', () => {
+      const helperMaps = buildHelperMaps([]);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle messages with no children', () => {
+      const messages: Message[] = [
+        {
+          content: 'Lone message',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({
+        children: [],
+        id: 'msg-1',
+      });
+    });
+
+    it('should handle messages with missing parent references', () => {
+      const messages: Message[] = [
+        {
+          content: 'Orphan',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          parentId: 'non-existent',
+          role: 'user',
+          updatedAt: 1000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      // Orphan messages without valid parents are not in main flow
+      expect(result).toEqual([]);
+    });
+
+    it('should build correct tree when all messages are threaded', () => {
+      const messages: Message[] = [
+        {
+          content: 'Thread 1',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          threadId: 'thread-1',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Thread 2',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          role: 'assistant',
+          threadId: 'thread-1',
+          updatedAt: 2000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('complex scenarios', () => {
+    it('should build tree with mixed branches and linear paths', () => {
+      const messages: Message[] = [
+        {
+          content: 'Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Branch A',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        {
+          content: 'Branch A -> Child',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 3000,
+        },
+        {
+          content: 'Branch B',
+          createdAt: 4000,
+          id: 'msg-4',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 4000,
+        },
+        {
+          content: 'Branch B -> Child 1',
+          createdAt: 5000,
+          id: 'msg-5',
+          meta: {},
+          parentId: 'msg-4',
+          role: 'user',
+          updatedAt: 5000,
+        },
+        {
+          content: 'Branch B -> Child 2',
+          createdAt: 6000,
+          id: 'msg-6',
+          meta: {},
+          parentId: 'msg-4',
+          role: 'user',
+          updatedAt: 6000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[0].children).toHaveLength(2);
+
+      // Branch A
+      expect(result[0].children[0].id).toBe('msg-2');
+      expect(result[0].children[0].children).toHaveLength(1);
+      expect(result[0].children[0].children[0].id).toBe('msg-3');
+
+      // Branch B
+      expect(result[0].children[1].id).toBe('msg-4');
+      expect(result[0].children[1].children).toHaveLength(2);
+      expect(result[0].children[1].children[0].id).toBe('msg-5');
+      expect(result[0].children[1].children[1].id).toBe('msg-6');
+    });
+
+    it('should handle multiple root trees', () => {
+      const messages: Message[] = [
+        // Tree 1
+        {
+          content: 'Tree 1 Root',
+          createdAt: 1000,
+          id: 'msg-1',
+          meta: {},
+          role: 'user',
+          updatedAt: 1000,
+        },
+        {
+          content: 'Tree 1 Child',
+          createdAt: 2000,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 2000,
+        },
+        // Tree 2
+        {
+          content: 'Tree 2 Root',
+          createdAt: 3000,
+          id: 'msg-3',
+          meta: {},
+          role: 'user',
+          updatedAt: 3000,
+        },
+        {
+          content: 'Tree 2 Child',
+          createdAt: 4000,
+          id: 'msg-4',
+          meta: {},
+          parentId: 'msg-3',
+          role: 'assistant',
+          updatedAt: 4000,
+        },
+      ];
+
+      const helperMaps = buildHelperMaps(messages);
+      const result = buildIdTree(helperMaps);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[0].children[0].id).toBe('msg-2');
+      expect(result[1].id).toBe('msg-3');
+      expect(result[1].children[0].id).toBe('msg-4');
+    });
+  });
+
+  describe('performance', () => {
+    it('should build tree for large dataset efficiently', () => {
+      const messages: Message[] = Array.from({ length: 1000 }, (_, i) => ({
+        content: `Message ${i}`,
+        createdAt: i,
+        id: `msg-${i}`,
+        meta: {},
+        parentId: i > 0 ? `msg-${i - 1}` : undefined,
+        role: i % 2 === 0 ? ('user' as const) : ('assistant' as const),
+        updatedAt: i,
+      }));
+
+      const helperMaps = buildHelperMaps(messages);
+
+      const startTime = performance.now();
+      const result = buildIdTree(helperMaps);
+      const endTime = performance.now();
+
+      const executionTime = endTime - startTime;
+
+      expect(result).toHaveLength(1);
+      expect(executionTime).toBeLessThan(50); // Should be fast
+    });
+  });
+});

package/packages/database/src/client/db.ts

@@ -38,7 +38,7 @@ export class DatabaseManager {
   private callbacks?: DatabaseLoadingCallbacks;
   private isLocalDBSchemaSynced = false;
 
-  // CDN 配置
+  // CDN configuration
   private static WASM_CDN_URL =
     'https://registry.npmmirror.com/@electric-sql/pglite/0.2.17/files/dist/postgres.wasm';
 
@@ -57,7 +57,7 @@ export class DatabaseManager {
     return DatabaseManager.instance;
   }
 
-  // 加载并编译 WASM 模块
+  // Load and compile WASM module
   private async loadWasmModule(): Promise<WebAssembly.Module> {
     const start = Date.now();
     this.callbacks?.onStateChange?.(DatabaseLoadingState.LoadingWasm);
@@ -72,7 +72,7 @@ export class DatabaseManager {
     let receivedLength = 0;
     const chunks: Uint8Array[] = [];
 
-    // 读取数据流
+    // Read data stream
     // eslint-disable-next-line no-constant-condition
     while (true) {
       const { done, value } = await reader.read();
@@ -82,7 +82,7 @@ export class DatabaseManager {
       chunks.push(value);
       receivedLength += value.length;
 
-      // 计算并报告进度
+      // Calculate and report progress
       const progress = Math.min(Math.round((receivedLength / contentLength) * 100), 100);
       this.callbacks?.onProgress?.({
         phase: 'wasm',
@@ -90,7 +90,7 @@ export class DatabaseManager {
       });
     }
 
-    // 合并数据块
+    // Merge data chunks
     const wasmBytes = new Uint8Array(receivedLength);
     let position = 0;
     for (const chunk of chunks) {
@@ -104,7 +104,7 @@ export class DatabaseManager {
       progress: 100,
     });
 
-    // 编译 WASM 模块
+    // Compile WASM module
     return WebAssembly.compile(wasmBytes);
   }
 
@@ -114,7 +114,7 @@ export class DatabaseManager {
     return await res.blob();
   };
 
-  // 异步加载 PGlite 相关依赖
+  // Asynchronously load PGlite related dependencies
   private async loadDependencies() {
     const start = Date.now();
     this.callbacks?.onStateChange?.(DatabaseLoadingState.LoadingDependencies);
@@ -135,7 +135,7 @@ export class DatabaseManager {
         const result = await importPromise;
         loaded += 1;
 
-        // 计算加载进度
+        // Calculate loading progress
         this.callbacks?.onProgress?.({
           phase: 'dependencies',
           progress: Math.min(Math.round((loaded / imports.length) * 100), 100),
@@ -156,7 +156,7 @@ export class DatabaseManager {
     return { IdbFs, MemoryFS, PGlite, fsBundle, vector };
   }
 
-  // 数据库迁移方法
+  // Database migration method
   private async migrate(skipMultiRun = false): Promise<DrizzleInstance> {
     if (this.isLocalDBSchemaSynced && skipMultiRun) return this.db;
 
@@ -169,17 +169,17 @@ export class DatabaseManager {
         try {
           const drizzleMigration = new DrizzleMigrationModel(this.db as any);
 
-          // 检查数据库中是否存在表
+          // Check if tables exist in database
           const tableCount = await drizzleMigration.getTableCounts();
 
-          // 如果表数量大于0，则认为数据库已正确初始化
+          // If table count > 0, consider database properly initialized
           if (tableCount > 0) {
             this.isLocalDBSchemaSynced = true;
             return this.db;
           }
         } catch (error) {
           console.warn('Error checking table existence, proceeding with migration', error);
-          // 如果查询失败，继续执行迁移以确保安全
+          // If query fails, continue migration to ensure safety
         }
       }
     }