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

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/import/server.ts

@@ -1,133 +0,0 @@
-import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
-
-import { lambdaClient } from '@/libs/trpc/client';
-import { uploadService } from '@/services/upload';
-import { useUserStore } from '@/store/user';
-import { ImportPgDataStructure } from '@/types/export';
-import { ImportStage, OnImportCallbacks } from '@/types/importer';
-import { uuid } from '@/utils/uuid';
-
-import { IImportService } from './type';
-
-export class ServerService implements IImportService {
-  importSettings: IImportService['importSettings'] = async (settings) => {
-    await useUserStore.getState().importAppSettings(settings);
-  };
-
-  importData: IImportService['importData'] = async (data, callbacks) => {
-    const handleError = (e: unknown) => {
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as DefaultErrorShape;
-
-      callbacks?.onError?.({
-        code: error.data.code,
-        httpStatus: error.data.httpStatus,
-        message: error.message,
-        path: error.data.path,
-      });
-    };
-
-    const totalLength =
-      (data.messages?.length || 0) +
-      (data.sessionGroups?.length || 0) +
-      (data.sessions?.length || 0) +
-      (data.topics?.length || 0);
-
-    if (totalLength < 500) {
-      callbacks?.onStageChange?.(ImportStage.Importing);
-      const time = Date.now();
-      try {
-        const result = await lambdaClient.importer.importByPost.mutate({ data });
-        const duration = Date.now() - time;
-
-        callbacks?.onStageChange?.(ImportStage.Success);
-        callbacks?.onSuccess?.(result.results, duration);
-      } catch (e) {
-        handleError(e);
-      }
-
-      return;
-    }
-
-    await this.uploadData(data, { callbacks, handleError });
-  };
-
-  importPgData: IImportService['importPgData'] = async (
-    data: ImportPgDataStructure,
-    {
-      callbacks,
-    }: {
-      callbacks?: OnImportCallbacks;
-      overwriteExisting?: boolean;
-    } = {},
-  ): Promise<void> => {
-    const handleError = (e: unknown) => {
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as DefaultErrorShape;
-
-      callbacks?.onError?.({
-        code: error.data.code,
-        httpStatus: error.data.httpStatus,
-        message: error.message,
-        path: error.data.path,
-      });
-    };
-
-    const totalLength = Object.values(data.data)
-      .map((d) => d.length)
-      .reduce((a, b) => a + b, 0);
-
-    if (totalLength < 500) {
-      callbacks?.onStageChange?.(ImportStage.Importing);
-      const time = Date.now();
-      try {
-        const result = await lambdaClient.importer.importPgByPost.mutate(data);
-        const duration = Date.now() - time;
-
-        callbacks?.onStageChange?.(ImportStage.Success);
-        callbacks?.onSuccess?.(result.results, duration);
-      } catch (e) {
-        handleError(e);
-      }
-
-      return;
-    }
-
-    await this.uploadData(data, { callbacks, handleError });
-  };
-
-  private uploadData = async (
-    data: object,
-    { callbacks, handleError }: { callbacks?: OnImportCallbacks; handleError: (e: unknown) => any },
-  ) => {
-    // if the data is too large, upload it to S3 and upload by file
-    const filename = `${uuid()}.json`;
-
-    let pathname;
-    try {
-      callbacks?.onStageChange?.(ImportStage.Uploading);
-      const result = await uploadService.uploadDataToS3(data, {
-        filename,
-        onProgress: (status, state) => {
-          callbacks?.onFileUploading?.(state);
-        },
-        pathname: `import_config/${filename}`,
-      });
-      pathname = result.data.path;
-      console.log(pathname);
-    } catch {
-      throw new Error('Upload Error');
-    }
-
-    callbacks?.onStageChange?.(ImportStage.Importing);
-    const time = Date.now();
-    try {
-      const result = await lambdaClient.importer.importByFile.mutate({ pathname });
-      const duration = Date.now() - time;
-      callbacks?.onStageChange?.(ImportStage.Success);
-      callbacks?.onSuccess?.(result.results, duration);
-    } catch (e) {
-      handleError(e);
-    }
-  };
-}

package/src/services/import/type.ts

@@ -1,17 +0,0 @@
-import { ImportPgDataStructure } from '@/types/export';
-import { ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
-
-export interface IImportService {
-  importData(data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void>;
-
-  importPgData(
-    data: ImportPgDataStructure,
-    options?: {
-      callbacks?: OnImportCallbacks;
-      overwriteExisting?: boolean;
-    },
-  ): Promise<void>;
-
-  importSettings(settings: UserSettings): Promise<void>;
-}

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