@lobehub/lobehub 2.0.0-next.3 → 2.0.0-next.30

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.');
-  }
-}

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

@@ -1,410 +0,0 @@
-import {
-  ChatMessageError,
-  ChatTTS,
-  ChatTranslate,
-  CreateMessageParams,
-  DBMessageItem,
-  UIChatMessage,
-} from '@lobechat/types';
-import { and, eq } from 'drizzle-orm';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { clientDB, initializeDB } from '@/database/client/db';
-import {
-  files,
-  messagePlugins,
-  messageTTS,
-  messageTranslates,
-  messages,
-  sessions,
-  topics,
-  users,
-} from '@/database/schemas';
-
-import { ClientService } from './client';
-
-const userId = 'message-db';
-const sessionId = '1';
-const topicId = 'topic-id';
-
-// Mock data
-const mockMessageId = 'mock-message-id';
-const mockMessage = {
-  id: mockMessageId,
-  content: 'Mock message content',
-  sessionId,
-  role: 'user',
-} as UIChatMessage;
-
-const mockMessages = [mockMessage];
-
-beforeEach(async () => {
-  await initializeDB();
-
-  // 在每个测试用例之前，清空表
-  await clientDB.transaction(async (trx) => {
-    await trx.delete(users);
-    await trx.insert(users).values([{ id: userId }, { id: '456' }]);
-
-    await trx.insert(sessions).values([{ id: sessionId, userId }]);
-    await trx.insert(topics).values([{ id: topicId, sessionId, userId }]);
-    await trx.insert(files).values({
-      id: 'f1',
-      userId: userId,
-      url: 'abc',
-      name: 'file-1',
-      fileType: 'image/png',
-      size: 1000,
-    });
-  });
-});
-
-afterEach(async () => {
-  // 在每个测试用例之后，清空表
-  await clientDB.delete(users);
-});
-
-const messageService = new ClientService(userId);
-
-describe('MessageClientService', () => {
-  describe('create', () => {
-    it('should create a message and return its id', async () => {
-      // Setup
-      const createParams: CreateMessageParams = {
-        content: 'New message content',
-        sessionId,
-        role: 'user',
-      };
-
-      // Execute
-      const messageId = await messageService.createMessage(createParams);
-
-      // Assert
-      expect(messageId).toMatch(/^msg_/);
-    });
-  });
-
-  describe('batchCreate', () => {
-    it('should batch create messages', async () => {
-      // Execute
-      await messageService.batchCreateMessages([
-        {
-          content: 'Mock message content',
-          sessionId,
-          role: 'user',
-        },
-        {
-          content: 'Mock message content',
-          sessionId,
-          role: 'user',
-        },
-      ] as DBMessageItem[]);
-      const count = await clientDB.$count(messages);
-
-      // Assert
-      expect(count).toBe(2);
-    });
-  });
-
-  describe('removeMessage', () => {
-    it('should remove a message by id', async () => {
-      // Execute
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      await messageService.removeMessage(mockMessageId);
-
-      // Assert
-      const count = await clientDB.$count(messages);
-
-      expect(count).toBe(0);
-    });
-  });
-  describe('removeMessages', () => {
-    it('should remove a message by id', async () => {
-      // Setup
-      await clientDB.insert(messages).values([
-        { id: mockMessageId, role: 'user', userId },
-        { role: 'assistant', userId },
-      ]);
-
-      // Execute
-      await messageService.removeMessages([mockMessageId]);
-
-      // Assert
-      const count = await clientDB.$count(messages);
-
-      expect(count).toBe(1);
-    });
-  });
-
-  describe('getMessages', () => {
-    it('should retrieve messages by sessionId and topicId', async () => {
-      // Setup
-      await clientDB
-        .insert(messages)
-        .values({ id: mockMessageId, sessionId, topicId, role: 'user', userId });
-
-      // Execute
-      const data = await messageService.getMessages(sessionId, topicId);
-
-      // Assert
-      expect(data[0]).toMatchObject({ id: mockMessageId, role: 'user' });
-    });
-  });
-
-  describe('getAllMessagesInSession', () => {
-    it('should retrieve all messages in a session', async () => {
-      // Setup
-      const sessionId = 'session-id';
-      await clientDB.insert(sessions).values([
-        { id: 'bbb', userId },
-        { id: sessionId, userId },
-      ]);
-      await clientDB.insert(messages).values([
-        { sessionId, topicId, role: 'user', userId },
-        { sessionId, topicId, role: 'assistant', userId },
-        { sessionId: 'bbb', topicId, role: 'assistant', userId },
-      ]);
-
-      // Execute
-      const data = await messageService.getAllMessagesInSession(sessionId);
-
-      // Assert
-      expect(data.length).toBe(2);
-    });
-  });
-
-  describe('removeMessagesByAssistant', () => {
-    it('should batch remove messages by assistantId and topicId', async () => {
-      // Setup
-      const assistantId = 'assistant-id';
-      const sessionId = 'session-id';
-      await clientDB.insert(sessions).values([
-        { id: 'bbb', userId },
-        { id: sessionId, userId },
-      ]);
-      await clientDB.insert(messages).values([
-        { sessionId, topicId, role: 'user', userId },
-        { sessionId, topicId, role: 'assistant', userId },
-        { sessionId: 'bbb', topicId, role: 'assistant', userId },
-      ]);
-
-      // Execute
-      await messageService.removeMessagesByAssistant(sessionId, topicId);
-
-      // Assert
-      const result = await clientDB.query.messages.findMany({
-        where: and(eq(messages.sessionId, sessionId), eq(messages.topicId, topicId)),
-      });
-
-      expect(result.length).toBe(0);
-    });
-  });
-
-  describe('clearAllMessage', () => {
-    it('should clear all messages from the table', async () => {
-      // Setup
-      await clientDB.insert(users).values({ id: 'another' });
-      await clientDB.insert(messages).values([
-        { id: mockMessageId, role: 'user', userId },
-        { role: 'user', userId: 'another' },
-      ]);
-
-      // Execute
-      await messageService.removeAllMessages();
-
-      // Assert
-      const result = await clientDB.query.messages.findMany({
-        where: eq(messages.userId, userId),
-      });
-      expect(result.length).toBe(0);
-    });
-  });
-
-  describe('getAllMessages', () => {
-    it('should retrieve all messages', async () => {
-      await clientDB.insert(messages).values([
-        { sessionId, topicId, content: '1', role: 'user', userId },
-        { sessionId, topicId, content: '2', role: 'assistant', userId },
-      ]);
-
-      // Execute
-      const data = await messageService.getAllMessages();
-
-      // Assert
-      expect(data).toMatchObject([
-        { sessionId, topicId, content: '1', role: 'user', userId },
-        { sessionId, topicId, content: '2', role: 'assistant', userId },
-      ]);
-    });
-  });
-
-  describe('updateMessageError', () => {
-    it('should update the error field of a message', async () => {
-      // Setup
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      const newError = {
-        type: 'InvalidProviderAPIKey',
-        message: 'Error occurred',
-      } as ChatMessageError;
-
-      // Execute
-      await messageService.updateMessageError(mockMessageId, newError);
-
-      // Assert
-      const result = await clientDB.query.messages.findFirst({
-        where: eq(messages.id, mockMessageId),
-      });
-
-      expect(result!.error).toEqual(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
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      await clientDB.insert(messagePlugins).values({ id: mockMessageId, userId });
-      const key = 'stateKey';
-      const value = 'stateValue';
-      const newPluginState = { [key]: value };
-
-      // Execute
-      await messageService.updateMessagePluginState(mockMessageId, { stateKey: value });
-
-      // Assert
-      const result = await clientDB.query.messagePlugins.findFirst({
-        where: eq(messagePlugins.id, mockMessageId),
-      });
-      expect(result!.state).toEqual(newPluginState);
-    });
-  });
-
-  describe('updateMessagePluginArguments', () => {
-    it('should update the plugin arguments object of a message', async () => {
-      // Setup
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      await clientDB.insert(messagePlugins).values({ id: mockMessageId, userId });
-      const value = 'stateValue';
-
-      // Execute
-      await messageService.updateMessagePluginArguments(mockMessageId, { key: value });
-
-      // Assert
-      const result = await clientDB.query.messagePlugins.findFirst({
-        where: eq(messageTTS.id, mockMessageId),
-      });
-      expect(result).toMatchObject({ arguments: '{"key":"stateValue"}' });
-    });
-    it('should update the plugin arguments string of a message', async () => {
-      // Setup
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      await clientDB.insert(messagePlugins).values({ id: mockMessageId, userId });
-      const value = 'stateValue';
-      // Execute
-      await messageService.updateMessagePluginArguments(
-        mockMessageId,
-        JSON.stringify({ abc: value }),
-      );
-
-      // Assert
-      const result = await clientDB.query.messagePlugins.findFirst({
-        where: eq(messageTTS.id, mockMessageId),
-      });
-      expect(result).toMatchObject({ arguments: '{"abc":"stateValue"}' });
-    });
-  });
-
-  describe('countMessages', () => {
-    it('should count the total number of messages', async () => {
-      // Setup
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-
-      // Execute
-      const count = await messageService.countMessages();
-
-      // Assert
-      expect(count).toBe(1);
-    });
-  });
-
-  describe('updateMessageTTS', () => {
-    it('should update the TTS field of a message', async () => {
-      // Setup
-      await clientDB
-        .insert(files)
-        .values({ id: 'file-abc', fileType: 'text', name: 'abc', url: 'abc', size: 100, userId });
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      const newTTS: ChatTTS = { contentMd5: 'abc', file: 'file-abc' };
-
-      // Execute
-      await messageService.updateMessageTTS(mockMessageId, newTTS);
-
-      // Assert
-      const result = await clientDB.query.messageTTS.findFirst({
-        where: eq(messageTTS.id, mockMessageId),
-      });
-
-      expect(result).toMatchObject({ contentMd5: 'abc', fileId: 'file-abc', id: mockMessageId });
-    });
-  });
-
-  describe('updateMessageTranslate', () => {
-    it('should update the translate field of a message', async () => {
-      // Setup
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-      const newTranslate: ChatTranslate = { content: 'Translated text', to: 'es' };
-
-      // Execute
-      await messageService.updateMessageTranslate(mockMessageId, newTranslate);
-
-      // Assert
-      const result = await clientDB.query.messageTranslates.findFirst({
-        where: eq(messageTranslates.id, mockMessageId),
-      });
-
-      expect(result).toMatchObject(newTranslate);
-    });
-  });
-
-  describe('hasMessages', () => {
-    it('should return true if there are messages', async () => {
-      // Setup
-      await clientDB.insert(messages).values({ id: mockMessageId, role: 'user', userId });
-
-      // Execute
-      const result = await messageService.hasMessages();
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should return false if there are no messages', async () => {
-      // Execute
-      const result = await messageService.hasMessages();
-
-      // Assert
-      expect(result).toBe(false);
-    });
-  });
-});