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

package/src/services/message/{__tests__/server.test.ts → server.test.ts}

@@ -2,11 +2,11 @@ import { describe, expect, it } from 'vitest';
 
 import { INBOX_SESSION_ID } from '@/const/session';
 
-import { ServerService } from '../server';
+import { MessageService } from './index';
 
-describe('ServerService', () => {
+describe('MessageService', () => {
   describe('toDbSessionId', () => {
-    const service = new ServerService();
+    const service = new MessageService();
     // @ts-ignore access private method for testing
     const toDbSessionId = service.toDbSessionId;
 

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

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

package/src/services/plugin/index.ts

@@ -1,3 +1,54 @@
-import { ServerService } from './server';
+import { LobeTool } from '@lobechat/types';
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 
-export const pluginService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+import { LobeToolCustomPlugin } from '@/types/tool/plugin';
+
+export interface InstallPluginParams {
+  customParams?: Record<string, any>;
+  identifier: string;
+  manifest: LobeChatPluginManifest;
+  settings?: Record<string, any>;
+  type: 'plugin' | 'customPlugin';
+}
+
+export class PluginService {
+  installPlugin = async (plugin: InstallPluginParams): Promise<void> => {
+    await lambdaClient.plugin.createOrInstallPlugin.mutate(plugin);
+  };
+
+  getInstalledPlugins = (): Promise<LobeTool[]> => {
+    return lambdaClient.plugin.getPlugins.query();
+  };
+
+  uninstallPlugin = async (identifier: string): Promise<void> => {
+    await lambdaClient.plugin.removePlugin.mutate({ id: identifier });
+  };
+
+  createCustomPlugin = async (customPlugin: LobeToolCustomPlugin): Promise<void> => {
+    await lambdaClient.plugin.createPlugin.mutate({ ...customPlugin, type: 'customPlugin' });
+  };
+
+  updatePlugin = async (id: string, value: Partial<LobeToolCustomPlugin>): Promise<void> => {
+    await lambdaClient.plugin.updatePlugin.mutate({
+      customParams: value.customParams,
+      id,
+      manifest: value.manifest,
+      settings: value.settings,
+    });
+  };
+
+  updatePluginManifest = async (id: string, manifest: LobeChatPluginManifest): Promise<void> => {
+    await lambdaClient.plugin.updatePlugin.mutate({ id, manifest });
+  };
+
+  removeAllPlugins = async (): Promise<void> => {
+    await lambdaClient.plugin.removeAllPlugins.mutate();
+  };
+
+  updatePluginSettings = async (id: string, settings: any, signal?: AbortSignal): Promise<void> => {
+    await lambdaClient.plugin.updatePlugin.mutate({ id, settings }, { signal });
+  };
+}
+
+export const pluginService = new PluginService();

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

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

package/src/services/session/index.ts

@@ -1,3 +1,146 @@
-import { ServerService } from './server';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { PartialDeep } from 'type-fest';
 
-export const sessionService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
+import { MetaData } from '@/types/meta';
+import { BatchTaskResult } from '@/types/service';
+import {
+  ChatSessionList,
+  LobeAgentSession,
+  LobeSessionType,
+  LobeSessions,
+  SessionGroupItem,
+  SessionGroups,
+  SessionRankItem,
+  UpdateSessionParams,
+} from '@/types/session';
+
+export class SessionService {
+  hasSessions = async (): Promise<boolean> => {
+    const result = await this.countSessions();
+    return result === 0;
+  };
+
+  createSession = async (
+    type: LobeSessionType,
+    data: Partial<LobeAgentSession>,
+  ): Promise<string> => {
+    const { config, group, meta, ...session } = data;
+    return lambdaClient.session.createSession.mutate({
+      config: { ...config, ...meta } as any,
+      session: { ...session, groupId: group },
+      type,
+    });
+  };
+
+  cloneSession = (id: string, newTitle: string): Promise<string | undefined> => {
+    return lambdaClient.session.cloneSession.mutate({ id, newTitle });
+  };
+
+  getGroupedSessions = (): Promise<ChatSessionList> => {
+    return lambdaClient.session.getGroupedSessions.query();
+  };
+
+  countSessions = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.session.countSessions.query(params);
+  };
+
+  rankSessions = async (limit?: number): Promise<SessionRankItem[]> => {
+    return lambdaClient.session.rankSessions.query(limit);
+  };
+
+  updateSession = (id: string, data: Partial<UpdateSessionParams>) => {
+    const { group, pinned, meta, updatedAt } = data;
+    return lambdaClient.session.updateSession.mutate({
+      id,
+      value: { groupId: group === 'default' ? null : group, pinned, ...meta, updatedAt },
+    });
+  };
+
+  // TODO: Need to be fixed
+  getSessionConfig = async (id: string): Promise<LobeAgentConfig> => {
+    // @ts-ignore
+    return lambdaClient.agent.getAgentConfig.query({ sessionId: id });
+  };
+
+  updateSessionConfig = (
+    id: string,
+    config: PartialDeep<LobeAgentConfig>,
+    signal?: AbortSignal,
+  ) => {
+    return lambdaClient.session.updateSessionConfig.mutate(
+      { id, value: config },
+      {
+        context: { showNotification: false },
+        signal,
+      },
+    );
+  };
+
+  updateSessionMeta = (id: string, meta: Partial<MetaData>, signal?: AbortSignal) => {
+    return lambdaClient.session.updateSessionConfig.mutate({ id, value: meta }, { signal });
+  };
+
+  updateSessionChatConfig = (
+    id: string,
+    value: Partial<LobeAgentChatConfig>,
+    signal?: AbortSignal,
+  ) => {
+    return lambdaClient.session.updateSessionChatConfig.mutate({ id, value }, { signal });
+  };
+
+  searchSessions = (keywords: string): Promise<LobeSessions> => {
+    return lambdaClient.session.searchSessions.query({ keywords });
+  };
+
+  removeSession = (id: string) => {
+    return lambdaClient.session.removeSession.mutate({ id });
+  };
+
+  removeAllSessions = () => {
+    return lambdaClient.session.removeAllSessions.mutate();
+  };
+
+  // ************************************** //
+  // ***********  SessionGroup  *********** //
+  // ************************************** //
+
+  createSessionGroup = (name: string, sort?: number): Promise<string> => {
+    return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
+  };
+
+  getSessionGroups = (): Promise<SessionGroupItem[]> => {
+    return lambdaClient.sessionGroup.getSessionGroup.query();
+  };
+
+  /**
+   * 需要废弃
+   * @deprecated
+   */
+  batchCreateSessionGroups = (groups: SessionGroups): Promise<BatchTaskResult> => {
+    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
+  };
+
+  removeSessionGroup = (id: string, removeChildren?: boolean) => {
+    return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
+  };
+
+  removeSessionGroups = () => {
+    return lambdaClient.sessionGroup.removeAllSessionGroups.mutate();
+  };
+
+  updateSessionGroup = (id: string, value: Partial<SessionGroupItem>) => {
+    return lambdaClient.sessionGroup.updateSessionGroup.mutate({ id, value });
+  };
+
+  updateSessionGroupOrder = (sortMap: { id: string; sort: number }[]) => {
+    return lambdaClient.sessionGroup.updateSessionGroupOrder.mutate({ sortMap });
+  };
+}
+
+export const sessionService = new SessionService();

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

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

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;