@lobehub/chat 1.37.0 → 1.37.2

package/src/services/file/client.ts

@@ -1,24 +1,31 @@
-import { FileModel } from '@/database/_deprecated/models/file';
+import { clientDB } from '@/database/client/db';
+import { FileModel } from '@/database/server/models/file';
+import { BaseClientService } from '@/services/baseClientService';
 import { clientS3Storage } from '@/services/file/ClientS3';
 import { FileItem, UploadFileParams } from '@/types/files';
 
 import { IFileService } from './type';
 
-export class ClientService implements IFileService {
+export class ClientService extends BaseClientService implements IFileService {
+  private get fileModel(): FileModel {
+    return new FileModel(clientDB as any, this.userId);
+  }
+
   async createFile(file: UploadFileParams) {
     // save to local storage
     // we may want to save to a remote server later
-    const res = await FileModel.create({
-      createdAt: Date.now(),
-      data: undefined,
-      fileHash: file.hash,
-      fileType: file.fileType,
-      metadata: file.metadata,
-      name: file.name,
-      saveMode: 'url',
-      size: file.size,
-      url: file.url,
-    } as any);
+    const res = await this.fileModel.create(
+      {
+        fileHash: file.hash,
+        fileType: file.fileType,
+        knowledgeBaseId: file.knowledgeBaseId,
+        metadata: file.metadata,
+        name: file.name,
+        size: file.size,
+        url: file.url!,
+      },
+      true,
+    );
 
     // get file to base64 url
     const base64 = await this.getBase64ByFileHash(file.hash!);
@@ -29,24 +36,17 @@ export class ClientService implements IFileService {
     };
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async checkFileHash(_hash: string) {
-    return { isExist: false, metadata: {} };
-  }
-
   async getFile(id: string): Promise<FileItem> {
-    const item = await FileModel.findById(id);
+    const item = await this.fileModel.findById(id);
     if (!item) {
       throw new Error('file not found');
     }
 
-    // arrayBuffer to blob or base64 to blob
-    const blob = !!item.data
-      ? new Blob([item.data!], { type: item.fileType })
-      : // @ts-ignore
-        new Blob([Buffer.from(item.base64!, 'base64')], { type: item.fileType });
+    // arrayBuffer to url
+    const fileItem = await clientS3Storage.getObject(item.fileHash!);
+    if (!fileItem) throw new Error('file not found');
 
-    const url = URL.createObjectURL(blob);
+    const url = URL.createObjectURL(fileItem);
 
     return {
       createdAt: new Date(item.createdAt),
@@ -60,15 +60,19 @@ export class ClientService implements IFileService {
   }
 
   async removeFile(id: string) {
-    return FileModel.delete(id);
+    await this.fileModel.delete(id, false);
   }
 
   async removeFiles(ids: string[]) {
-    await Promise.all(ids.map((id) => FileModel.delete(id)));
+    await this.fileModel.deleteMany(ids, false);
   }
 
   async removeAllFiles() {
-    return FileModel.clear();
+    return this.fileModel.clear();
+  }
+
+  async checkFileHash(hash: string) {
+    return this.fileModel.checkHash(hash);
   }
 
   private async getBase64ByFileHash(hash: string) {

package/src/services/file/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/import/_deprecated.ts

@@ -0,0 +1,74 @@
+import { MessageModel } from '@/database/_deprecated/models/message';
+import { SessionModel } from '@/database/_deprecated/models/session';
+import { SessionGroupModel } from '@/database/_deprecated/models/sessionGroup';
+import { TopicModel } from '@/database/_deprecated/models/topic';
+import { ImportResult, ImportResults } from '@/services/config';
+import { useUserStore } from '@/store/user';
+import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
+import { UserSettings } from '@/types/user/settings';
+
+export class ClientService {
+  importSettings = async (settings: UserSettings) => {
+    await useUserStore.getState().importAppSettings(settings);
+  };
+
+  importData = async (
+    config: ImporterEntryData,
+    callbacks?: OnImportCallbacks,
+  ): Promise<ImportResults> => {
+    callbacks?.onStageChange?.(ImportStage.Importing);
+    const time = Date.now();
+
+    const { messages = [], sessionGroups = [], sessions = [], topics = [] } = config;
+
+    let messageResult: ImportResult | undefined;
+    let sessionResult: ImportResult | undefined;
+    let sessionGroupResult: ImportResult | undefined;
+    let topicResult: ImportResult | undefined;
+
+    if (messages.length > 0) {
+      const res = await MessageModel.batchCreate(messages as any);
+      messageResult = this.mapImportResult(res);
+    }
+
+    if (sessionGroups.length > 0) {
+      const res = await SessionGroupModel.batchCreate(sessionGroups as any);
+      sessionGroupResult = this.mapImportResult(res);
+    }
+
+    if (topics.length > 0) {
+      const res = await TopicModel.batchCreate(topics as any);
+      topicResult = this.mapImportResult(res);
+    }
+
+    if (sessions.length > 0) {
+      const data = await SessionModel.batchCreate(sessions as any);
+      sessionResult = this.mapImportResult(data);
+    }
+
+    const result = {
+      messages: messageResult,
+      sessionGroups: sessionGroupResult,
+      sessions: sessionResult,
+      topics: topicResult,
+    };
+
+    const duration = Date.now() - time;
+    callbacks?.onStageChange?.(ImportStage.Success);
+    callbacks?.onSuccess?.(result, duration);
+
+    return result;
+  };
+
+  private mapImportResult = (input: {
+    added: number;
+    errors?: Error[];
+    skips: string[];
+  }): ImportResult => {
+    return {
+      added: input.added,
+      errors: input.errors?.length || 0,
+      skips: input.skips.length,
+    };
+  };
+}

package/src/services/import/{pglite.test.ts → client.test.ts}

@@ -15,7 +15,7 @@ import {
 import { CURRENT_CONFIG_VERSION } from '@/migrations';
 import { ImportResults, ImporterEntryData } from '@/types/importer';
 
-import { ClientService } from './pglite';
+import { ClientService } from './client';
 
 const userId = 'test-user-id';
 const service = new ClientService(userId);

package/src/services/import/client.ts

@@ -1,74 +1,34 @@
-import { MessageModel } from '@/database/_deprecated/models/message';
-import { SessionModel } from '@/database/_deprecated/models/session';
-import { SessionGroupModel } from '@/database/_deprecated/models/sessionGroup';
-import { TopicModel } from '@/database/_deprecated/models/topic';
-import { ImportResult, ImportResults } from '@/services/config';
+import { clientDB } from '@/database/client/db';
+import { DataImporterRepos } from '@/database/repositories/dataImporter';
+import { BaseClientService } from '@/services/baseClientService';
 import { useUserStore } from '@/store/user';
 import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
 import { UserSettings } from '@/types/user/settings';
 
-export class ClientService {
+export class ClientService extends BaseClientService {
+  private get dataImporter(): DataImporterRepos {
+    return new DataImporterRepos(clientDB as any, this.userId);
+  }
+
   importSettings = async (settings: UserSettings) => {
     await useUserStore.getState().importAppSettings(settings);
   };
 
-  importData = async (
-    config: ImporterEntryData,
-    callbacks?: OnImportCallbacks,
-  ): Promise<ImportResults> => {
+  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks) => {
     callbacks?.onStageChange?.(ImportStage.Importing);
     const time = Date.now();
-
-    const { messages = [], sessionGroups = [], sessions = [], topics = [] } = config;
-
-    let messageResult: ImportResult | undefined;
-    let sessionResult: ImportResult | undefined;
-    let sessionGroupResult: ImportResult | undefined;
-    let topicResult: ImportResult | undefined;
-
-    if (messages.length > 0) {
-      const res = await MessageModel.batchCreate(messages as any);
-      messageResult = this.mapImportResult(res);
-    }
-
-    if (sessionGroups.length > 0) {
-      const res = await SessionGroupModel.batchCreate(sessionGroups as any);
-      sessionGroupResult = this.mapImportResult(res);
-    }
-
-    if (topics.length > 0) {
-      const res = await TopicModel.batchCreate(topics as any);
-      topicResult = this.mapImportResult(res);
+    try {
+      const result = await this.dataImporter.importData(data);
+      const duration = Date.now() - time;
+
+      callbacks?.onStageChange?.(ImportStage.Success);
+      callbacks?.onSuccess?.(result, duration);
+    } catch (e) {
+      console.error(e);
+      callbacks?.onStageChange?.(ImportStage.Error);
+      const error = e as Error;
+
+      callbacks?.onError?.({ code: 'ImportError', httpStatus: 0, message: error.message });
     }
-
-    if (sessions.length > 0) {
-      const data = await SessionModel.batchCreate(sessions as any);
-      sessionResult = this.mapImportResult(data);
-    }
-
-    const result = {
-      messages: messageResult,
-      sessionGroups: sessionGroupResult,
-      sessions: sessionResult,
-      topics: topicResult,
-    };
-
-    const duration = Date.now() - time;
-    callbacks?.onStageChange?.(ImportStage.Success);
-    callbacks?.onSuccess?.(result, duration);
-
-    return result;
-  };
-
-  private mapImportResult = (input: {
-    added: number;
-    errors?: Error[];
-    skips: string[];
-  }): ImportResult => {
-    return {
-      added: input.added,
-      errors: input.errors?.length || 0,
-      skips: input.skips.length,
-    };
   };
 }

package/src/services/import/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/message/_deprecated.test.ts

@@ -0,0 +1,398 @@
+import dayjs from 'dayjs';
+import { Mock, describe, expect, it, vi } from 'vitest';
+
+import { CreateMessageParams, MessageModel } from '@/database/_deprecated/models/message';
+import {
+  ChatMessage,
+  ChatMessageError,
+  ChatPluginPayload,
+  ChatTTS,
+  ChatTranslate,
+} from '@/types/message';
+
+import { ClientService } from './_deprecated';
+
+const messageService = new ClientService();
+
+// Mock the MessageModel
+vi.mock('@/database/_deprecated/models/message', () => {
+  return {
+    MessageModel: {
+      create: vi.fn(),
+      batchCreate: vi.fn(),
+      count: vi.fn(),
+      query: vi.fn(),
+      delete: vi.fn(),
+      bulkDelete: vi.fn(),
+      queryBySessionId: vi.fn(),
+      update: vi.fn(),
+      updatePlugin: vi.fn(),
+      batchDelete: vi.fn(),
+      clearTable: vi.fn(),
+      batchUpdate: vi.fn(),
+      queryAll: vi.fn(),
+      updatePluginState: vi.fn(),
+    },
+  };
+});
+
+describe('MessageClientService', () => {
+  // Mock data
+  const mockMessageId = 'mock-message-id';
+  const mockMessage = {
+    id: mockMessageId,
+    content: 'Mock message content',
+    sessionId: 'mock-session-id',
+    createdAt: 100,
+    updatedAt: 100,
+    role: 'user',
+    // ... other properties
+  } as ChatMessage;
+  const mockMessages = [mockMessage];
+
+  beforeEach(() => {
+    // Reset all mocks before running each test case
+    vi.resetAllMocks();
+  });
+
+  describe('create', () => {
+    it('should create a message and return its id', async () => {
+      // Setup
+      const createParams = {
+        content: 'New message content',
+        sessionId: '1',
+        // ... other properties
+      } as CreateMessageParams;
+      (MessageModel.create as Mock).mockResolvedValue({ id: mockMessageId });
+
+      // Execute
+      const messageId = await messageService.createMessage(createParams);
+
+      // Assert
+      expect(MessageModel.create).toHaveBeenCalledWith(createParams);
+      expect(messageId).toBe(mockMessageId);
+    });
+  });
+
+  describe('batchCreate', () => {
+    it('should batch create messages', async () => {
+      // Setup
+      (MessageModel.batchCreate as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const result = await messageService.batchCreateMessages(mockMessages);
+
+      // Assert
+      expect(MessageModel.batchCreate).toHaveBeenCalledWith(mockMessages);
+      expect(result).toBe(mockMessages);
+    });
+  });
+
+  describe('removeMessage', () => {
+    it('should remove a message by id', async () => {
+      // Setup
+      (MessageModel.delete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.removeMessage(mockMessageId);
+
+      // Assert
+      expect(MessageModel.delete).toHaveBeenCalledWith(mockMessageId);
+      expect(result).toBe(true);
+    });
+  });
+  describe('removeMessages', () => {
+    it('should remove a message by id', async () => {
+      // Setup
+      (MessageModel.bulkDelete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.removeMessages([mockMessageId]);
+
+      // Assert
+      expect(MessageModel.bulkDelete).toHaveBeenCalledWith([mockMessageId]);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getMessages', () => {
+    it('should retrieve messages by sessionId and topicId', async () => {
+      // Setup
+      const sessionId = 'session-id';
+      const topicId = 'topic-id';
+      (MessageModel.query as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const messages = await messageService.getMessages(sessionId, topicId);
+
+      // Assert
+      expect(MessageModel.query).toHaveBeenCalledWith({ sessionId, topicId });
+      expect(messages).toEqual(mockMessages.map((i) => ({ ...i, imageList: [] })));
+    });
+  });
+
+  describe('getAllMessagesInSession', () => {
+    it('should retrieve all messages in a session', async () => {
+      // Setup
+      const sessionId = 'session-id';
+      (MessageModel.queryBySessionId as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const messages = await messageService.getAllMessagesInSession(sessionId);
+
+      // Assert
+      expect(MessageModel.queryBySessionId).toHaveBeenCalledWith(sessionId);
+      expect(messages).toBe(mockMessages);
+    });
+  });
+
+  describe('removeMessagesByAssistant', () => {
+    it('should batch remove messages by assistantId and topicId', async () => {
+      // Setup
+      const assistantId = 'assistant-id';
+      const topicId = 'topic-id';
+      (MessageModel.batchDelete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.removeMessagesByAssistant(assistantId, topicId);
+
+      // Assert
+      expect(MessageModel.batchDelete).toHaveBeenCalledWith(assistantId, topicId);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('clearAllMessage', () => {
+    it('should clear all messages from the table', async () => {
+      // Setup
+      (MessageModel.clearTable as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.removeAllMessages();
+
+      // Assert
+      expect(MessageModel.clearTable).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('bindMessagesToTopic', () => {
+    it('should batch update messages to bind them to a topic', async () => {
+      // Setup
+      const topicId = 'topic-id';
+      const messageIds = [mockMessageId];
+      (MessageModel.batchUpdate as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const result = await messageService.bindMessagesToTopic(topicId, messageIds);
+
+      // Assert
+      expect(MessageModel.batchUpdate).toHaveBeenCalledWith(messageIds, { topicId });
+      expect(result).toBe(mockMessages);
+    });
+  });
+
+  describe('getAllMessages', () => {
+    it('should retrieve all messages', async () => {
+      // Setup
+      (MessageModel.queryAll as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const messages = await messageService.getAllMessages();
+
+      // Assert
+      expect(MessageModel.queryAll).toHaveBeenCalled();
+      expect(messages).toBe(mockMessages);
+    });
+  });
+
+  describe('updateMessageError', () => {
+    it('should update the error field of a message', async () => {
+      // Setup
+      const newError = {
+        type: 'InvalidProviderAPIKey',
+        message: 'Error occurred',
+      } as ChatMessageError;
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, error: newError });
+
+      // Execute
+      const result = await messageService.updateMessageError(mockMessageId, newError);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { error: newError });
+      expect(result).toEqual({ ...mockMessage, error: newError });
+    });
+  });
+
+  // describe('updateMessagePlugin', () => {
+  // it('should update the plugin payload of a message', async () => {
+  //   // Setup
+  //   const newPlugin = {
+  //     type: 'default',
+  //     apiName: 'abc',
+  //     arguments: '',
+  //     identifier: 'plugin1',
+  //   } as ChatPluginPayload;
+  //
+  //   (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, plugin: newPlugin });
+  //
+  //   // Execute
+  //   const result = await messageService.updateMessagePlugin(mockMessageId, newPlugin);
+  //
+  //   // Assert
+  //   expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { plugin: newPlugin });
+  //   expect(result).toEqual({ ...mockMessage, plugin: newPlugin });
+  // });
+  // });
+
+  describe('updateMessagePluginState', () => {
+    it('should update the plugin state of a message', async () => {
+      // Setup
+      const key = 'stateKey';
+      const value = 'stateValue';
+      const newPluginState = { [key]: value };
+      (MessageModel.updatePluginState as Mock).mockResolvedValue({
+        ...mockMessage,
+        pluginState: newPluginState,
+      });
+
+      // Execute
+      const result = await messageService.updateMessagePluginState(mockMessageId, { key: value });
+
+      // Assert
+      expect(MessageModel.updatePluginState).toHaveBeenCalledWith(mockMessageId, { key: value });
+      expect(result).toEqual({ ...mockMessage, pluginState: newPluginState });
+    });
+  });
+
+  describe('updateMessagePluginArguments', () => {
+    it('should update the plugin arguments object of a message', async () => {
+      // Setup
+      const key = 'stateKey';
+      const value = 'stateValue';
+      (MessageModel.updatePlugin as Mock).mockResolvedValue({});
+
+      // Execute
+      await messageService.updateMessagePluginArguments(mockMessageId, { key: value });
+
+      // Assert
+      expect(MessageModel.updatePlugin).toHaveBeenCalledWith(mockMessageId, {
+        arguments: '{"key":"stateValue"}',
+      });
+    });
+    it('should update the plugin arguments string of a message', async () => {
+      // Setup
+      const key = 'stateKey';
+      const value = 'stateValue';
+      (MessageModel.updatePlugin as Mock).mockResolvedValue({});
+
+      // Execute
+      await messageService.updateMessagePluginArguments(
+        mockMessageId,
+        JSON.stringify({ key: value }),
+      );
+
+      // Assert
+      expect(MessageModel.updatePlugin).toHaveBeenCalledWith(mockMessageId, {
+        arguments: '{"key":"stateValue"}',
+      });
+    });
+  });
+
+  describe('countMessages', () => {
+    it('should count the total number of messages', async () => {
+      // Setup
+      const mockCount = 10;
+      (MessageModel.count as Mock).mockResolvedValue(mockCount);
+
+      // Execute
+      const count = await messageService.countMessages();
+
+      // Assert
+      expect(MessageModel.count).toHaveBeenCalled();
+      expect(count).toBe(mockCount);
+    });
+  });
+
+  describe('countTodayMessages', () => {
+    it('should count the number of messages created today', async () => {
+      // Setup
+      const today = dayjs().format('YYYY-MM-DD');
+      const mockMessages = [
+        { ...mockMessage, createdAt: today },
+        { ...mockMessage, createdAt: today },
+        { ...mockMessage, createdAt: '2023-01-01' },
+      ];
+      (MessageModel.queryAll as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const count = await messageService.countTodayMessages();
+
+      // Assert
+      expect(MessageModel.queryAll).toHaveBeenCalled();
+      expect(count).toBe(2);
+    });
+  });
+
+  describe('updateMessageTTS', () => {
+    it('should update the TTS field of a message', async () => {
+      // Setup
+      const newTTS: ChatTTS = {
+        contentMd5: 'abc',
+        file: 'file-abc',
+      };
+
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, tts: newTTS });
+
+      // Execute
+      const result = await messageService.updateMessageTTS(mockMessageId, newTTS);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { tts: newTTS });
+      expect(result).toEqual({ ...mockMessage, tts: newTTS });
+    });
+  });
+
+  describe('updateMessageTranslate', () => {
+    it('should update the translate field of a message', async () => {
+      // Setup
+      const newTranslate: ChatTranslate = {
+        content: 'Translated text',
+        to: 'es',
+      };
+
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, translate: newTranslate });
+
+      // Execute
+      const result = await messageService.updateMessageTranslate(mockMessageId, newTranslate);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { translate: newTranslate });
+      expect(result).toEqual({ ...mockMessage, translate: newTranslate });
+    });
+  });
+
+  describe('hasMessages', () => {
+    it('should return true if there are messages', async () => {
+      // Setup
+      (MessageModel.count as Mock).mockResolvedValue(1);
+
+      // Execute
+      const result = await messageService.hasMessages();
+
+      // Assert
+      expect(result).toBe(true);
+    });
+
+    it('should return false if there are no messages', async () => {
+      // Setup
+      (MessageModel.count as Mock).mockResolvedValue(0);
+
+      // Execute
+      const result = await messageService.hasMessages();
+
+      // Assert
+      expect(result).toBe(false);
+    });
+  });
+});