@lobehub/chat 1.35.9 → 1.35.10

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

@@ -1,10 +1,11 @@
 import { Column, asc, count, inArray, like, sql } from 'drizzle-orm';
-import { and, desc, eq, isNull, not, or } from 'drizzle-orm/expressions';
+import { and, desc, eq, not, or } from 'drizzle-orm/expressions';
 
 import { appEnv } from '@/config/app';
 import { INBOX_SESSION_ID } from '@/const/session';
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import { serverDB } from '@/database/server/core/db';
+import { LobeChatDatabase } from '@/database/type';
+import { idGenerator } from '@/database/utils/idGenerator';
 import { parseAgentConfig } from '@/server/globalConfig/parseDefaultAgent';
 import { ChatSessionList, LobeAgentSession } from '@/types/session';
 import { merge } from '@/utils/merge';
@@ -19,20 +20,21 @@ import {
   sessionGroups,
   sessions,
 } from '../../schemas';
-import { idGenerator } from '@/database/utils/idGenerator';
 
 export class SessionModel {
   private userId: string;
+  private db: LobeChatDatabase;
 
-  constructor(userId: string) {
+  constructor(db: LobeChatDatabase, userId: string) {
     this.userId = userId;
+    this.db = db;
   }
   // **************** Query *************** //
 
   async query({ current = 0, pageSize = 9999 } = {}) {
     const offset = current * pageSize;
 
-    return serverDB.query.sessions.findMany({
+    return this.db.query.sessions.findMany({
       limit: pageSize,
       offset,
       orderBy: [desc(sessions.updatedAt)],
@@ -45,7 +47,7 @@ export class SessionModel {
     // 查询所有会话
     const result = await this.query();
 
-    const groups = await serverDB.query.sessionGroups.findMany({
+    const groups = await this.db.query.sessionGroups.findMany({
       orderBy: [asc(sessionGroups.sort), desc(sessionGroups.createdAt)],
       where: eq(sessions.userId, this.userId),
     });
@@ -69,7 +71,7 @@ export class SessionModel {
   async findByIdOrSlug(
     idOrSlug: string,
   ): Promise<(SessionItem & { agent: AgentItem }) | undefined> {
-    const result = await serverDB.query.sessions.findFirst({
+    const result = await this.db.query.sessions.findFirst({
       where: and(
         or(eq(sessions.id, idOrSlug), eq(sessions.slug, idOrSlug)),
         eq(sessions.userId, this.userId),
@@ -83,7 +85,7 @@ export class SessionModel {
   }
 
   async count() {
-    const result = await serverDB
+    const result = await this.db
       .select({
         count: count(),
       })
@@ -109,7 +111,7 @@ export class SessionModel {
     slug?: string;
     type: 'agent' | 'group';
   }): Promise<SessionItem> {
-    return serverDB.transaction(async (trx) => {
+    return this.db.transaction(async (trx) => {
       const newAgents = await trx
         .insert(agents)
         .values({
@@ -144,7 +146,7 @@ export class SessionModel {
   }
 
   async createInbox() {
-    const item = await serverDB.query.sessions.findFirst({
+    const item = await this.db.query.sessions.findFirst({
       where: and(eq(sessions.userId, this.userId), eq(sessions.slug, INBOX_SESSION_ID)),
     });
     if (item) return;
@@ -167,7 +169,7 @@ export class SessionModel {
       };
     });
 
-    return serverDB.insert(sessions).values(sessionsToInsert);
+    return this.db.insert(sessions).values(sessionsToInsert);
   }
 
   async duplicate(id: string, newTitle?: string) {
@@ -199,7 +201,7 @@ export class SessionModel {
    * Delete a session, also delete all messages and topics associated with it.
    */
   async delete(id: string) {
-    return serverDB
+    return this.db
       .delete(sessions)
       .where(and(eq(sessions.id, id), eq(sessions.userId, this.userId)));
   }
@@ -208,18 +210,18 @@ export class SessionModel {
    * Batch delete sessions, also delete all messages and topics associated with them.
    */
   async batchDelete(ids: string[]) {
-    return serverDB
+    return this.db
       .delete(sessions)
       .where(and(inArray(sessions.id, ids), eq(sessions.userId, this.userId)));
   }
 
   async deleteAll() {
-    return serverDB.delete(sessions).where(eq(sessions.userId, this.userId));
+    return this.db.delete(sessions).where(eq(sessions.userId, this.userId));
   }
   // **************** Update *************** //
 
   async update(id: string, data: Partial<SessionItem>) {
-    return serverDB
+    return this.db
       .update(sessions)
       .set(data)
       .where(and(eq(sessions.id, id), eq(sessions.userId, this.userId)))
@@ -227,7 +229,7 @@ export class SessionModel {
   }
 
   async updateConfig(id: string, data: Partial<AgentItem>) {
-    return serverDB
+    return this.db
       .update(agents)
       .set(data)
       .where(and(eq(agents.id, id), eq(agents.userId, this.userId)));
@@ -262,65 +264,22 @@ export class SessionModel {
     } as any;
   };
 
-  async findSessions(params: {
-    current?: number;
-    group?: string;
-    keyword?: string;
-    pageSize?: number;
-    pinned?: boolean;
-  }) {
-    const { pinned, keyword, group, pageSize = 9999, current = 0 } = params;
-
-    const offset = current * pageSize;
-    return serverDB.query.sessions.findMany({
-      limit: pageSize,
-      offset,
-      orderBy: [desc(sessions.updatedAt)],
-      where: and(
-        eq(sessions.userId, this.userId),
-        pinned !== undefined ? eq(sessions.pinned, pinned) : eq(sessions.userId, this.userId),
-        keyword
-          ? or(
-            like(
-              sql`lower(${sessions.title})` as unknown as Column,
-              `%${keyword.toLowerCase()}%`,
-            ),
-            like(
-              sql`lower(${sessions.description})` as unknown as Column,
-              `%${keyword.toLowerCase()}%`,
-            ),
-          )
-          : eq(sessions.userId, this.userId),
-        group ? eq(sessions.groupId, group) : isNull(sessions.groupId),
-      ),
-
-      with: { agentsToSessions: { columns: {}, with: { agent: true } }, group: true },
-    });
-  }
-
-  async findSessionsByKeywords(params: {
-    current?: number;
-    keyword: string;
-    pageSize?: number;
-  }) {
+  async findSessionsByKeywords(params: { current?: number; keyword: string; pageSize?: number }) {
     const { keyword, pageSize = 9999, current = 0 } = params;
     const offset = current * pageSize;
-    const results = await serverDB.query.agents.findMany({
+    const results = await this.db.query.agents.findMany({
       limit: pageSize,
       offset,
       orderBy: [desc(agents.updatedAt)],
       where: and(
         eq(agents.userId, this.userId),
         or(
-          like(
-            sql`lower(${agents.title})` as unknown as Column,
-            `%${keyword.toLowerCase()}%`,
-          ),
+          like(sql`lower(${agents.title})` as unknown as Column, `%${keyword.toLowerCase()}%`),
           like(
             sql`lower(${agents.description})` as unknown as Column,
             `%${keyword.toLowerCase()}%`,
           ),
-        )
+        ),
       ),
       with: { agentsToSessions: { columns: {}, with: { session: true } } },
     });
@@ -328,6 +287,6 @@ export class SessionModel {
       // @ts-expect-error
       return results.map((item) => item.agentsToSessions[0].session);
     } catch {}
-    return []
+    return [];
   }
 }

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

@@ -1,20 +1,22 @@
 import { eq } from 'drizzle-orm';
 import { and, asc, desc } from 'drizzle-orm/expressions';
 
-import { serverDB } from '@/database/server';
+import { LobeChatDatabase } from '@/database/type';
 import { idGenerator } from '@/database/utils/idGenerator';
 
 import { SessionGroupItem, sessionGroups } from '../../schemas';
 
 export class SessionGroupModel {
   private userId: string;
+  private db: LobeChatDatabase;
 
-  constructor(userId: string) {
+  constructor(db: LobeChatDatabase, userId: string) {
     this.userId = userId;
+    this.db = db;
   }
 
   create = async (params: { name: string; sort?: number }) => {
-    const [result] = await serverDB
+    const [result] = await this.db
       .insert(sessionGroups)
       .values({ ...params, id: this.genId(), userId: this.userId })
       .returning();
@@ -23,37 +25,37 @@ export class SessionGroupModel {
   };
 
   delete = async (id: string) => {
-    return serverDB
+    return this.db
       .delete(sessionGroups)
       .where(and(eq(sessionGroups.id, id), eq(sessionGroups.userId, this.userId)));
   };
 
   deleteAll = async () => {
-    return serverDB.delete(sessionGroups).where(eq(sessionGroups.userId, this.userId));
+    return this.db.delete(sessionGroups).where(eq(sessionGroups.userId, this.userId));
   };
 
   query = async () => {
-    return serverDB.query.sessionGroups.findMany({
+    return this.db.query.sessionGroups.findMany({
       orderBy: [asc(sessionGroups.sort), desc(sessionGroups.createdAt)],
       where: eq(sessionGroups.userId, this.userId),
     });
   };
 
   findById = async (id: string) => {
-    return serverDB.query.sessionGroups.findFirst({
+    return this.db.query.sessionGroups.findFirst({
       where: and(eq(sessionGroups.id, id), eq(sessionGroups.userId, this.userId)),
     });
   };
 
   async update(id: string, value: Partial<SessionGroupItem>) {
-    return serverDB
+    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 }[]) {
-    await serverDB.transaction(async (tx) => {
+    await this.db.transaction(async (tx) => {
       const updates = sortMap.map(({ id, sort }) => {
         return tx
           .update(sessionGroups)

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

@@ -1,7 +1,7 @@
 import { eq } from 'drizzle-orm';
 import { and, desc } from 'drizzle-orm/expressions';
 
-import { serverDB } from '@/database/server';
+import { LobeChatDatabase } from '@/database/type';
 import { CreateThreadParams, ThreadStatus } from '@/types/topic';
 
 import { ThreadItem, threads } from '../../schemas';
@@ -20,14 +20,16 @@ const queryColumns = {
 
 export class ThreadModel {
   private userId: string;
+  private db: LobeChatDatabase;
 
-  constructor(userId: string) {
+  constructor(db: LobeChatDatabase, userId: string) {
     this.userId = userId;
+    this.db = db;
   }
 
   create = async (params: CreateThreadParams) => {
     // @ts-ignore
-    const [result] = await serverDB
+    const [result] = await this.db
       .insert(threads)
       .values({ ...params, status: ThreadStatus.Active, userId: this.userId })
       .onConflictDoNothing()
@@ -37,15 +39,15 @@ export class ThreadModel {
   };
 
   delete = async (id: string) => {
-    return serverDB.delete(threads).where(and(eq(threads.id, id), eq(threads.userId, this.userId)));
+    return this.db.delete(threads).where(and(eq(threads.id, id), eq(threads.userId, this.userId)));
   };
 
   deleteAll = async () => {
-    return serverDB.delete(threads).where(eq(threads.userId, this.userId));
+    return this.db.delete(threads).where(eq(threads.userId, this.userId));
   };
 
   query = async () => {
-    const data = await serverDB
+    const data = await this.db
       .select(queryColumns)
       .from(threads)
       .where(eq(threads.userId, this.userId))
@@ -55,7 +57,7 @@ export class ThreadModel {
   };
 
   queryByTopicId = async (topicId: string) => {
-    const data = await serverDB
+    const data = await this.db
       .select(queryColumns)
       .from(threads)
       .where(and(eq(threads.topicId, topicId), eq(threads.userId, this.userId)))
@@ -65,13 +67,13 @@ export class ThreadModel {
   };
 
   findById = async (id: string) => {
-    return serverDB.query.threads.findFirst({
+    return this.db.query.threads.findFirst({
       where: and(eq(threads.id, id), eq(threads.userId, this.userId)),
     });
   };
 
   async update(id: string, value: Partial<ThreadItem>) {
-    return serverDB
+    return this.db
       .update(threads)
       .set({ ...value, updatedAt: new Date() })
       .where(and(eq(threads.id, id), eq(threads.userId, this.userId)));

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

@@ -1,7 +1,7 @@
 import { Column, count, inArray, sql } from 'drizzle-orm';
 import { and, desc, eq, exists, isNull, like, or } from 'drizzle-orm/expressions';
 
-import { serverDB } from '@/database/server/core/db';
+import { LobeChatDatabase } from '@/database/type';
 
 import { NewMessage, TopicItem, messages, topics } from '../../schemas';
 import { idGenerator } from '@/database/utils/idGenerator';
@@ -21,9 +21,11 @@ interface QueryTopicParams {
 
 export class TopicModel {
   private userId: string;
+  private db: LobeChatDatabase;
 
-  constructor(userId: string) {
+  constructor(db: LobeChatDatabase, userId: string) {
     this.userId = userId;
+    this.db = db;
   }
   // **************** Query *************** //
 
@@ -31,7 +33,7 @@ export class TopicModel {
     const offset = current * pageSize;
 
     return (
-      serverDB
+      this.db
         .select({
           createdAt: topics.createdAt,
           favorite: topics.favorite,
@@ -52,13 +54,13 @@ export class TopicModel {
   }
 
   async findById(id: string) {
-    return serverDB.query.topics.findFirst({
+    return this.db.query.topics.findFirst({
       where: and(eq(topics.id, id), eq(topics.userId, this.userId)),
     });
   }
 
   async queryAll(): Promise<TopicItem[]> {
-    return serverDB
+    return this.db
       .select()
       .from(topics)
       .orderBy(topics.updatedAt)
@@ -74,7 +76,7 @@ export class TopicModel {
     const matchKeyword = (field: any) =>
       like(sql`lower(${field})` as unknown as Column, `%${keywordLowerCase}%`);
 
-    return serverDB.query.topics.findMany({
+    return this.db.query.topics.findMany({
       orderBy: [desc(topics.updatedAt)],
       where: and(
         eq(topics.userId, this.userId),
@@ -82,15 +84,10 @@ export class TopicModel {
         or(
           matchKeyword(topics.title),
           exists(
-            serverDB
+            this.db
               .select()
               .from(messages)
-              .where(
-                and(
-                  eq(messages.topicId, topics.id),
-                  matchKeyword(messages.content)
-                )
-              ),
+              .where(and(eq(messages.topicId, topics.id), matchKeyword(messages.content))),
           ),
         ),
       ),
@@ -98,7 +95,7 @@ export class TopicModel {
   }
 
   async count() {
-    const result = await serverDB
+    const result = await this.db
       .select({
         count: count(),
       })
@@ -115,7 +112,7 @@ export class TopicModel {
     { messages: messageIds, ...params }: CreateTopicParams,
     id: string = this.genId(),
   ): Promise<TopicItem> {
-    return serverDB.transaction(async (tx) => {
+    return this.db.transaction(async (tx) => {
       // 在 topics 表中插入新的 topic
       const [topic] = await tx
         .insert(topics)
@@ -140,7 +137,7 @@ export class TopicModel {
 
   async batchCreate(topicParams: (CreateTopicParams & { id?: string })[]) {
     // 开始一个事务
-    return serverDB.transaction(async (tx) => {
+    return this.db.transaction(async (tx) => {
       // 在 topics 表中批量插入新的 topics
       const createdTopics = await tx
         .insert(topics)
@@ -173,7 +170,7 @@ export class TopicModel {
   }
 
   async duplicate(topicId: string, newTitle?: string) {
-    return serverDB.transaction(async (tx) => {
+    return this.db.transaction(async (tx) => {
       // find original topic
       const originalTopic = await tx.query.topics.findFirst({
         where: and(eq(topics.id, topicId), eq(topics.userId, this.userId)),
@@ -228,14 +225,14 @@ export class TopicModel {
    * Delete a session, also delete all messages and topics associated with it.
    */
   async delete(id: string) {
-    return serverDB.delete(topics).where(and(eq(topics.id, id), eq(topics.userId, this.userId)));
+    return this.db.delete(topics).where(and(eq(topics.id, id), eq(topics.userId, this.userId)));
   }
 
   /**
    * Deletes multiple topics based on the sessionId.
    */
   async batchDeleteBySessionId(sessionId?: string | null) {
-    return serverDB
+    return this.db
       .delete(topics)
       .where(and(this.matchSession(sessionId), eq(topics.userId, this.userId)));
   }
@@ -244,19 +241,19 @@ export class TopicModel {
    * Deletes multiple topics and all messages associated with them in a transaction.
    */
   async batchDelete(ids: string[]) {
-    return serverDB
+    return this.db
       .delete(topics)
       .where(and(inArray(topics.id, ids), eq(topics.userId, this.userId)));
   }
 
   async deleteAll() {
-    return serverDB.delete(topics).where(eq(topics.userId, this.userId));
+    return this.db.delete(topics).where(eq(topics.userId, this.userId));
   }
 
   // **************** Update *************** //
 
   async update(id: string, data: Partial<TopicItem>) {
-    return serverDB
+    return this.db
       .update(topics)
       .set({ ...data, updatedAt: new Date() })
       .where(and(eq(topics.id, id), eq(topics.userId, this.userId)))