@lobehub/lobehub 2.0.0-next.2 → 2.0.0-next.20

package/src/services/import/client.ts

@@ -1,64 +0,0 @@
-import { clientDB } from '@/database/client/db';
-import { DataImporterRepos } from '@/database/repositories/dataImporter';
-import { BaseClientService } from '@/services/baseClientService';
-import { useUserStore } from '@/store/user';
-import { ImportStage } from '@/types/importer';
-
-import { IImportService } from './type';
-
-export class ClientService extends BaseClientService implements IImportService {
-  private get dataImporter(): DataImporterRepos {
-    return new DataImporterRepos(clientDB as any, this.userId);
-  }
-
-  importSettings: IImportService['importSettings'] = async (settings) => {
-    await useUserStore.getState().importAppSettings(settings);
-  };
-
-  importData: IImportService['importData'] = async (data, callbacks) => {
-    callbacks?.onStageChange?.(ImportStage.Importing);
-    const time = Date.now();
-    try {
-      const result = await this.dataImporter.importData(data);
-      const duration = Date.now() - time;
-
-      callbacks?.onStageChange?.(ImportStage.Success);
-      callbacks?.onSuccess?.(result.results, duration);
-    } catch (e) {
-      console.error(e);
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as Error;
-
-      callbacks?.onError?.({ code: 'ImportError', httpStatus: 0, message: error.message });
-    }
-  };
-
-  importPgData: IImportService['importPgData'] = async (
-    data,
-    { callbacks, overwriteExisting } = {},
-  ) => {
-    callbacks?.onStageChange?.(ImportStage.Importing);
-    const time = Date.now();
-    try {
-      const result = await this.dataImporter.importPgData(
-        data,
-        overwriteExisting ? 'override' : 'skip',
-      );
-
-      const duration = Date.now() - time;
-
-      callbacks?.onStageChange?.(ImportStage.Success);
-      if (result.success) {
-        callbacks?.onSuccess?.(result.results, duration);
-      } else {
-        callbacks?.onError?.({ code: 'ImportError', httpStatus: 0, message: result.error.message });
-      }
-    } catch (e) {
-      console.error(e);
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as Error;
-
-      callbacks?.onError?.({ code: 'ImportError', httpStatus: 0, message: error.message });
-    }
-  };
-}

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

@@ -1,398 +0,0 @@
-import {
-  ChatMessageError,
-  ChatPluginPayload,
-  ChatTTS,
-  ChatTranslate,
-  UIChatMessage,
-} from '@lobechat/types';
-import dayjs from 'dayjs';
-import { Mock, describe, expect, it, vi } from 'vitest';
-
-import { CreateMessageParams, MessageModel } from '@/database/_deprecated/models/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 UIChatMessage;
-  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);
-    });
-  });
-});

package/src/services/message/_deprecated.ts

@@ -1,168 +0,0 @@
-import {
-  ChatFileItem,
-  ChatMessageError,
-  ChatTTS,
-  ChatTranslate,
-  CreateMessageParams,
-  CreateNewMessageParams,
-  ModelRankItem,
-  UIChatMessage,
-} from '@lobechat/types';
-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 { IMessageService } from './type';
-
-export class ClientService implements IMessageService {
-  async createMessage(data: CreateMessageParams) {
-    const { id } = await MessageModel.create(data);
-
-    return id;
-  }
-
-  async createNewMessage(data: CreateNewMessageParams) {
-    const { id } = await MessageModel.create(data as any);
-    const messages = await this.getMessages(data.sessionId, data.topicId);
-
-    return { id, messages };
-  }
-
-  // @ts-ignore
-  async batchCreateMessages(messages: UIChatMessage[]) {
-    return MessageModel.batchCreate(messages);
-  }
-
-  async getMessages(sessionId: string, topicId?: string): Promise<UIChatMessage[]> {
-    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[];
-
-    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,
-        })),
-    }));
-  }
-
-  async getGroupMessages(groupId: string, topicId?: string): Promise<UIChatMessage[]> {
-    // For the deprecated service, group messages are the same as regular messages
-    // since the old schema doesn't differentiate between session and group messages
-    return this.getMessages(groupId, topicId);
-  }
-
-  async getAllMessages() {
-    return MessageModel.queryAll();
-  }
-
-  async countMessages() {
-    return MessageModel.count();
-  }
-
-  // @ts-ignore
-  async rankModels(): Promise<ModelRankItem[]> {
-    throw new Error('Method not implemented.');
-  }
-
-  // @ts-ignore
-  async countWords(): Promise<number> {
-    throw new Error('Method not implemented.');
-  }
-
-  // @ts-ignore
-  async getHeatmaps() {
-    throw new Error('Method not implemented.');
-  }
-
-  async countTodayMessages() {
-    const topics = await 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);
-  }
-
-  async updateMessageError(id: string, error: ChatMessageError) {
-    return MessageModel.update(id, { error });
-  }
-
-  // @ts-ignore
-  async updateMessage(id: string, message: Partial<DB_Message>) {
-    return MessageModel.update(id, message);
-  }
-
-  async updateMessageTTS(id: string, tts: Partial<ChatTTS> | false) {
-    return MessageModel.update(id, { tts });
-  }
-
-  async updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false) {
-    return MessageModel.update(id, { translate });
-  }
-
-  async updateMessagePluginState(id: string, value: Record<string, any>) {
-    return 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 });
-  }
-
-  async removeMessage(id: string) {
-    return MessageModel.delete(id);
-  }
-
-  async removeMessages(ids: string[]) {
-    return MessageModel.bulkDelete(ids);
-  }
-
-  async removeMessagesByAssistant(assistantId: string, topicId?: string) {
-    return MessageModel.batchDelete(assistantId, topicId);
-  }
-
-  async removeMessagesByGroup(groupId: string, topicId?: string) {
-    return MessageModel.batchDelete(groupId, topicId);
-  }
-
-  async removeAllMessages() {
-    return MessageModel.clearTable();
-  }
-
-  async hasMessages() {
-    const number = await this.countMessages();
-    return number > 0;
-  }
-
-  async messageCountToCheckTrace() {
-    const number = await this.countMessages();
-    return number >= 4;
-  }
-
-  async updateMessagePluginError() {
-    throw new Error('Method not implemented.');
-  }
-
-  async updateMessageRAG(): Promise<void> {
-    throw new Error('Method not implemented.');
-  }
-}