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

package/src/database/_deprecated/models/__tests__/topic.test.ts

@@ -1,523 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { DBModel } from '@/database/_deprecated/core/types/db';
-import { CreateMessageParams, MessageModel } from '@/database/_deprecated/models/message';
-import { DB_Message } from '@/database/_deprecated/schemas/message';
-import { DB_Topic } from '@/database/_deprecated/schemas/topic';
-import { nanoid } from '@/utils/uuid';
-import * as uuidUtils from '@/utils/uuid';
-
-import { CreateTopicParams, QueryTopicParams, TopicModel } from '../topic';
-
-describe('TopicModel', () => {
-  let topicData: CreateTopicParams;
-  const currentSessionId = 'session1';
-  beforeEach(() => {
-    // Set up topic data with the correct structure
-    topicData = {
-      sessionId: currentSessionId,
-      title: 'Test Topic',
-      favorite: false,
-    };
-  });
-
-  afterEach(async () => {
-    // Clean up the database after each test
-    await TopicModel.clearTable();
-  });
-
-  describe('create', () => {
-    it('should create a topic record', async () => {
-      const result = await TopicModel.create(topicData);
-
-      expect(result).toHaveProperty('id');
-      // Verify that the topic has been added to the database
-      const topicInDb = await TopicModel.findById(result.id);
-
-      expect(topicInDb).toEqual(
-        expect.objectContaining({
-          title: topicData.title,
-          favorite: topicData.favorite ? 1 : 0,
-          sessionId: topicData.sessionId,
-        }),
-      );
-    });
-
-    it('should create a topic with favorite set to true', async () => {
-      const favoriteTopicData: CreateTopicParams = {
-        ...topicData,
-        favorite: true,
-      };
-      const result = await TopicModel.create(favoriteTopicData);
-
-      expect(result).toHaveProperty('id');
-      const topicInDb = await TopicModel.findById(result.id);
-      expect(topicInDb).toEqual(
-        expect.objectContaining({
-          title: favoriteTopicData.title,
-          favorite: 1,
-          sessionId: favoriteTopicData.sessionId,
-        }),
-      );
-    });
-
-    it('should update messages with the new topic id when messages are provided', async () => {
-      const messagesToUpdate = [nanoid(), nanoid()];
-      // 假设这些消息存在于数据库中
-      for (const messageId of messagesToUpdate) {
-        await MessageModel.table.add({ id: messageId, text: 'Sample message', topicId: null });
-      }
-
-      const topicDataWithMessages = {
-        ...topicData,
-        messages: messagesToUpdate,
-      };
-
-      const topic = await TopicModel.create(topicDataWithMessages);
-      expect(topic).toHaveProperty('id');
-
-      // 验证数据库中的消息是否已更新
-      const updatedMessages: DB_Message[] = await MessageModel.table
-        .where('id')
-        .anyOf(messagesToUpdate)
-        .toArray();
-
-      expect(updatedMessages).toHaveLength(messagesToUpdate.length);
-      for (const message of updatedMessages) {
-        expect(message.topicId).toEqual(topic.id);
-      }
-    });
-
-    it('should create a topic with a unique id when no id is provided', async () => {
-      const spy = vi.spyOn(uuidUtils, 'nanoid'); // 使用 Vitest 的 spy 功能来监视 nanoid 调用
-      const result = await TopicModel.create(topicData);
-
-      expect(spy).toHaveBeenCalled(); // 验证 nanoid 被调用来生成 id
-      expect(result).toHaveProperty('id');
-      expect(typeof result.id).toBe('string');
-      spy.mockRestore(); // 测试结束后恢复原始行为
-    });
-  });
-  describe('batch create', () => {
-    it('should batch create topic records', async () => {
-      const topicsToCreate = [topicData, topicData];
-      const results = await TopicModel.batchCreate(topicsToCreate);
-
-      expect(results.ids).toHaveLength(topicsToCreate.length);
-      // Verify that the topics have been added to the database
-      for (const result of results.ids!) {
-        const topicInDb = await TopicModel.findById(result);
-        expect(topicInDb).toEqual(
-          expect.objectContaining({
-            title: topicData.title,
-            favorite: topicData.favorite ? 1 : 0,
-            sessionId: topicData.sessionId,
-          }),
-        );
-      }
-    });
-
-    it('should batch create topics with mixed favorite values', async () => {
-      const mixedTopicsData: CreateTopicParams[] = [
-        { ...topicData, favorite: true },
-        { ...topicData, favorite: false },
-      ];
-
-      const results = await TopicModel.batchCreate(mixedTopicsData);
-
-      expect(results.ids).toHaveLength(mixedTopicsData.length);
-      for (const id of results.ids!) {
-        const topicInDb = await TopicModel.findById(id);
-        expect(topicInDb).toBeDefined();
-        expect(topicInDb.favorite).toBeGreaterThanOrEqual(0);
-        expect(topicInDb.favorite).toBeLessThanOrEqual(1);
-      }
-    });
-  });
-
-  it('should query topics with pagination', async () => {
-    // Create multiple topics to test the query method
-    await TopicModel.batchCreate([topicData, topicData]);
-
-    const queryParams: QueryTopicParams = { pageSize: 1, current: 0, containerId: 'session1' };
-    const queriedTopics = await TopicModel.query(queryParams);
-
-    expect(queriedTopics).toHaveLength(1);
-  });
-
-  it('should find topics by session id', async () => {
-    // Create multiple topics to test the findBySessionId method
-    await TopicModel.batchCreate([topicData, topicData]);
-
-    const topicsBySessionId = await TopicModel.findBySessionId(topicData.sessionId);
-
-    expect(topicsBySessionId).toHaveLength(2);
-    expect(topicsBySessionId.every((i) => i.sessionId === topicData.sessionId)).toBeTruthy();
-  });
-
-  it('should delete a topic and its associated messages', async () => {
-    const createdTopic = await TopicModel.create(topicData);
-
-    await TopicModel.delete(createdTopic.id);
-
-    // Verify the topic and its related messages are deleted
-    const topicInDb = await TopicModel.findById(createdTopic.id);
-    expect(topicInDb).toBeUndefined();
-
-    // You need to verify that messages related to the topic are also deleted
-    // This would require additional setup to create messages associated with the topic
-    // and then assertions to check that they're deleted after the topic itself is deleted
-  });
-
-  it('should batch delete topics by session id', async () => {
-    // Create multiple topics to test the batchDeleteBySessionId method
-    await TopicModel.batchCreate([topicData, topicData]);
-
-    await TopicModel.batchDeleteBySessionId(topicData.sessionId);
-
-    // Verify that all topics with the given session id are deleted
-    const topicsInDb = await TopicModel.findBySessionId(topicData.sessionId);
-    expect(topicsInDb).toHaveLength(0);
-  });
-
-  it('should update a topic', async () => {
-    const createdTopic = await TopicModel.create(topicData);
-    const updateData = { title: 'New Title' };
-
-    await TopicModel.update(createdTopic.id, updateData);
-    const updatedTopic = await TopicModel.findById(createdTopic.id);
-
-    expect(updatedTopic).toHaveProperty('title', 'New Title');
-  });
-
-  describe('toggleFavorite', () => {
-    it('should toggle favorite status of a topic', async () => {
-      const createdTopic = await TopicModel.create(topicData);
-
-      const newState = await TopicModel.toggleFavorite(createdTopic.id);
-
-      expect(newState).toBe(true);
-      const topicInDb = await TopicModel.findById(createdTopic.id);
-      expect(topicInDb).toHaveProperty('favorite', 1);
-    });
-
-    it('should handle toggleFavorite when topic does not exist', async () => {
-      const nonExistentTopicId = 'non-existent-id';
-      await expect(TopicModel.toggleFavorite(nonExistentTopicId)).rejects.toThrow(
-        `Topic with id ${nonExistentTopicId} not found`,
-      );
-    });
-
-    it('should set favorite to specific state using toggleFavorite', async () => {
-      const createdTopic = await TopicModel.create(topicData);
-
-      // Set favorite to true regardless of current state
-      await TopicModel.toggleFavorite(createdTopic.id, true);
-      let topicInDb = await TopicModel.findById(createdTopic.id);
-      expect(topicInDb.favorite).toBe(1);
-
-      // Set favorite to false regardless of current state
-      await TopicModel.toggleFavorite(createdTopic.id, false);
-      topicInDb = await TopicModel.findById(createdTopic.id);
-      expect(topicInDb.favorite).toBe(0);
-    });
-  });
-
-  it('should delete a topic and its associated messages', async () => {
-    // 创建话题和相关联的消息
-    const createdTopic = await TopicModel.create(topicData);
-    const messageData: CreateMessageParams = {
-      content: 'Test Message',
-      topicId: createdTopic.id,
-      sessionId: topicData.sessionId,
-      role: 'user',
-    };
-    await MessageModel.create(messageData);
-
-    // 删除话题
-    await TopicModel.delete(createdTopic.id);
-
-    // 验证话题是否被删除
-    const topicInDb = await TopicModel.findById(createdTopic.id);
-    expect(topicInDb).toBeUndefined();
-
-    // 验证与话题关联的消息是否也被删除
-    const messagesInDb = await MessageModel.query({
-      sessionId: topicData.sessionId,
-      topicId: createdTopic.id,
-    });
-    expect(messagesInDb).toHaveLength(0);
-  });
-
-  it('should batch delete topics and their associated messages', async () => {
-    // 创建多个话题和相关联的消息
-    const createdTopic1 = await TopicModel.create(topicData);
-    const createdTopic2 = await TopicModel.create(topicData);
-
-    const messageData1: CreateMessageParams = {
-      content: 'Test Message 1',
-      topicId: createdTopic1.id,
-      sessionId: topicData.sessionId,
-      role: 'user',
-    };
-    const messageData2: CreateMessageParams = {
-      content: 'Test Message 2',
-      topicId: createdTopic2.id,
-      sessionId: topicData.sessionId,
-      role: 'user',
-    };
-    await MessageModel.create(messageData1);
-    await MessageModel.create(messageData2);
-
-    // 执行批量删除
-    await TopicModel.batchDelete([createdTopic1.id, createdTopic2.id]);
-
-    // 验证话题是否被删除
-    const topicInDb1 = await TopicModel.findById(createdTopic1.id);
-    const topicInDb2 = await TopicModel.findById(createdTopic2.id);
-    expect(topicInDb1).toBeUndefined();
-    expect(topicInDb2).toBeUndefined();
-
-    // 验证与话题关联的消息是否也被删除
-    const messagesInDb1 = await MessageModel.query({
-      sessionId: topicData.sessionId,
-      topicId: createdTopic1.id,
-    });
-    const messagesInDb2 = await MessageModel.query({
-      sessionId: topicData.sessionId,
-      topicId: createdTopic2.id,
-    });
-    expect(messagesInDb1).toHaveLength(0);
-    expect(messagesInDb2).toHaveLength(0);
-  });
-
-  describe('duplicateTopic', () => {
-    let originalTopic: DBModel<DB_Topic>;
-    let originalMessages: any[];
-
-    beforeEach(async () => {
-      // 创建一个原始主题
-      const { id } = await TopicModel.create({
-        title: 'Original Topic',
-        sessionId: 'session1',
-        favorite: false,
-      });
-      originalTopic = await TopicModel.findById(id);
-
-      // 创建一些关联到原始主题的消息
-      originalMessages = await Promise.all(
-        ['Message 1', 'Message 2'].map((text) =>
-          MessageModel.create({
-            content: text,
-            topicId: originalTopic.id,
-            sessionId: originalTopic.sessionId!,
-            role: 'user',
-          }),
-        ),
-      );
-    });
-
-    afterEach(async () => {
-      // 清理数据库中的所有主题和消息
-      await TopicModel.clearTable();
-      await MessageModel.clearTable();
-    });
-
-    it('should duplicate a topic with all associated messages', async () => {
-      // 执行复制操作
-      await TopicModel.duplicateTopic(originalTopic.id);
-
-      // 验证复制后的主题是否存在
-      const duplicatedTopic = await TopicModel.findBySessionId(originalTopic.sessionId!);
-      expect(duplicatedTopic).toHaveLength(2);
-
-      // 验证复制后的消息是否存在
-      const duplicatedMessages = await MessageModel.query({
-        sessionId: originalTopic.sessionId!,
-        topicId: duplicatedTopic[1].id, // 假设复制的主题是第二个
-      });
-      expect(duplicatedMessages).toHaveLength(originalMessages.length);
-    });
-
-    it('should throw an error if the topic does not exist', async () => {
-      // 尝试复制一个不存在的主题
-      const nonExistentTopicId = nanoid();
-      await expect(TopicModel.duplicateTopic(nonExistentTopicId)).rejects.toThrow(
-        `Topic with id ${nonExistentTopicId} not found`,
-      );
-    });
-
-    it('should preserve the properties of the duplicated topic', async () => {
-      // 执行复制操作
-      await TopicModel.duplicateTopic(originalTopic.id);
-
-      // 获取复制的主题
-      const topics = await TopicModel.findBySessionId(originalTopic.sessionId!);
-      const duplicatedTopic = topics.find((topic) => topic.id !== originalTopic.id);
-
-      // 验证复制的主题是否保留了原始主题的属性
-      expect(duplicatedTopic).toBeDefined();
-      expect(duplicatedTopic).toMatchObject({
-        title: originalTopic.title,
-        favorite: originalTopic.favorite,
-        sessionId: originalTopic.sessionId,
-      });
-      // 确保生成了新的 ID
-      expect(duplicatedTopic.id).not.toBe(originalTopic.id);
-    });
-
-    it('should properly handle the messages hierarchy when duplicating', async () => {
-      // 创建一个子消息关联到其中一个原始消息
-      const { id } = await MessageModel.create({
-        content: 'Child Message',
-        topicId: originalTopic.id,
-        parentId: originalMessages[0].id,
-        sessionId: originalTopic.sessionId!,
-        role: 'user',
-      });
-      const childMessage = await MessageModel.findById(id);
-
-      // 执行复制操作
-      await TopicModel.duplicateTopic(originalTopic.id);
-
-      // 获取复制的消息
-      const duplicatedMessages = await MessageModel.queryBySessionId(originalTopic.sessionId!);
-
-      // 验证复制的子消息是否存在并且 parentId 已更新
-      const duplicatedChildMessage = duplicatedMessages.find(
-        (message) => message.content === childMessage.content && message.id !== childMessage.id,
-      );
-
-      expect(duplicatedChildMessage).toBeDefined();
-      expect(duplicatedChildMessage.parentId).not.toBe(childMessage.parentId);
-      expect(duplicatedChildMessage.parentId).toBeDefined();
-    });
-
-    it('should fail if the database transaction fails', async () => {
-      // 强制数据库事务失败，例如通过在复制过程中抛出异常
-      const dbTransactionFailedError = new Error('DB transaction failed');
-      const spyOn = vi.spyOn(TopicModel['db'], 'transaction').mockImplementation((async () => {
-        throw dbTransactionFailedError;
-      }) as any);
-
-      // 尝试复制主题并捕捉期望的错误
-      await expect(TopicModel.duplicateTopic(originalTopic.id)).rejects.toThrow(
-        dbTransactionFailedError,
-      );
-      spyOn.mockRestore();
-    });
-
-    it('should not create partial duplicates if the process fails at some point', async () => {
-      // 假设复制消息的过程中发生了错误
-      vi.spyOn(MessageModel, 'duplicateMessages').mockImplementation(async () => {
-        throw new Error('Failed to duplicate messages');
-      });
-
-      // 尝试复制主题，期望会抛出错误
-      await expect(TopicModel.duplicateTopic(originalTopic.id)).rejects.toThrow();
-
-      // 确保没有创建任何副本
-      const topics = await TopicModel.findBySessionId(originalTopic.sessionId!);
-      expect(topics).toHaveLength(1); // 只有原始主题
-
-      const messages = await MessageModel.queryBySessionId(originalTopic.sessionId!);
-      expect(messages).toHaveLength(originalMessages.length); // 只有原始消息
-    });
-  });
-
-  describe('clearTable', () => {
-    it('should clear the table', async () => {
-      // Create a topic to ensure the table is not empty
-      await TopicModel.create(topicData);
-
-      // Clear the table
-      await TopicModel.clearTable();
-
-      // Verify the table is empty
-      const topics = await TopicModel.queryAll();
-      expect(topics).toHaveLength(0);
-    });
-  });
-
-  describe('update', () => {
-    it('should update a topic', async () => {
-      // Create a topic
-      const createdTopic = await TopicModel.create(topicData);
-
-      // Update the topic
-      const newTitle = 'Updated Title';
-      await TopicModel.update(createdTopic.id, { title: newTitle });
-
-      // Verify the topic is updated
-      const updatedTopic = await TopicModel.findById(createdTopic.id);
-      expect(updatedTopic.title).toBe(newTitle);
-    });
-  });
-
-  describe('batchDelete', () => {
-    it('should batch delete topics', async () => {
-      // Create multiple topics
-      const topic1 = await TopicModel.create(topicData);
-      const topic2 = await TopicModel.create(topicData);
-
-      await TopicModel.create(topicData);
-
-      const ids = [topic1.id, topic2.id];
-      // Batch delete the topics
-      await TopicModel.batchDelete(ids);
-
-      expect(await TopicModel.table.count()).toEqual(1);
-    });
-  });
-
-  describe('queryAll', () => {
-    it('should query all topics', async () => {
-      // Create multiple topics
-      await TopicModel.batchCreate([topicData, topicData]);
-
-      // Query all topics
-      const topics = await TopicModel.queryAll();
-
-      // Verify all topics are queried
-      expect(topics).toHaveLength(2);
-    });
-  });
-
-  describe('queryByKeyword', () => {
-    it('should query global topics by keyword', async () => {
-      // Create a topic with a unique title
-      const uniqueTitle = 'Unique Title';
-      await TopicModel.create({ ...topicData, title: uniqueTitle });
-
-      // Query topics by the unique title
-      const topics = await TopicModel.queryByKeyword(uniqueTitle);
-
-      // Verify the correct topic is queried
-      expect(topics).toHaveLength(1);
-      expect(topics[0].title).toBe(uniqueTitle);
-    });
-    it('should query topics in current session by keyword', async () => {
-      // Create a topic with a unique title
-      const uniqueTitle = 'Unique Title';
-      await TopicModel.create({ ...topicData, title: uniqueTitle });
-
-      // Query topics by the unique title
-      const topics = await TopicModel.queryByKeyword(uniqueTitle, currentSessionId);
-
-      // Verify the correct topic is queried
-      expect(topics).toHaveLength(1);
-      expect(topics[0].title).toBe(uniqueTitle);
-    });
-    it('should not query any topic in other session by keyword', async () => {
-      // Create a topic with a unique title
-      const uniqueTitle = 'Unique Title';
-      await TopicModel.create({ ...topicData, title: uniqueTitle });
-
-      // Query topics by the unique title
-      const topics = await TopicModel.queryByKeyword(uniqueTitle, 'session-id-2');
-
-      // Verify the correct topic is queried
-      expect(topics).toHaveLength(0);
-    });
-  });
-});

package/src/database/_deprecated/models/__tests__/user.test.ts

@@ -1,82 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { UserModel } from '../user';
-
-describe('UserModel', () => {
-  let userData: any;
-
-  beforeEach(() => {
-    // Set up user data with the correct structure
-    userData = {
-      uuid: 'user1',
-      settings: {},
-      avatar: 'avatar.png',
-    };
-  });
-
-  afterEach(async () => {
-    // Clean up the database after each test
-    await UserModel.clear();
-  });
-
-  it('should create a user record', async () => {
-    const result = await UserModel.create(userData);
-
-    expect(result).toEqual(1);
-    // Verify that the user has been added to the database
-    const userInDb = await UserModel.getUser();
-
-    expect(userInDb).toEqual(
-      expect.objectContaining({
-        uuid: userData.uuid,
-        settings: userData.settings,
-        avatar: userData.avatar,
-      }),
-    );
-  });
-
-  it('should update a user record', async () => {
-    const result = await UserModel.create(userData);
-
-    const newAvatar = 'new_avatar.png';
-    await UserModel.updateAvatar(newAvatar);
-
-    const userInDb = await UserModel.getUser();
-
-    expect(userInDb).toHaveProperty('avatar', newAvatar);
-  });
-
-  it('should update user settings', async () => {
-    await UserModel.create(userData);
-
-    await UserModel.updateSettings({ general: { themeMode: 'dark' } });
-
-    const userInDb = await UserModel.getUser();
-
-    expect(userInDb).toHaveProperty('settings', {
-      general: { themeMode: 'dark' },
-    });
-  });
-
-  it('should reset user settings', async () => {
-    await UserModel.create(userData);
-
-    await UserModel.updateSettings({ general: { themeMode: 'dark' } });
-
-    await UserModel.resetSettings();
-
-    const userInDb = await UserModel.getUser();
-
-    expect(userInDb.settings).toBeUndefined();
-  });
-
-  it('should clear the user table', async () => {
-    await UserModel.create(userData);
-
-    await UserModel.clear();
-
-    const userInDb = await UserModel.table.count();
-
-    expect(userInDb).toEqual(0);
-  });
-});

package/src/database/_deprecated/models/file.ts

@@ -1,51 +0,0 @@
-import { DBModel } from '@/database/_deprecated/core/types/db';
-import { DB_File, DB_FileSchema } from '@/database/_deprecated/schemas/files';
-import { clientS3Storage } from '@/services/file/ClientS3';
-import { nanoid } from '@/utils/uuid';
-
-import { BaseModel } from '../core';
-
-class _FileModel extends BaseModel<'files'> {
-  constructor() {
-    super('files', DB_FileSchema);
-  }
-
-  async create(file: DB_File) {
-    const id = nanoid();
-
-    return this._addWithSync(file, `file-${id}`);
-  }
-
-  async findById(id: string): Promise<DBModel<DB_File> | undefined> {
-    const item = await this.table.get(id);
-    if (!item) return;
-
-    // arrayBuffer to url
-    let base64;
-    if (!item.data) {
-      const hash = (item.url as string).replace('client-s3://', '');
-      base64 = await this.getBase64ByFileHash(hash);
-    } else {
-      base64 = Buffer.from(item.data).toString('base64');
-    }
-
-    return { ...item, base64, url: `data:${item.fileType};base64,${base64}` };
-  }
-
-  async delete(id: string) {
-    return this.table.delete(id);
-  }
-
-  async clear() {
-    return this.table.clear();
-  }
-
-  private async getBase64ByFileHash(hash: string) {
-    const fileItem = await clientS3Storage.getObject(hash);
-    if (!fileItem) throw new Error('file not found');
-
-    return Buffer.from(await fileItem.arrayBuffer()).toString('base64');
-  }
-}
-
-export const FileModel = new _FileModel();