@lobehub/chat 1.37.0 → 1.37.2

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+### [Version 1.37.2](https://github.com/lobehub/lobe-chat/compare/v1.37.1...v1.37.2)
+
+<sup>Released on **2024-12-22**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Move pglite to client service.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Move pglite to client service, closes [#5133](https://github.com/lobehub/lobe-chat/issues/5133) ([c2ded24](https://github.com/lobehub/lobe-chat/commit/c2ded24))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.37.1](https://github.com/lobehub/lobe-chat/compare/v1.37.0...v1.37.1)
+
+<sup>Released on **2024-12-22**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor the client service to deprecated.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor the client service to deprecated, closes [#5132](https://github.com/lobehub/lobe-chat/issues/5132) ([e603234](https://github.com/lobehub/lobe-chat/commit/e603234))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 1.37.0](https://github.com/lobehub/lobe-chat/compare/v1.36.46...v1.37.0)
 
 <sup>Released on **2024-12-22**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Move pglite to client service."
+      ]
+    },
+    "date": "2024-12-22",
+    "version": "1.37.2"
+  },
+  {
+    "children": {
+      "improvements": [
+        "Refactor the client service to deprecated."
+      ]
+    },
+    "date": "2024-12-22",
+    "version": "1.37.1"
+  },
   {
     "children": {
       "features": [

package/locales/en-US/common.json

@@ -59,14 +59,14 @@
       "features": {
         "knowledgeBase": {
           "desc": "Build your personal knowledge base and easily start conversations with your assistant (coming soon)",
-          "title": "Support for knowledge base conversations, unlock your second brain"
+          "title": "Support for knowledge base conversations"
         },
         "localFirst": {
           "desc": "Chat data is stored entirely in the browser, keeping your data always under your control.",
           "title": "Local first, privacy first"
         },
         "pglite": {
-          "desc": "Built on PGlite, natively supports AI Native advanced features (vector retrieval)",
+          "desc": "Built on PGlite, natively supports AI Native advanced features (vector search)",
           "title": "Next-generation client storage architecture"
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.37.0",
+  "version": "1.37.2",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

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

@@ -0,0 +1,119 @@
+import { Mock, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { fileEnv } from '@/config/file';
+import { FileModel } from '@/database/_deprecated/models/file';
+import { DB_File } from '@/database/_deprecated/schemas/files';
+import { clientS3Storage } from '@/services/file/ClientS3';
+import { serverConfigSelectors } from '@/store/serverConfig/selectors';
+import { createServerConfigStore } from '@/store/serverConfig/store';
+
+import { ClientService } from './_deprecated';
+
+const fileService = new ClientService();
+
+beforeAll(() => {
+  createServerConfigStore();
+});
+// Mocks for the FileModel
+vi.mock('@/database/_deprecated/models/file', () => ({
+  FileModel: {
+    create: vi.fn(),
+    delete: vi.fn(),
+    findById: vi.fn(),
+    clear: vi.fn(),
+  },
+}));
+
+let s3Domain: string;
+
+vi.mock('@/config/file', () => ({
+  fileEnv: {
+    get NEXT_PUBLIC_S3_DOMAIN() {
+      return s3Domain;
+    },
+  },
+}));
+
+// Mocks for the URL and Blob objects
+global.URL.createObjectURL = vi.fn();
+global.Blob = vi.fn();
+
+beforeEach(() => {
+  // Reset all mocks before each test
+  vi.resetAllMocks();
+  s3Domain = '';
+});
+
+describe('FileService', () => {
+  it('createFile should save the file to the database', async () => {
+    const localFile = {
+      name: 'test',
+      fileType: 'image/png',
+      url: 'client-s3://123',
+      size: 1,
+      hash: '123',
+    };
+
+    await clientS3Storage.putObject(
+      '123',
+      new File([new ArrayBuffer(1)], 'test.png', { type: 'image/png' }),
+    );
+
+    (FileModel.create as Mock).mockResolvedValue(localFile);
+
+    const result = await fileService.createFile(localFile);
+
+    expect(result).toEqual({ url: 'data:image/png;base64,AA==' });
+  });
+
+  it('removeFile should delete the file from the database', async () => {
+    const fileId = '1';
+    (FileModel.delete as Mock).mockResolvedValue(true);
+
+    const result = await fileService.removeFile(fileId);
+
+    expect(FileModel.delete).toHaveBeenCalledWith(fileId);
+    expect(result).toBe(true);
+  });
+
+  describe('getFile', () => {
+    it('should retrieve and convert local file info to FilePreview', async () => {
+      const fileId = '1';
+      const fileData = {
+        name: 'test',
+        data: new ArrayBuffer(1),
+        fileType: 'image/png',
+        saveMode: 'local',
+        size: 1,
+        createdAt: 1,
+        updatedAt: 2,
+      } as DB_File;
+
+      (FileModel.findById as Mock).mockResolvedValue(fileData);
+      (global.URL.createObjectURL as Mock).mockReturnValue('blob:test');
+      (global.Blob as Mock).mockImplementation(() => ['test']);
+
+      const result = await fileService.getFile(fileId);
+
+      expect(FileModel.findById).toHaveBeenCalledWith(fileId);
+      expect(result).toEqual({
+        createdAt: new Date(1),
+        id: '1',
+        size: 1,
+        type: 'image/png',
+        name: 'test',
+        url: 'blob:test',
+        updatedAt: new Date(2),
+      });
+    });
+
+    it('should throw an error when the file is not found', async () => {
+      const fileId = 'non-existent';
+      (FileModel.findById as Mock).mockResolvedValue(null);
+
+      const getFilePromise = fileService.getFile(fileId);
+
+      await expect(getFilePromise).rejects.toThrow('file not found');
+    });
+  });
+});

package/src/services/file/{pglite.ts → _deprecated.ts}

@@ -1,31 +1,24 @@
-import { clientDB } from '@/database/client/db';
-import { FileModel } from '@/database/server/models/file';
-import { BaseClientService } from '@/services/baseClientService';
+import { FileModel } from '@/database/_deprecated/models/file';
 import { clientS3Storage } from '@/services/file/ClientS3';
 import { FileItem, UploadFileParams } from '@/types/files';
 
 import { IFileService } from './type';
 
-export class ClientService extends BaseClientService implements IFileService {
-  private get fileModel(): FileModel {
-    return new FileModel(clientDB as any, this.userId);
-  }
-
+export class ClientService implements IFileService {
   async createFile(file: UploadFileParams) {
     // save to local storage
     // we may want to save to a remote server later
-    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,
-    );
+    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);
 
     // get file to base64 url
     const base64 = await this.getBase64ByFileHash(file.hash!);
@@ -36,17 +29,24 @@ export class ClientService extends BaseClientService 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 this.fileModel.findById(id);
+    const item = await FileModel.findById(id);
     if (!item) {
       throw new Error('file not found');
     }
 
-    // arrayBuffer to url
-    const fileItem = await clientS3Storage.getObject(item.fileHash!);
-    if (!fileItem) 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 });
 
-    const url = URL.createObjectURL(fileItem);
+    const url = URL.createObjectURL(blob);
 
     return {
       createdAt: new Date(item.createdAt),
@@ -60,19 +60,15 @@ export class ClientService extends BaseClientService implements IFileService {
   }
 
   async removeFile(id: string) {
-    await this.fileModel.delete(id, false);
+    return FileModel.delete(id);
   }
 
   async removeFiles(ids: string[]) {
-    await this.fileModel.deleteMany(ids, false);
+    await Promise.all(ids.map((id) => FileModel.delete(id)));
   }
 
   async removeAllFiles() {
-    return this.fileModel.clear();
-  }
-
-  async checkFileHash(hash: string) {
-    return this.fileModel.checkHash(hash);
+    return FileModel.clear();
   }
 
   private async getBase64ByFileHash(hash: string) {

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

@@ -1,119 +1,198 @@
-import { Mock, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { eq } from 'drizzle-orm';
+import { beforeEach, describe, expect, it } from 'vitest';
 
-import { fileEnv } from '@/config/file';
-import { FileModel } from '@/database/_deprecated/models/file';
-import { DB_File } from '@/database/_deprecated/schemas/files';
+import { clientDB, initializeDB } from '@/database/client/db';
+import { files, globalFiles, users } from '@/database/schemas';
 import { clientS3Storage } from '@/services/file/ClientS3';
-import { serverConfigSelectors } from '@/store/serverConfig/selectors';
-import { createServerConfigStore } from '@/store/serverConfig/store';
+import { UploadFileParams } from '@/types/files';
 
 import { ClientService } from './client';
 
-const fileService = new ClientService();
+const userId = 'file-user';
 
-beforeAll(() => {
-  createServerConfigStore();
-});
-// Mocks for the FileModel
-vi.mock('@/database/_deprecated/models/file', () => ({
-  FileModel: {
-    create: vi.fn(),
-    delete: vi.fn(),
-    findById: vi.fn(),
-    clear: vi.fn(),
-  },
-}));
-
-let s3Domain: string;
-
-vi.mock('@/config/file', () => ({
-  fileEnv: {
-    get NEXT_PUBLIC_S3_DOMAIN() {
-      return s3Domain;
-    },
-  },
-}));
-
-// Mocks for the URL and Blob objects
-global.URL.createObjectURL = vi.fn();
-global.Blob = vi.fn();
-
-beforeEach(() => {
-  // Reset all mocks before each test
-  vi.resetAllMocks();
-  s3Domain = '';
+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', () => {
-  it('createFile should save the file to the database', async () => {
-    const localFile = {
-      name: 'test',
-      fileType: 'image/png',
-      url: 'client-s3://123',
-      size: 1,
-      hash: '123',
-    };
+  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' }),
+      );
 
-    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==' });
+    });
 
-    (FileModel.create as Mock).mockResolvedValue(localFile);
+    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',
+      };
 
-    const result = await fileService.createFile(localFile);
+      // 不调用 clientS3Storage.putObject，模拟文件不存在的情况
 
-    expect(result).toEqual({ url: 'data:image/png;base64,AA==' });
+      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';
-    (FileModel.delete as Mock).mockResolvedValue(true);
+    await clientDB.insert(files).values({ id: fileId, userId, ...mockFile });
 
-    const result = await fileService.removeFile(fileId);
+    await fileService.removeFile(fileId);
+
+    const result = await clientDB.query.files.findFirst({
+      where: eq(files.id, fileId),
+    });
 
-    expect(FileModel.delete).toHaveBeenCalledWith(fileId);
-    expect(result).toBe(true);
+    expect(result).toBeUndefined();
   });
 
   describe('getFile', () => {
     it('should retrieve and convert local file info to FilePreview', async () => {
-      const fileId = '1';
-      const fileData = {
-        name: 'test',
-        data: new ArrayBuffer(1),
+      const fileId = 'rwlijweled';
+      const file = {
         fileType: 'image/png',
-        saveMode: 'local',
         size: 1,
-        createdAt: 1,
-        updatedAt: 2,
-      } as DB_File;
+        name: 'test.png',
+        url: 'idb://12312/abc.png',
+        hashId: '123tttt',
+      };
 
-      (FileModel.findById as Mock).mockResolvedValue(fileData);
-      (global.URL.createObjectURL as Mock).mockReturnValue('blob:test');
-      (global.Blob as Mock).mockImplementation(() => ['test']);
+      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(FileModel.findById).toHaveBeenCalledWith(fileId);
-      expect(result).toEqual({
+      expect(result).toMatchObject({
         createdAt: new Date(1),
-        id: '1',
+        id: 'rwlijweled',
         size: 1,
         type: 'image/png',
-        name: 'test',
-        url: 'blob:test',
+        name: 'test.png',
         updatedAt: new Date(2),
       });
     });
 
     it('should throw an error when the file is not found', async () => {
       const fileId = 'non-existent';
-      (FileModel.findById as Mock).mockResolvedValue(null);
 
       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 });
+    });
+  });
 });