@lobehub/chat 1.37.0 → 1.37.2

package/src/services/session/client.ts

@@ -1,10 +1,11 @@
 import { DeepPartial } from 'utility-types';
 
 import { INBOX_SESSION_ID } from '@/const/session';
-import { SessionModel } from '@/database/_deprecated/models/session';
-import { SessionGroupModel } from '@/database/_deprecated/models/sessionGroup';
-import { UserModel } from '@/database/_deprecated/models/user';
-import { useUserStore } from '@/store/user';
+import { clientDB } from '@/database/client/db';
+import { AgentItem } from '@/database/schemas';
+import { SessionModel } from '@/database/server/models/session';
+import { SessionGroupModel } from '@/database/server/models/sessionGroup';
+import { BaseClientService } from '@/services/baseClientService';
 import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
 import { MetaData } from '@/types/meta';
 import {
@@ -14,17 +15,28 @@ import {
   LobeSessions,
   SessionGroupItem,
   SessionGroups,
+  UpdateSessionParams,
 } from '@/types/session';
-import { merge } from '@/utils/merge';
 
 import { ISessionService } from './type';
 
-export class ClientService implements ISessionService {
-  async createSession(
-    type: LobeSessionType,
-    defaultValue: Partial<LobeAgentSession>,
-  ): Promise<string> {
-    const item = await SessionModel.create(type, defaultValue);
+export class ClientService extends BaseClientService implements ISessionService {
+  private get sessionModel(): SessionModel {
+    return new SessionModel(clientDB as any, this.userId);
+  }
+
+  private get sessionGroupModel(): SessionGroupModel {
+    return new SessionGroupModel(clientDB as any, this.userId);
+  }
+
+  async createSession(type: LobeSessionType, data: Partial<LobeAgentSession>): Promise<string> {
+    const { config, group, meta, ...session } = data;
+
+    const item = await this.sessionModel.create({
+      config: { ...config, ...meta } as any,
+      session: { ...session, groupId: group },
+      type,
+    });
     if (!item) {
       throw new Error('session create Error');
     }
@@ -32,72 +44,63 @@ export class ClientService implements ISessionService {
   }
 
   async batchCreateSessions(importSessions: LobeSessions) {
-    return SessionModel.batchCreate(importSessions);
+    // @ts-ignore
+    return this.sessionModel.batchCreate(importSessions);
   }
 
   async cloneSession(id: string, newTitle: string): Promise<string | undefined> {
-    const res = await SessionModel.duplicate(id, newTitle);
+    const res = await this.sessionModel.duplicate(id, newTitle);
 
     if (res) return res?.id;
   }
 
   async getGroupedSessions(): Promise<ChatSessionList> {
-    return SessionModel.queryWithGroups();
+    return this.sessionModel.queryWithGroups();
   }
 
   async getSessionConfig(id: string): Promise<LobeAgentConfig> {
-    if (!id || id === INBOX_SESSION_ID) {
-      return UserModel.getAgentConfig();
-    }
-
-    const res = await SessionModel.findById(id);
+    const res = await this.sessionModel.findByIdOrSlug(id);
 
     if (!res) throw new Error('Session not found');
 
-    return res.config as LobeAgentConfig;
+    return res.agent as LobeAgentConfig;
   }
 
+  /**
+   * 这个方法要对应移除的
+   */
   async getSessionsByType(type: 'agent' | 'group' | 'all' = 'all'): Promise<LobeSessions> {
     switch (type) {
       // TODO: add a filter to get only agents or agents
       case 'group': {
-        return SessionModel.query();
+        // @ts-ignore
+        return this.sessionModel.query();
       }
       case 'agent': {
-        return SessionModel.query();
+        // @ts-ignore
+        return this.sessionModel.query();
       }
 
       case 'all': {
-        return SessionModel.query();
+        // @ts-ignore
+        return this.sessionModel.query();
       }
     }
   }
 
-  async getAllAgents(): Promise<LobeSessions> {
-    // TODO: add a filter to get only agents
-    return await SessionModel.query();
-  }
-
   async countSessions() {
-    return SessionModel.count();
-  }
-
-  async hasSessions() {
-    return (await this.countSessions()) !== 0;
+    return this.sessionModel.count();
   }
 
   async searchSessions(keyword: string) {
-    return SessionModel.queryByKeyword(keyword);
+    return this.sessionModel.queryByKeyword(keyword);
   }
 
-  async updateSession(
-    id: string,
-    data: Partial<Pick<LobeAgentSession, 'group' | 'meta' | 'pinned'>>,
-  ) {
-    const pinned = typeof data.pinned === 'boolean' ? (data.pinned ? 1 : 0) : undefined;
-    const prev = await SessionModel.findById(id);
-
-    return SessionModel.update(id, merge(prev, { ...data, pinned }));
+  async updateSession(id: string, value: Partial<UpdateSessionParams>) {
+    return this.sessionModel.update(id, {
+      ...value,
+      groupId: value.group === 'default' ? null : value.group,
+    });
   }
 
   async updateSessionConfig(
@@ -106,13 +109,10 @@ export class ClientService implements ISessionService {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _?: AbortSignal,
   ) {
-    // TODO: 需要删除这部分处理逻辑
-    // 后续直接给用户创建一个 inbox 的 session
-    if (activeId === INBOX_SESSION_ID) {
-      return useUserStore.getState().updateDefaultAgent({ config });
-    }
+    const session = await this.sessionModel.findByIdOrSlug(activeId);
+    if (!session || !config) return;
 
-    return SessionModel.updateConfig(activeId, config);
+    return this.sessionModel.updateConfig(session.agent.id, config as AgentItem);
   }
 
   async updateSessionMeta(
@@ -124,7 +124,7 @@ export class ClientService implements ISessionService {
     // inbox 不允许修改 meta
     if (activeId === INBOX_SESSION_ID) return;
 
-    return SessionModel.update(activeId, { meta });
+    return this.sessionModel.update(activeId, meta);
   }
 
   async updateSessionChatConfig(
@@ -137,11 +137,11 @@ export class ClientService implements ISessionService {
   }
 
   async removeSession(id: string) {
-    return SessionModel.delete(id);
+    return this.sessionModel.delete(id);
   }
 
   async removeAllSessions() {
-    return SessionModel.clearTable();
+    return this.sessionModel.deleteAll();
   }
 
   // ************************************** //
@@ -149,7 +149,7 @@ export class ClientService implements ISessionService {
   // ************************************** //
 
   async createSessionGroup(name: string, sort?: number) {
-    const item = await SessionGroupModel.create(name, sort);
+    const item = await this.sessionGroupModel.create({ name, sort });
     if (!item) {
       throw new Error('session group create Error');
     }
@@ -157,27 +157,28 @@ export class ClientService implements ISessionService {
     return item.id;
   }
 
-  async batchCreateSessionGroups(groups: SessionGroups) {
-    return SessionGroupModel.batchCreate(groups);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async batchCreateSessionGroups(_groups: SessionGroups) {
+    return { added: 0, ids: [], skips: [], success: true };
   }
 
-  async removeSessionGroup(id: string, removeChildren?: boolean) {
-    return await SessionGroupModel.delete(id, removeChildren);
+  async removeSessionGroup(id: string) {
+    return await this.sessionGroupModel.delete(id);
   }
 
   async updateSessionGroup(id: string, data: Partial<SessionGroupItem>) {
-    return SessionGroupModel.update(id, data as any);
+    return this.sessionGroupModel.update(id, data);
   }
 
   async updateSessionGroupOrder(sortMap: { id: string; sort: number }[]) {
-    return SessionGroupModel.updateOrder(sortMap);
+    return this.sessionGroupModel.updateOrder(sortMap);
   }
 
   async getSessionGroups(): Promise<SessionGroupItem[]> {
-    return SessionGroupModel.query();
+    return this.sessionGroupModel.query();
   }
 
   async removeSessionGroups() {
-    return SessionGroupModel.clear();
+    return this.sessionGroupModel.deleteAll();
   }
 }

package/src/services/session/index.ts

@@ -1,5 +1,5 @@
-import { ClientService as DeprecatedService } from './client';
-import { ClientService } from './pglite';
+import { ClientService as DeprecatedService } from './_deprecated';
+import { ClientService } from './client';
 import { ServerService } from './server';
 
 const clientService =

package/src/services/topic/{client.test.ts → _deprecated.test.ts}

@@ -4,7 +4,7 @@ import { SessionModel } from '@/database/_deprecated/models/session';
 import { CreateTopicParams, TopicModel } from '@/database/_deprecated/models/topic';
 import { ChatTopic } from '@/types/topic';
 
-import { ClientService } from './client';
+import { ClientService } from './_deprecated';
 
 const topicService = new ClientService();
 // Mock the TopicModel

package/src/services/topic/_deprecated.ts

@@ -0,0 +1,70 @@
+import { TopicModel } from '@/database/_deprecated/models/topic';
+import { ChatTopic } from '@/types/topic';
+
+import { CreateTopicParams, ITopicService, QueryTopicParams } from './type';
+
+export class ClientService implements ITopicService {
+  async createTopic(params: CreateTopicParams): Promise<string> {
+    const item = await TopicModel.create(params as any);
+
+    if (!item) {
+      throw new Error('topic create Error');
+    }
+
+    return item.id;
+  }
+
+  async batchCreateTopics(importTopics: ChatTopic[]) {
+    return TopicModel.batchCreate(importTopics as any);
+  }
+
+  async cloneTopic(id: string, newTitle?: string) {
+    return TopicModel.duplicateTopic(id, newTitle);
+  }
+
+  async getTopics(params: QueryTopicParams): Promise<ChatTopic[]> {
+    return TopicModel.query(params);
+  }
+
+  async searchTopics(keyword: string, sessionId?: string) {
+    return TopicModel.queryByKeyword(keyword, sessionId);
+  }
+
+  async getAllTopics() {
+    return TopicModel.queryAll();
+  }
+
+  async countTopics() {
+    return TopicModel.count();
+  }
+
+  async updateTopicFavorite(id: string, favorite?: boolean) {
+    return this.updateTopic(id, { favorite });
+  }
+
+  async updateTopicTitle(id: string, text: string) {
+    return this.updateTopic(id, { title: text });
+  }
+
+  async updateTopic(id: string, data: Partial<ChatTopic>) {
+    const favorite = typeof data.favorite !== 'undefined' ? (data.favorite ? 1 : 0) : undefined;
+
+    return TopicModel.update(id, { ...data, favorite });
+  }
+
+  async removeTopic(id: string) {
+    return TopicModel.delete(id);
+  }
+
+  async removeTopics(sessionId: string) {
+    return TopicModel.batchDeleteBySessionId(sessionId);
+  }
+
+  async batchRemoveTopics(topics: string[]) {
+    return TopicModel.batchDelete(topics);
+  }
+
+  async removeAllTopic() {
+    return TopicModel.clearTable();
+  }
+}

package/src/services/topic/client.ts

@@ -1,11 +1,21 @@
-import { TopicModel } from '@/database/_deprecated/models/topic';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { clientDB } from '@/database/client/db';
+import { TopicModel } from '@/database/server/models/topic';
+import { BaseClientService } from '@/services/baseClientService';
 import { ChatTopic } from '@/types/topic';
 
 import { CreateTopicParams, ITopicService, QueryTopicParams } from './type';
 
-export class ClientService implements ITopicService {
+export class ClientService extends BaseClientService implements ITopicService {
+  private get topicModel(): TopicModel {
+    return new TopicModel(clientDB as any, this.userId);
+  }
+
   async createTopic(params: CreateTopicParams): Promise<string> {
-    const item = await TopicModel.create(params as any);
+    const item = await this.topicModel.create({
+      ...params,
+      sessionId: this.toDbSessionId(params.sessionId),
+    } as any);
 
     if (!item) {
       throw new Error('topic create Error');
@@ -15,56 +25,61 @@ export class ClientService implements ITopicService {
   }
 
   async batchCreateTopics(importTopics: ChatTopic[]) {
-    return TopicModel.batchCreate(importTopics as any);
+    const data = await this.topicModel.batchCreate(importTopics as any);
+
+    return { added: data.length, ids: [], skips: [], success: true };
   }
 
   async cloneTopic(id: string, newTitle?: string) {
-    return TopicModel.duplicateTopic(id, newTitle);
+    const data = await this.topicModel.duplicate(id, newTitle);
+    return data.topic.id;
   }
 
-  async getTopics(params: QueryTopicParams): Promise<ChatTopic[]> {
-    return TopicModel.query(params);
+  async getTopics(params: QueryTopicParams) {
+    const data = await this.topicModel.query({
+      ...params,
+      sessionId: this.toDbSessionId(params.sessionId),
+    });
+    return data as unknown as Promise<ChatTopic[]>;
   }
 
   async searchTopics(keyword: string, sessionId?: string) {
-    return TopicModel.queryByKeyword(keyword, sessionId);
-  }
+    const data = await this.topicModel.queryByKeyword(keyword, this.toDbSessionId(sessionId));
 
-  async getAllTopics() {
-    return TopicModel.queryAll();
+    return data as unknown as Promise<ChatTopic[]>;
   }
 
-  async countTopics() {
-    return TopicModel.count();
-  }
+  async getAllTopics() {
+    const data = await this.topicModel.queryAll();
 
-  async updateTopicFavorite(id: string, favorite?: boolean) {
-    return this.updateTopic(id, { favorite });
+    return data as unknown as Promise<ChatTopic[]>;
   }
 
-  async updateTopicTitle(id: string, text: string) {
-    return this.updateTopic(id, { title: text });
+  async countTopics() {
+    return this.topicModel.count();
   }
 
   async updateTopic(id: string, data: Partial<ChatTopic>) {
-    const favorite = typeof data.favorite !== 'undefined' ? (data.favorite ? 1 : 0) : undefined;
-
-    return TopicModel.update(id, { ...data, favorite });
+    return this.topicModel.update(id, data as any);
   }
 
   async removeTopic(id: string) {
-    return TopicModel.delete(id);
+    return this.topicModel.delete(id);
   }
 
   async removeTopics(sessionId: string) {
-    return TopicModel.batchDeleteBySessionId(sessionId);
+    return this.topicModel.batchDeleteBySessionId(this.toDbSessionId(sessionId));
   }
 
   async batchRemoveTopics(topics: string[]) {
-    return TopicModel.batchDelete(topics);
+    return this.topicModel.batchDelete(topics);
   }
 
   async removeAllTopic() {
-    return TopicModel.clearTable();
+    return this.topicModel.deleteAll();
+  }
+
+  private toDbSessionId(sessionId?: string | null) {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
   }
 }

package/src/services/topic/index.ts

@@ -1,5 +1,5 @@
-import { ClientService as DeprecatedService } from './client';
-import { ClientService } from './pglite';
+import { ClientService as DeprecatedService } from './_deprecated';
+import { ClientService } from './client';
 import { ServerService } from './server';
 
 const clientService =

package/src/services/topic/pglite.test.ts

@@ -5,7 +5,7 @@ import { clientDB, initializeDB } from '@/database/client/db';
 import { sessions, topics, users } from '@/database/schemas';
 import { ChatTopic } from '@/types/topic';
 
-import { ClientService } from './pglite';
+import { ClientService } from './client';
 
 // Mock data
 const userId = 'topic-user-test';

package/src/services/user/{pglite.test.ts → _deprecated.test.ts}

@@ -1,13 +1,20 @@
-import { eq } from 'drizzle-orm';
 import { DeepPartial } from 'utility-types';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { clientDB, initializeDB } from '@/database/client/db';
-import { userSettings, users } from '@/database/schemas';
+import { UserModel } from '@/database/_deprecated/models/user';
 import { UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
-import { ClientService } from './pglite';
+import { ClientService } from './_deprecated';
+
+vi.mock('@/database/_deprecated/models/user', () => ({
+  UserModel: {
+    getUser: vi.fn(),
+    updateSettings: vi.fn(),
+    resetSettings: vi.fn(),
+    updateAvatar: vi.fn(),
+  },
+}));
 
 const mockUser = {
   avatar: 'avatar.png',
@@ -18,67 +25,63 @@ const mockUser = {
 const mockPreference = {
   useCmdEnterToSend: true,
 } as UserPreference;
-const clientService = new ClientService(mockUser.uuid);
-
-beforeEach(async () => {
-  vi.clearAllMocks();
 
-  await initializeDB();
-  await clientDB.delete(users);
+describe('ClientService', () => {
+  let clientService: ClientService;
 
-  await clientDB.insert(users).values({ id: mockUser.uuid, avatar: 'avatar.png' });
-  await clientDB
-    .insert(userSettings)
-    .values({ id: mockUser.uuid, general: { themeMode: 'light' } });
-});
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clientService = new ClientService();
+  });
 
-describe('ClientService', () => {
   it('should get user state correctly', async () => {
+    (UserModel.getUser as Mock).mockResolvedValue(mockUser);
     const spyOn = vi
       .spyOn(clientService['preferenceStorage'], 'getFromLocalStorage')
       .mockResolvedValue(mockPreference);
 
     const userState = await clientService.getUserState();
 
-    expect(userState).toMatchObject({
+    expect(userState).toEqual({
       avatar: mockUser.avatar,
       isOnboard: true,
       canEnablePWAGuide: false,
       hasConversation: false,
       canEnableTrace: false,
       preference: mockPreference,
-      settings: { general: { themeMode: 'light' } },
+      settings: mockUser.settings,
       userId: mockUser.uuid,
     });
+    expect(UserModel.getUser).toHaveBeenCalledTimes(1);
     expect(spyOn).toHaveBeenCalledTimes(1);
   });
 
   it('should update user settings correctly', async () => {
     const settingsPatch: DeepPartial<UserSettings> = { general: { themeMode: 'dark' } };
+    (UserModel.updateSettings as Mock).mockResolvedValue(undefined);
 
     await clientService.updateUserSettings(settingsPatch);
 
-    const result = await clientDB.query.userSettings.findFirst({
-      where: eq(userSettings.id, mockUser.uuid),
-    });
-
-    expect(result).toMatchObject(settingsPatch);
+    expect(UserModel.updateSettings).toHaveBeenCalledWith(settingsPatch);
+    expect(UserModel.updateSettings).toHaveBeenCalledTimes(1);
   });
 
   it('should reset user settings correctly', async () => {
-    await clientService.resetUserSettings();
+    (UserModel.resetSettings as Mock).mockResolvedValue(undefined);
 
-    const result = await clientDB.query.userSettings.findFirst({
-      where: eq(userSettings.id, mockUser.uuid),
-    });
+    await clientService.resetUserSettings();
 
-    expect(result).toBeUndefined();
+    expect(UserModel.resetSettings).toHaveBeenCalledTimes(1);
   });
 
   it('should update user avatar correctly', async () => {
     const newAvatar = 'new-avatar.png';
+    (UserModel.updateAvatar as Mock).mockResolvedValue(undefined);
 
     await clientService.updateAvatar(newAvatar);
+
+    expect(UserModel.updateAvatar).toHaveBeenCalledWith(newAvatar);
+    expect(UserModel.updateAvatar).toHaveBeenCalledTimes(1);
   });
 
   it('should update user preference correctly', async () => {

package/src/services/user/_deprecated.ts

@@ -0,0 +1,57 @@
+import { DeepPartial } from 'utility-types';
+
+import { MessageModel } from '@/database/_deprecated/models/message';
+import { SessionModel } from '@/database/_deprecated/models/session';
+import { UserModel } from '@/database/_deprecated/models/user';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
+import { UserSettings } from '@/types/user/settings';
+import { AsyncLocalStorage } from '@/utils/localStorage';
+
+import { IUserService } from './type';
+
+export class ClientService implements IUserService {
+  private preferenceStorage: AsyncLocalStorage<UserPreference>;
+
+  constructor() {
+    this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
+  }
+
+  async getUserState(): Promise<UserInitializationState> {
+    const user = await UserModel.getUser();
+    const messageCount = await MessageModel.count();
+    const sessionCount = await SessionModel.count();
+
+    return {
+      avatar: user.avatar,
+      canEnablePWAGuide: messageCount >= 4,
+      canEnableTrace: messageCount >= 4,
+      hasConversation: messageCount > 0 || sessionCount > 0,
+      isOnboard: true,
+      preference: await this.preferenceStorage.getFromLocalStorage(),
+      settings: user.settings as UserSettings,
+      userId: user.uuid,
+    };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  updateUserSettings = async (patch: DeepPartial<UserSettings>, _?: any) => {
+    return UserModel.updateSettings(patch);
+  };
+
+  resetUserSettings = async () => {
+    return UserModel.resetSettings();
+  };
+
+  async updateAvatar(avatar: string) {
+    await UserModel.updateAvatar(avatar);
+  }
+
+  async updatePreference(preference: Partial<UserPreference>) {
+    await this.preferenceStorage.saveToLocalStorage(preference);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,unused-imports/no-unused-vars
+  async updateGuide(guide: Partial<UserGuide>) {
+    throw new Error('Method not implemented.');
+  }
+}