@lobehub/chat 1.37.0 → 1.37.2

package/src/services/message/client.ts

@@ -1,10 +1,11 @@
 import dayjs from 'dayjs';
 
-import { FileModel } from '@/database/_deprecated/models/file';
-import { MessageModel } from '@/database/_deprecated/models/message';
-import { DB_Message } from '@/database/_deprecated/schemas/message';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { clientDB } from '@/database/client/db';
+import { MessageItem } from '@/database/schemas';
+import { MessageModel } from '@/database/server/models/message';
+import { BaseClientService } from '@/services/baseClientService';
 import {
-  ChatFileItem,
   ChatMessage,
   ChatMessageError,
   ChatTTS,
@@ -14,108 +15,104 @@ import {
 
 import { IMessageService } from './type';
 
-export class ClientService implements IMessageService {
-  async createMessage(data: CreateMessageParams) {
-    const { id } = await MessageModel.create(data);
+export class ClientService extends BaseClientService implements IMessageService {
+  private get messageModel(): MessageModel {
+    return new MessageModel(clientDB as any, this.userId);
+  }
+
+  async createMessage({ sessionId, ...params }: CreateMessageParams) {
+    const { id } = await this.messageModel.create({
+      ...params,
+      sessionId: this.toDbSessionId(sessionId) as string,
+    });
 
     return id;
   }
 
-  // @ts-ignore
-  async batchCreateMessages(messages: ChatMessage[]) {
-    return MessageModel.batchCreate(messages);
+  async batchCreateMessages(messages: MessageItem[]) {
+    return this.messageModel.batchCreate(messages);
   }
 
-  async getMessages(sessionId: string, topicId?: string): Promise<ChatMessage[]> {
-    const messages = await MessageModel.query({ sessionId, topicId });
-
-    const fileList = (await Promise.all(
-      messages
-        .flatMap((item) => item.files)
-        .filter(Boolean)
-        .map(async (id) => FileModel.findById(id!)),
-    )) as ChatFileItem[];
+  async getMessages(sessionId: string, topicId?: string) {
+    const data = await this.messageModel.query({
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+    });
 
-    return messages.map((item) => ({
-      ...item,
-      imageList: fileList
-        .filter((file) => item.files?.includes(file.id) && file.fileType.startsWith('image'))
-        .map((file) => ({
-          alt: file.name,
-          id: file.id,
-          url: file.url,
-        })),
-    }));
+    return data as unknown as ChatMessage[];
   }
 
   async getAllMessages() {
-    return MessageModel.queryAll();
+    const data = await this.messageModel.queryAll();
+
+    return data as unknown as ChatMessage[];
   }
 
   async countMessages() {
-    return MessageModel.count();
+    return this.messageModel.count();
   }
 
   async countTodayMessages() {
-    const topics = await MessageModel.queryAll();
+    const topics = await this.messageModel.queryAll();
     return topics.filter(
       (item) => dayjs(item.createdAt).format('YYYY-MM-DD') === dayjs().format('YYYY-MM-DD'),
     ).length;
   }
 
   async getAllMessagesInSession(sessionId: string) {
-    return MessageModel.queryBySessionId(sessionId);
+    const data = this.messageModel.queryBySessionId(this.toDbSessionId(sessionId));
+
+    return data as unknown as ChatMessage[];
   }
 
   async updateMessageError(id: string, error: ChatMessageError) {
-    return MessageModel.update(id, { error });
+    return this.messageModel.update(id, { error });
   }
 
-  // @ts-ignore
-  async updateMessage(id: string, message: Partial<DB_Message>) {
-    return MessageModel.update(id, message);
+  async updateMessage(id: string, message: Partial<MessageItem>) {
+    return this.messageModel.update(id, message);
   }
 
   async updateMessageTTS(id: string, tts: Partial<ChatTTS> | false) {
-    return MessageModel.update(id, { tts });
+    return this.messageModel.updateTTS(id, tts as any);
   }
 
   async updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false) {
-    return MessageModel.update(id, { translate });
+    return this.messageModel.updateTranslate(id, translate as any);
   }
 
   async updateMessagePluginState(id: string, value: Record<string, any>) {
-    return MessageModel.updatePluginState(id, value);
+    return this.messageModel.updatePluginState(id, value);
   }
 
   async updateMessagePluginArguments(id: string, value: string | Record<string, any>) {
     const args = typeof value === 'string' ? value : JSON.stringify(value);
 
-    return MessageModel.updatePlugin(id, { arguments: args });
-  }
-
-  async bindMessagesToTopic(topicId: string, messageIds: string[]) {
-    return MessageModel.batchUpdate(messageIds, { topicId });
+    return this.messageModel.updateMessagePlugin(id, { arguments: args });
   }
 
   async removeMessage(id: string) {
-    return MessageModel.delete(id);
+    return this.messageModel.deleteMessage(id);
   }
 
   async removeMessages(ids: string[]) {
-    return MessageModel.bulkDelete(ids);
+    return this.messageModel.deleteMessages(ids);
   }
 
-  async removeMessagesByAssistant(assistantId: string, topicId?: string) {
-    return MessageModel.batchDelete(assistantId, topicId);
+  async removeMessagesByAssistant(sessionId: string, topicId?: string) {
+    return this.messageModel.deleteMessagesBySession(this.toDbSessionId(sessionId), topicId);
   }
 
   async removeAllMessages() {
-    return MessageModel.clearTable();
+    return this.messageModel.deleteAllMessages();
   }
 
   async hasMessages() {
     const number = await this.countMessages();
     return number > 0;
   }
+
+  private toDbSessionId(sessionId: string | undefined) {
+    return sessionId === INBOX_SESSION_ID ? undefined : sessionId;
+  }
 }

package/src/services/message/index.ts

@@ -1,5 +1,5 @@
-import { ClientService as DeprecatedService } from './client';
-import { ClientService } from './pglite';
+import { ClientService as DeprecatedService } from './_deprecated';
+import { ClientService } from './client';
 import { ServerService } from './server';
 
 const clientService =

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

@@ -0,0 +1,162 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { PluginModel } from '@/database/_deprecated/models/plugin';
+import { DB_Plugin } from '@/database/_deprecated/schemas/plugin';
+import { LobeTool } from '@/types/tool';
+import { LobeToolCustomPlugin } from '@/types/tool/plugin';
+
+import { ClientService } from './_deprecated';
+import { InstallPluginParams } from './type';
+
+const pluginService = new ClientService();
+
+// Mocking modules and functions
+
+vi.mock('@/database/_deprecated/models/plugin', () => ({
+  PluginModel: {
+    getList: vi.fn(),
+    create: vi.fn(),
+    delete: vi.fn(),
+    update: vi.fn(),
+    clear: vi.fn(),
+  },
+}));
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe('PluginService', () => {
+  describe('installPlugin', () => {
+    it('should install a plugin', async () => {
+      // Arrange
+      const fakePlugin = {
+        identifier: 'test-plugin',
+        manifest: { name: 'TestPlugin', version: '1.0.0' } as unknown as LobeChatPluginManifest,
+        type: 'plugin',
+      } as InstallPluginParams;
+      vi.mocked(PluginModel.create).mockResolvedValue(fakePlugin);
+
+      // Act
+      const installedPlugin = await pluginService.installPlugin(fakePlugin);
+
+      // Assert
+      expect(PluginModel.create).toHaveBeenCalledWith(fakePlugin);
+      expect(installedPlugin).toEqual(fakePlugin);
+    });
+  });
+
+  describe('getInstalledPlugins', () => {
+    it('should return a list of installed plugins', async () => {
+      // Arrange
+      const fakePlugins = [{ identifier: 'test-plugin', type: 'plugin' }] as LobeTool[];
+      vi.mocked(PluginModel.getList).mockResolvedValue(fakePlugins as DB_Plugin[]);
+
+      // Act
+      const installedPlugins = await pluginService.getInstalledPlugins();
+
+      // Assert
+      expect(PluginModel.getList).toHaveBeenCalled();
+      expect(installedPlugins).toEqual(fakePlugins);
+    });
+  });
+
+  describe('uninstallPlugin', () => {
+    it('should uninstall a plugin', async () => {
+      // Arrange
+      const identifier = 'test-plugin';
+      vi.mocked(PluginModel.delete).mockResolvedValue();
+
+      // Act
+      const result = await pluginService.uninstallPlugin(identifier);
+
+      // Assert
+      expect(PluginModel.delete).toHaveBeenCalledWith(identifier);
+      expect(result).toBe(undefined);
+    });
+  });
+
+  describe('createCustomPlugin', () => {
+    it('should create a custom plugin', async () => {
+      // Arrange
+      const customPlugin = {
+        identifier: 'custom-plugin',
+        manifest: {},
+        type: 'customPlugin',
+      } as LobeToolCustomPlugin;
+      vi.mocked(PluginModel.create).mockResolvedValue(customPlugin);
+
+      // Act
+      const result = await pluginService.createCustomPlugin(customPlugin);
+
+      // Assert
+      expect(PluginModel.create).toHaveBeenCalledWith({
+        ...customPlugin,
+        type: 'customPlugin',
+      });
+      expect(result).toEqual(customPlugin);
+    });
+  });
+
+  describe('updatePlugin', () => {
+    it('should update a plugin', async () => {
+      // Arrange
+      const id = 'plugin-id';
+      const value = { settings: { ab: '1' } } as unknown as LobeToolCustomPlugin;
+      vi.mocked(PluginModel.update).mockResolvedValue(1);
+
+      // Act
+      const result = await pluginService.updatePlugin(id, value);
+
+      // Assert
+      expect(PluginModel.update).toHaveBeenCalledWith(id, value);
+      expect(result).toEqual(undefined);
+    });
+  });
+
+  describe('updatePluginManifest', () => {
+    it('should update a plugin manifest', async () => {
+      // Arrange
+      const id = 'plugin-id';
+      const manifest = { name: 'NewPluginManifest' } as unknown as LobeChatPluginManifest;
+      vi.mocked(PluginModel.update).mockResolvedValue(1);
+
+      // Act
+      const result = await pluginService.updatePluginManifest(id, manifest);
+
+      // Assert
+      expect(PluginModel.update).toHaveBeenCalledWith(id, { manifest });
+      expect(result).toEqual(undefined);
+    });
+  });
+
+  describe('removeAllPlugins', () => {
+    it('should remove all plugins', async () => {
+      // Arrange
+      vi.mocked(PluginModel.clear).mockResolvedValue(undefined);
+
+      // Act
+      const result = await pluginService.removeAllPlugins();
+
+      // Assert
+      expect(PluginModel.clear).toHaveBeenCalled();
+      expect(result).toBe(undefined);
+    });
+  });
+
+  describe('updatePluginSettings', () => {
+    it('should update plugin settings', async () => {
+      // Arrange
+      const id = 'plugin-id';
+      const settings = { color: 'blue' };
+
+      // Act
+      const result = await pluginService.updatePluginSettings(id, settings);
+
+      // Assert
+      expect(PluginModel.update).toHaveBeenCalledWith(id, { settings });
+      expect(result).toEqual(undefined);
+    });
+  });
+});

package/src/services/plugin/_deprecated.ts

@@ -0,0 +1,42 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+
+import { PluginModel } from '@/database/_deprecated/models/plugin';
+import { LobeTool } from '@/types/tool';
+import { LobeToolCustomPlugin } from '@/types/tool/plugin';
+
+import { IPluginService, InstallPluginParams } from './type';
+
+export class ClientService implements IPluginService {
+  installPlugin = async (plugin: InstallPluginParams) => {
+    return PluginModel.create(plugin);
+  };
+
+  getInstalledPlugins = () => {
+    return PluginModel.getList() as Promise<LobeTool[]>;
+  };
+
+  uninstallPlugin(identifier: string) {
+    return PluginModel.delete(identifier);
+  }
+
+  async createCustomPlugin(customPlugin: LobeToolCustomPlugin) {
+    return PluginModel.create({ ...customPlugin, type: 'customPlugin' });
+  }
+
+  async updatePlugin(id: string, value: LobeToolCustomPlugin) {
+    await PluginModel.update(id, value);
+    return;
+  }
+  async updatePluginManifest(id: string, manifest: LobeChatPluginManifest) {
+    await PluginModel.update(id, { manifest });
+  }
+
+  async removeAllPlugins() {
+    return PluginModel.clear();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async updatePluginSettings(id: string, settings: any, _?: AbortSignal) {
+    await PluginModel.update(id, { settings });
+  }
+}

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

@@ -1,30 +1,29 @@
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { eq } from 'drizzle-orm';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { PluginModel } from '@/database/_deprecated/models/plugin';
-import { DB_Plugin } from '@/database/_deprecated/schemas/plugin';
+import { clientDB, initializeDB } from '@/database/client/db';
+import { installedPlugins, users } from '@/database/schemas';
 import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
 import { ClientService } from './client';
 import { InstallPluginParams } from './type';
 
-const pluginService = new ClientService();
-
 // Mocking modules and functions
 
-vi.mock('@/database/_deprecated/models/plugin', () => ({
-  PluginModel: {
-    getList: vi.fn(),
-    create: vi.fn(),
-    delete: vi.fn(),
-    update: vi.fn(),
-    clear: vi.fn(),
-  },
-}));
-
-beforeEach(() => {
-  vi.resetAllMocks();
+const userId = 'message-db';
+const pluginService = new ClientService(userId);
+
+// Mock data
+beforeEach(async () => {
+  await initializeDB();
+
+  // 在每个测试用例之前，重置表数据
+  await clientDB.transaction(async (trx) => {
+    await trx.delete(users);
+    await trx.insert(users).values([{ id: userId }, { id: '456' }]);
+  });
 });
 
 describe('PluginService', () => {
@@ -32,18 +31,19 @@ describe('PluginService', () => {
     it('should install a plugin', async () => {
       // Arrange
       const fakePlugin = {
-        identifier: 'test-plugin',
+        identifier: 'test-plugin-d',
         manifest: { name: 'TestPlugin', version: '1.0.0' } as unknown as LobeChatPluginManifest,
         type: 'plugin',
       } as InstallPluginParams;
-      vi.mocked(PluginModel.create).mockResolvedValue(fakePlugin);
 
       // Act
-      const installedPlugin = await pluginService.installPlugin(fakePlugin);
+      await pluginService.installPlugin(fakePlugin);
 
       // Assert
-      expect(PluginModel.create).toHaveBeenCalledWith(fakePlugin);
-      expect(installedPlugin).toEqual(fakePlugin);
+      const result = await clientDB.query.installedPlugins.findFirst({
+        where: eq(installedPlugins.identifier, fakePlugin.identifier),
+      });
+      expect(result).toMatchObject(fakePlugin);
     });
   });
 
@@ -51,14 +51,14 @@ describe('PluginService', () => {
     it('should return a list of installed plugins', async () => {
       // Arrange
       const fakePlugins = [{ identifier: 'test-plugin', type: 'plugin' }] as LobeTool[];
-      vi.mocked(PluginModel.getList).mockResolvedValue(fakePlugins as DB_Plugin[]);
-
+      await clientDB
+        .insert(installedPlugins)
+        .values([{ identifier: 'test-plugin', type: 'plugin', userId }]);
       // Act
-      const installedPlugins = await pluginService.getInstalledPlugins();
+      const data = await pluginService.getInstalledPlugins();
 
       // Assert
-      expect(PluginModel.getList).toHaveBeenCalled();
-      expect(installedPlugins).toEqual(fakePlugins);
+      expect(data).toMatchObject(fakePlugins);
     });
   });
 
@@ -66,13 +66,15 @@ describe('PluginService', () => {
     it('should uninstall a plugin', async () => {
       // Arrange
       const identifier = 'test-plugin';
-      vi.mocked(PluginModel.delete).mockResolvedValue();
+      await clientDB.insert(installedPlugins).values([{ identifier, type: 'plugin', userId }]);
 
       // Act
-      const result = await pluginService.uninstallPlugin(identifier);
+      await pluginService.uninstallPlugin(identifier);
 
       // Assert
-      expect(PluginModel.delete).toHaveBeenCalledWith(identifier);
+      const result = await clientDB.query.installedPlugins.findFirst({
+        where: eq(installedPlugins.identifier, identifier),
+      });
       expect(result).toBe(undefined);
     });
   });
@@ -81,67 +83,74 @@ describe('PluginService', () => {
     it('should create a custom plugin', async () => {
       // Arrange
       const customPlugin = {
-        identifier: 'custom-plugin',
+        identifier: 'custom-plugin-x',
         manifest: {},
         type: 'customPlugin',
       } as LobeToolCustomPlugin;
-      vi.mocked(PluginModel.create).mockResolvedValue(customPlugin);
 
       // Act
-      const result = await pluginService.createCustomPlugin(customPlugin);
+      await pluginService.createCustomPlugin(customPlugin);
 
       // Assert
-      expect(PluginModel.create).toHaveBeenCalledWith({
-        ...customPlugin,
-        type: 'customPlugin',
+      const result = await clientDB.query.installedPlugins.findFirst({
+        where: eq(installedPlugins.identifier, customPlugin.identifier),
       });
-      expect(result).toEqual(customPlugin);
+      expect(result).toMatchObject(customPlugin);
     });
   });
 
   describe('updatePlugin', () => {
     it('should update a plugin', async () => {
       // Arrange
-      const id = 'plugin-id';
-      const value = { settings: { ab: '1' } } as unknown as LobeToolCustomPlugin;
-      vi.mocked(PluginModel.update).mockResolvedValue(1);
+      const identifier = 'plugin-id';
+      const value = { customParams: { ab: '1' } } as unknown as LobeToolCustomPlugin;
+      await clientDB.insert(installedPlugins).values([{ identifier, type: 'plugin', userId }]);
 
       // Act
-      const result = await pluginService.updatePlugin(id, value);
+      await pluginService.updatePlugin(identifier, value);
 
       // Assert
-      expect(PluginModel.update).toHaveBeenCalledWith(id, value);
-      expect(result).toEqual(undefined);
+      const result = await clientDB.query.installedPlugins.findFirst({
+        where: eq(installedPlugins.identifier, identifier),
+      });
+      expect(result).toMatchObject(value);
     });
   });
 
   describe('updatePluginManifest', () => {
     it('should update a plugin manifest', async () => {
       // Arrange
-      const id = 'plugin-id';
+      const identifier = 'plugin-id';
       const manifest = { name: 'NewPluginManifest' } as unknown as LobeChatPluginManifest;
-      vi.mocked(PluginModel.update).mockResolvedValue(1);
+      await clientDB.insert(installedPlugins).values([{ identifier, type: 'plugin', userId }]);
 
       // Act
-      const result = await pluginService.updatePluginManifest(id, manifest);
+      await pluginService.updatePluginManifest(identifier, manifest);
 
       // Assert
-      expect(PluginModel.update).toHaveBeenCalledWith(id, { manifest });
-      expect(result).toEqual(undefined);
+      const result = await clientDB.query.installedPlugins.findFirst({
+        where: eq(installedPlugins.identifier, identifier),
+      });
+      expect(result).toMatchObject({ manifest });
     });
   });
 
   describe('removeAllPlugins', () => {
     it('should remove all plugins', async () => {
       // Arrange
-      vi.mocked(PluginModel.clear).mockResolvedValue(undefined);
+      await clientDB.insert(installedPlugins).values([
+        { identifier: '123', type: 'plugin', userId },
+        { identifier: '234', type: 'plugin', userId },
+      ]);
 
       // Act
-      const result = await pluginService.removeAllPlugins();
+      await pluginService.removeAllPlugins();
 
       // Assert
-      expect(PluginModel.clear).toHaveBeenCalled();
-      expect(result).toBe(undefined);
+      const result = await clientDB.query.installedPlugins.findMany({
+        where: eq(installedPlugins.userId, userId),
+      });
+      expect(result.length).toEqual(0);
     });
   });
 
@@ -150,13 +159,17 @@ describe('PluginService', () => {
       // Arrange
       const id = 'plugin-id';
       const settings = { color: 'blue' };
+      await clientDB.insert(installedPlugins).values([{ identifier: id, type: 'plugin', userId }]);
 
       // Act
-      const result = await pluginService.updatePluginSettings(id, settings);
+      await pluginService.updatePluginSettings(id, settings);
 
       // Assert
-      expect(PluginModel.update).toHaveBeenCalledWith(id, { settings });
-      expect(result).toEqual(undefined);
+      const result = await clientDB.query.installedPlugins.findFirst({
+        where: eq(installedPlugins.identifier, id),
+      });
+
+      expect(result).toMatchObject({ settings });
     });
   });
 });

package/src/services/plugin/client.ts

@@ -1,42 +1,51 @@
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 
-import { PluginModel } from '@/database/_deprecated/models/plugin';
+import { clientDB } from '@/database/client/db';
+import { PluginModel } from '@/database/server/models/plugin';
+import { BaseClientService } from '@/services/baseClientService';
 import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
 import { IPluginService, InstallPluginParams } from './type';
 
-export class ClientService implements IPluginService {
+export class ClientService extends BaseClientService implements IPluginService {
+  private get pluginModel(): PluginModel {
+    return new PluginModel(clientDB as any, this.userId);
+  }
+
   installPlugin = async (plugin: InstallPluginParams) => {
-    return PluginModel.create(plugin);
+    await this.pluginModel.create(plugin);
+    return;
   };
 
   getInstalledPlugins = () => {
-    return PluginModel.getList() as Promise<LobeTool[]>;
+    return this.pluginModel.query() as Promise<LobeTool[]>;
   };
 
-  uninstallPlugin(identifier: string) {
-    return PluginModel.delete(identifier);
+  async uninstallPlugin(identifier: string) {
+    await this.pluginModel.delete(identifier);
+    return;
   }
 
   async createCustomPlugin(customPlugin: LobeToolCustomPlugin) {
-    return PluginModel.create({ ...customPlugin, type: 'customPlugin' });
+    await this.pluginModel.create({ ...customPlugin, type: 'customPlugin' });
+    return;
   }
 
   async updatePlugin(id: string, value: LobeToolCustomPlugin) {
-    await PluginModel.update(id, value);
+    await this.pluginModel.update(id, value);
     return;
   }
   async updatePluginManifest(id: string, manifest: LobeChatPluginManifest) {
-    await PluginModel.update(id, { manifest });
+    await this.pluginModel.update(id, { manifest });
   }
 
   async removeAllPlugins() {
-    return PluginModel.clear();
+    await this.pluginModel.deleteAll();
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async updatePluginSettings(id: string, settings: any, _?: AbortSignal) {
-    await PluginModel.update(id, { settings });
+    await this.pluginModel.update(id, { settings });
   }
 }