@lobehub/chat 1.36.30 → 1.36.32

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

@@ -19,6 +19,10 @@ export class PluginModel {
     const [result] = await this.db
       .insert(installedPlugins)
       .values({ ...params, createdAt: new Date(), updatedAt: new Date(), userId: this.userId })
+      .onConflictDoUpdate({
+        set: { ...params, updatedAt: new Date() },
+        target: [installedPlugins.identifier, installedPlugins.userId],
+      })
       .returning();
 
     return result;
@@ -56,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 {

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

@@ -1,7 +1,7 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq } from 'drizzle-orm/expressions';
 
-import { serverDB } from '@/database/server';
 import { NewEvaluationRecordsItem, evaluationRecords } from '@/database/schemas';
+import { serverDB } from '@/database/server';
 
 export class EvaluationRecordModel {
   private userId: string;

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

@@ -31,7 +31,7 @@ export class SessionModel {
   }
   // **************** Query *************** //
 
-  async query({ current = 0, pageSize = 9999 } = {}) {
+  query = async ({ current = 0, pageSize = 9999 } = {}) => {
     const offset = current * pageSize;
 
     return this.db.query.sessions.findMany({
@@ -41,9 +41,9 @@ export class SessionModel {
       where: and(eq(sessions.userId, this.userId), not(eq(sessions.slug, INBOX_SESSION_ID))),
       with: { agentsToSessions: { columns: {}, with: { agent: true } }, group: true },
     });
-  }
+  };
 
-  async queryWithGroups(): Promise<ChatSessionList> {
+  queryWithGroups = async (): Promise<ChatSessionList> => {
     // 查询所有会话
     const result = await this.query();
 
@@ -56,9 +56,9 @@ export class SessionModel {
       sessionGroups: groups as unknown as ChatSessionList['sessionGroups'],
       sessions: result.map((item) => this.mapSessionItem(item as any)),
     };
-  }
+  };
 
-  async queryByKeyword(keyword: string) {
+  queryByKeyword = async (keyword: string) => {
     if (!keyword) return [];
 
     const keywordLowerCase = keyword.toLowerCase();
@@ -66,11 +66,11 @@ export class SessionModel {
     const data = await this.findSessionsByKeywords({ keyword: keywordLowerCase });
 
     return data.map((item) => this.mapSessionItem(item as any));
-  }
+  };
 
-  async findByIdOrSlug(
+  findByIdOrSlug = async (
     idOrSlug: string,
-  ): Promise<(SessionItem & { agent: AgentItem }) | undefined> {
+  ): Promise<(SessionItem & { agent: AgentItem }) | undefined> => {
     const result = await this.db.query.sessions.findFirst({
       where: and(
         or(eq(sessions.id, idOrSlug), eq(sessions.slug, idOrSlug)),
@@ -82,23 +82,22 @@ export class SessionModel {
     if (!result) return;
 
     return { ...result, agent: (result?.agentsToSessions?.[0] as any)?.agent } as any;
-  }
+  };
 
-  async count() {
+  count = async (): Promise<number> => {
     const result = await this.db
       .select({
-        count: count(),
+        count: count(sessions.id),
       })
       .from(sessions)
-      .where(eq(sessions.userId, this.userId))
-      .execute();
+      .where(eq(sessions.userId, this.userId));
 
     return result[0].count;
-  }
+  };
 
   // **************** Create *************** //
 
-  async create({
+  create = async ({
     id = idGenerator('sessions'),
     type = 'agent',
     session = {},
@@ -110,7 +109,7 @@ export class SessionModel {
     session?: Partial<NewSession>;
     slug?: string;
     type: 'agent' | 'group';
-  }): Promise<SessionItem> {
+  }): Promise<SessionItem> => {
     return this.db.transaction(async (trx) => {
       const newAgents = await trx
         .insert(agents)
@@ -143,9 +142,9 @@ export class SessionModel {
 
       return result[0];
     });
-  }
+  };
 
-  async createInbox() {
+  createInbox = async () => {
     const item = await this.db.query.sessions.findFirst({
       where: and(eq(sessions.userId, this.userId), eq(sessions.slug, INBOX_SESSION_ID)),
     });
@@ -158,9 +157,9 @@ export class SessionModel {
       slug: INBOX_SESSION_ID,
       type: 'agent',
     });
-  }
+  };
 
-  async batchCreate(newSessions: NewSession[]) {
+  batchCreate = async (newSessions: NewSession[]) => {
     const sessionsToInsert = newSessions.map((s) => {
       return {
         ...s,
@@ -170,9 +169,9 @@ export class SessionModel {
     });
 
     return this.db.insert(sessions).values(sessionsToInsert);
-  }
+  };
 
-  async duplicate(id: string, newTitle?: string) {
+  duplicate = async (id: string, newTitle?: string) => {
     const result = await this.findByIdOrSlug(id);
 
     if (!result) return;
@@ -193,47 +192,49 @@ export class SessionModel {
       },
       type: 'agent',
     });
-  }
+  };
 
   // **************** Delete *************** //
 
   /**
    * Delete a session, also delete all messages and topics associated with it.
    */
-  async delete(id: string) {
+  delete = async (id: string) => {
     return this.db
       .delete(sessions)
       .where(and(eq(sessions.id, id), eq(sessions.userId, this.userId)));
-  }
+  };
 
   /**
    * Batch delete sessions, also delete all messages and topics associated with them.
    */
-  async batchDelete(ids: string[]) {
+  batchDelete = async (ids: string[]) => {
     return this.db
       .delete(sessions)
       .where(and(inArray(sessions.id, ids), eq(sessions.userId, this.userId)));
-  }
+  };
 
-  async deleteAll() {
+  deleteAll = async () => {
     return this.db.delete(sessions).where(eq(sessions.userId, this.userId));
-  }
+  };
   // **************** Update *************** //
 
-  async update(id: string, data: Partial<SessionItem>) {
+  update = async (id: string, data: Partial<SessionItem>) => {
     return this.db
       .update(sessions)
       .set(data)
       .where(and(eq(sessions.id, id), eq(sessions.userId, this.userId)))
       .returning();
-  }
+  };
+
+  updateConfig = async (id: string, data: Partial<AgentItem>) => {
+    if (Object.keys(data).length === 0) return;
 
-  async updateConfig(id: string, data: Partial<AgentItem>) {
     return this.db
       .update(agents)
       .set(data)
       .where(and(eq(agents.id, id), eq(agents.userId, this.userId)));
-  }
+  };
 
   // **************** Helper *************** //
 
@@ -264,7 +265,11 @@ export class SessionModel {
     } as any;
   };
 
-  async findSessionsByKeywords(params: { current?: number; keyword: string; pageSize?: number }) {
+  findSessionsByKeywords = async (params: {
+    current?: number;
+    keyword: string;
+    pageSize?: number;
+  }) => {
     const { keyword, pageSize = 9999, current = 0 } = params;
     const offset = current * pageSize;
     const results = await this.db.query.agents.findMany({
@@ -288,5 +293,5 @@ export class SessionModel {
       return results.map((item) => item.agentsToSessions[0].session);
     } catch {}
     return [];
-  }
+  };
 }

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

@@ -46,14 +46,14 @@ export class SessionGroupModel {
     });
   };
 
-  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)));
-  }
+  };
 
-  async updateOrder(sortMap: { id: string; sort: number }[]) {
+  updateOrder = async (sortMap: { id: string; sort: number }[]) => {
     await this.db.transaction(async (tx) => {
       const updates = sortMap.map(({ id, sort }) => {
         return tx
@@ -64,7 +64,7 @@ export class SessionGroupModel {
 
       await Promise.all(updates);
     });
-  }
+  };
 
   private genId = () => idGenerator('sessionGroups');
 }

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

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