@lobehub/chat 1.36.31 → 1.36.32

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

@@ -1,4 +1,4 @@
-import { eq, inArray } from 'drizzle-orm';
+import { eq, inArray } from 'drizzle-orm/expressions';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { getTestDBInstance } from '@/database/server/core/dbForTest';

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

@@ -1,4 +1,4 @@
-import { eq } from 'drizzle-orm';
+import { eq } from 'drizzle-orm/expressions';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { INBOX_SESSION_ID } from '@/const/session';

package/src/database/server/models/_template.ts

@@ -45,10 +45,10 @@ export class TemplateModel {
     });
   };
 
-  async update(id: string, value: Partial<SessionGroupItem>) {
+  update = async (id: string, value: Partial<SessionGroupItem>) => {
     return this.db
       .update(sessionGroups)
       .set({ ...value, updatedAt: new Date() })
       .where(and(eq(sessionGroups.id, id), eq(sessionGroups.userId, this.userId)));
-  }
+  };
 }

package/src/database/server/models/agent.ts

@@ -19,15 +19,15 @@ export class AgentModel {
     this.db = db;
   }
 
-  async getAgentConfigById(id: string) {
+  getAgentConfigById = async (id: string) => {
     const agent = await this.db.query.agents.findFirst({ where: eq(agents.id, id) });
 
     const knowledge = await this.getAgentAssignedKnowledge(id);
 
     return { ...agent, ...knowledge };
-  }
+  };
 
-  async getAgentAssignedKnowledge(id: string) {
+  getAgentAssignedKnowledge = async (id: string) => {
     const knowledgeBaseResult = await this.db
       .select({ enabled: agentsKnowledgeBases.enabled, knowledgeBases })
       .from(agentsKnowledgeBases)
@@ -52,12 +52,12 @@ export class AgentModel {
         enabled: item.enabled,
       })),
     };
-  }
+  };
 
   /**
    * Find agent by session id
    */
-  async findBySessionId(sessionId: string) {
+  findBySessionId = async (sessionId: string) => {
     const item = await this.db.query.agentsToSessions.findFirst({
       where: eq(agentsToSessions.sessionId, sessionId),
     });
@@ -66,22 +66,19 @@ export class AgentModel {
     const agentId = item.agentId;
 
     return this.getAgentConfigById(agentId);
-  }
+  };
 
   createAgentKnowledgeBase = async (
     agentId: string,
     knowledgeBaseId: string,
     enabled: boolean = true,
   ) => {
-    return this.db
-      .insert(agentsKnowledgeBases)
-      .values({
-        agentId,
-        enabled,
-        knowledgeBaseId,
-        userId: this.userId,
-      })
-      .execute();
+    return this.db.insert(agentsKnowledgeBases).values({
+      agentId,
+      enabled,
+      knowledgeBaseId,
+      userId: this.userId,
+    });
   };
 
   deleteAgentKnowledgeBase = async (agentId: string, knowledgeBaseId: string) => {
@@ -93,8 +90,7 @@ export class AgentModel {
           eq(agentsKnowledgeBases.knowledgeBaseId, knowledgeBaseId),
           eq(agentsKnowledgeBases.userId, this.userId),
         ),
-      )
-      .execute();
+      );
   };
 
   toggleKnowledgeBase = async (agentId: string, knowledgeBaseId: string, enabled?: boolean) => {
@@ -107,8 +103,7 @@ export class AgentModel {
           eq(agentsKnowledgeBases.knowledgeBaseId, knowledgeBaseId),
           eq(agentsKnowledgeBases.userId, this.userId),
         ),
-      )
-      .execute();
+      );
   };
 
   createAgentFiles = async (agentId: string, fileIds: string[], enabled: boolean = true) => {
@@ -134,8 +129,7 @@ export class AgentModel {
       .insert(agentsFiles)
       .values(
         needToInsertFileIds.map((fileId) => ({ agentId, enabled, fileId, userId: this.userId })),
-      )
-      .execute();
+      );
   };
 
   deleteAgentFile = async (agentId: string, fileId: string) => {
@@ -147,8 +141,7 @@ export class AgentModel {
           eq(agentsFiles.fileId, fileId),
           eq(agentsFiles.userId, this.userId),
         ),
-      )
-      .execute();
+      );
   };
 
   toggleFile = async (agentId: string, fileId: string, enabled?: boolean) => {
@@ -161,7 +154,6 @@ export class AgentModel {
           eq(agentsFiles.fileId, fileId),
           eq(agentsFiles.userId, this.userId),
         ),
-      )
-      .execute();
+      );
   };
 }

package/src/database/server/models/asyncTask.ts

@@ -64,7 +64,7 @@ export class AsyncTaskModel {
   /**
    * make the task status to be `error` if the task is not finished in 20 seconds
    */
-  async checkTimeoutTasks(ids: string[]) {
+  checkTimeoutTasks = async (ids: string[]) => {
     const tasks = await this.db
       .select({ id: asyncTasks.id })
       .from(asyncTasks)
@@ -93,5 +93,5 @@ export class AsyncTaskModel {
           ),
         );
     }
-  }
+  };
 }

package/src/database/server/models/chunk.ts

@@ -76,7 +76,7 @@ export class ChunkModel {
     });
   };
 
-  async findByFileId(id: string, page = 0) {
+  findByFileId = async (id: string, page = 0) => {
     const data = await this.db
       .select({
         abstract: chunks.abstract,
@@ -100,9 +100,9 @@ export class ChunkModel {
 
       return { ...item, metadata, pageNumber: metadata?.pageNumber } as FileChunk;
     });
-  }
+  };
 
-  async getChunksTextByFileId(id: string): Promise<{ id: string; text: string }[]> {
+  getChunksTextByFileId = async (id: string): Promise<{ id: string; text: string }[]> => {
     const data = await this.db
       .select()
       .from(chunks)
@@ -113,9 +113,9 @@ export class ChunkModel {
       .map((item) => item.chunks)
       .map((chunk) => ({ id: chunk.id, text: this.mapChunkText(chunk) }))
       .filter((chunk) => chunk.text) as { id: string; text: string }[];
-  }
+  };
 
-  async countByFileIds(ids: string[]) {
+  countByFileIds = async (ids: string[]) => {
     if (ids.length === 0) return [];
 
     return this.db
@@ -126,9 +126,9 @@ export class ChunkModel {
       .from(fileChunks)
       .where(inArray(fileChunks.fileId, ids))
       .groupBy(fileChunks.fileId);
-  }
+  };
 
-  async countByFileId(ids: string) {
+  countByFileId = async (ids: string) => {
     const data = await this.db
       .select({
         count: count(fileChunks.chunkId),
@@ -139,16 +139,16 @@ export class ChunkModel {
       .groupBy(fileChunks.fileId);
 
     return data[0]?.count ?? 0;
-  }
+  };
 
-  async semanticSearch({
+  semanticSearch = async ({
     embedding,
     fileIds,
   }: {
     embedding: number[];
     fileIds: string[] | undefined;
     query: string;
-  }) {
+  }) => {
     const similarity = sql<number>`1 - (${cosineDistance(embeddings.embeddings, embedding)})`;
 
     const data = await this.db
@@ -174,16 +174,16 @@ export class ChunkModel {
       ...item,
       metadata: item.metadata as ChunkMetadata,
     }));
-  }
+  };
 
-  async semanticSearchForChat({
+  semanticSearchForChat = async ({
     embedding,
     fileIds,
   }: {
     embedding: number[];
     fileIds: string[] | undefined;
     query: string;
-  }) {
+  }) => {
     const similarity = sql<number>`1 - (${cosineDistance(embeddings.embeddings, embedding)})`;
 
     const hasFiles = fileIds && fileIds.length > 0;
@@ -219,7 +219,7 @@ export class ChunkModel {
         text: this.mapChunkText(item),
       };
     });
-  }
+  };
 
   private mapChunkText = (chunk: { metadata: any; text: string | null; type: string | null }) => {
     let text = chunk.text;

package/src/database/server/models/embedding.ts

@@ -50,7 +50,7 @@ export class EmbeddingModel {
     });
   };
 
-  countUsage = async () => {
+  countUsage = async (): Promise<number> => {
     const result = await this.db
       .select({
         count: count(),

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

@@ -1,5 +1,5 @@
-import { asc, count, eq, ilike, inArray, notExists, or, sum } from 'drizzle-orm';
-import { and, desc, like } from 'drizzle-orm/expressions';
+import { count, sum } from 'drizzle-orm';
+import { and, asc, desc, eq, ilike, inArray, like, notExists, or } from 'drizzle-orm/expressions';
 import type { PgTransaction } from 'drizzle-orm/pg-core';
 
 import { LobeChatDatabase } from '@/database/type';
@@ -276,12 +276,11 @@ export class FileModel {
     return result[0].count;
   };
 
-  async update(id: string, value: Partial<FileItem>) {
-    return this.db
+  update = async (id: string, value: Partial<FileItem>) =>
+    this.db
       .update(files)
       .set({ ...value, updatedAt: new Date() })
       .where(and(eq(files.id, id), eq(files.userId, this.userId)));
-  }
 
   /**
    * get the corresponding file type prefix according to FilesTabs
@@ -306,17 +305,16 @@ export class FileModel {
     }
   };
 
-  async findByNames(fileNames: string[]) {
-    return this.db.query.files.findMany({
+  findByNames = async (fileNames: string[]) =>
+    this.db.query.files.findMany({
       where: and(
         or(...fileNames.map((name) => like(files.name, `${name}%`))),
         eq(files.userId, this.userId),
       ),
     });
-  }
 
   // 抽象出通用的删除 chunks 方法
-  private async deleteFileChunks(trx: PgTransaction<any>, fileIds: string[]) {
+  private deleteFileChunks = async (trx: PgTransaction<any>, fileIds: string[]) => {
     const BATCH_SIZE = 1000; // 每批处理的数量
 
     // 1. 获取所有关联的 chunk IDs
@@ -339,5 +337,5 @@ export class FileModel {
     }
 
     return chunkIds;
-  }
+  };
 }

package/src/database/server/models/knowledgeBase.ts

@@ -80,16 +80,14 @@ export class KnowledgeBaseModel {
   };
 
   // update
-  async update(id: string, value: Partial<KnowledgeBaseItem>) {
-    return this.db
+  update = async (id: string, value: Partial<KnowledgeBaseItem>) =>
+    this.db
       .update(knowledgeBases)
       .set({ ...value, updatedAt: new Date() })
       .where(and(eq(knowledgeBases.id, id), eq(knowledgeBases.userId, this.userId)));
-  }
 
-  static async findById(db: LobeChatDatabase, id: string) {
-    return db.query.knowledgeBases.findFirst({
+  static findById = async (db: LobeChatDatabase, id: string) =>
+    db.query.knowledgeBases.findFirst({
       where: eq(knowledgeBases.id, id),
     });
-  }
 }

package/src/database/server/models/message.ts

@@ -46,10 +46,10 @@ export class MessageModel {
   }
 
   // **************** Query *************** //
-  async query(
+  query = async (
     { current = 0, pageSize = 1000, sessionId, topicId }: QueryMessageParams = {},
     options: { postProcessUrl?: (path: string | null) => Promise<string> } = {},
-  ): Promise<MessageItem[]> {
+  ): Promise<MessageItem[]> => {
     const offset = current * pageSize;
 
     // 1. get basic messages
@@ -212,15 +212,15 @@ export class MessageModel {
         };
       },
     );
-  }
+  };
 
-  async findById(id: string) {
+  findById = async (id: string) => {
     return this.db.query.messages.findFirst({
       where: and(eq(messages.id, id), eq(messages.userId, this.userId)),
     });
-  }
+  };
 
-  async findMessageQueriesById(messageId: string) {
+  findMessageQueriesById = async (messageId: string) => {
     const result = await this.db
       .select({
         embeddings: embeddings.embeddings,
@@ -236,47 +236,43 @@ export class MessageModel {
     if (result.length === 0) return undefined;
 
     return result[0];
-  }
+  };
 
-  async queryAll(): Promise<MessageItem[]> {
+  queryAll = async (): Promise<MessageItem[]> => {
     return this.db
       .select()
       .from(messages)
       .orderBy(messages.createdAt)
-      .where(eq(messages.userId, this.userId))
-
-      .execute();
-  }
+      .where(eq(messages.userId, this.userId));
+  };
 
-  async queryBySessionId(sessionId?: string | null): Promise<MessageItem[]> {
+  queryBySessionId = async (sessionId?: string | null): Promise<MessageItem[]> => {
     return this.db.query.messages.findMany({
       orderBy: [asc(messages.createdAt)],
       where: and(eq(messages.userId, this.userId), this.matchSession(sessionId)),
     });
-  }
+  };
 
-  async queryByKeyword(keyword: string): Promise<MessageItem[]> {
+  queryByKeyword = async (keyword: string): Promise<MessageItem[]> => {
     if (!keyword) return [];
-
     return this.db.query.messages.findMany({
       orderBy: [desc(messages.createdAt)],
       where: and(eq(messages.userId, this.userId), like(messages.content, `%${keyword}%`)),
     });
-  }
+  };
 
-  async count() {
+  count = async (): Promise<number> => {
     const result = await this.db
       .select({
-        count: count(),
+        count: count(messages.id),
       })
       .from(messages)
-      .where(eq(messages.userId, this.userId))
-      .execute();
+      .where(eq(messages.userId, this.userId));
 
     return result[0].count;
-  }
+  };
 
-  async countToday() {
+  countToday = async (): Promise<number> => {
     const today = new Date();
     today.setHours(0, 0, 0, 0);
     const tomorrow = new Date(today);
@@ -284,7 +280,7 @@ export class MessageModel {
 
     const result = await this.db
       .select({
-        count: count(),
+        count: count(messages.id),
       })
       .from(messages)
       .where(
@@ -293,15 +289,14 @@ export class MessageModel {
           gte(messages.createdAt, today),
           lt(messages.createdAt, tomorrow),
         ),
-      )
-      .execute();
+      );
 
     return result[0].count;
-  }
+  };
 
   // **************** Create *************** //
 
-  async create(
+  create = async (
     {
       fromModel,
       fromProvider,
@@ -313,7 +308,7 @@ export class MessageModel {
       ...message
     }: CreateMessageParams,
     id: string = this.genId(),
-  ): Promise<MessageItem> {
+  ): Promise<MessageItem> => {
     return this.db.transaction(async (trx) => {
       const [item] = (await trx
         .insert(messages)
@@ -358,31 +353,31 @@ export class MessageModel {
 
       return item;
     });
-  }
+  };
 
-  async batchCreate(newMessages: MessageItem[]) {
+  batchCreate = async (newMessages: MessageItem[]) => {
     const messagesToInsert = newMessages.map((m) => {
       return { ...m, userId: this.userId };
     });
 
     return this.db.insert(messages).values(messagesToInsert);
-  }
+  };
 
-  async createMessageQuery(params: NewMessageQuery) {
+  createMessageQuery = async (params: NewMessageQuery) => {
     const result = await this.db.insert(messageQueries).values(params).returning();
 
     return result[0];
-  }
+  };
   // **************** Update *************** //
 
-  async update(id: string, message: Partial<MessageItem>) {
+  update = async (id: string, message: Partial<MessageItem>) => {
     return this.db
       .update(messages)
       .set(message)
       .where(and(eq(messages.id, id), eq(messages.userId, this.userId)));
-  }
+  };
 
-  async updatePluginState(id: string, state: Record<string, any>) {
+  updatePluginState = async (id: string, state: Record<string, any>) => {
     const item = await this.db.query.messagePlugins.findFirst({
       where: eq(messagePlugins.id, id),
     });
@@ -392,18 +387,18 @@ export class MessageModel {
       .update(messagePlugins)
       .set({ state: merge(item.state || {}, state) })
       .where(eq(messagePlugins.id, id));
-  }
+  };
 
-  async updateMessagePlugin(id: string, value: Partial<MessagePluginItem>) {
+  updateMessagePlugin = async (id: string, value: Partial<MessagePluginItem>) => {
     const item = await this.db.query.messagePlugins.findFirst({
       where: eq(messagePlugins.id, id),
     });
     if (!item) throw new Error('Plugin not found');
 
     return this.db.update(messagePlugins).set(value).where(eq(messagePlugins.id, id));
-  }
+  };
 
-  async updateTranslate(id: string, translate: Partial<MessageItem>) {
+  updateTranslate = async (id: string, translate: Partial<MessageItem>) => {
     const result = await this.db.query.messageTranslates.findFirst({
       where: and(eq(messageTranslates.id, id)),
     });
@@ -415,9 +410,9 @@ export class MessageModel {
 
     // or just update the existing one
     return this.db.update(messageTranslates).set(translate).where(eq(messageTranslates.id, id));
-  }
+  };
 
-  async updateTTS(id: string, tts: Partial<ChatTTS>) {
+  updateTTS = async (id: string, tts: Partial<ChatTTS>) => {
     const result = await this.db.query.messageTTS.findFirst({
       where: and(eq(messageTTS.id, id)),
     });
@@ -434,11 +429,11 @@ export class MessageModel {
       .update(messageTTS)
       .set({ contentMd5: tts.contentMd5, fileId: tts.file, voice: tts.voice })
       .where(eq(messageTTS.id, id));
-  }
+  };
 
   // **************** Delete *************** //
 
-  async deleteMessage(id: string) {
+  deleteMessage = async (id: string) => {
     return this.db.transaction(async (tx) => {
       // 1. 查询要删除的 message 的完整信息
       const message = await tx
@@ -460,8 +455,7 @@ export class MessageModel {
         const res = await tx
           .select({ id: messagePlugins.id })
           .from(messagePlugins)
-          .where(inArray(messagePlugins.toolCallId, toolCallIds))
-          .execute();
+          .where(inArray(messagePlugins.toolCallId, toolCallIds));
 
         relatedMessageIds = res.map((row) => row.id);
       }
@@ -472,28 +466,24 @@ export class MessageModel {
       // 5. 删除所有相关的 message
       await tx.delete(messages).where(inArray(messages.id, messageIdsToDelete));
     });
-  }
+  };
 
-  async deleteMessages(ids: string[]) {
-    return this.db
+  deleteMessages = async (ids: string[]) =>
+    this.db
       .delete(messages)
       .where(and(eq(messages.userId, this.userId), inArray(messages.id, ids)));
-  }
 
-  async deleteMessageTranslate(id: string) {
-    return this.db.delete(messageTranslates).where(and(eq(messageTranslates.id, id)));
-  }
+  deleteMessageTranslate = async (id: string) =>
+    this.db.delete(messageTranslates).where(and(eq(messageTranslates.id, id)));
 
-  async deleteMessageTTS(id: string) {
-    return this.db.delete(messageTTS).where(and(eq(messageTTS.id, id)));
-  }
+  deleteMessageTTS = async (id: string) =>
+    this.db.delete(messageTTS).where(and(eq(messageTTS.id, id)));
 
-  async deleteMessageQuery(id: string) {
-    return this.db.delete(messageQueries).where(and(eq(messageQueries.id, id)));
-  }
+  deleteMessageQuery = async (id: string) =>
+    this.db.delete(messageQueries).where(and(eq(messageQueries.id, id)));
 
-  async deleteMessagesBySession(sessionId?: string | null, topicId?: string | null) {
-    return this.db
+  deleteMessagesBySession = async (sessionId?: string | null, topicId?: string | null) =>
+    this.db
       .delete(messages)
       .where(
         and(
@@ -502,11 +492,10 @@ export class MessageModel {
           this.matchTopic(topicId),
         ),
       );
-  }
 
-  async deleteAllMessages() {
+  deleteAllMessages = async () => {
     return this.db.delete(messages).where(eq(messages.userId, this.userId));
-  }
+  };
 
   // **************** Helper *************** //
 

package/src/database/server/models/plugin.ts

@@ -60,10 +60,10 @@ export class PluginModel {
     });
   };
 
-  async update(id: string, value: Partial<InstalledPluginItem>) {
+  update = async (id: string, value: Partial<InstalledPluginItem>) => {
     return this.db
       .update(installedPlugins)
       .set({ ...value, updatedAt: new Date() })
       .where(and(eq(installedPlugins.identifier, id), eq(installedPlugins.userId, this.userId)));
-  }
+  };
 }

package/src/database/server/models/ragEval/dataset.ts

@@ -1,7 +1,7 @@
-import { and, desc, eq } from 'drizzle-orm';
+import { and, desc, eq } from 'drizzle-orm/expressions';
 
-import { serverDB } from '@/database/server';
 import { NewEvalDatasetsItem, evalDatasets } from '@/database/schemas';
+import { serverDB } from '@/database/server';
 import { RAGEvalDataSetItem } from '@/types/eval';
 
 export class EvalDatasetModel {

package/src/database/server/models/ragEval/datasetRecord.ts

@@ -1,11 +1,7 @@
-import { and, eq, inArray } from 'drizzle-orm';
+import { and, eq, inArray } from 'drizzle-orm/expressions';
 
+import { NewEvalDatasetRecordsItem, evalDatasetRecords, files } from '@/database/schemas';
 import { serverDB } from '@/database/server';
-import {
-  NewEvalDatasetRecordsItem,
-  evalDatasetRecords,
-  files,
-} from '@/database/schemas';
 import { EvalDatasetRecordRefFile } from '@/types/eval';
 
 export class EvalDatasetRecordModel {
@@ -50,8 +46,7 @@ export class EvalDatasetRecordModel {
     const fileItems = await serverDB
       .select({ fileType: files.fileType, id: files.id, name: files.name })
       .from(files)
-      .where(and(inArray(files.id, fileList), eq(files.userId, this.userId)))
-      .execute();
+      .where(and(inArray(files.id, fileList), eq(files.userId, this.userId)));
 
     return list.map((item) => {
       return {

package/src/database/server/models/ragEval/evaluation.ts

@@ -1,12 +1,13 @@
-import { SQL, and, count, desc, eq, inArray } from 'drizzle-orm';
+import { SQL, count } from 'drizzle-orm';
+import { and, desc, eq, inArray } from 'drizzle-orm/expressions';
 
-import { serverDB } from '@/database/server';
 import {
   NewEvalEvaluationItem,
   evalDatasets,
   evalEvaluation,
   evaluationRecords,
 } from '@/database/schemas';
+import { serverDB } from '@/database/server';
 import { EvalEvaluationStatus, RAGEvalEvaluationItem } from '@/types/eval';
 
 export class EvalEvaluationModel {