@lobehub/lobehub 2.0.0-next.26 → 2.0.0-next.28

package/src/services/thread/index.ts

@@ -1,3 +1,39 @@
-import { ServerService } from './server';
+import { CreateMessageParams } from '@lobechat/types';
 
-export const threadService = new ServerService();
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { CreateThreadParams, ThreadItem } from '@/types/topic';
+
+interface CreateThreadWithMessageParams extends CreateThreadParams {
+  message: CreateMessageParams;
+}
+
+export class ThreadService {
+  getThreads = (topicId: string): Promise<ThreadItem[]> => {
+    return lambdaClient.thread.getThreads.query({ topicId });
+  };
+
+  createThreadWithMessage = async ({
+    message,
+    ...params
+  }: CreateThreadWithMessageParams): Promise<{ messageId: string; threadId: string }> => {
+    return lambdaClient.thread.createThreadWithMessage.mutate({
+      ...params,
+      message: { ...message, sessionId: this.toDbSessionId(message.sessionId) },
+    });
+  };
+
+  updateThread = async (id: string, data: Partial<ThreadItem>) => {
+    return lambdaClient.thread.updateThread.mutate({ id, value: data });
+  };
+
+  removeThread = async (id: string) => {
+    return lambdaClient.thread.removeThread.mutate({ id });
+  };
+
+  private toDbSessionId = (sessionId: string | undefined) => {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  };
+}
+
+export const threadService = new ThreadService();

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

@@ -0,0 +1,8 @@
+import { describe } from 'vitest';
+import { testService } from '~test-utils';
+
+import { TopicService } from './index';
+
+describe('TopicService', () => {
+  testService(TopicService, { checkAsync: false });
+});

package/src/services/topic/index.ts

@@ -1,3 +1,77 @@
-import { ServerService } from './server';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { BatchTaskResult } from '@/types/service';
+import { ChatTopic, CreateTopicParams, QueryTopicParams, TopicRankItem } from '@/types/topic';
 
-export const topicService = new ServerService();
+export class TopicService {
+  createTopic = (params: CreateTopicParams): Promise<string> => {
+    return lambdaClient.topic.createTopic.mutate({
+      ...params,
+      sessionId: this.toDbSessionId(params.sessionId),
+    });
+  };
+
+  batchCreateTopics = (importTopics: ChatTopic[]): Promise<BatchTaskResult> => {
+    return lambdaClient.topic.batchCreateTopics.mutate(importTopics);
+  };
+
+  cloneTopic = (id: string, newTitle?: string): Promise<string> => {
+    return lambdaClient.topic.cloneTopic.mutate({ id, newTitle });
+  };
+
+  getTopics = (params: QueryTopicParams): Promise<ChatTopic[]> => {
+    return lambdaClient.topic.getTopics.query({
+      ...params,
+      containerId: this.toDbSessionId(params.containerId),
+    }) as any;
+  };
+
+  getAllTopics = (): Promise<ChatTopic[]> => {
+    return lambdaClient.topic.getAllTopics.query() as any;
+  };
+
+  countTopics = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.topic.countTopics.query(params);
+  };
+
+  rankTopics = async (limit?: number): Promise<TopicRankItem[]> => {
+    return lambdaClient.topic.rankTopics.query(limit);
+  };
+
+  searchTopics = (keywords: string, sessionId?: string, groupId?: string): Promise<ChatTopic[]> => {
+    return lambdaClient.topic.searchTopics.query({
+      groupId,
+      keywords,
+      sessionId: this.toDbSessionId(sessionId),
+    }) as any;
+  };
+
+  updateTopic = (id: string, data: Partial<ChatTopic>) => {
+    return lambdaClient.topic.updateTopic.mutate({ id, value: data });
+  };
+
+  removeTopic = (id: string) => {
+    return lambdaClient.topic.removeTopic.mutate({ id });
+  };
+
+  removeTopics = (sessionId: string) => {
+    return lambdaClient.topic.batchDeleteBySessionId.mutate({ id: this.toDbSessionId(sessionId) });
+  };
+
+  batchRemoveTopics = (topics: string[]) => {
+    return lambdaClient.topic.batchDelete.mutate({ ids: topics });
+  };
+
+  removeAllTopic = () => {
+    return lambdaClient.topic.removeAllTopics.mutate();
+  };
+
+  private toDbSessionId = (sessionId?: string | null) =>
+    sessionId === INBOX_SESSION_ID ? null : sessionId;
+}
+
+export const topicService = new TopicService();

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

@@ -0,0 +1,8 @@
+import { describe } from 'vitest';
+import { testService } from '~test-utils';
+
+import { UserService } from './index';
+
+describe('UserService', () => {
+  testService(UserService);
+});

package/src/services/user/index.ts

@@ -1,3 +1,54 @@
-import { ServerService } from './server';
+import type { AdapterAccount } from 'next-auth/adapters';
+import type { PartialDeep } from 'type-fest';
 
-export const userService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
+import { UserSettings } from '@/types/user/settings';
+
+export class UserService {
+  getUserRegistrationDuration = async (): Promise<{
+    createdAt: string;
+    duration: number;
+    updatedAt: string;
+  }> => {
+    return lambdaClient.user.getUserRegistrationDuration.query();
+  };
+
+  getUserState = async (): Promise<UserInitializationState> => {
+    return lambdaClient.user.getUserState.query();
+  };
+
+  getUserSSOProviders = async (): Promise<AdapterAccount[]> => {
+    return lambdaClient.user.getUserSSOProviders.query();
+  };
+
+  unlinkSSOProvider = async (provider: string, providerAccountId: string) => {
+    return lambdaClient.user.unlinkSSOProvider.mutate({ provider, providerAccountId });
+  };
+
+  makeUserOnboarded = async () => {
+    return lambdaClient.user.makeUserOnboarded.mutate();
+  };
+
+  updateAvatar = async (avatar: string) => {
+    return lambdaClient.user.updateAvatar.mutate(avatar);
+  };
+
+  updatePreference = async (preference: Partial<UserPreference>) => {
+    return lambdaClient.user.updatePreference.mutate(preference);
+  };
+
+  updateGuide = async (guide: Partial<UserGuide>) => {
+    return lambdaClient.user.updateGuide.mutate(guide);
+  };
+
+  updateUserSettings = async (value: PartialDeep<UserSettings>, signal?: AbortSignal) => {
+    return lambdaClient.user.updateSettings.mutate(value, { signal });
+  };
+
+  resetUserSettings = async () => {
+    return lambdaClient.user.resetSettings.mutate();
+  };
+}
+
+export const userService = new UserService();

package/src/store/aiInfra/slices/aiModel/action.test.ts

@@ -101,7 +101,7 @@ describe('AiModelAction', () => {
         .mockResolvedValue(undefined);
       const serviceSpy = vi
         .spyOn(aiModelService, 'batchUpdateAiModels')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.batchUpdateAiModels(models);
@@ -119,7 +119,7 @@ describe('AiModelAction', () => {
       const { result } = renderHook(() => useStore());
       const serviceSpy = vi
         .spyOn(aiModelService, 'batchUpdateAiModels')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.batchUpdateAiModels([]);
@@ -137,7 +137,7 @@ describe('AiModelAction', () => {
         .mockResolvedValue(undefined);
       const serviceSpy = vi
         .spyOn(aiModelService, 'clearModelsByProvider')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.clearModelsByProvider('test-provider');
@@ -154,7 +154,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'clearRemoteModels').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'clearRemoteModels')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.clearRemoteModels('test-provider');
@@ -178,7 +180,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'createAiModel').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'createAiModel')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.createNewAiModel(params);
@@ -349,7 +353,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'deleteAiModel').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'deleteAiModel')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.removeAiModel('model-1', 'test-provider');
@@ -371,7 +377,7 @@ describe('AiModelAction', () => {
         .mockResolvedValue(undefined);
       const serviceSpy = vi
         .spyOn(aiModelService, 'toggleModelEnabled')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.toggleModelEnabled({ enabled: true, id: 'model-1' });
@@ -395,7 +401,7 @@ describe('AiModelAction', () => {
       const { result } = renderHook(() => useStore());
       const serviceSpy = vi
         .spyOn(aiModelService, 'toggleModelEnabled')
-        .mockResolvedValue(undefined);
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.toggleModelEnabled({ enabled: true, id: 'model-1' });
@@ -435,7 +441,9 @@ describe('AiModelAction', () => {
       const refreshSpy = vi
         .spyOn(result.current, 'refreshAiModelList')
         .mockResolvedValue(undefined);
-      const serviceSpy = vi.spyOn(aiModelService, 'updateAiModel').mockResolvedValue(undefined);
+      const serviceSpy = vi
+        .spyOn(aiModelService, 'updateAiModel')
+        .mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.updateAiModelsConfig('model-1', 'test-provider', updateData);

package/src/store/chat/slices/aiChat/actions/__tests__/helpers.ts

@@ -63,10 +63,12 @@ export const spyOnMessageService = () => {
   const updateMessageSpy = vi
     .spyOn(messageService, 'updateMessage')
     .mockResolvedValue({ messages: [], success: true });
-  const removeMessageSpy = vi.spyOn(messageService, 'removeMessage').mockResolvedValue(undefined);
+  const removeMessageSpy = vi
+    .spyOn(messageService, 'removeMessage')
+    .mockResolvedValue(undefined as any);
   const updateMessageErrorSpy = vi
     .spyOn(messageService, 'updateMessageError')
-    .mockResolvedValue(undefined);
+    .mockResolvedValue(undefined as any);
 
   return {
     createMessageSpy,

package/src/store/chat/slices/topic/action.test.ts

@@ -254,7 +254,7 @@ describe('topic action', () => {
 
       const updateFavoriteSpy = vi
         .spyOn(topicService, 'updateTopic')
-        .mockResolvedValue({ success: 1 });
+        .mockResolvedValue(undefined as any);
 
       const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
 

package/src/store/chat/slices/topic/action.ts

@@ -15,7 +15,6 @@ import { useClientDataSWR } from '@/libs/swr';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
-import { CreateTopicParams } from '@/services/topic/type';
 import type { ChatStore } from '@/store/chat';
 import type { ChatStoreState } from '@/store/chat/initialState';
 import { messageMapKey } from '@/store/chat/utils/messageMapKey';
@@ -24,7 +23,7 @@ import { useSessionStore } from '@/store/session';
 import { sessionSelectors } from '@/store/session/selectors';
 import { useUserStore } from '@/store/user';
 import { systemAgentSelectors } from '@/store/user/selectors';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, CreateTopicParams } from '@/types/topic';
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
 

package/src/store/chat/slices/topic/reducer.ts

@@ -1,7 +1,6 @@
 import { produce } from 'immer';
 
-import { CreateTopicParams } from '@/services/topic/type';
-import { ChatTopic } from '@/types/topic';
+import { ChatTopic, CreateTopicParams } from '@/types/topic';
 
 interface AddChatTopicAction {
   type: 'addTopic';

package/src/store/file/slices/chat/action.ts

@@ -4,7 +4,6 @@ import { StateCreator } from 'zustand/vanilla';
 import { notification } from '@/components/AntdStaticMethods';
 import { FILE_UPLOAD_BLACKLIST } from '@/const/file';
 import { fileService } from '@/services/file';
-import { ServerService } from '@/services/file/server';
 import { ragService } from '@/services/rag';
 import { UPLOAD_NETWORK_ERROR } from '@/services/upload';
 import {
@@ -21,8 +20,6 @@ import { FileStore } from '../../store';
 
 const n = setNamespace('chat');
 
-const serverFileService = new ServerService();
-
 export interface FileAction {
   clearChatUploadFileList: () => void;
   dispatchChatUploadFileList: (payload: UploadFileListDispatch) => void;
@@ -71,7 +68,7 @@ export const createFileSlice: StateCreator<
       let fileItem: FileListItem | undefined = undefined;
 
       try {
-        fileItem = await serverFileService.getFileItem(id);
+        fileItem = await fileService.getFileItem(id);
       } catch (e) {
         console.error('getFileItem Error:', e);
         continue;

package/src/store/file/slices/fileManager/action.ts

@@ -4,8 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { useClientDataSWR } from '@/libs/swr';
-import { fileService } from '@/services/file';
-import { ServerService } from '@/services/file/server';
+import { fileService , FileService } from '@/services/file';
 import { ragService } from '@/services/rag';
 import {
   UploadFileListDispatch,
@@ -18,7 +17,7 @@ import { unzipFile } from '@/utils/unzipFile';
 import { FileStore } from '../../store';
 import { fileManagerSelectors } from './selectors';
 
-const serverFileService = new ServerService();
+const serverFileService = new FileService();
 
 export interface FileManageAction {
   dispatchDockFileList: (payload: UploadFileListDispatch) => void;

package/src/store/session/slices/sessionGroup/action.test.ts

@@ -42,7 +42,7 @@ describe('createSessionGroupSlice', () => {
     it('should clear session groups and refresh sessions', async () => {
       const spyOn = vi
         .spyOn(sessionService, 'removeSessionGroups')
-        .mockResolvedValueOnce(undefined);
+        .mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -59,7 +59,7 @@ describe('createSessionGroupSlice', () => {
   describe('removeSessionGroup', () => {
     it('should remove a session group and refresh sessions', async () => {
       const mockId = 'mock-id';
-      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -77,7 +77,7 @@ describe('createSessionGroupSlice', () => {
     it('should update a session group id and refresh sessions', async () => {
       const mockSessionId = 'session-id';
       const mockGroupId = 'group-id';
-      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -98,7 +98,7 @@ describe('createSessionGroupSlice', () => {
       const mockId = 'mock-id';
       const mockName = 'New Name';
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
-      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined as any);
 
       const { result } = renderHook(() => useSessionStore());
 
@@ -117,7 +117,7 @@ describe('createSessionGroupSlice', () => {
         { id: 'id1', sort: 0 },
         { id: 'id2', sort: 1 },
       ];
-      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());

package/src/store/tool/slices/mcpStore/action.test.ts

@@ -20,6 +20,44 @@ vi.mock('@/utils/sleep', () => ({
   sleep: vi.fn().mockResolvedValue(undefined),
 }));
 
+const ORIGINAL_DESKTOP_ENV = process.env.NEXT_PUBLIC_IS_DESKTOP_APP;
+
+const bootstrapToolStoreWithDesktop = async (isDesktopEnv: boolean) => {
+  vi.resetModules();
+  vi.mock('zustand/traditional');
+  process.env.NEXT_PUBLIC_IS_DESKTOP_APP = isDesktopEnv ? '1' : '0';
+
+  vi.doMock('@lobechat/const', async () => {
+    const actual = await vi.importActual<typeof import('@lobechat/const')>('@lobechat/const');
+    return {
+      ...actual,
+      isDesktop: isDesktopEnv,
+    };
+  });
+
+  const storeModule = await import('@/store/tool');
+  const discoverModule = await import('@/services/discover');
+  const helpersModule = await import('@/store/global/helpers');
+
+  const cleanup = () => {
+    vi.resetModules();
+    vi.doUnmock('@lobechat/const');
+    vi.mock('zustand/traditional');
+    if (ORIGINAL_DESKTOP_ENV === undefined) {
+      delete process.env.NEXT_PUBLIC_IS_DESKTOP_APP;
+    } else {
+      process.env.NEXT_PUBLIC_IS_DESKTOP_APP = ORIGINAL_DESKTOP_ENV;
+    }
+  };
+
+  return {
+    useToolStore: storeModule.useToolStore,
+    discoverService: discoverModule.discoverService,
+    globalHelpers: helpersModule.globalHelpers,
+    cleanup,
+  };
+};
+
 beforeEach(() => {
   vi.clearAllMocks();
 
@@ -48,6 +86,14 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
+afterAll(() => {
+  if (ORIGINAL_DESKTOP_ENV === undefined) {
+    delete process.env.NEXT_PUBLIC_IS_DESKTOP_APP;
+  } else {
+    process.env.NEXT_PUBLIC_IS_DESKTOP_APP = ORIGINAL_DESKTOP_ENV;
+  }
+});
+
 describe('mcpStore actions', () => {
   describe('updateMCPInstallProgress', () => {
     it('should update install progress for an identifier', () => {
@@ -487,7 +533,9 @@ describe('mcpStore actions', () => {
         expect(result.current.data).toEqual(mockData);
       });
 
-      expect(discoverService.getMCPPluginList).toHaveBeenCalledWith({ page: 1, pageSize: 20 });
+      expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(
+        expect.objectContaining({ page: 1, pageSize: 20, connectionType: 'http' }),
+      );
 
       const state = useToolStore.getState();
       expect(state.mcpPluginItems).toEqual(mockData.items);
@@ -542,7 +590,9 @@ describe('mcpStore actions', () => {
       renderHook(() => useToolStore.getState().useFetchMCPPluginList(params));
 
       await waitFor(() => {
-        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(params);
+        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(
+          expect.objectContaining({ ...params, connectionType: 'http' }),
+        );
       });
     });
 
@@ -561,9 +611,51 @@ describe('mcpStore actions', () => {
       renderHook(() => useToolStore.getState().useFetchMCPPluginList(params));
 
       await waitFor(() => {
-        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(params);
+        expect(discoverService.getMCPPluginList).toHaveBeenCalledWith(
+          expect.objectContaining({ ...params, connectionType: 'http' }),
+        );
       });
     });
+
+    it('should not append connectionType in desktop environment', async () => {
+      const {
+        useToolStore: desktopStore,
+        discoverService: desktopDiscoverService,
+        globalHelpers: desktopGlobalHelpers,
+        cleanup,
+      } = await bootstrapToolStoreWithDesktop(true);
+
+      const mockData = {
+        items: [{ identifier: 'desktop-plugin', name: 'Desktop Plugin' }] as PluginItem[],
+        categories: [],
+        totalCount: 1,
+        totalPages: 1,
+        currentPage: 1,
+        pageSize: 20,
+      };
+
+      try {
+        vi.spyOn(desktopGlobalHelpers, 'getCurrentLanguage').mockReturnValue('en-US');
+        const fetchSpy = vi
+          .spyOn(desktopDiscoverService, 'getMCPPluginList')
+          .mockResolvedValue(mockData);
+
+        const { result } = renderHook(() =>
+          desktopStore.getState().useFetchMCPPluginList({ page: 1, pageSize: 20 }),
+        );
+
+        await waitFor(() => {
+          expect(result.current.data).toEqual(mockData);
+        });
+
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        const [firstCallArgs] = fetchSpy.mock.calls[0];
+        expect(firstCallArgs).toMatchObject({ page: 1, pageSize: 20 });
+        expect(firstCallArgs.connectionType).toBeUndefined();
+      } finally {
+        cleanup();
+      }
+    });
   });
 
   describe('installMCPPlugin', () => {