@lobehub/chat 0.147.16 → 0.147.17

package/src/services/message/client.ts

@@ -2,42 +2,29 @@ import { MessageModel } from '@/database/client/models/message';
 import { DB_Message } from '@/database/client/schemas/message';
 import { ChatMessage, ChatMessageError, ChatPluginPayload } from '@/types/message';
 
-export interface CreateMessageParams
-  extends Partial<Omit<ChatMessage, 'content' | 'role'>>,
-    Pick<ChatMessage, 'content' | 'role'> {
-  fromModel?: string;
-  fromProvider?: string;
-  sessionId: string;
-  traceId?: string;
-}
+import { CreateMessageParams, IMessageService } from './type';
 
-export class MessageService {
-  async create(data: CreateMessageParams) {
+export class ClientService implements IMessageService {
+  async createMessage(data: CreateMessageParams) {
     const { id } = await MessageModel.create(data);
 
     return id;
   }
 
-  async batchCreate(messages: ChatMessage[]) {
+  async batchCreateMessages(messages: ChatMessage[]) {
     return MessageModel.batchCreate(messages);
   }
 
-  async hasMessages() {
-    const number = await MessageModel.count();
-    return number > 0;
-  }
-
-  async messageCountToCheckTrace() {
-    const number = await MessageModel.count();
-    return number >= 4;
-  }
-
   async getMessages(sessionId: string, topicId?: string): Promise<ChatMessage[]> {
     return MessageModel.query({ sessionId, topicId });
   }
 
-  async removeMessage(id: string) {
-    return MessageModel.delete(id);
+  async getAllMessages() {
+    return MessageModel.queryAll();
+  }
+
+  async countMessages() {
+    return MessageModel.count();
   }
 
   async getAllMessagesInSession(sessionId: string) {
@@ -48,18 +35,6 @@ export class MessageService {
     return MessageModel.update(id, { error });
   }
 
-  async removeMessages(assistantId: string, topicId?: string) {
-    return MessageModel.batchDelete(assistantId, topicId);
-  }
-
-  async clearAllMessage() {
-    return MessageModel.clearTable();
-  }
-
-  async bindMessagesToTopic(topicId: string, messageIds: string[]) {
-    return MessageModel.batchUpdate(messageIds, { topicId });
-  }
-
   async updateMessage(id: string, message: Partial<DB_Message>) {
     return MessageModel.update(id, message);
   }
@@ -72,7 +47,19 @@ export class MessageService {
     return MessageModel.updatePluginState(id, key, value);
   }
 
-  async getAllMessages() {
-    return MessageModel.queryAll();
+  async bindMessagesToTopic(topicId: string, messageIds: string[]) {
+    return MessageModel.batchUpdate(messageIds, { topicId });
+  }
+
+  async removeMessage(id: string) {
+    return MessageModel.delete(id);
+  }
+
+  async removeMessages(assistantId: string, topicId?: string) {
+    return MessageModel.batchDelete(assistantId, topicId);
+  }
+
+  async removeAllMessages() {
+    return MessageModel.clearTable();
   }
 }

package/src/services/message/index.test.ts

@@ -0,0 +1,48 @@
+import { Mock, describe, expect, it, vi } from 'vitest';
+
+import { CreateMessageParams, MessageModel } from '@/database/client/models/message';
+import { ChatMessage, ChatMessageError, ChatPluginPayload } from '@/types/message';
+
+import { messageService } from './index';
+
+// Mock the MessageModel
+vi.mock('@/database/client/models/message', () => {
+  return {
+    MessageModel: {
+      count: vi.fn(),
+    },
+  };
+});
+
+describe('MessageService', () => {
+  beforeEach(() => {
+    // Reset all mocks before running each test case
+    vi.resetAllMocks();
+  });
+
+  describe('hasMessages', () => {
+    it('should return true if there are messages', async () => {
+      // Setup
+      (MessageModel.count as Mock).mockResolvedValue(1);
+
+      // Execute
+      const hasMessages = await messageService.hasMessages();
+
+      // Assert
+      expect(MessageModel.count).toHaveBeenCalled();
+      expect(hasMessages).toBe(true);
+    });
+
+    it('should return false if there are no messages', async () => {
+      // Setup
+      (MessageModel.count as Mock).mockResolvedValue(0);
+
+      // Execute
+      const hasMessages = await messageService.hasMessages();
+
+      // Assert
+      expect(MessageModel.count).toHaveBeenCalled();
+      expect(hasMessages).toBe(false);
+    });
+  });
+});

package/src/services/message/index.ts

@@ -1,4 +1,24 @@
-import { MessageService } from './client';
+// import { getClientConfig } from '@/config/client';
+// import { ServerService } from './server';
+// import { ClientService } from './client';
+//
+// const { ENABLED_SERVER_SERVICE } = getClientConfig();
+//
+// export const messageService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
+import { ClientService } from './client';
+
+export type { CreateMessageParams } from './type';
+
+class MessageService extends ClientService {
+  async hasMessages() {
+    const number = await this.countMessages();
+    return number > 0;
+  }
+
+  async messageCountToCheckTrace() {
+    const number = await this.countMessages();
+    return number >= 4;
+  }
+}
 
 export const messageService = new MessageService();
-export type { CreateMessageParams } from './client';

package/src/services/message/type.ts

@@ -0,0 +1,33 @@
+import { DB_Message } from '@/database/client/schemas/message';
+import { ChatMessage, ChatMessageError, ChatPluginPayload } from '@/types/message';
+
+/* eslint-disable typescript-sort-keys/interface */
+
+export interface CreateMessageParams
+  extends Partial<Omit<ChatMessage, 'content' | 'role'>>,
+    Pick<ChatMessage, 'content' | 'role'> {
+  fromModel?: string;
+  fromProvider?: string;
+  sessionId: string;
+  traceId?: string;
+}
+
+export interface IMessageService {
+  createMessage(data: CreateMessageParams): Promise<string>;
+  batchCreateMessages(messages: ChatMessage[]): Promise<any>;
+
+  getMessages(sessionId: string, topicId?: string): Promise<ChatMessage[]>;
+  getAllMessages(): Promise<ChatMessage[]>;
+  getAllMessagesInSession(sessionId: string): Promise<ChatMessage[]>;
+  countMessages(): Promise<number>;
+
+  updateMessageError(id: string, error: ChatMessageError): Promise<any>;
+  updateMessage(id: string, message: Partial<DB_Message>): Promise<any>;
+  updateMessagePlugin(id: string, plugin: ChatPluginPayload): Promise<any>;
+  updateMessagePluginState(id: string, key: string, value: any): Promise<any>;
+  bindMessagesToTopic(topicId: string, messageIds: string[]): Promise<any>;
+
+  removeMessage(id: string): Promise<any>;
+  removeMessages(assistantId: string, topicId?: string): Promise<any>;
+  removeAllMessages(): Promise<any>;
+}

package/src/services/plugin/client.test.ts

@@ -6,9 +6,9 @@ import { DB_Plugin } from '@/database/client/schemas/plugin';
 import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
-import { InstallPluginParams, PluginService } from './client';
+import { ClientService, InstallPluginParams } from './client';
 
-const pluginService = new PluginService();
+const pluginService = new ClientService();
 
 // Mocking modules and functions
 

package/src/services/plugin/client.ts

@@ -10,7 +10,7 @@ export interface InstallPluginParams {
   type: 'plugin' | 'customPlugin';
 }
 
-export class PluginService {
+export class ClientService {
   installPlugin = async (plugin: InstallPluginParams) => {
     return PluginModel.create(plugin);
   };

package/src/services/plugin/index.ts

@@ -1,5 +1,11 @@
-import { PluginService } from './client';
+// import { getClientConfig } from '@/config/client';
+import { ClientService } from './client';
 
-export type { InstallPluginParams } from './client';
+// import { ServerService } from './server';
+//
+// export type { InstallPluginParams } from './client';
+//
+// const { ENABLED_SERVER_SERVICE } = getClientConfig();
 
-export const pluginService = new PluginService();
+// export const pluginService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
+export const pluginService = new ClientService();

package/src/services/session/client.test.ts

@@ -5,9 +5,9 @@ import { SessionGroupModel } from '@/database/client/models/sessionGroup';
 import { LobeAgentConfig } from '@/types/agent';
 import { LobeAgentSession, LobeSessionType, SessionGroups } from '@/types/session';
 
-import { SessionService } from './client';
+import { ClientService } from './client';
 
-const sessionService = new SessionService();
+const sessionService = new ClientService();
 
 // Mock the SessionModel
 vi.mock('@/database/client/models/session', () => {
@@ -18,6 +18,7 @@ vi.mock('@/database/client/models/session', () => {
       delete: vi.fn(),
       clearTable: vi.fn(),
       update: vi.fn(),
+      count: vi.fn(),
       batchCreate: vi.fn(),
       isEmpty: vi.fn(),
       queryByKeyword: vi.fn(),
@@ -63,7 +64,7 @@ describe('SessionService', () => {
     vi.resetAllMocks();
   });
 
-  describe('createNewSession', () => {
+  describe('createSession', () => {
     it('should create a new session and return its id', async () => {
       // Setup
       const sessionType = LobeSessionType.Agent;
@@ -71,7 +72,7 @@ describe('SessionService', () => {
       (SessionModel.create as Mock).mockResolvedValue(mockSession);
 
       // Execute
-      const sessionId = await sessionService.createNewSession(sessionType, defaultValue);
+      const sessionId = await sessionService.createSession(sessionType, defaultValue);
 
       // Assert
       expect(SessionModel.create).toHaveBeenCalledWith(sessionType, defaultValue);
@@ -85,7 +86,7 @@ describe('SessionService', () => {
       (SessionModel.create as Mock).mockResolvedValue(null);
 
       // Execute & Assert
-      await expect(sessionService.createNewSession(sessionType, defaultValue)).rejects.toThrow(
+      await expect(sessionService.createSession(sessionType, defaultValue)).rejects.toThrow(
         'session create Error',
       );
     });
@@ -105,21 +106,19 @@ describe('SessionService', () => {
     });
   });
 
-  describe('getSessions', () => {
+  describe('getSessionsByType', () => {
     it('should retrieve sessions with their group ids', async () => {
       // Setup
       (SessionModel.query as Mock).mockResolvedValue(mockSessions);
 
       // Execute
-      const sessions = await sessionService.getSessions();
+      const sessions = await sessionService.getSessionsByType();
 
       // Assert
       expect(SessionModel.query).toHaveBeenCalled();
       expect(sessions).toBe(mockSessions);
     });
-  });
 
-  describe('getAllAgents', () => {
     it('should retrieve all agent sessions', async () => {
       // Setup
       // Assuming that SessionModel.query has been modified to accept filters
@@ -127,7 +126,7 @@ describe('SessionService', () => {
       (SessionModel.query as Mock).mockResolvedValue(agentSessions);
 
       // Execute
-      const result = await sessionService.getAllAgents();
+      const result = await sessionService.getSessionsByType('agent');
 
       // Assert
       // Assuming that SessionModel.query would be called with a filter for agents
@@ -164,34 +163,43 @@ describe('SessionService', () => {
     });
   });
 
-  describe('updateSessionGroupId', () => {
+  describe('updateSession', () => {
     it('should update the group of a session', async () => {
       // Setup
       const groupId = 'new-group';
       (SessionModel.update as Mock).mockResolvedValue({ ...mockSession, group: groupId });
 
       // Execute
-      const result = await sessionService.updateSessionGroupId(mockSessionId, groupId);
+      const result = await sessionService.updateSession(mockSessionId, { group: groupId });
 
       // Assert
       expect(SessionModel.update).toHaveBeenCalledWith(mockSessionId, { group: groupId });
       expect(result).toEqual({ ...mockSession, group: groupId });
     });
-  });
 
-  describe('updateSessionMeta', () => {
     it('should update the meta of a session', async () => {
       // Setup
       const newMeta = { description: 'Updated description' };
       (SessionModel.update as Mock).mockResolvedValue({ ...mockSession, meta: newMeta });
 
       // Execute
-      const result = await sessionService.updateSessionMeta(mockSessionId, newMeta);
+      const result = await sessionService.updateSession(mockSessionId, { meta: newMeta });
 
       // Assert
       expect(SessionModel.update).toHaveBeenCalledWith(mockSessionId, { meta: newMeta });
       expect(result).toEqual({ ...mockSession, meta: newMeta });
     });
+
+    it('should update the pinned status of a session', async () => {
+      // Setup
+      const pinned = true;
+
+      // Execute
+      await sessionService.updateSession(mockSessionId, { pinned });
+
+      // Assert
+      expect(SessionModel.update).toHaveBeenCalledWith(mockSessionId, { pinned: 1 });
+    });
   });
 
   describe('updateSessionConfig', () => {
@@ -209,29 +217,29 @@ describe('SessionService', () => {
     });
   });
 
-  describe('hasSessions', () => {
+  describe('countSessions', () => {
     it('should return false if no sessions exist', async () => {
       // Setup
-      (SessionModel.isEmpty as Mock).mockResolvedValue(true);
+      (SessionModel.count as Mock).mockResolvedValue(0);
 
       // Execute
-      const result = await sessionService.hasSessions();
+      const result = await sessionService.countSessions();
 
       // Assert
-      expect(SessionModel.isEmpty).toHaveBeenCalled();
-      expect(result).toBe(false);
+      expect(SessionModel.count).toHaveBeenCalled();
+      expect(result).toBe(0);
     });
 
     it('should return true if sessions exist', async () => {
       // Setup
-      (SessionModel.isEmpty as Mock).mockResolvedValue(false);
+      (SessionModel.count as Mock).mockResolvedValue(1);
 
       // Execute
-      const result = await sessionService.hasSessions();
+      const result = await sessionService.countSessions();
 
       // Assert
-      expect(SessionModel.isEmpty).toHaveBeenCalled();
-      expect(result).toBe(true);
+      expect(SessionModel.count).toHaveBeenCalled();
+      expect(result).toBe(1);
     });
   });
 
@@ -250,7 +258,7 @@ describe('SessionService', () => {
     });
   });
 
-  describe('duplicateSession', () => {
+  describe('cloneSession', () => {
     it('should duplicate a session and return its id', async () => {
       // Setup
       const newTitle = 'Duplicated Session';
@@ -260,7 +268,7 @@ describe('SessionService', () => {
       });
 
       // Execute
-      const duplicatedSessionId = await sessionService.duplicateSession(mockSessionId, newTitle);
+      const duplicatedSessionId = await sessionService.cloneSession(mockSessionId, newTitle);
 
       // Assert
       expect(SessionModel.duplicate).toHaveBeenCalledWith(mockSessionId, newTitle);
@@ -268,13 +276,13 @@ describe('SessionService', () => {
     });
   });
 
-  describe('getSessionsWithGroup', () => {
+  describe('getGroupedSessions', () => {
     it('should retrieve sessions with their group', async () => {
       // Setup
       (SessionModel.queryWithGroups as Mock).mockResolvedValue(mockSessions);
 
       // Execute
-      const sessionsWithGroup = await sessionService.getSessionsWithGroup();
+      const sessionsWithGroup = await sessionService.getGroupedSessions();
 
       // Assert
       expect(SessionModel.queryWithGroups).toHaveBeenCalled();
@@ -282,21 +290,6 @@ describe('SessionService', () => {
     });
   });
 
-  describe('updateSessionPinned', () => {
-    it('should update the pinned status of a session', async () => {
-      // Setup
-      const pinned = true;
-      (SessionModel.updatePinned as Mock).mockResolvedValue({ ...mockSession, pinned });
-
-      // Execute
-      const result = await sessionService.updateSessionPinned(mockSessionId, pinned);
-
-      // Assert
-      expect(SessionModel.updatePinned).toHaveBeenCalledWith(mockSessionId, pinned);
-      expect(result).toEqual({ ...mockSession, pinned });
-    });
-  });
-
   // SessionGroup related tests
   describe('createSessionGroup', () => {
     it('should create a new session group and return its id', async () => {
@@ -358,7 +351,7 @@ describe('SessionService', () => {
       (SessionGroupModel.clear as Mock).mockResolvedValue(true);
 
       // Execute
-      const result = await sessionService.clearSessionGroups();
+      const result = await sessionService.removeSessionGroups();
 
       // Assert
       expect(SessionGroupModel.clear).toHaveBeenCalled();

package/src/services/session/client.ts

@@ -3,19 +3,19 @@ import { DeepPartial } from 'utility-types';
 import { SessionModel } from '@/database/client/models/session';
 import { SessionGroupModel } from '@/database/client/models/sessionGroup';
 import { LobeAgentConfig } from '@/types/agent';
-import { MetaData } from '@/types/meta';
 import {
   ChatSessionList,
   LobeAgentSession,
   LobeSessionType,
   LobeSessions,
-  SessionGroupId,
   SessionGroupItem,
   SessionGroups,
 } from '@/types/session';
 
-export class SessionService {
-  async createNewSession(
+import { ISessionService } from './type';
+
+export class ClientService implements ISessionService {
+  async createSession(
     type: LobeSessionType,
     defaultValue: Partial<LobeAgentSession>,
   ): Promise<string> {
@@ -30,18 +30,30 @@ export class SessionService {
     return SessionModel.batchCreate(importSessions);
   }
 
-  async duplicateSession(id: string, newTitle: string): Promise<string | undefined> {
+  async cloneSession(id: string, newTitle: string): Promise<string | undefined> {
     const res = await SessionModel.duplicate(id, newTitle);
 
     if (res) return res?.id;
   }
 
-  async getSessions(): Promise<LobeSessions> {
-    return SessionModel.query();
+  async getGroupedSessions(): Promise<ChatSessionList> {
+    return SessionModel.queryWithGroups();
   }
 
-  async getSessionsWithGroup(): Promise<ChatSessionList> {
-    return SessionModel.queryWithGroups();
+  async getSessionsByType(type: 'agent' | 'group' | 'all' = 'all'): Promise<LobeSessions> {
+    switch (type) {
+      // TODO: add a filter to get only agents or agents
+      case 'group': {
+        return SessionModel.query();
+      }
+      case 'agent': {
+        return SessionModel.query();
+      }
+
+      case 'all': {
+        return SessionModel.query();
+      }
+    }
   }
 
   async getAllAgents(): Promise<LobeSessions> {
@@ -49,24 +61,20 @@ export class SessionService {
     return await SessionModel.query();
   }
 
-  async hasSessions() {
-    const isEmpty = await SessionModel.isEmpty();
-    return !isEmpty;
+  async countSessions() {
+    return SessionModel.count();
   }
 
   async searchSessions(keyword: string) {
     return SessionModel.queryByKeyword(keyword);
   }
 
-  async updateSessionGroupId(id: string, group: SessionGroupId) {
-    return SessionModel.update(id, { group });
-  }
-  async updateSessionPinned(id: string, pinned: boolean) {
-    return SessionModel.updatePinned(id, pinned);
-  }
-
-  async updateSessionMeta(activeId: string, meta: Partial<MetaData>) {
-    return SessionModel.update(activeId, { meta });
+  async updateSession(
+    id: string,
+    data: Partial<Pick<LobeAgentSession, 'group' | 'meta' | 'pinned'>>,
+  ) {
+    const pinned = typeof data.pinned === 'boolean' ? (data.pinned ? 1 : 0) : undefined;
+    return SessionModel.update(id, { ...data, pinned });
   }
 
   async updateSessionConfig(activeId: string, config: DeepPartial<LobeAgentConfig>) {
@@ -114,7 +122,7 @@ export class SessionService {
     return SessionGroupModel.query();
   }
 
-  async clearSessionGroups() {
+  async removeSessionGroups() {
     return SessionGroupModel.clear();
   }
 }

package/src/services/session/index.ts

@@ -1,3 +1,10 @@
-import { SessionService } from './client';
+// import { getClientConfig } from '@/config/client';
+//
+import { ClientService } from './client';
 
-export const sessionService = new SessionService();
+// import { ServerService } from './server';
+
+// const { ENABLED_SERVER_SERVICE } = getClientConfig();
+
+// export const sessionService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
+export const sessionService = new ClientService();

package/src/services/session/type.ts

@@ -0,0 +1,44 @@
+/* eslint-disable typescript-sort-keys/interface */
+import { DeepPartial } from 'utility-types';
+
+import { LobeAgentConfig } from '@/types/agent';
+import {
+  ChatSessionList,
+  LobeAgentSession,
+  LobeSessionType,
+  LobeSessions,
+  SessionGroupItem,
+  SessionGroups,
+} from '@/types/session';
+
+export interface ISessionService {
+  createSession(type: LobeSessionType, defaultValue: Partial<LobeAgentSession>): Promise<string>;
+  batchCreateSessions(importSessions: LobeSessions): Promise<any>;
+  cloneSession(id: string, newTitle: string): Promise<string | undefined>;
+
+  getGroupedSessions(): Promise<ChatSessionList>;
+  getSessionsByType(type: 'agent' | 'group' | 'all'): Promise<LobeSessions>;
+  countSessions(): Promise<number>;
+  searchSessions(keyword: string): Promise<LobeSessions>;
+
+  updateSession(id: string, data: Partial<Pick<LobeAgentSession, 'group' | 'meta'>>): Promise<any>;
+  updateSessionConfig(id: string, config: DeepPartial<LobeAgentConfig>): Promise<any>;
+
+  removeSession(id: string): Promise<any>;
+  removeAllSessions(): Promise<any>;
+
+  // ************************************** //
+  // ***********  SessionGroup  *********** //
+  // ************************************** //
+
+  createSessionGroup(name: string, sort?: number): Promise<string>;
+  batchCreateSessionGroups(groups: SessionGroups): Promise<any>;
+
+  getSessionGroups(): Promise<SessionGroupItem[]>;
+
+  updateSessionGroup(id: string, data: Partial<SessionGroupItem>): Promise<any>;
+  updateSessionGroupOrder(sortMap: { id: string; sort: number }[]): Promise<any>;
+
+  removeSessionGroup(id: string, removeChildren?: boolean): Promise<any>;
+  removeSessionGroups(): Promise<any>;
+}