@lobehub/lobehub 2.0.0-next.12 → 2.0.0-next.14

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

@@ -1,81 +0,0 @@
-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',
-      id: '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, updatedAt: expect.any(Number) });
-    });
-  });
-
-  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/_deprecated/models/__tests__/session.test.ts

@@ -1,253 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import { CreateMessageParams, MessageModel } from '@/database/_deprecated/models/message';
-import { SessionGroupModel } from '@/database/_deprecated/models/sessionGroup';
-import { TopicModel } from '@/database/_deprecated/models/topic';
-import { LobeAgentConfig } from '@/types/agent';
-import {
-  LobeAgentSession,
-  LobeSessionType,
-  SessionDefaultGroup,
-  SessionGroupId,
-} from '@/types/session';
-
-import { SessionModel } from '../session';
-
-describe('SessionModel', () => {
-  let sessionData: Partial<LobeAgentSession>;
-
-  beforeEach(() => {
-    // Set up session data with the correct structure
-    sessionData = {
-      type: LobeSessionType.Agent,
-      group: 'testGroup',
-      meta: {},
-      config: DEFAULT_AGENT_CONFIG,
-    };
-  });
-
-  afterEach(async () => {
-    // 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);
-
-      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));
-      }
-    });
-
-    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);
-      }
-    });
-  });
-
-  describe('query', () => {
-    it('should query sessions with pagination', async () => {
-      // Create multiple sessions to test the query method
-      await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
-
-      const queriedSessions = await SessionModel.query({ pageSize: 1, current: 0 });
-
-      expect(queriedSessions).toHaveLength(1);
-    });
-  });
-
-  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);
-
-      await SessionModel.batchCreate([sessionData, sessionData] as LobeAgentSession[]);
-
-      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();
-    });
-  });
-
-  describe('update', () => {
-    it('should update a session', async () => {
-      const createdSession = await SessionModel.create('agent', sessionData);
-      const updateData = { group: 'newGroup' };
-
-      await SessionModel.update(createdSession.id, updateData);
-      const updatedSession = await SessionModel.findById(createdSession.id);
-
-      expect(updatedSession).toHaveProperty('group', 'newGroup');
-    });
-
-    it('should update pinned status of a session', async () => {
-      const createdSession = await SessionModel.create('agent', sessionData);
-      await SessionModel.update(createdSession.id, { pinned: 1 });
-      const updatedSession = await SessionModel.findById(createdSession.id);
-      expect(updatedSession).toHaveProperty('pinned', 1);
-    });
-  });
-
-  describe('updateConfig', () => {
-    it('should update config of a session', async () => {
-      const { id } = await SessionModel.create('agent', sessionData);
-      const dbSession = await SessionModel.findById(id);
-
-      const newConfig = { ...dbSession.config, systemRole: 'newValue' } as LobeAgentConfig;
-      await SessionModel.updateConfig(id, newConfig);
-      const updatedSession = await SessionModel.findById(id);
-      expect(updatedSession.config).toEqual(newConfig);
-    });
-  });
-
-  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);
-    });
-  });
-
-  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();
-    });
-  });
-
-  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);
-    });
-  });
-
-  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.sessions).toHaveLength(1);
-      expect(sessionsWithGroups.sessions[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);
-    });
-  });
-
-  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);
-
-      if (!duplicatedSession) return;
-      const session = await SessionModel.findById(duplicatedSession.id);
-
-      expect(session).toEqual(expect.objectContaining(sessionData));
-    });
-  });
-});

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

@@ -1,220 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { SessionModel } from '@/database/_deprecated/models/session';
-import { SessionGroups } from '@/types/session';
-
-import { DB_SessionGroup } from '../../schemas/sessionGroup';
-import { SessionGroupModel } from '../sessionGroup';
-
-const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
-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);
-      });
-    });
-    it('should update associated sessions to default group when a session group is deleted', async () => {
-      const createdGroup = await SessionGroupModel.create(
-        sessionGroupData.name,
-        sessionGroupData.sort,
-      );
-      const sessionId = await SessionModel.create('agent', {}, createdGroup.id);
-      await SessionGroupModel.delete(createdGroup.id);
-      const updatedSession = await SessionModel.findById(sessionId.id);
-      expect(updatedSession.group).toEqual('default');
-    });
-  });
-
-  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');
-      await sleep(10);
-      const group1 = await SessionGroupModel.create('group1', 1);
-      await sleep(10);
-      const group2 = await SessionGroupModel.create('group2');
-      await sleep(10);
-      const group3 = await SessionGroupModel.create('group3', 2);
-      await sleep(10);
-
-      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);
-    });
-
-    it('should sort session groups correctly when only b has a sort value', async () => {
-      const groupA = await SessionGroupModel.create('groupA'); // sort undefined
-      const groupB = await SessionGroupModel.create('groupB', 1); // sort defined
-      const fetchedGroups = await SessionGroupModel.query();
-      expect(fetchedGroups[0].id).toEqual(groupB.id);
-      expect(fetchedGroups[1].id).toEqual(groupA.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);
-    });
-  });
-});