@lobehub/chat 0.120.6 → 0.121.1

package/src/database/models/__tests__/plugin.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { DB_Plugin } from '../../schemas/plugin';
+import { PluginModel } from '../plugin';
+
+describe('PluginModel', () => {
+  let pluginData: DB_Plugin;
+
+  beforeEach(() => {
+    // 设置正确结构的插件数据
+    pluginData = {
+      identifier: 'test-plugin',
+      manifest: {},
+      type: 'plugin',
+    };
+  });
+
+  afterEach(async () => {
+    // 每次测试后清理数据库
+    await PluginModel.clear();
+  });
+
+  describe('getList', () => {
+    it('should fetch and return the plugin list', async () => {
+      await PluginModel.create(pluginData);
+      const plugins = await PluginModel.getList();
+      expect(plugins).toHaveLength(1);
+      expect(plugins[0]).toEqual(pluginData);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a plugin record', async () => {
+      await PluginModel.create(pluginData);
+      const plugins = await PluginModel.getList();
+      expect(plugins).toHaveLength(1);
+      expect(plugins[0]).toEqual(pluginData);
+    });
+  });
+
+  describe('batchCreate', () => {
+    it('should batch create plugin records', async () => {
+      await PluginModel.batchCreate([pluginData, { ...pluginData, identifier: 'abc' }]);
+      const plugins = await PluginModel.getList();
+      expect(plugins).toHaveLength(2);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a plugin', async () => {
+      await PluginModel.create(pluginData);
+      await PluginModel.delete(pluginData.identifier);
+      const plugins = await PluginModel.getList();
+      expect(plugins).toHaveLength(0);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a plugin', async () => {
+      await PluginModel.create(pluginData);
+      const updatedPluginData: DB_Plugin = { ...pluginData, type: 'customPlugin' };
+      await PluginModel.update(pluginData.identifier, updatedPluginData);
+      const plugins = await PluginModel.getList();
+      expect(plugins).toHaveLength(1);
+      expect(plugins[0]).toEqual(updatedPluginData);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear the table', async () => {
+      await PluginModel.create(pluginData);
+      await PluginModel.clear();
+      const plugins = await PluginModel.getList();
+      expect(plugins).toHaveLength(0);
+    });
+  });
+});

package/src/database/models/__tests__/session.test.ts

@@ -2,8 +2,15 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
 import { CreateMessageParams, MessageModel } from '@/database/models/message';
+import { SessionGroupModel } from '@/database/models/sessionGroup';
 import { TopicModel } from '@/database/models/topic';
-import { LobeAgentSession, LobeSessionType, SessionGroupKey } from '@/types/session';
+import { LobeAgentConfig } from '@/types/agent';
+import {
+  LobeAgentSession,
+  LobeSessionType,
+  SessionDefaultGroup,
+  SessionGroupId,
+} from '@/types/session';
 
 import { SessionModel } from '../session';
 
@@ -25,93 +32,225 @@ describe('SessionModel', () => {
     // Clean up the database after each test
     await SessionModel.clearTable();
   });
+  describe('create', () => {
+    it('should create a session record', async () => {
+      const result = await SessionModel.create('agent', sessionData);
 
-  it('should create a session record', async () => {
-    const result = await SessionModel.create('agent', sessionData);
+      expect(result).toHaveProperty('id');
+      // Verify that the session has been added to the database
+      // Assuming findById is a method that retrieves a session by ID
+      const sessionInDb = await SessionModel.findById(result.id);
 
-    expect(result).toHaveProperty('id');
-    // Verify that the session has been added to the database
-    // Assuming findById is a method that retrieves a session by ID
-    const sessionInDb = await SessionModel.findById(result.id);
+      expect(sessionInDb).toEqual(expect.objectContaining(sessionData));
+    });
+  });
+
+  describe('batchCreate', () => {
+    it('should batch create session records', async () => {
+      const sessionsToCreate = [sessionData, sessionData];
+      const results = await SessionModel.batchCreate(sessionsToCreate as LobeAgentSession[]);
+
+      expect(results.ids).toHaveLength(sessionsToCreate.length);
+      // Verify that the sessions have been added to the database
+      for (const result of results.ids!) {
+        const sessionInDb = await SessionModel.findById(result);
+        expect(sessionInDb).toEqual(expect.objectContaining(sessionData));
+      }
+    });
 
-    expect(sessionInDb).toEqual(expect.objectContaining(sessionData));
+    it('should set group to default if it does not exist in SessionGroup', async () => {
+      const sessionDataWithInvalidGroup = {
+        ...sessionData,
+        group: 'nonExistentGroup',
+      } as LobeAgentSession;
+
+      const results = await SessionModel.batchCreate([sessionDataWithInvalidGroup]);
+
+      // Verify that the group has been set to default
+      for (const result of results.ids!) {
+        const sessionInDb = await SessionModel.findById(result);
+        expect(sessionInDb.group).toEqual(SessionDefaultGroup.Default);
+      }
+    });
   });
 
-  it('should batch create session records', async () => {
-    const sessionsToCreate = [sessionData, sessionData];
-    const results = await SessionModel.batchCreate(sessionsToCreate as LobeAgentSession[]);
+  describe('query', () => {
+    it('should query sessions with pagination', async () => {
+      // Create multiple sessions to test the query method
+      await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
 
-    expect(results.ids).toHaveLength(sessionsToCreate.length);
-    // Verify that the sessions have been added to the database
-    for (const result of results.ids!) {
-      const sessionInDb = await SessionModel.findById(result);
-      expect(sessionInDb).toEqual(expect.objectContaining(sessionData));
-    }
+      const queriedSessions = await SessionModel.query({ pageSize: 1, current: 0 });
+
+      expect(queriedSessions).toHaveLength(1);
+    });
   });
 
-  it('should query sessions with pagination', async () => {
-    // Create multiple sessions to test the query method
-    await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
+  describe('querySessionsByGroupId', () => {
+    it('should query sessions by group', async () => {
+      // Create multiple sessions to test the queryByGroup method
+      const group: SessionGroupId = 'testGroup';
+      await SessionGroupModel.create('测试分组', 0, group);
 
-    const queriedSessions = await SessionModel.query({ pageSize: 1, current: 0 });
+      await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
 
-    expect(queriedSessions).toHaveLength(1);
+      const sessionsByGroup = await SessionModel.querySessionsByGroupId(group);
+
+      // Assuming all created sessions belong to the same group
+      expect(sessionsByGroup).toHaveLength(2);
+      expect(sessionsByGroup.every((i) => i.group === group)).toBeTruthy();
+    });
   });
 
-  it('should query sessions by group', async () => {
-    // Create multiple sessions to test the queryByGroup method
-    const group: SessionGroupKey = 'testGroup';
-    await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
+  describe('update', () => {
+    it('should update a session', async () => {
+      const createdSession = await SessionModel.create('agent', sessionData);
+      const updateData = { group: 'newGroup' };
 
-    const sessionsByGroup = await SessionModel.queryByGroup(group);
+      await SessionModel.update(createdSession.id, updateData);
+      const updatedSession = await SessionModel.findById(createdSession.id);
 
-    // Assuming all created sessions belong to the same group
-    expect(sessionsByGroup).toHaveLength(2);
-    expect(sessionsByGroup.every((i) => i.group === group)).toBeTruthy();
+      expect(updatedSession).toHaveProperty('group', 'newGroup');
+    });
   });
 
-  it('should update a session', async () => {
-    const createdSession = await SessionModel.create('agent', sessionData);
-    const updateData = { group: 'newGroup' };
+  describe('updatePinned', () => {
+    it('should update pinned status of a session', async () => {
+      const createdSession = await SessionModel.create('agent', sessionData);
+      await SessionModel.updatePinned(createdSession.id, true);
+      const updatedSession = await SessionModel.findById(createdSession.id);
+      expect(updatedSession).toHaveProperty('pinned', 1);
+    });
+  });
 
-    await SessionModel.update(createdSession.id, updateData);
-    const updatedSession = await SessionModel.findById(createdSession.id);
+  describe('updateConfig', () => {
+    it('should update config of a session', async () => {
+      const { id } = await SessionModel.create('agent', sessionData);
+      const dbSession = await SessionModel.findById(id);
 
-    expect(updatedSession).toHaveProperty('group', 'newGroup');
+      const newConfig = { ...dbSession.config, systemRole: 'newValue' } as LobeAgentConfig;
+      await SessionModel.updateConfig(id, newConfig);
+      const updatedSession = await SessionModel.findById(id);
+      expect(updatedSession.config).toEqual(newConfig);
+    });
   });
 
-  // 删除一个 session 时，也需要同步删除具有 sessionId 的 topic 和 message
-  it('should delete a session and its associated data', async () => {
-    // create session , topic and message test data
-    const { id: sessionId } = await SessionModel.create('agent', sessionData);
+  describe('clearTable', () => {
+    it('should clear all sessions', async () => {
+      await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
+      await SessionModel.clearTable();
+      const sessionsInDb = await SessionModel.query();
+      expect(sessionsInDb).toHaveLength(0);
+    });
+  });
 
-    const topicData = {
-      title: 'Test Topic',
-      sessionId: sessionId,
-      favorite: false,
-    };
-    const createdTopic = await TopicModel.create(topicData);
+  describe('isEmpty', () => {
+    it('should check if table is empty', async () => {
+      await SessionModel.clearTable();
+      const isEmpty = await SessionModel.isEmpty();
+      expect(isEmpty).toBeTruthy();
+      await SessionModel.create('agent', sessionData);
+      const isNotEmpty = await SessionModel.isEmpty();
+      expect(isNotEmpty).toBeFalsy();
+    });
+  });
 
-    const messageData: CreateMessageParams = {
-      content: 'Test Message',
-      sessionId: sessionId,
-      topicId: createdTopic.id,
-      role: 'user',
-    };
-    await MessageModel.create(messageData);
+  describe('queryByKeyword', () => {
+    it('should query sessions by keyword', async () => {
+      const keyword = 'testKeyword';
+      const sessionWithKeyword = { ...sessionData, meta: { title: keyword } };
+      await SessionModel.create('agent', sessionWithKeyword);
+      const sessionsByKeyword = await SessionModel.queryByKeyword(keyword);
+      expect(sessionsByKeyword).toHaveLength(1);
+      expect(sessionsByKeyword[0].meta.title).toContain(keyword);
+    });
+  });
 
-    await SessionModel.delete(sessionId);
+  describe('getPinnedSessions', () => {
+    it('should get pinned sessions', async () => {
+      const pinnedSession = { ...sessionData, pinned: true };
+      const unpinnedSession = { ...sessionData, pinned: false };
+      await SessionModel.batchCreate([pinnedSession, unpinnedSession] as LobeAgentSession[]);
+      const pinnedSessions = await SessionModel.getPinnedSessions();
+      expect(pinnedSessions).toHaveLength(1);
+      expect(pinnedSessions[0].pinned).toBeTruthy();
+    });
+  });
+
+  describe('queryWithGroups', () => {
+    it('should query sessions with groups', async () => {
+      await SessionModel.create('agent', sessionData);
+
+      const sessionsWithGroups = await SessionModel.queryWithGroups();
+      expect(sessionsWithGroups.all).toHaveLength(1);
+      expect(sessionsWithGroups.all[0]).toEqual(expect.objectContaining(sessionData));
+    });
+  });
+
+  describe('queryByGroupIds', () => {
+    it('should query sessions by group ids', async () => {
+      const createdSession = await SessionModel.create('agent', sessionData);
+      const session = await SessionModel.findById(createdSession.id);
+      const sessionsByGroupIds = await SessionModel.queryByGroupIds([session.group]);
+      expect(sessionsByGroupIds[session.group]).toHaveLength(1);
+      expect(sessionsByGroupIds[session.group][0]).toEqual(expect.objectContaining(sessionData));
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a session', async () => {
+      const createdSession = await SessionModel.create('agent', sessionData);
+      await SessionModel.delete(createdSession.id);
+      const sessionInDb = await SessionModel.findById(createdSession.id);
+      expect(sessionInDb).toBeUndefined();
+    });
+
+    // 删除一个 session 时，也需要同步删除具有 sessionId 的 topic 和 message
+    it('should delete a session and its associated data', async () => {
+      // create session , topic and message test data
+      const { id: sessionId } = await SessionModel.create('agent', sessionData);
+
+      const topicData = {
+        title: 'Test Topic',
+        sessionId: sessionId,
+        favorite: false,
+      };
+      const createdTopic = await TopicModel.create(topicData);
+
+      const messageData: CreateMessageParams = {
+        content: 'Test Message',
+        sessionId: sessionId,
+        topicId: createdTopic.id,
+        role: 'user',
+      };
+      await MessageModel.create(messageData);
+
+      await SessionModel.delete(sessionId);
+
+      // Verify the session and its related data (topics, messages) are deleted
+      const sessionInDb = await SessionModel.findById(sessionId);
+      expect(sessionInDb).toBeUndefined();
+
+      // You need to verify that topics and messages related to the session are also deleted
+      const topicsInDb = await TopicModel.findBySessionId(sessionId);
+      expect(topicsInDb).toHaveLength(0);
+
+      // Verify all associated messages are deleted
+      const messagesInDb = await MessageModel.query({ sessionId });
+      expect(messagesInDb).toHaveLength(0);
+    });
+  });
 
-    // Verify the session and its related data (topics, messages) are deleted
-    const sessionInDb = await SessionModel.findById(sessionId);
-    expect(sessionInDb).toBeUndefined();
+  describe('duplicate', () => {
+    it('should duplicate a session', async () => {
+      const createdSession = await SessionModel.create('agent', sessionData);
+      const duplicatedSession = await SessionModel.duplicate(createdSession.id);
+      const sessionsInDb = await SessionModel.query();
+      expect(sessionsInDb).toHaveLength(2);
 
-    // You need to verify that topics and messages related to the session are also deleted
-    const topicsInDb = await TopicModel.findBySessionId(sessionId);
-    expect(topicsInDb).toHaveLength(0);
+      if (!duplicatedSession) return;
+      const session = await SessionModel.findById(duplicatedSession.id);
 
-    // Verify all associated messages are deleted
-    const messagesInDb = await MessageModel.query({ sessionId });
-    expect(messagesInDb).toHaveLength(0);
+      expect(session).toEqual(expect.objectContaining(sessionData));
+    });
   });
 });

package/src/database/models/__tests__/sessionGroup.test.ts

@@ -0,0 +1,195 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { SessionModel } from '@/database/models/session';
+import { SessionGroups } from '@/types/session';
+
+import { DB_SessionGroup } from '../../schemas/sessionGroup';
+import { SessionGroupModel } from '../sessionGroup';
+
+describe('SessionGroupModel', () => {
+  let sessionGroupData: DB_SessionGroup;
+
+  beforeEach(() => {
+    // 设置正确结构的会话组数据
+    sessionGroupData = {
+      name: 'test-group',
+      sort: 1,
+    };
+  });
+
+  afterEach(async () => {
+    // 每次测试后清理数据库
+    await SessionGroupModel.clear();
+  });
+
+  describe('create', () => {
+    it('should create a session group record', async () => {
+      const createdGroup = await SessionGroupModel.create(
+        sessionGroupData.name,
+        sessionGroupData.sort,
+      );
+      const item = await SessionGroupModel.findById(createdGroup.id);
+      expect(item.name).toEqual(sessionGroupData.name);
+      expect(item.sort).toEqual(sessionGroupData.sort);
+    });
+  });
+
+  describe('batchCreate', () => {
+    it('should batch create session group records', async () => {
+      const groups = [
+        sessionGroupData,
+        { ...sessionGroupData, name: 'another-group' },
+      ] as SessionGroups;
+      await SessionGroupModel.batchCreate(groups);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups).toHaveLength(2);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a session group', async () => {
+      const createdGroup = await SessionGroupModel.create(
+        sessionGroupData.name,
+        sessionGroupData.sort,
+      );
+      const updatedGroupData: DB_SessionGroup = { ...sessionGroupData, name: 'updated-group' };
+      await SessionGroupModel.update(createdGroup.id, updatedGroupData);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups[0].name).toEqual(updatedGroupData.name);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a session group', async () => {
+      const createdGroup = await SessionGroupModel.create(
+        sessionGroupData.name,
+        sessionGroupData.sort,
+      );
+      await SessionGroupModel.delete(createdGroup.id);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups).toHaveLength(0);
+    });
+    it('should delete a session group and update associated sessions', async () => {
+      // Create a new session group
+      const createdGroup = await SessionGroupModel.create(
+        sessionGroupData.name,
+        sessionGroupData.sort,
+      );
+
+      // Delete the created session group
+      await SessionGroupModel.delete(createdGroup.id);
+
+      // Fetch all session groups to confirm deletion
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups).toHaveLength(0);
+
+      // Fetch all sessions to confirm update
+      const fetchedSessions = await SessionModel.query();
+      fetchedSessions.forEach((session) => {
+        expect(session.group).not.toEqual(createdGroup.id);
+      });
+    });
+  });
+
+  describe('query', () => {
+    it('should fetch and return the session group list', async () => {
+      await SessionGroupModel.create(sessionGroupData.name, sessionGroupData.sort);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups).toHaveLength(1);
+      expect(fetchedGroups[0].name).toEqual(sessionGroupData.name);
+    });
+
+    it('should return an empty array when there are no session groups', async () => {
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups).toEqual([]);
+    });
+
+    it('should return session groups sorted by sort field when it exists', async () => {
+      const group1 = await SessionGroupModel.create('group1', 2);
+      const group2 = await SessionGroupModel.create('group2', 1);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups[0].id).toEqual(group2.id);
+      expect(fetchedGroups[1].id).toEqual(group1.id);
+    });
+
+    it('should return session groups sorted by createdAt when sort field does not exist', async () => {
+      const group1 = await SessionGroupModel.create('group1');
+      await new Promise((resolve) => setTimeout(() => resolve(undefined), 300));
+      const group2 = await SessionGroupModel.create('group2');
+
+      const fetchedGroups = await SessionGroupModel.query();
+
+      expect(fetchedGroups[0].id).toEqual(group2.id);
+      expect(fetchedGroups[1].id).toEqual(group1.id);
+    });
+
+    it('should return session groups sorted by sort field first and then by createdAt', async () => {
+      const group0 = await SessionGroupModel.create('group0');
+      const group1 = await SessionGroupModel.create('group1', 1);
+      const group2 = await SessionGroupModel.create('group2');
+      const group3 = await SessionGroupModel.create('group3', 2);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups[0].id).toEqual(group1.id);
+      expect(fetchedGroups[1].id).toEqual(group3.id);
+      expect(fetchedGroups[2].id).toEqual(group2.id);
+      expect(fetchedGroups[3].id).toEqual(group0.id);
+    });
+
+    it('should return session groups sorted by sort ', async () => {
+      const group1 = await SessionGroupModel.create('group1', 1);
+      const group2 = await SessionGroupModel.create('group2');
+      const group3 = await SessionGroupModel.create('group3', 2);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups[0].id).toEqual(group1.id);
+      expect(fetchedGroups[1].id).toEqual(group3.id);
+      expect(fetchedGroups[2].id).toEqual(group2.id);
+    });
+
+    it('should return session groups sorted by createdAt when sort fields are equal', async () => {
+      const group1 = await SessionGroupModel.create('group1', 1);
+      await new Promise((resolve) => setTimeout(() => resolve(undefined), 300));
+      const group2 = await SessionGroupModel.create('group2', 1);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups[0].id).toEqual(group2.id);
+      expect(fetchedGroups[1].id).toEqual(group1.id);
+    });
+  });
+
+  describe('updateOrder', () => {
+    it('should update the order of session groups', async () => {
+      const group1 = await SessionGroupModel.create(sessionGroupData.name, sessionGroupData.sort);
+      const group2 = await SessionGroupModel.create('another-group', 2);
+      await SessionGroupModel.updateOrder([
+        { id: group1.id, sort: 2 },
+        { id: group2.id, sort: 1 },
+      ]);
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups[0].id).toEqual(group2.id);
+      expect(fetchedGroups[1].id).toEqual(group1.id);
+    });
+  });
+
+  describe('findById', () => {
+    it('should find a session group by id', async () => {
+      const createdGroup = await SessionGroupModel.create(
+        sessionGroupData.name,
+        sessionGroupData.sort,
+      );
+      const fetchedGroup = await SessionGroupModel.findById(createdGroup.id);
+      expect(fetchedGroup).toMatchObject({ ...createdGroup, ...sessionGroupData });
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all session groups', async () => {
+      await SessionGroupModel.create(sessionGroupData.name, sessionGroupData.sort);
+      const first = await SessionGroupModel.query();
+      expect(first).toHaveLength(1);
+
+      await SessionGroupModel.clear();
+
+      const fetchedGroups = await SessionGroupModel.query();
+      expect(fetchedGroups).toHaveLength(0);
+    });
+  });
+});