@lobehub/chat 1.71.4 → 1.72.0

package/src/database/{server/models → models}/__tests__/message.test.ts

@@ -2,7 +2,8 @@ import dayjs from 'dayjs';
 import { eq } from 'drizzle-orm/expressions';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { getTestDBInstance } from '@/database/server/core/dbForTest';
+import { getTestDB } from '@/database/models/__tests__/_util';
+import { LobeChatDatabase } from '@/database/type';
 import { MessageItem } from '@/types/message';
 import { uuid } from '@/utils/uuid';
 
@@ -21,15 +22,15 @@ import {
   sessions,
   topics,
   users,
-} from '../../../schemas';
-import { MessageModel } from '../message';
+} from '../../schemas';
+import { MessageModel } from '../../server/models/message';
 import { codeEmbedding } from './fixtures/embedding';
 
-let serverDB = await getTestDBInstance();
+const serverDB: LobeChatDatabase = await getTestDB();
 
 const userId = 'message-db';
 const messageModel = new MessageModel(serverDB, userId);
-
+const embeddingsId = uuid();
 beforeEach(async () => {
   // 在每个测试用例之前，清空表
   await serverDB.transaction(async (trx) => {
@@ -49,6 +50,12 @@ beforeEach(async () => {
       fileType: 'image/png',
       size: 1000,
     });
+
+    await trx.insert(embeddings).values({
+      id: embeddingsId,
+      embeddings: codeEmbedding,
+      userId,
+    });
   });
 });
 
@@ -201,13 +208,14 @@ describe('MessageModel', () => {
           { id: 'f-1', url: 'abc', name: 'file-1', userId, fileType: 'image/png', size: 100 },
           { id: 'f-3', url: 'abc', name: 'file-3', userId, fileType: 'image/png', size: 400 },
         ]);
-        await trx
-          .insert(messageTTS)
-          .values([{ id: '1' }, { id: '2', voice: 'a', fileId: 'f-1', contentMd5: 'abc' }]);
+        await trx.insert(messageTTS).values([
+          { id: '1', userId },
+          { id: '2', voice: 'a', fileId: 'f-1', contentMd5: 'abc', userId },
+        ]);
 
         await trx.insert(messagesFiles).values([
-          { fileId: 'f-0', messageId: '1' },
-          { fileId: 'f-3', messageId: '1' },
+          { fileId: 'f-0', messageId: '1', userId },
+          { fileId: 'f-3', messageId: '1', userId },
         ]);
       });
 
@@ -244,10 +252,10 @@ describe('MessageModel', () => {
         ]);
         await trx
           .insert(messageTranslates)
-          .values([{ id: '1', content: 'translated', from: 'en', to: 'zh' }]);
+          .values([{ id: '1', content: 'translated', from: 'en', to: 'zh', userId }]);
         await trx
           .insert(messageTTS)
-          .values([{ id: '1', voice: 'voice1', fileId: 'f1', contentMd5: 'md5' }]);
+          .values([{ id: '1', voice: 'voice1', fileId: 'f1', contentMd5: 'md5', userId }]);
       });
 
       // 调用 query 方法
@@ -281,7 +289,81 @@ describe('MessageModel', () => {
       expect(result3).toHaveLength(0);
     });
 
-    // 补充测试复杂查询场景
+    describe('query with messageQueries', () => {
+      it('should include ragQuery, ragQueryId and ragRawQuery in query results', async () => {
+        // 创建测试数据
+        const messageId = 'msg-with-query';
+        const queryId = uuid();
+
+        await serverDB.insert(messages).values({
+          id: messageId,
+          userId,
+          role: 'user',
+          content: 'test message',
+        });
+
+        await serverDB.insert(messageQueries).values({
+          id: queryId,
+          messageId,
+          userQuery: 'original query',
+          rewriteQuery: 'rewritten query',
+          userId,
+        });
+
+        // 调用 query 方法
+        const result = await messageModel.query();
+
+        // 断言结果
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe(messageId);
+        expect(result[0].ragQueryId).toBe(queryId);
+        expect(result[0].ragQuery).toBe('rewritten query');
+        expect(result[0].ragRawQuery).toBe('original query');
+      });
+
+      it.skip('should handle multiple message queries for the same message', async () => {
+        // 创建测试数据
+        const messageId = 'msg-multi-query';
+        const queryId1 = uuid();
+        const queryId2 = uuid();
+
+        await serverDB.insert(messages).values({
+          id: messageId,
+          userId,
+          role: 'user',
+          content: 'test message',
+        });
+
+        // 创建两个查询，但查询结果应该只包含一个（最新的）
+        await serverDB.insert(messageQueries).values([
+          {
+            id: queryId1,
+            messageId,
+            userQuery: 'original query 1',
+            rewriteQuery: 'rewritten query 1',
+            userId,
+          },
+          {
+            id: queryId2,
+            messageId,
+            userQuery: 'original query 2',
+            rewriteQuery: 'rewritten query 2',
+            userId,
+          },
+        ]);
+
+        // 调用 query 方法
+        const result = await messageModel.query();
+
+        // 断言结果 - 应该只包含最新的查询
+        expect(result).toHaveLength(1);
+        expect(result[0].id).toBe(messageId);
+        expect(result[0].ragQueryId).toBe(queryId2);
+        expect(result[0].ragQuery).toBe('rewritten query 2');
+        expect(result[0].ragRawQuery).toBe('original query 2');
+      });
+    });
+
     it('should handle complex query with multiple joins and file chunks', async () => {
       await serverDB.transaction(async (trx) => {
         const chunk1Id = uuid();
@@ -316,12 +398,14 @@ describe('MessageModel', () => {
         // 关联消息和文件
         await trx.insert(messagesFiles).values({
           messageId: 'msg1',
+          userId,
           fileId: 'file1',
         });
 
         // 创建文件块关联
         await trx.insert(fileChunks).values({
           fileId: 'file1',
+          userId,
           chunkId: chunk1Id,
         });
 
@@ -329,6 +413,7 @@ describe('MessageModel', () => {
         await trx.insert(messageQueries).values({
           id: query1Id,
           messageId: 'msg1',
+          userId,
           userQuery: 'original query',
           rewriteQuery: 'rewritten query',
         });
@@ -339,6 +424,7 @@ describe('MessageModel', () => {
           queryId: query1Id,
           chunkId: chunk1Id,
           similarity: '0.95',
+          userId,
         });
       });
 
@@ -648,6 +734,135 @@ describe('MessageModel', () => {
       expect(pluginResult[0].identifier).toBe('lobe-web-browsing');
       expect(pluginResult[0].state!).toMatchObject(state);
     });
+
+    describe('create with advanced parameters', () => {
+      it('should create a message with custom ID', async () => {
+        const customId = 'custom-msg-id';
+
+        const result = await messageModel.create(
+          {
+            role: 'user',
+            content: 'message with custom ID',
+            sessionId: '1',
+          },
+          customId,
+        );
+
+        expect(result.id).toBe(customId);
+
+        // 验证数据库中的记录
+        const dbResult = await serverDB.select().from(messages).where(eq(messages.id, customId));
+        expect(dbResult).toHaveLength(1);
+        expect(dbResult[0].id).toBe(customId);
+      });
+
+      it.skip('should create a message with file chunks and RAG query ID', async () => {
+        // 创建测试数据
+        const chunkId1 = uuid();
+        const chunkId2 = uuid();
+        const ragQueryId = uuid();
+
+        await serverDB.insert(chunks).values([
+          { id: chunkId1, text: 'chunk text 1' },
+          { id: chunkId2, text: 'chunk text 2' },
+        ]);
+
+        // 调用 create 方法
+        const result = await messageModel.create({
+          role: 'assistant',
+          content: 'message with file chunks',
+          fileChunks: [
+            { id: chunkId1, similarity: 0.95 },
+            { id: chunkId2, similarity: 0.85 },
+          ],
+          ragQueryId,
+          sessionId: '1',
+        });
+
+        // 验证消息创建成功
+        expect(result.id).toBeDefined();
+
+        // 验证消息查询块关联创建成功
+        const queryChunks = await serverDB
+          .select()
+          .from(messageQueryChunks)
+          .where(eq(messageQueryChunks.messageId, result.id));
+
+        expect(queryChunks).toHaveLength(2);
+        expect(queryChunks[0].chunkId).toBe(chunkId1);
+        expect(queryChunks[0].queryId).toBe(ragQueryId);
+        expect(queryChunks[0].similarity).toBe('0.95');
+        expect(queryChunks[1].chunkId).toBe(chunkId2);
+        expect(queryChunks[1].similarity).toBe('0.85');
+      });
+
+      it('should create a message with files', async () => {
+        // 创建测试数据
+        await serverDB.insert(files).values([
+          {
+            id: 'file1',
+            name: 'file1.txt',
+            fileType: 'text/plain',
+            size: 100,
+            url: 'url1',
+            userId,
+          },
+          {
+            id: 'file2',
+            name: 'file2.jpg',
+            fileType: 'image/jpeg',
+            size: 200,
+            url: 'url2',
+            userId,
+          },
+        ]);
+
+        // 调用 create 方法
+        const result = await messageModel.create({
+          role: 'user',
+          content: 'message with files',
+          files: ['file1', 'file2'],
+          sessionId: '1',
+        });
+
+        // 验证消息创建成功
+        expect(result.id).toBeDefined();
+
+        // 验证消息文件关联创建成功
+        const messageFiles = await serverDB
+          .select()
+          .from(messagesFiles)
+          .where(eq(messagesFiles.messageId, result.id));
+
+        expect(messageFiles).toHaveLength(2);
+        expect(messageFiles[0].fileId).toBe('file1');
+        expect(messageFiles[1].fileId).toBe('file2');
+      });
+
+      it('should create a message with custom timestamps', async () => {
+        const customCreatedAt = '2022-05-15T10:30:00Z';
+        const customUpdatedAt = '2022-05-16T11:45:00Z';
+
+        const result = await messageModel.create({
+          role: 'user',
+          content: 'message with custom timestamps',
+          createdAt: customCreatedAt as any,
+          updatedAt: customUpdatedAt as any,
+          sessionId: '1',
+        });
+
+        // 验证数据库中的记录
+        const dbResult = await serverDB.select().from(messages).where(eq(messages.id, result.id));
+
+        // 日期比较需要考虑时区和格式化问题，所以使用 toISOString 进行比较
+        expect(new Date(dbResult[0].createdAt!).toISOString()).toBe(
+          new Date(customCreatedAt).toISOString(),
+        );
+        expect(new Date(dbResult[0].updatedAt!).toISOString()).toBe(
+          new Date(customUpdatedAt).toISOString(),
+        );
+      });
+    });
   });
 
   describe('batchCreateMessages', () => {
@@ -734,10 +949,122 @@ describe('MessageModel', () => {
 
       // 断言结果
       const result = await serverDB.select().from(messages).where(eq(messages.id, '1'));
-      expect(result[0].tools[0].arguments).toBe(
+      expect((result[0].tools as any)[0].arguments).toBe(
         '{"query":"2024 杭州暴雨","searchEngines":["duckduckgo","google","brave"]}',
       );
     });
+
+    describe('update with imageList', () => {
+      it('should update a message and add image files', async () => {
+        // 创建测试数据
+        await serverDB.insert(messages).values({
+          id: 'msg-to-update',
+          userId,
+          role: 'user',
+          content: 'original content',
+        });
+
+        await serverDB.insert(files).values([
+          {
+            id: 'img1',
+            name: 'image1.jpg',
+            fileType: 'image/jpeg',
+            size: 100,
+            url: 'url1',
+            userId,
+          },
+          { id: 'img2', name: 'image2.png', fileType: 'image/png', size: 200, url: 'url2', userId },
+        ]);
+
+        // 调用 update 方法
+        await messageModel.update('msg-to-update', {
+          content: 'updated content',
+          imageList: [
+            { id: 'img1', alt: 'image 1', url: 'url1' },
+            { id: 'img2', alt: 'image 2', url: 'url2' },
+          ],
+        });
+
+        // 验证消息更新成功
+        const updatedMessage = await serverDB
+          .select()
+          .from(messages)
+          .where(eq(messages.id, 'msg-to-update'));
+
+        expect(updatedMessage[0].content).toBe('updated content');
+
+        // 验证消息文件关联创建成功
+        const messageFiles = await serverDB
+          .select()
+          .from(messagesFiles)
+          .where(eq(messagesFiles.messageId, 'msg-to-update'));
+
+        expect(messageFiles).toHaveLength(2);
+        expect(messageFiles[0].fileId).toBe('img1');
+        expect(messageFiles[1].fileId).toBe('img2');
+      });
+
+      it('should handle empty imageList', async () => {
+        // 创建测试数据
+        await serverDB.insert(messages).values({
+          id: 'msg-no-images',
+          userId,
+          role: 'user',
+          content: 'original content',
+        });
+
+        // 调用 update 方法，不提供 imageList
+        await messageModel.update('msg-no-images', {
+          content: 'updated content',
+        });
+
+        // 验证消息更新成功
+        const updatedMessage = await serverDB
+          .select()
+          .from(messages)
+          .where(eq(messages.id, 'msg-no-images'));
+
+        expect(updatedMessage[0].content).toBe('updated content');
+
+        // 验证没有创建消息文件关联
+        const messageFiles = await serverDB
+          .select()
+          .from(messagesFiles)
+          .where(eq(messagesFiles.messageId, 'msg-no-images'));
+
+        expect(messageFiles).toHaveLength(0);
+      });
+
+      it('should update multiple fields at once', async () => {
+        // 创建测试数据
+        await serverDB.insert(messages).values({
+          id: 'msg-multi-update',
+          userId,
+          role: 'user',
+          content: 'original content',
+          model: 'gpt-3.5',
+        });
+
+        // 调用 update 方法，更新多个字段
+        await messageModel.update('msg-multi-update', {
+          content: 'updated content',
+          role: 'assistant',
+          model: 'gpt-4',
+          metadata: { tps: 1 },
+        });
+
+        // 验证消息更新成功
+        const updatedMessage = await serverDB
+          .select()
+          .from(messages)
+          .where(eq(messages.id, 'msg-multi-update'));
+
+        expect(updatedMessage[0].content).toBe('updated content');
+        expect(updatedMessage[0].role).toBe('assistant');
+        expect(updatedMessage[0].model).toBe('gpt-4');
+        expect(updatedMessage[0].metadata).toEqual({ tps: 1 });
+      });
+    });
   });
 
   describe('deleteMessage', () => {
@@ -764,7 +1091,7 @@ describe('MessageModel', () => {
         ]);
         await trx
           .insert(messagePlugins)
-          .values([{ id: '2', toolCallId: 'tool1', identifier: 'plugin-1' }]);
+          .values([{ id: '2', toolCallId: 'tool1', identifier: 'plugin-1', userId }]);
       });
 
       // 调用 deleteMessage 方法
@@ -858,11 +1185,15 @@ describe('MessageModel', () => {
     it('should update the state field in messagePlugins table', async () => {
       // 创建测试数据
       await serverDB.insert(messages).values({ id: '1', content: 'abc', role: 'user', userId });
-      await serverDB
-        .insert(messagePlugins)
-        .values([
-          { id: '1', toolCallId: 'tool1', identifier: 'plugin1', state: { key1: 'value1' } },
-        ]);
+      await serverDB.insert(messagePlugins).values([
+        {
+          id: '1',
+          toolCallId: 'tool1',
+          identifier: 'plugin1',
+          state: { key1: 'value1' },
+          userId,
+        },
+      ]);
 
       // 调用 updatePluginState 方法
       await messageModel.updatePluginState('1', { key2: 'value2' });
@@ -884,11 +1215,15 @@ describe('MessageModel', () => {
     it('should update the state field in messagePlugins table', async () => {
       // 创建测试数据
       await serverDB.insert(messages).values({ id: '1', content: 'abc', role: 'user', userId });
-      await serverDB
-        .insert(messagePlugins)
-        .values([
-          { id: '1', toolCallId: 'tool1', identifier: 'plugin1', state: { key1: 'value1' } },
-        ]);
+      await serverDB.insert(messagePlugins).values([
+        {
+          id: '1',
+          toolCallId: 'tool1',
+          identifier: 'plugin1',
+          state: { key1: 'value1' },
+          userId,
+        },
+      ]);
 
       // 调用 updatePluginState 方法
       await messageModel.updateMessagePlugin('1', { identifier: 'plugin2' });
@@ -939,7 +1274,7 @@ describe('MessageModel', () => {
           .values([{ id: '1', userId, role: 'user', content: 'message 1' }]);
         await trx
           .insert(messageTranslates)
-          .values([{ id: '1', content: 'translated message 1', from: 'en', to: 'zh' }]);
+          .values([{ id: '1', content: 'translated message 1', from: 'en', to: 'zh', userId }]);
       });
 
       // 调用 updateTranslate 方法
@@ -980,7 +1315,7 @@ describe('MessageModel', () => {
           .values([{ id: '1', userId, role: 'user', content: 'message 1' }]);
         await trx
           .insert(messageTTS)
-          .values([{ id: '1', contentMd5: 'md5', fileId: 'f1', voice: 'voice1' }]);
+          .values([{ id: '1', contentMd5: 'md5', fileId: 'f1', voice: 'voice1', userId }]);
       });
 
       // 调用 updateTTS 方法
@@ -997,7 +1332,7 @@ describe('MessageModel', () => {
     it('should delete the message translate record', async () => {
       // 创建测试数据
       await serverDB.insert(messages).values([{ id: '1', role: 'abc', userId }]);
-      await serverDB.insert(messageTranslates).values([{ id: '1' }]);
+      await serverDB.insert(messageTranslates).values([{ id: '1', userId }]);
 
       // 调用 deleteMessageTranslate 方法
       await messageModel.deleteMessageTranslate('1');
@@ -1016,7 +1351,7 @@ describe('MessageModel', () => {
     it('should delete the message TTS record', async () => {
       // 创建测试数据
       await serverDB.insert(messages).values([{ id: '1', role: 'abc', userId }]);
-      await serverDB.insert(messageTTS).values([{ id: '1' }]);
+      await serverDB.insert(messageTTS).values([{ userId, id: '1' }]);
 
       // 调用 deleteMessageTTS 方法
       await messageModel.deleteMessageTTS('1');
@@ -1042,6 +1377,90 @@ describe('MessageModel', () => {
       // 断言结果
       expect(result).toBe(2);
     });
+
+    describe('count with date filters', () => {
+      beforeEach(async () => {
+        // 创建测试数据，包含不同日期的消息
+        await serverDB.insert(messages).values([
+          {
+            id: 'date1',
+            userId,
+            role: 'user',
+            content: 'message 1',
+            createdAt: new Date('2023-01-15'),
+          },
+          {
+            id: 'date2',
+            userId,
+            role: 'user',
+            content: 'message 2',
+            createdAt: new Date('2023-02-15'),
+          },
+          {
+            id: 'date3',
+            userId,
+            role: 'user',
+            content: 'message 3',
+            createdAt: new Date('2023-03-15'),
+          },
+          {
+            id: 'date4',
+            userId,
+            role: 'user',
+            content: 'message 4',
+            createdAt: new Date('2023-04-15'),
+          },
+        ]);
+      });
+
+      it('should count messages with startDate filter', async () => {
+        const result = await messageModel.count({ startDate: '2023-02-01' });
+        expect(result).toBe(3); // 2月15日, 3月15日, 4月15日的消息
+      });
+
+      it('should count messages with endDate filter', async () => {
+        const result = await messageModel.count({ endDate: '2023-03-01' });
+        expect(result).toBe(2); // 1月15日, 2月15日的消息
+      });
+
+      it('should count messages with both startDate and endDate filters', async () => {
+        const result = await messageModel.count({
+          startDate: '2023-02-01',
+          endDate: '2023-03-31',
+        });
+        expect(result).toBe(2); // 2月15日, 3月15日的消息
+      });
+
+      it('should count messages with range filter', async () => {
+        const result = await messageModel.count({
+          range: ['2023-02-01', '2023-04-01'],
+        });
+        expect(result).toBe(2); // 2月15日, 3月15日的消息
+      });
+
+      it('should handle edge cases in date filters', async () => {
+        // 边界日期
+        const result1 = await messageModel.count({
+          startDate: '2023-01-15',
+          endDate: '2023-04-15',
+        });
+        expect(result1).toBe(4); // 包含所有消息
+
+        // 没有消息的日期范围
+        const result2 = await messageModel.count({
+          startDate: '2023-05-01',
+          endDate: '2023-06-01',
+        });
+        expect(result2).toBe(0);
+
+        // 精确到一天
+        const result3 = await messageModel.count({
+          startDate: '2023-01-15',
+          endDate: '2023-01-15',
+        });
+        expect(result3).toBe(1);
+      });
+    });
   });
 
   describe('findMessageQueriesById', () => {
@@ -1068,6 +1487,7 @@ describe('MessageModel', () => {
           userQuery: 'test query',
           rewriteQuery: 'rewritten query',
           embeddingsId: embeddings1Id,
+          userId,
         });
       });
 
@@ -1523,4 +1943,180 @@ describe('MessageModel', () => {
       expect(result3).toBe(true);
     });
   });
+
+  describe('createMessageQuery', () => {
+    it('should create a new message query', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg1',
+        userId,
+        role: 'user',
+        content: 'test message',
+      });
+
+      // 调用 createMessageQuery 方法
+      const result = await messageModel.createMessageQuery({
+        messageId: 'msg1',
+        userQuery: 'original query',
+        rewriteQuery: 'rewritten query',
+        embeddingsId,
+      });
+
+      // 断言结果
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+      expect(result.messageId).toBe('msg1');
+      expect(result.userQuery).toBe('original query');
+      expect(result.rewriteQuery).toBe('rewritten query');
+      expect(result.userId).toBe(userId);
+
+      // 验证数据库中的记录
+      const dbResult = await serverDB
+        .select()
+        .from(messageQueries)
+        .where(eq(messageQueries.id, result.id));
+
+      expect(dbResult).toHaveLength(1);
+      expect(dbResult[0].messageId).toBe('msg1');
+      expect(dbResult[0].userQuery).toBe('original query');
+      expect(dbResult[0].rewriteQuery).toBe('rewritten query');
+    });
+
+    it('should create a message query with embeddings ID', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg2',
+        userId,
+        role: 'user',
+        content: 'test message',
+      });
+
+      // 调用 createMessageQuery 方法
+      const result = await messageModel.createMessageQuery({
+        messageId: 'msg2',
+        userQuery: 'test query',
+        rewriteQuery: 'test rewritten query',
+        embeddingsId,
+      });
+
+      // 断言结果
+      expect(result).toBeDefined();
+      expect(result.embeddingsId).toBe(embeddingsId);
+
+      // 验证数据库中的记录
+      const dbResult = await serverDB
+        .select()
+        .from(messageQueries)
+        .where(eq(messageQueries.id, result.id));
+
+      expect(dbResult[0].embeddingsId).toBe(embeddingsId);
+    });
+
+    it('should generate a unique ID for each message query', async () => {
+      // 创建测试数据
+      await serverDB.insert(messages).values({
+        id: 'msg3',
+        userId,
+        role: 'user',
+        content: 'test message',
+      });
+
+      // 连续创建两个消息查询
+      const result1 = await messageModel.createMessageQuery({
+        messageId: 'msg3',
+        userQuery: 'query 1',
+        rewriteQuery: 'rewritten query 1',
+        embeddingsId,
+      });
+
+      const result2 = await messageModel.createMessageQuery({
+        messageId: 'msg3',
+        userQuery: 'query 2',
+        rewriteQuery: 'rewritten query 2',
+        embeddingsId,
+      });
+
+      // 断言结果
+      expect(result1.id).not.toBe(result2.id);
+    });
+  });
+
+  describe('deleteMessageQuery', () => {
+    it('should delete a message query by ID', async () => {
+      // 创建测试数据
+      const queryId = uuid();
+      await serverDB.insert(messages).values({
+        id: 'msg4',
+        userId,
+        role: 'user',
+        content: 'test message',
+      });
+
+      await serverDB.insert(messageQueries).values({
+        id: queryId,
+        messageId: 'msg4',
+        userQuery: 'test query',
+        rewriteQuery: 'rewritten query',
+        userId,
+      });
+
+      // 验证查询已创建
+      const beforeDelete = await serverDB
+        .select()
+        .from(messageQueries)
+        .where(eq(messageQueries.id, queryId));
+
+      expect(beforeDelete).toHaveLength(1);
+
+      // 调用 deleteMessageQuery 方法
+      await messageModel.deleteMessageQuery(queryId);
+
+      // 验证查询已删除
+      const afterDelete = await serverDB
+        .select()
+        .from(messageQueries)
+        .where(eq(messageQueries.id, queryId));
+
+      expect(afterDelete).toHaveLength(0);
+    });
+
+    it('should only delete message queries belonging to the user', async () => {
+      // 创建测试数据 - 其他用户的查询
+      const queryId = uuid();
+      await serverDB.insert(messages).values({
+        id: 'msg5',
+        userId: '456',
+        role: 'user',
+        content: 'test message',
+      });
+
+      await serverDB.insert(messageQueries).values({
+        id: queryId,
+        messageId: 'msg5',
+        userQuery: 'test query',
+        rewriteQuery: 'rewritten query',
+        userId: '456', // 其他用户
+      });
+
+      // 调用 deleteMessageQuery 方法
+      await messageModel.deleteMessageQuery(queryId);
+
+      // 验证查询未被删除
+      const afterDelete = await serverDB
+        .select()
+        .from(messageQueries)
+        .where(eq(messageQueries.id, queryId));
+
+      expect(afterDelete).toHaveLength(1);
+    });
+
+    it('should throw error when deleting non-existent message query', async () => {
+      // 调用 deleteMessageQuery 方法删除不存在的查询
+      try {
+        await messageModel.deleteMessageQuery('non-existent-id');
+      } catch (e) {
+        expect(e).toBeInstanceOf(Error);
+      }
+    });
+  });
 });