@lobehub/chat 1.36.46 → 1.37.0

package/src/services/session/pglite.ts

@@ -0,0 +1,184 @@
+import { DeepPartial } from 'utility-types';
+
+import { INBOX_SESSION_ID } from '@/const/session';
+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 {
+  ChatSessionList,
+  LobeAgentSession,
+  LobeSessionType,
+  LobeSessions,
+  SessionGroupItem,
+  SessionGroups,
+  UpdateSessionParams,
+} from '@/types/session';
+
+import { ISessionService } from './type';
+
+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');
+    }
+    return item.id;
+  }
+
+  async batchCreateSessions(importSessions: LobeSessions) {
+    // @ts-ignore
+    return this.sessionModel.batchCreate(importSessions);
+  }
+
+  async cloneSession(id: string, newTitle: string): Promise<string | undefined> {
+    const res = await this.sessionModel.duplicate(id, newTitle);
+
+    if (res) return res?.id;
+  }
+
+  async getGroupedSessions(): Promise<ChatSessionList> {
+    return this.sessionModel.queryWithGroups();
+  }
+
+  async getSessionConfig(id: string): Promise<LobeAgentConfig> {
+    const res = await this.sessionModel.findByIdOrSlug(id);
+
+    if (!res) throw new Error('Session not found');
+
+    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': {
+        // @ts-ignore
+        return this.sessionModel.query();
+      }
+      case 'agent': {
+        // @ts-ignore
+        return this.sessionModel.query();
+      }
+
+      case 'all': {
+        // @ts-ignore
+        return this.sessionModel.query();
+      }
+    }
+  }
+
+  async countSessions() {
+    return this.sessionModel.count();
+  }
+
+  async searchSessions(keyword: string) {
+    return this.sessionModel.queryByKeyword(keyword);
+  }
+
+  async updateSession(id: string, value: Partial<UpdateSessionParams>) {
+    return this.sessionModel.update(id, {
+      ...value,
+      groupId: value.group === 'default' ? null : value.group,
+    });
+  }
+
+  async updateSessionConfig(
+    activeId: string,
+    config: DeepPartial<LobeAgentConfig>,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _?: AbortSignal,
+  ) {
+    const session = await this.sessionModel.findByIdOrSlug(activeId);
+    if (!session || !config) return;
+
+    return this.sessionModel.updateConfig(session.agent.id, config as AgentItem);
+  }
+
+  async updateSessionMeta(
+    activeId: string,
+    meta: Partial<MetaData>,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _?: AbortSignal,
+  ) {
+    // inbox 不允许修改 meta
+    if (activeId === INBOX_SESSION_ID) return;
+
+    return this.sessionModel.update(activeId, meta);
+  }
+
+  async updateSessionChatConfig(
+    activeId: string,
+    config: DeepPartial<LobeAgentChatConfig>,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _?: AbortSignal,
+  ) {
+    return this.updateSessionConfig(activeId, { chatConfig: config });
+  }
+
+  async removeSession(id: string) {
+    return this.sessionModel.delete(id);
+  }
+
+  async removeAllSessions() {
+    return this.sessionModel.deleteAll();
+  }
+
+  // ************************************** //
+  // ***********  SessionGroup  *********** //
+  // ************************************** //
+
+  async createSessionGroup(name: string, sort?: number) {
+    const item = await this.sessionGroupModel.create({ name, sort });
+    if (!item) {
+      throw new Error('session group create Error');
+    }
+
+    return item.id;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async batchCreateSessionGroups(_groups: SessionGroups) {
+    return { added: 0, ids: [], skips: [], success: true };
+  }
+
+  async removeSessionGroup(id: string) {
+    return await this.sessionGroupModel.delete(id);
+  }
+
+  async updateSessionGroup(id: string, data: Partial<SessionGroupItem>) {
+    return this.sessionGroupModel.update(id, data);
+  }
+
+  async updateSessionGroupOrder(sortMap: { id: string; sort: number }[]) {
+    return this.sessionGroupModel.updateOrder(sortMap);
+  }
+
+  async getSessionGroups(): Promise<SessionGroupItem[]> {
+    return this.sessionGroupModel.query();
+  }
+
+  async removeSessionGroups() {
+    return this.sessionGroupModel.deleteAll();
+  }
+}

package/src/services/session/type.ts

@@ -16,13 +16,21 @@ import {
 
 export interface ISessionService {
   createSession(type: LobeSessionType, defaultValue: Partial<LobeAgentSession>): Promise<string>;
+
+  /**
+   * 需要废弃
+   * @deprecated
+   */
   batchCreateSessions(importSessions: LobeSessions): Promise<any>;
   cloneSession(id: string, newTitle: string): Promise<string | undefined>;
 
   getGroupedSessions(): Promise<ChatSessionList>;
+
+  /**
+   * @deprecated
+   */
   getSessionsByType(type: 'agent' | 'group' | 'all'): Promise<LobeSessions>;
   countSessions(): Promise<number>;
-  hasSessions(): Promise<boolean>;
   searchSessions(keyword: string): Promise<LobeSessions>;
 
   updateSession(
@@ -53,6 +61,11 @@ export interface ISessionService {
   // ************************************** //
 
   createSessionGroup(name: string, sort?: number): Promise<string>;
+
+  /**
+   * 需要废弃
+   * @deprecated
+   */
   batchCreateSessionGroups(groups: SessionGroups): Promise<BatchTaskResult>;
 
   getSessionGroups(): Promise<SessionGroupItem[]>;

package/src/services/topic/index.ts

@@ -1,6 +1,9 @@
-
-import { ClientService } from './client';
+import { ClientService as DeprecatedService } from './client';
+import { ClientService } from './pglite';
 import { ServerService } from './server';
 
+const clientService =
+  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+
 export const topicService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;

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

@@ -0,0 +1,212 @@
+import { eq } from 'drizzle-orm';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { clientDB, initializeDB } from '@/database/client/db';
+import { sessions, topics, users } from '@/database/schemas';
+import { ChatTopic } from '@/types/topic';
+
+import { ClientService } from './pglite';
+
+// Mock data
+const userId = 'topic-user-test';
+const sessionId = 'topic-session';
+const mockTopicId = 'mock-topic-id';
+
+const mockTopic = {
+  id: mockTopicId,
+  title: 'Mock Topic',
+};
+
+const topicService = new ClientService(userId);
+
+beforeEach(async () => {
+  await initializeDB();
+
+  await clientDB.delete(users);
+
+  // 创建测试数据
+  await clientDB.transaction(async (tx) => {
+    await tx.insert(users).values({ id: userId });
+    await tx.insert(sessions).values({ id: sessionId, userId });
+    await tx.insert(topics).values({ ...mockTopic, sessionId, userId });
+  });
+});
+
+describe('TopicService', () => {
+  describe('createTopic', () => {
+    it('should create a topic and return its id', async () => {
+      // Setup
+      const createParams = {
+        title: 'New Topic',
+        sessionId: sessionId,
+      };
+
+      // Execute
+      const topicId = await topicService.createTopic(createParams);
+
+      // Assert
+      expect(topicId).toBeDefined();
+    });
+
+    it('should throw an error if topic creation fails', async () => {
+      // Setup
+      const createParams = {
+        title: 'New Topic',
+        sessionId: 123 as any, // sessionId should be string
+      };
+
+      // Execute & Assert
+      await expect(topicService.createTopic(createParams)).rejects.toThrowError();
+    });
+  });
+
+  describe('getTopics', () => {
+    // Example for getTopics
+    it('should query topics with given parameters', async () => {
+      // Setup
+      const queryParams = { sessionId };
+
+      // Execute
+      const data = await topicService.getTopics(queryParams);
+
+      // Assert
+      expect(data[0]).toMatchObject(mockTopic);
+    });
+  });
+
+  describe('updateTopic', () => {
+    // Example for updateFavorite
+    it('should toggle favorite status of a topic', async () => {
+      // Execute
+      const result = await topicService.updateTopic(mockTopicId, { favorite: true });
+
+      // Assert
+      expect(result[0].favorite).toBeTruthy();
+    });
+
+    it('should update the title of a topic', async () => {
+      // Setup
+      const newTitle = 'Updated Topic Title';
+
+      // Execute
+      const result = await topicService.updateTopic(mockTopicId, { title: newTitle });
+
+      // Assert
+      expect(result[0].title).toEqual(newTitle);
+    });
+  });
+
+  describe('removeTopic', () => {
+    it('should remove a topic by id', async () => {
+      // Execute
+      await topicService.removeTopic(mockTopicId);
+      const result = await clientDB.query.topics.findFirst({ where: eq(topics.id, mockTopicId) });
+
+      // Assert
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('removeTopics', () => {
+    it('should remove all topics with a given session id', async () => {
+      // Setup
+      const sessionId = 'session-id';
+
+      // Execute
+      await topicService.removeTopics(sessionId);
+      const result = await clientDB.query.topics.findMany({
+        where: eq(topics.sessionId, sessionId),
+      });
+
+      expect(result.length).toEqual(0);
+    });
+  });
+
+  describe('batchRemoveTopics', () => {
+    it('should batch remove topics', async () => {
+      await clientDB.insert(topics).values([{ id: 'topic-id-1', title: 'topic-title', userId }]);
+      // Setup
+      const topicIds = [mockTopicId, 'another-topic-id'];
+
+      // Execute
+      await topicService.batchRemoveTopics(topicIds);
+
+      const count = await clientDB.$count(topics);
+
+      // Assert
+      expect(count).toBe(1);
+    });
+  });
+
+  describe('removeAllTopic', () => {
+    it('should clear all topics from the table', async () => {
+      // Execute
+      await topicService.removeAllTopic();
+
+      const count = await clientDB.$count(topics);
+      // Assert
+      expect(count).toBe(0);
+    });
+  });
+
+  describe('batchCreateTopics', () => {
+    it('should batch create topics', async () => {
+      // Execute
+      const result = await topicService.batchCreateTopics([
+        { id: 'topic-id-1', title: 'topic-title' },
+        { id: 'topic-id-2', title: 'topic-title' },
+      ] as ChatTopic[]);
+
+      // Assert
+      expect(result.success).toBeTruthy();
+      expect(result.added).toBe(2);
+    });
+  });
+
+  describe('getAllTopics', () => {
+    it('should retrieve all topics', async () => {
+      await clientDB.insert(topics).values([
+        { id: 'topic-id-1', title: 'topic-title', userId },
+        { id: 'topic-id-2', title: 'topic-title', userId },
+      ]);
+      // Execute
+      const result = await topicService.getAllTopics();
+
+      // Assert
+      expect(result.length).toEqual(3);
+    });
+  });
+
+  describe('searchTopics', () => {
+    it('should return all topics that match the keyword', async () => {
+      // Setup
+      const keyword = 'Topic';
+
+      // Execute
+      const result = await topicService.searchTopics(keyword, sessionId);
+
+      // Assert
+      expect(result.length).toEqual(1);
+    });
+    it('should return empty topic if not match the keyword', async () => {
+      // Setup
+      const keyword = 'search';
+
+      // Execute
+      const result = await topicService.searchTopics(keyword, sessionId);
+
+      // Assert
+      expect(result.length).toEqual(0);
+    });
+  });
+
+  describe('countTopics', () => {
+    it('should return topic counts', async () => {
+      // Execute
+      const result = await topicService.countTopics();
+
+      // Assert
+      expect(result).toBe(1);
+    });
+  });
+});

package/src/services/topic/pglite.ts

@@ -0,0 +1,85 @@
+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 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 this.topicModel.create({
+      ...params,
+      sessionId: this.toDbSessionId(params.sessionId),
+    } as any);
+
+    if (!item) {
+      throw new Error('topic create Error');
+    }
+
+    return item.id;
+  }
+
+  async batchCreateTopics(importTopics: ChatTopic[]) {
+    const data = await this.topicModel.batchCreate(importTopics as any);
+
+    return { added: data.length, ids: [], skips: [], success: true };
+  }
+
+  async cloneTopic(id: string, newTitle?: string) {
+    const data = await this.topicModel.duplicate(id, newTitle);
+    return data.topic.id;
+  }
+
+  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) {
+    const data = await this.topicModel.queryByKeyword(keyword, this.toDbSessionId(sessionId));
+
+    return data as unknown as Promise<ChatTopic[]>;
+  }
+
+  async getAllTopics() {
+    const data = await this.topicModel.queryAll();
+
+    return data as unknown as Promise<ChatTopic[]>;
+  }
+
+  async countTopics() {
+    return this.topicModel.count();
+  }
+
+  async updateTopic(id: string, data: Partial<ChatTopic>) {
+    return this.topicModel.update(id, data as any);
+  }
+
+  async removeTopic(id: string) {
+    return this.topicModel.delete(id);
+  }
+
+  async removeTopics(sessionId: string) {
+    return this.topicModel.batchDeleteBySessionId(this.toDbSessionId(sessionId));
+  }
+
+  async batchRemoveTopics(topics: string[]) {
+    return this.topicModel.batchDelete(topics);
+  }
+
+  async removeAllTopic() {
+    return this.topicModel.deleteAll();
+  }
+
+  private toDbSessionId(sessionId?: string | null) {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  }
+}

package/src/services/user/client.test.ts

@@ -4,7 +4,6 @@ import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
 import { UserModel } from '@/database/_deprecated/models/user';
 import { UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
-import { AsyncLocalStorage } from '@/utils/localStorage';
 
 import { ClientService } from './client';
 

package/src/services/user/index.ts

@@ -1,5 +1,11 @@
-import { ClientService } from './client';
+import { ClientService as DeprecatedService } from './client';
+import { ClientService } from './pglite';
 import { ServerService } from './server';
 
+const clientService =
+  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+
 export const userService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : new ClientService();
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+
+export const userClientService = clientService;

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

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