@lobehub/chat 1.37.0 → 1.37.2

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

@@ -1,21 +1,14 @@
+import { eq } from 'drizzle-orm';
 import { DeepPartial } from 'utility-types';
-import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { UserModel } from '@/database/_deprecated/models/user';
+import { clientDB, initializeDB } from '@/database/client/db';
+import { userSettings, users } from '@/database/schemas';
 import { UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
 import { ClientService } from './client';
 
-vi.mock('@/database/_deprecated/models/user', () => ({
-  UserModel: {
-    getUser: vi.fn(),
-    updateSettings: vi.fn(),
-    resetSettings: vi.fn(),
-    updateAvatar: vi.fn(),
-  },
-}));
-
 const mockUser = {
   avatar: 'avatar.png',
   settings: { themeMode: 'light' } as unknown as UserSettings,
@@ -25,63 +18,67 @@ const mockUser = {
 const mockPreference = {
   useCmdEnterToSend: true,
 } as UserPreference;
+const clientService = new ClientService(mockUser.uuid);
 
-describe('ClientService', () => {
-  let clientService: ClientService;
+beforeEach(async () => {
+  vi.clearAllMocks();
 
-  beforeEach(() => {
-    vi.clearAllMocks();
-    clientService = new ClientService();
-  });
+  await initializeDB();
+  await clientDB.delete(users);
 
+  await clientDB.insert(users).values({ id: mockUser.uuid, avatar: 'avatar.png' });
+  await clientDB
+    .insert(userSettings)
+    .values({ id: mockUser.uuid, general: { themeMode: 'light' } });
+});
+
+describe('ClientService', () => {
   it('should get user state correctly', async () => {
-    (UserModel.getUser as Mock).mockResolvedValue(mockUser);
     const spyOn = vi
       .spyOn(clientService['preferenceStorage'], 'getFromLocalStorage')
       .mockResolvedValue(mockPreference);
 
     const userState = await clientService.getUserState();
 
-    expect(userState).toEqual({
+    expect(userState).toMatchObject({
       avatar: mockUser.avatar,
       isOnboard: true,
       canEnablePWAGuide: false,
       hasConversation: false,
       canEnableTrace: false,
       preference: mockPreference,
-      settings: mockUser.settings,
+      settings: { general: { themeMode: 'light' } },
       userId: mockUser.uuid,
     });
-    expect(UserModel.getUser).toHaveBeenCalledTimes(1);
     expect(spyOn).toHaveBeenCalledTimes(1);
   });
 
   it('should update user settings correctly', async () => {
     const settingsPatch: DeepPartial<UserSettings> = { general: { themeMode: 'dark' } };
-    (UserModel.updateSettings as Mock).mockResolvedValue(undefined);
 
     await clientService.updateUserSettings(settingsPatch);
 
-    expect(UserModel.updateSettings).toHaveBeenCalledWith(settingsPatch);
-    expect(UserModel.updateSettings).toHaveBeenCalledTimes(1);
+    const result = await clientDB.query.userSettings.findFirst({
+      where: eq(userSettings.id, mockUser.uuid),
+    });
+
+    expect(result).toMatchObject(settingsPatch);
   });
 
   it('should reset user settings correctly', async () => {
-    (UserModel.resetSettings as Mock).mockResolvedValue(undefined);
-
     await clientService.resetUserSettings();
 
-    expect(UserModel.resetSettings).toHaveBeenCalledTimes(1);
+    const result = await clientDB.query.userSettings.findFirst({
+      where: eq(userSettings.id, mockUser.uuid),
+    });
+
+    expect(result).toBeUndefined();
   });
 
   it('should update user avatar correctly', async () => {
     const newAvatar = 'new-avatar.png';
-    (UserModel.updateAvatar as Mock).mockResolvedValue(undefined);
 
     await clientService.updateAvatar(newAvatar);
-
-    expect(UserModel.updateAvatar).toHaveBeenCalledWith(newAvatar);
-    expect(UserModel.updateAvatar).toHaveBeenCalledTimes(1);
   });
 
   it('should update user preference correctly', async () => {

package/src/services/user/client.ts

@@ -1,49 +1,70 @@
 import { DeepPartial } from 'utility-types';
 
-import { MessageModel } from '@/database/_deprecated/models/message';
-import { SessionModel } from '@/database/_deprecated/models/session';
-import { UserModel } from '@/database/_deprecated/models/user';
+import { clientDB } from '@/database/client/db';
+import { users } from '@/database/schemas';
+import { MessageModel } from '@/database/server/models/message';
+import { SessionModel } from '@/database/server/models/session';
+import { UserModel } from '@/database/server/models/user';
+import { BaseClientService } from '@/services/baseClientService';
 import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 import { AsyncLocalStorage } from '@/utils/localStorage';
 
 import { IUserService } from './type';
 
-export class ClientService implements IUserService {
+export class ClientService extends BaseClientService implements IUserService {
   private preferenceStorage: AsyncLocalStorage<UserPreference>;
 
-  constructor() {
+  private get userModel(): UserModel {
+    return new UserModel(clientDB as any, this.userId);
+  }
+  private get messageModel(): MessageModel {
+    return new MessageModel(clientDB as any, this.userId);
+  }
+  private get sessionModel(): SessionModel {
+    return new SessionModel(clientDB as any, this.userId);
+  }
+
+  constructor(userId?: string) {
+    super(userId);
     this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
   }
 
   async getUserState(): Promise<UserInitializationState> {
-    const user = await UserModel.getUser();
-    const messageCount = await MessageModel.count();
-    const sessionCount = await SessionModel.count();
+    // if user not exist in the db, create one to make sure the user exist
+    await this.makeSureUserExist();
+
+    const state = await this.userModel.getUserState((encryptKeyVaultsStr) =>
+      encryptKeyVaultsStr ? JSON.parse(encryptKeyVaultsStr) : {},
+    );
+
+    const user = await UserModel.findById(clientDB as any, this.userId);
+    const messageCount = await this.messageModel.count();
+    const sessionCount = await this.sessionModel.count();
 
     return {
-      avatar: user.avatar,
+      ...state,
+      avatar: user?.avatar as string,
       canEnablePWAGuide: messageCount >= 4,
       canEnableTrace: messageCount >= 4,
       hasConversation: messageCount > 0 || sessionCount > 0,
       isOnboard: true,
       preference: await this.preferenceStorage.getFromLocalStorage(),
-      settings: user.settings as UserSettings,
-      userId: user.uuid,
     };
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  updateUserSettings = async (patch: DeepPartial<UserSettings>, _?: any) => {
-    return UserModel.updateSettings(patch);
+  updateUserSettings = async (value: DeepPartial<UserSettings>) => {
+    const { keyVaults, ...res } = value;
+
+    return this.userModel.updateSetting({ ...res, keyVaults: JSON.stringify(keyVaults) });
   };
 
   resetUserSettings = async () => {
-    return UserModel.resetSettings();
+    return this.userModel.deleteSetting();
   };
 
   async updateAvatar(avatar: string) {
-    await UserModel.updateAvatar(avatar);
+    await this.userModel.updateUser({ avatar });
   }
 
   async updatePreference(preference: Partial<UserPreference>) {
@@ -54,4 +75,18 @@ export class ClientService implements IUserService {
   async updateGuide(guide: Partial<UserGuide>) {
     throw new Error('Method not implemented.');
   }
+
+  async makeSureUserExist() {
+    const existUsers = await clientDB.query.users.findMany();
+
+    let user: { id: string };
+    if (existUsers.length === 0) {
+      const result = await clientDB.insert(users).values({ id: this.userId }).returning();
+      user = result[0];
+    } else {
+      user = existUsers[0];
+    }
+
+    return user;
+  }
 }

package/src/services/user/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/store/chat/slices/builtinTool/action.test.ts

@@ -2,7 +2,7 @@ import { act, renderHook } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 
 import { fileService } from '@/services/file';
-import { ClientService } from '@/services/file/client';
+import { ClientService } from '@/services/file/_deprecated';
 import { messageService } from '@/services/message';
 import { imageGenerationService } from '@/services/textToImage';
 import { uploadService } from '@/services/upload';

package/src/store/user/slices/common/action.test.ts

@@ -5,7 +5,7 @@ import { withSWR } from '~test-utils';
 
 import { DEFAULT_PREFERENCE } from '@/const/user';
 import { userService } from '@/services/user';
-import { ClientService } from '@/services/user/client';
+import { ClientService } from '@/services/user/_deprecated';
 import { useUserStore } from '@/store/user';
 import { preferenceSelectors } from '@/store/user/selectors';
 import { GlobalServerConfig } from '@/types/serverConfig';

package/src/services/file/pglite.test.ts

@@ -1,198 +0,0 @@
-import { eq } from 'drizzle-orm';
-import { beforeEach, describe, expect, it } from 'vitest';
-
-import { clientDB, initializeDB } from '@/database/client/db';
-import { files, globalFiles, users } from '@/database/schemas';
-import { clientS3Storage } from '@/services/file/ClientS3';
-import { UploadFileParams } from '@/types/files';
-
-import { ClientService } from './pglite';
-
-const userId = 'file-user';
-
-const fileService = new ClientService(userId);
-
-const mockFile = {
-  name: 'mock.png',
-  fileType: 'image/png',
-  size: 1,
-  url: '',
-};
-
-beforeEach(async () => {
-  await initializeDB();
-
-  await clientDB.delete(users);
-  await clientDB.delete(globalFiles);
-  // 创建测试数据
-  await clientDB.transaction(async (tx) => {
-    await tx.insert(users).values({ id: userId });
-  });
-});
-
-describe('FileService', () => {
-  describe('createFile', () => {
-    it('createFile should save the file to the database', async () => {
-      const localFile: UploadFileParams = {
-        name: 'test',
-        fileType: 'image/png',
-        url: '',
-        size: 1,
-        hash: '123',
-      };
-
-      await clientS3Storage.putObject(
-        '123',
-        new File([new ArrayBuffer(1)], 'test.png', { type: 'image/png' }),
-      );
-
-      const result = await fileService.createFile(localFile);
-
-      expect(result).toMatchObject({ url: 'data:image/png;base64,AA==' });
-    });
-
-    it('should throw error when file is not found in storage during base64 conversion', async () => {
-      const localFile: UploadFileParams = {
-        name: 'test',
-        fileType: 'image/png',
-        url: '',
-        size: 1,
-        hash: 'non-existing-hash',
-      };
-
-      // 不调用 clientS3Storage.putObject，模拟文件不存在的情况
-
-      const promise = fileService.createFile(localFile);
-
-      await expect(promise).rejects.toThrow('file not found');
-    });
-  });
-
-  it('removeFile should delete the file from the database', async () => {
-    const fileId = '1';
-    await clientDB.insert(files).values({ id: fileId, userId, ...mockFile });
-
-    await fileService.removeFile(fileId);
-
-    const result = await clientDB.query.files.findFirst({
-      where: eq(files.id, fileId),
-    });
-
-    expect(result).toBeUndefined();
-  });
-
-  describe('getFile', () => {
-    it('should retrieve and convert local file info to FilePreview', async () => {
-      const fileId = 'rwlijweled';
-      const file = {
-        fileType: 'image/png',
-        size: 1,
-        name: 'test.png',
-        url: 'idb://12312/abc.png',
-        hashId: '123tttt',
-      };
-
-      await clientDB.insert(globalFiles).values(file);
-
-      await clientDB.insert(files).values({
-        id: fileId,
-        userId,
-        ...file,
-        createdAt: new Date(1),
-        updatedAt: new Date(2),
-        fileHash: file.hashId,
-      });
-
-      await clientS3Storage.putObject(
-        file.hashId,
-        new File([new ArrayBuffer(1)], file.name, { type: file.fileType }),
-      );
-
-      const result = await fileService.getFile(fileId);
-
-      expect(result).toMatchObject({
-        createdAt: new Date(1),
-        id: 'rwlijweled',
-        size: 1,
-        type: 'image/png',
-        name: 'test.png',
-        updatedAt: new Date(2),
-      });
-    });
-
-    it('should throw an error when the file is not found', async () => {
-      const fileId = 'non-existent';
-
-      const getFilePromise = fileService.getFile(fileId);
-
-      await expect(getFilePromise).rejects.toThrow('file not found');
-    });
-  });
-
-  describe('removeFiles', () => {
-    it('should delete multiple files from the database', async () => {
-      const fileIds = ['1', '2', '3'];
-
-      // 插入测试文件数据
-      await Promise.all(
-        fileIds.map((id) => clientDB.insert(files).values({ id, userId, ...mockFile })),
-      );
-
-      await fileService.removeFiles(fileIds);
-
-      // 验证所有文件都被删除
-      const remainingFiles = await clientDB.query.files.findMany({
-        where: (fields, { inArray }) => inArray(fields.id, fileIds),
-      });
-
-      expect(remainingFiles).toHaveLength(0);
-    });
-  });
-
-  describe('removeAllFiles', () => {
-    it('should clear all files for the user', async () => {
-      // 插入测试文件数据
-      await Promise.all([
-        clientDB.insert(files).values({ id: '1', userId, ...mockFile }),
-        clientDB.insert(files).values({ id: '2', userId, ...mockFile }),
-      ]);
-
-      await fileService.removeAllFiles();
-
-      // 验证用户的所有文件都被删除
-      const remainingFiles = await clientDB.query.files.findMany({
-        where: eq(files.userId, userId),
-      });
-
-      expect(remainingFiles).toHaveLength(0);
-    });
-  });
-
-  describe('checkFileHash', () => {
-    it('should return true if file hash exists', async () => {
-      const hash = 'existing-hash';
-      await clientDB.insert(globalFiles).values({
-        ...mockFile,
-        hashId: hash,
-      });
-      await clientDB.insert(files).values({
-        id: '1',
-        userId,
-        ...mockFile,
-        fileHash: hash,
-      });
-
-      const exists = await fileService.checkFileHash(hash);
-
-      expect(exists).toMatchObject({ isExist: true });
-    });
-
-    it('should return false if file hash does not exist', async () => {
-      const hash = 'non-existing-hash';
-
-      const exists = await fileService.checkFileHash(hash);
-
-      expect(exists).toEqual({ isExist: false });
-    });
-  });
-});

package/src/services/import/pglite.ts

@@ -1,34 +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, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
-
-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 (data: ImporterEntryData, callbacks?: OnImportCallbacks) => {
-    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, duration);
-    } catch (e) {
-      console.error(e);
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as Error;
-
-      callbacks?.onError?.({ code: 'ImportError', httpStatus: 0, message: error.message });
-    }
-  };
-}