@lobehub/chat 1.76.1 → 1.77.1

package/src/database/repositories/dataImporter/__tests__/index.test.ts

@@ -1,940 +1,180 @@
-// @vitest-environment node
 import { eq, inArray } from 'drizzle-orm/expressions';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import {
-  agents,
-  agentsToSessions,
-  messages,
-  sessionGroups,
-  sessions,
-  topics,
-  users,
-} from '@/database/schemas';
-import { getTestDBInstance } from '@/database/server/core/dbForTest';
-import { CURRENT_CONFIG_VERSION } from '@/migrations';
-import { ImporterEntryData } from '@/types/importer';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getTestDB } from '@/database/models/__tests__/_util';
+import * as Schema from '@/database/schemas';
+import { ImportPgDataStructure } from '@/types/export';
 
 import { DataImporterRepos } from '../index';
-import mockImportData from './fixtures/messages.json';
+import agentsData from './fixtures/agents.json';
+import agentsToSessionsData from './fixtures/agentsToSessions.json';
+import topicsData from './fixtures/topic.json';
+import userSettingsData from './fixtures/userSettings.json';
 
-const serverDB = await getTestDBInstance();
+const clientDB = await getTestDB();
 
 const userId = 'test-user-id';
 let importer: DataImporterRepos;
 
 beforeEach(async () => {
-  await serverDB.delete(users);
+  await clientDB.delete(Schema.users);
 
   // 创建测试数据
-  await serverDB.transaction(async (tx) => {
-    await tx.insert(users).values({ id: userId });
+  await clientDB.transaction(async (tx) => {
+    await tx.insert(Schema.users).values({ id: userId });
   });
 
-  importer = new DataImporterRepos(serverDB, userId);
+  importer = new DataImporterRepos(clientDB, userId);
+});
+afterEach(async () => {
+  await clientDB.delete(Schema.users);
 });
 
 describe('DataImporter', () => {
-  describe('import sessionGroups', () => {
-    it('should import session groups and return correct result', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessionGroups: [
-          { id: 'group1', name: 'Group 1', createdAt: 1715186011586, updatedAt: 1715186015053 },
-          { id: 'group2', name: 'Group 2', createdAt: 1715186011586, updatedAt: 1715186015053 },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.sessionGroups.added).toBe(2);
-      expect(result.sessionGroups.skips).toBe(0);
-      expect(result.sessionGroups.errors).toBe(0);
-
-      const groups = await serverDB.query.sessionGroups.findMany({
-        where: eq(sessionGroups.userId, userId),
-      });
-      expect(groups).toHaveLength(2);
-    });
-
-    it('should skip existing session groups and return correct result', async () => {
-      await serverDB
-        .insert(sessionGroups)
-        .values({ clientId: 'group1', name: 'Existing Group', userId });
+  describe('import userSettings', () => {
+    const data = userSettingsData as ImportPgDataStructure;
+    it('should import userSettings correctly', async () => {
+      const result = await importer.importPgData(data);
 
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessionGroups: [
-          { id: 'group1', name: 'Group 1', createdAt: 1715186011586, updatedAt: 1715186015053 },
-          { id: 'group2', name: 'Group 2', createdAt: 1715186011586, updatedAt: 1715186015053 },
-        ],
-      };
+      expect(result.success).toBe(true);
+      expect(result.results.userSettings).toMatchObject({ added: 1, errors: 0, skips: 0 });
 
-      const result = await importer.importData(data);
-
-      expect(result.sessionGroups.added).toBe(1);
-      expect(result.sessionGroups.skips).toBe(1);
-      expect(result.sessionGroups.errors).toBe(0);
-    });
-  });
-
-  describe('import sessions', () => {
-    it('should import sessions and return correct result', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-          {
-            id: 'session2',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 2',
-            },
-          },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.sessions.added).toBe(2);
-      expect(result.sessions.skips).toBe(0);
-      expect(result.sessions.errors).toBe(0);
-
-      const importedSessions = await serverDB.query.sessions.findMany({
-        where: eq(sessions.userId, userId),
+      const res = await clientDB.query.userSettings.findMany({
+        where: eq(Schema.userSettings.id, userId),
       });
-      expect(importedSessions).toHaveLength(2);
+      expect(res).toHaveLength(1);
+      expect(res[0].general).toEqual({ fontSize: 12 });
+    });
 
-      const agentCount = await serverDB.query.agents.findMany({
-        where: eq(agents.userId, userId),
+    it('should merge exist userSettings correctly', async () => {
+      await clientDB.transaction(async (tx) => {
+        await tx.insert(Schema.userSettings).values({ id: userId, general: { fontSize: 24 } });
+        await tx
+          .update(Schema.userSettings)
+          .set({ general: { fontSize: 24 } })
+          .where(eq(Schema.userSettings.id, userId));
       });
 
-      expect(agentCount.length).toBe(2);
+      const result = await importer.importPgData(data);
 
-      const agentSessionCount = await serverDB.query.agentsToSessions.findMany();
-      expect(agentSessionCount.length).toBe(2);
-    });
-
-    it('should skip existing sessions and return correct result', async () => {
-      await serverDB.insert(sessions).values({ clientId: 'session1', userId });
-
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-          {
-            id: 'session2',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 2',
-            },
-          },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.sessions.added).toBe(1);
-      expect(result.sessions.skips).toBe(1);
-      expect(result.sessions.errors).toBe(0);
-    });
-
-    it('should associate imported sessions with session groups', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessionGroups: [
-          { id: 'group1', name: 'Group 1', createdAt: 1715186011586, updatedAt: 1715186015053 },
-          { id: 'group2', name: 'Group 2', createdAt: 1715186011586, updatedAt: 1715186015053 },
-        ],
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            group: 'group1',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-          {
-            id: 'session2',
-            group: 'group2',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 2',
-            },
-          },
-          {
-            id: 'session3',
-            group: 'group4',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 3',
-            },
-          },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.sessionGroups.added).toBe(2);
-      expect(result.sessionGroups.skips).toBe(0);
-
-      expect(result.sessions.added).toBe(3);
-      expect(result.sessions.skips).toBe(0);
-
-      // session 1 should be associated with group 1
-      const session1 = await serverDB.query.sessions.findFirst({
-        where: eq(sessions.clientId, 'session1'),
-        with: { group: true },
+      expect(result.success).toBe(true);
+      expect(result.results.userSettings).toMatchObject({
+        updated: 1,
+        errors: 0,
+        skips: 0,
+        added: 0,
       });
-      expect(session1?.group).toBeDefined();
 
-      // session 3 should not have group
-      const session3 = await serverDB.query.sessions.findFirst({
-        where: eq(sessions.clientId, 'session3'),
-        with: { group: true },
+      const res = await clientDB.query.userSettings.findMany({
+        where: eq(Schema.userSettings.id, userId),
       });
-      expect(session3?.group).toBeNull();
+      expect(res).toHaveLength(1);
+      expect(res[0].general).toEqual({ fontSize: 12 });
     });
+  });
 
-    it('should create agents and associate them with imported sessions', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'Test Agent 1',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-          {
-            id: 'session2',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'def',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'Test Agent 2',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 2',
-            },
-          },
-        ],
-      };
-
-      await importer.importData(data);
-
-      // 验证是否为每个 session 创建了对应的 agent
-      const agentCount = await serverDB.query.agents.findMany({
-        where: eq(agents.userId, userId),
-      });
-      expect(agentCount).toHaveLength(2);
+  describe('import agents and sessions', () => {
+    it('should import return correct result', async () => {
+      const data = agentsData as ImportPgDataStructure;
+      const result = await importer.importPgData(data);
 
-      // 验证 agent 的属性是否正确设置
-      const agent1 = await serverDB.query.agents.findFirst({
-        where: eq(agents.systemRole, 'Test Agent 1'),
-      });
-      expect(agent1?.model).toBe('abc');
+      expect(result.success).toBe(true);
+      expect(result.results.agents).toMatchObject({ added: 1, errors: 0, skips: 0 });
 
-      const agent2 = await serverDB.query.agents.findFirst({
-        where: eq(agents.systemRole, 'Test Agent 2'),
+      const agentRes = await clientDB.query.agents.findMany({
+        where: eq(Schema.agents.userId, userId),
       });
-      expect(agent2?.model).toBe('def');
-
-      // 验证 agentsToSessions 关联是否正确建立
-      const session1 = await serverDB.query.sessions.findFirst({
-        where: eq(sessions.clientId, 'session1'),
+      const sessionRes = await clientDB.query.sessions.findMany({
+        where: eq(Schema.sessions.userId, userId),
       });
-      const session1Agent = await serverDB.query.agentsToSessions.findFirst({
-        where: eq(agentsToSessions.sessionId, session1?.id!),
-        with: { agent: true },
+      const agentsToSessionRes = await clientDB.query.agentsToSessions.findMany({
+        where: eq(Schema.agentsToSessions.userId, userId),
       });
 
-      expect((session1Agent?.agent as any).systemRole).toBe('Test Agent 1');
-
-      const session2 = await serverDB.query.sessions.findFirst({
-        where: eq(sessions.clientId, 'session2'),
-      });
-      const session2Agent = await serverDB.query.agentsToSessions.findFirst({
-        where: eq(agentsToSessions.sessionId, session2?.id!),
-        with: { agent: true },
+      expect(agentRes).toHaveLength(1);
+      expect(sessionRes).toHaveLength(1);
+      expect(agentsToSessionRes).toHaveLength(1);
+      expect(agentsToSessionRes[0]).toMatchObject({
+        agentId: agentRes[0].id,
+        sessionId: sessionRes[0].id,
       });
 
-      expect((session2Agent?.agent as any).systemRole).toBe('Test Agent 2');
+      expect(agentRes[0].clientId).toEqual(agentsData.data.agents[0].id);
+      expect(sessionRes[0].clientId).toEqual(agentsData.data.sessions[0].id);
     });
 
-    it('should not create duplicate agents for existing sessions', async () => {
-      // 先导入一些 sessions
-      await importer.importData({
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'Test Agent 1',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-        ],
-        version: CURRENT_CONFIG_VERSION,
-      });
+    it('should skip duplicated data by default', async () => {
+      const data = agentsData as ImportPgDataStructure;
+      const result = await importer.importPgData(data);
 
-      // 再次导入相同的 sessions
-      await importer.importData({
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'Test Agent 1',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-        ],
-        version: CURRENT_CONFIG_VERSION,
-      });
+      expect(result.success).toBe(true);
+      expect(result.results.agents).toMatchObject({ added: 1, errors: 0, skips: 0 });
 
-      // 验证只创建了一个 agent
-      const agentCount = await serverDB.query.agents.findMany({
-        where: eq(agents.userId, userId),
+      // import again to make sure it skip duplicated by default
+      const result2 = await importer.importPgData(data);
+      expect(result2.success).toBe(true);
+      expect(result2.results).toEqual({
+        agents: { added: 0, errors: 0, skips: 1, updated: 0 },
+        agentsToSessions: { added: 0, errors: 0, skips: 1, updated: 0 },
+        sessions: { added: 0, errors: 0, skips: 1, updated: 0 },
       });
-      expect(agentCount).toHaveLength(1);
     });
-  });
 
-  describe('import topics', () => {
-    it('should import topics and return correct result', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        topics: [
-          {
-            id: 'topic1',
-            title: 'Topic 1',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-          },
-          {
-            id: 'topic2',
-            title: 'Topic 2',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session2',
-          },
-        ],
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-          {
-            id: 'session2',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 2',
-            },
-          },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.topics.added).toBe(2);
-      expect(result.topics.skips).toBe(0);
-      expect(result.topics.errors).toBe(0);
-
-      const importedTopics = await serverDB.query.topics.findMany({
-        where: eq(topics.userId, userId),
-      });
-      expect(importedTopics).toHaveLength(2);
-    });
+    it('should import without agentToSessions error', async () => {
+      const data = agentsToSessionsData as ImportPgDataStructure;
+      const result = await importer.importPgData(data);
 
-    it('should skip existing topics and return correct result', async () => {
-      await serverDB.insert(topics).values({ clientId: 'topic1', title: 'Existing Topic', userId });
-
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        topics: [
-          { id: 'topic1', title: 'Topic 1', createdAt: 1715186011586, updatedAt: 1715186015053 },
-          { id: 'topic2', title: 'Topic 2', createdAt: 1715186011586, updatedAt: 1715186015053 },
-        ],
-      };
-
-      const result = await importer.importData(data);
-      expect(result.topics.added).toBe(1);
-      expect(result.topics.skips).toBe(1);
-      expect(result.topics.errors).toBe(0);
-    });
+      expect(result.success).toBe(true);
+      expect(result.results.agentsToSessions).toMatchObject({ added: 9, errors: 0, skips: 0 });
 
-    it('should associate imported topics with sessions', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-        ],
-        topics: [
-          {
-            id: 'topic1',
-            title: 'Topic 1',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-          },
-          { id: 'topic2', title: 'Topic 2', createdAt: 1715186011586, updatedAt: 1715186015053 },
-        ],
-      };
-
-      await importer.importData(data);
-
-      // topic1 should be associated with session1
-      const [topic1] = await serverDB
-        .select({ sessionClientId: sessions.clientId })
-        .from(topics)
-        .where(eq(topics.clientId, 'topic1'))
-        .leftJoin(sessions, eq(topics.sessionId, sessions.id));
-
-      expect(topic1?.sessionClientId).toBe('session1');
-
-      // topic2 should not have session
-      const topic2 = await serverDB.query.topics.findFirst({
-        where: eq(topics.clientId, 'topic2'),
-        with: { session: true },
+      // import again to make sure it skip duplicated by default
+      const result2 = await importer.importPgData(data);
+      expect(result2.success).toBe(true);
+      expect(result2.results).toEqual({
+        agents: { added: 0, errors: 0, skips: 9, updated: 0 },
+        agentsToSessions: { added: 0, errors: 0, skips: 9, updated: 0 },
+        sessions: { added: 0, errors: 0, skips: 9, updated: 0 },
       });
-      expect(topic2?.session).toBeNull();
     });
   });
 
-  describe('import messages', () => {
-    it('should import messages and return correct result', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        messages: [
-          {
-            id: 'msg1',
-            content: 'Message 1',
-            role: 'user',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-            topicId: 'topic1',
-          },
-          {
-            id: 'msg2',
-            content: 'Message 2',
-            role: 'assistant',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-            topicId: 'topic1',
-            parentId: 'msg1',
-          },
-        ],
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-        ],
-        topics: [
-          {
-            id: 'topic1',
-            title: 'Topic 1',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-          },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.messages.added).toBe(2);
-      expect(result.messages.skips).toBe(0);
-      expect(result.messages.errors).toBe(0);
-
-      const importedMessages = await serverDB.query.messages.findMany({
-        where: eq(messages.userId, userId),
-      });
-      expect(importedMessages).toHaveLength(2);
-    });
+  describe('import message and topic', () => {
+    it('should import return correct result', async () => {
+      const exportData = topicsData as ImportPgDataStructure;
+      const result = await importer.importPgData(exportData);
 
-    it('should skip existing messages and return correct result', async () => {
-      await serverDB.insert(messages).values({
-        clientId: 'msg1',
-        content: 'Existing Message',
-        role: 'user',
-        userId,
-      });
+      expect(result.success).toBe(true);
+      expect(result.results.messages).toMatchObject({ added: 6, errors: 0, skips: 0 });
 
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        messages: [
-          {
-            id: 'msg1',
-            content: 'Message 1',
-            role: 'user',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-          },
-          {
-            id: 'msg2',
-            content: 'Message 2',
-            role: 'assistant',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-          },
-        ],
-      };
-
-      const result = await importer.importData(data);
-
-      expect(result.messages.added).toBe(1);
-      expect(result.messages.skips).toBe(1);
-      expect(result.messages.errors).toBe(0);
-    });
-
-    it('should associate imported messages with sessions and topics', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        sessions: [
-          {
-            id: 'session1',
-            createdAt: '2022-05-14T18:18:10.494Z',
-            updatedAt: '2023-01-01',
-            type: 'agent',
-            config: {
-              model: 'abc',
-              chatConfig: {} as any,
-              params: {},
-              systemRole: 'abc',
-              tts: {} as any,
-            },
-            meta: {
-              title: 'Session 1',
-            },
-          },
-        ],
-        topics: [
-          {
-            id: 'topic1',
-            title: 'Topic 1',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-          },
-        ],
-        messages: [
-          {
-            id: 'msg1',
-            content: 'Message 1',
-            role: 'user',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-            topicId: 'topic1',
-          },
-          {
-            id: 'msg2',
-            content: 'Message 2',
-            role: 'assistant',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            sessionId: 'session1',
-            topicId: 'topic1',
-            parentId: 'msg1',
-          },
-          {
-            id: 'msg3',
-            content: 'Message 3',
-            role: 'user',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-          },
-        ],
-      };
-
-      await importer.importData(data);
-
-      // msg1 and msg2 should be associated with session1 and topic1
-      const [msg1, msg2] = await serverDB.query.messages.findMany({
-        where: inArray(messages.clientId, ['msg1', 'msg2']),
-        with: {
-          session: true,
-          topic: true,
-        },
+      const messageRes = await clientDB.query.messages.findMany({
+        where: eq(Schema.agents.userId, userId),
       });
-
-      expect(msg1.session?.clientId).toBe('session1');
-      expect(msg1.topic?.clientId).toBe('topic1');
-      expect(msg2.session?.clientId).toBe('session1');
-      expect(msg2.topic?.clientId).toBe('topic1');
-
-      // msg3 should not have session and topic
-      const msg3 = await serverDB.query.messages.findFirst({
-        where: eq(messages.clientId, 'msg3'),
-        with: {
-          session: true,
-          topic: true,
-        },
+      const topicRes = await clientDB.query.topics.findMany({
+        where: eq(Schema.sessions.userId, userId),
       });
-      expect(msg3?.session).toBeNull();
-      expect(msg3?.topic).toBeNull();
-    });
 
-    it('should set parentId for messages', async () => {
-      const data: ImporterEntryData = {
-        version: CURRENT_CONFIG_VERSION,
-        messages: [
-          {
-            id: 'msg1',
-            content: 'Message 1',
-            role: 'user',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-          },
-          {
-            id: 'msg2',
-            content: 'Message 2',
-            role: 'assistant',
-            createdAt: 1715186011586,
-            updatedAt: 1715186015053,
-            parentId: 'msg1',
-          },
-        ],
-      };
-
-      await importer.importData(data);
-
-      const msg2 = await serverDB.query.messages.findFirst({
-        where: eq(messages.clientId, 'msg2'),
-        with: { parent: true },
-      });
+      expect(topicRes).toHaveLength(1);
+      expect(messageRes).toHaveLength(6);
 
-      expect(msg2?.parent?.clientId).toBe('msg1');
+      expect(topicRes[0].clientId).toEqual(topicsData.data.topics[0].id);
+      expect(
+        messageRes.find((msg) => msg.content === topicsData.data.messages[0].content)?.clientId,
+      ).toEqual(topicsData.data.messages[0].id);
     });
 
-    it('should import parentId Success', () => {});
-  });
+    it('should only return non-zero result', async () => {
+      const exportData = topicsData as ImportPgDataStructure;
+      const result = await importer.importPgData(exportData);
 
-  describe(
-    'real world examples',
-    () => {
-      it('should import successfully', async () => {
-        const result = await importer.importData({
-          messages: [
-            {
-              role: 'user',
-              content: 'hello',
-              files: [],
-              sessionId: 'inbox',
-              topicId: '2wcF8yaS',
-              createdAt: 1714236590340,
-              id: 'DCG1G1EH',
-              updatedAt: 1714236590340,
-              extra: {},
-            },
-            {
-              role: 'assistant',
-              content: '...',
-              parentId: 'DCG1G1EH',
-              sessionId: 'inbox',
-              topicId: '2wcF8yaS',
-              createdAt: 1714236590441,
-              id: 'gY41w5vQ',
-              updatedAt: 1714236590518,
-              error: {
-                body: {
-                  error: {
-                    message: "model 'mixtral' not found, try pulling it first",
-                    name: 'ResponseError',
-                    status_code: 404,
-                  },
-                  provider: 'ollama',
-                },
-                message:
-                  'Error requesting Ollama service, please troubleshoot or retry based on the following information',
-                type: 'OllamaBizError',
-              },
-              extra: { fromModel: 'mixtral', fromProvider: 'ollama' },
-            },
-            {
-              role: 'user',
-              content: 'hello',
-              files: [],
-              sessionId: 'a5fefc88-f6c1-44fb-9e98-3d366b1ed589',
-              topicId: 'v38snJ0A',
-              createdAt: 1717080410895,
-              id: 'qOIxEGEB',
-              updatedAt: 1717080410895,
-              extra: {},
-            },
-            {
-              role: 'assistant',
-              content: '...',
-              parentId: 'qOIxEGEB',
-              sessionId: 'a5fefc88-f6c1-44fb-9e98-3d366b1ed589',
-              topicId: 'v38snJ0A',
-              createdAt: 1717080410970,
-              id: 'w28FcqY5',
-              updatedAt: 1717080411485,
-              error: {
-                body: { error: { errorType: 'NoOpenAIAPIKey' }, provider: 'openai' },
-                message: 'OpenAI API Key is empty, please add a custom OpenAI API Key',
-                type: 'NoOpenAIAPIKey',
-              },
-              extra: { fromModel: 'gpt-3.5-turbo', fromProvider: 'openai' },
-            },
-          ],
-          sessionGroups: [
-            {
-              name: 'Writter',
-              sort: 0,
-              createdAt: 1706114744425,
-              id: 'XlUbvOvL',
-              updatedAt: 1706114747468,
-            },
-          ],
-          sessions: [
-            {
-              config: {
-                model: 'gpt-3.5-turbo',
-                params: {
-                  frequency_penalty: 0,
-                  presence_penalty: 0,
-                  temperature: 0.6,
-                  top_p: 1,
-                },
-                plugins: [],
-                systemRole:
-                  "You are a LobeChat technical operator 🍐🐊. You now need to write a developer's guide for LobeChat as a guide for them to develop LobeChat. This guide will include several sections, and you need to output the corresponding document content based on the user's input.\n\nHere is the technical introduction of LobeChat\n\n    LobeChat is an AI conversation application built with the Next.js framework. It uses a series of technology stacks to implement various functions and features.\n\n\n    ## Basic Technology Stack\n\n    The core technology stack of LobeChat is as follows:\n\n    - **Framework**: We chose [Next.js](https://nextjs.org/), a powerful React framework that provides key features such as server-side rendering, routing framework, and Router Handler for our project.\n    - **Component Library**: We use [Ant Design (antd)](https://ant.design/) as the basic component library, and introduce [lobe-ui](https://github.com/lobehub/lobe-ui) as our business component library.\n    - **State Management**: We use [zustand](https://github.com/pmndrs/zustand), a lightweight and easy-to-use state management library.\n    - **Network Request**: We adopt [swr](https://swr.vercel.app/), a React Hooks library for data fetching.\n    - **Routing**: We directly use the routing solution provided by [Next.js](https://nextjs.org/) itself.\n    - **Internationalization**: We use [i18next](https://www.i18next.com/) to implement multi-language support for the application.\n    - **Styling**: We use [antd-style](https://github.com/ant-design/antd-style), a CSS-in-JS library that is compatible with Ant Design.\n    - **Unit Testing**: We use [vitest](https://github.com/vitejs/vitest) for unit testing.\n\n    ## Folder Directory Structure\n\n    The folder directory structure of LobeChat is as follows:\n\n    \\`\\`\\`bash\n    src\n    ├── app        # Main logic and state management related code of the application\n    ├── components # Reusable UI components\n    ├── config     # Application configuration files, including client environment variables and server environment variables\n    ├── const      # Used to define constants, such as action types, route names, etc.\n    ├── features   # Function modules related to business functions, such as Agent settings, plugin development pop-ups, etc.\n    ├── hooks      # Custom utility Hooks reused throughout the application\n    ├── layout     # Layout components of the application, such as navigation bar, sidebar, etc.\n    ├── locales    # Language files for internationalization\n    ├── services   # Encapsulated backend service interfaces, such as HTTP requests\n    ├── store      # Zustand store for state management\n    ├── types      # TypeScript type definition files\n    └── utils      # Common utility functions\n    \\`\\`\\`\n",
-                tts: {
-                  showAllLocaleVoice: false,
-                  sttLocale: 'auto',
-                  ttsService: 'openai',
-                  voice: { openai: 'alloy' },
-                },
-                chatConfig: {
-                  autoCreateTopicThreshold: 2,
-                  displayMode: 'chat',
-                  enableAutoCreateTopic: true,
-                  historyCount: 1,
-                },
-              },
-              group: 'XlUbvOvL',
-              meta: {
-                avatar: '📝',
-                description:
-                  'LobeChat is an AI conversation application built with the Next.js framework. I will help you write the development documentation for LobeChat.',
-                tags: [
-                  'Development Documentation',
-                  'Technical Introduction',
-                  'next-js',
-                  'react',
-                  'lobe-chat',
-                ],
-                title: 'LobeChat Technical Documentation Expert',
-              },
-              type: 'agent',
-              createdAt: '2024-01-24T16:43:12.164Z',
-              id: 'a5fefc88-f6c1-44fb-9e98-3d366b1ed589',
-              updatedAt: '2024-01-24T16:46:15.226Z',
-              pinned: false,
-            },
-          ],
-          topics: [
-            {
-              title: 'Default Topic',
-              sessionId: 'inbox',
-              createdAt: 1714236590531,
-              id: '2wcF8yaS',
-              updatedAt: 1714236590531,
-            },
-            {
-              title: 'Default Topic',
-              sessionId: 'a5fefc88-f6c1-44fb-9e98-3d366b1ed589',
-              createdAt: 1717080410825,
-              id: 'v38snJ0A',
-              updatedAt: 1717080410825,
-            },
-          ],
-          version: mockImportData.version,
-        });
-
-        expect(result).toEqual({
-          sessionGroups: { added: 1, errors: 0, skips: 0 },
-          sessions: { added: 1, errors: 0, skips: 0 },
-          topics: { added: 2, errors: 0, skips: 0 },
-          messages: { added: 4, errors: 0, skips: 0 },
-        });
+      expect(result.success).toBe(true);
+      expect(result.results).toEqual({
+        agents: { added: 1, errors: 0, skips: 0, updated: 0 },
+        agentsToSessions: { added: 1, errors: 0, skips: 0, updated: 0 },
+        messagePlugins: { added: 1, errors: 0, skips: 0, updated: 0 },
+        messages: { added: 6, errors: 0, skips: 0, updated: 0 },
+        sessions: { added: 1, errors: 0, skips: 0, updated: 0 },
+        topics: { added: 1, errors: 0, skips: 0, updated: 0 },
       });
-
-      it('should import real world data', async () => {
-        const result = await importer.importData({
-          ...(mockImportData.state as any),
-          version: mockImportData.version,
-        });
-
-        expect(result).toEqual({
-          sessionGroups: { added: 2, errors: 0, skips: 0 },
-          sessions: { added: 15, errors: 0, skips: 0 },
-          topics: { added: 4, errors: 0, skips: 0 },
-          messages: { added: 32, errors: 0, skips: 0 },
-        });
-      });
-    },
-    { timeout: 15000 },
-  );
+    });
+  });
 });