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

package/src/services/import/index.ts

@@ -1,3 +1,134 @@
-import { ServerService } from './server';
+import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
 
-export const importService = new ServerService();
+import { lambdaClient } from '@/libs/trpc/client';
+import { uploadService } from '@/services/upload';
+import { useUserStore } from '@/store/user';
+import { ImportPgDataStructure } from '@/types/export';
+import { ImporterEntryData, ImportStage, OnImportCallbacks } from '@/types/importer';
+import { UserSettings } from '@/types/user/settings';
+import { uuid } from '@/utils/uuid';
+
+class ImportService {
+  importSettings = async (settings: UserSettings): Promise<void> => {
+    await useUserStore.getState().importAppSettings(settings);
+  };
+
+  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void> => {
+    const handleError = (e: unknown) => {
+      callbacks?.onStageChange?.(ImportStage.Error);
+      const error = e as DefaultErrorShape;
+
+      callbacks?.onError?.({
+        code: error.data.code,
+        httpStatus: error.data.httpStatus,
+        message: error.message,
+        path: error.data.path,
+      });
+    };
+
+    const totalLength =
+      (data.messages?.length || 0) +
+      (data.sessionGroups?.length || 0) +
+      (data.sessions?.length || 0) +
+      (data.topics?.length || 0);
+
+    if (totalLength < 500) {
+      callbacks?.onStageChange?.(ImportStage.Importing);
+      const time = Date.now();
+      try {
+        const result = await lambdaClient.importer.importByPost.mutate({ data });
+        const duration = Date.now() - time;
+
+        callbacks?.onStageChange?.(ImportStage.Success);
+        callbacks?.onSuccess?.(result.results, duration);
+      } catch (e) {
+        handleError(e);
+      }
+
+      return;
+    }
+
+    await this.uploadData(data, { callbacks, handleError });
+  };
+
+  importPgData = async (
+    data: ImportPgDataStructure,
+    options?: {
+      callbacks?: OnImportCallbacks;
+      overwriteExisting?: boolean;
+    },
+  ): Promise<void> => {
+    const { callbacks } = options || {};
+
+    const handleError = (e: unknown) => {
+      callbacks?.onStageChange?.(ImportStage.Error);
+      const error = e as DefaultErrorShape;
+
+      callbacks?.onError?.({
+        code: error.data.code,
+        httpStatus: error.data.httpStatus,
+        message: error.message,
+        path: error.data.path,
+      });
+    };
+
+    const totalLength = Object.values(data.data)
+      .map((d) => d.length)
+      .reduce((a, b) => a + b, 0);
+
+    if (totalLength < 500) {
+      callbacks?.onStageChange?.(ImportStage.Importing);
+      const time = Date.now();
+      try {
+        const result = await lambdaClient.importer.importPgByPost.mutate(data);
+        const duration = Date.now() - time;
+
+        callbacks?.onStageChange?.(ImportStage.Success);
+        callbacks?.onSuccess?.(result.results, duration);
+      } catch (e) {
+        handleError(e);
+      }
+
+      return;
+    }
+
+    await this.uploadData(data, { callbacks, handleError });
+  };
+
+  private uploadData = async (
+    data: object,
+    { callbacks, handleError }: { callbacks?: OnImportCallbacks; handleError: (e: unknown) => any },
+  ) => {
+    // if the data is too large, upload it to S3 and upload by file
+    const filename = `${uuid()}.json`;
+
+    let pathname;
+    try {
+      callbacks?.onStageChange?.(ImportStage.Uploading);
+      const result = await uploadService.uploadDataToS3(data, {
+        filename,
+        onProgress: (status, state) => {
+          callbacks?.onFileUploading?.(state);
+        },
+        pathname: `import_config/${filename}`,
+      });
+      pathname = result.data.path;
+      console.log(pathname);
+    } catch {
+      throw new Error('Upload Error');
+    }
+
+    callbacks?.onStageChange?.(ImportStage.Importing);
+    const time = Date.now();
+    try {
+      const result = await lambdaClient.importer.importByFile.mutate({ pathname });
+      const duration = Date.now() - time;
+      callbacks?.onStageChange?.(ImportStage.Success);
+      callbacks?.onSuccess?.(result.results, duration);
+    } catch (e) {
+      handleError(e);
+    }
+  };
+}
+
+export const importService = new ImportService();

package/src/services/message/index.ts

@@ -1,3 +1,177 @@
-import { ServerService } from './server';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  ChatMessageError,
+  ChatMessagePluginError,
+  ChatTranslate,
+  ChatTTS,
+  CreateMessageParams,
+  CreateMessageResult,
+  ModelRankItem,
+  UIChatMessage,
+  UpdateMessageParams,
+  UpdateMessageRAGParams,
+  UpdateMessageResult,
+} from '@lobechat/types';
+import type { HeatmapsProps } from '@lobehub/charts';
 
-export const messageService = new ServerService();
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { useUserStore } from '@/store/user';
+import { labPreferSelectors } from '@/store/user/selectors';
+
+export class MessageService {
+  createMessage = async ({ sessionId, ...params }: CreateMessageParams): Promise<string> => {
+    return lambdaClient.message.createMessage.mutate({
+      ...params,
+      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
+    });
+  };
+
+  createNewMessage = async ({
+    sessionId,
+    ...params
+  }: CreateMessageParams): Promise<CreateMessageResult> => {
+    return lambdaClient.message.createNewMessage.mutate({
+      ...params,
+      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
+    });
+  };
+
+  getMessages = async (
+    sessionId: string,
+    topicId?: string,
+    groupId?: string,
+  ): Promise<UIChatMessage[]> => {
+    // Get user lab preference for message grouping
+    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
+
+    const data = await lambdaClient.message.getMessages.query({
+      groupId,
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+      useGroup,
+    });
+
+    return data as unknown as UIChatMessage[];
+  };
+
+  getGroupMessages = async (groupId: string, topicId?: string): Promise<UIChatMessage[]> => {
+    // Get user lab preference for message grouping
+    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
+
+    const data = await lambdaClient.message.getMessages.query({
+      groupId,
+      topicId,
+      useGroup,
+    });
+    return data as unknown as UIChatMessage[];
+  };
+
+  countMessages = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.message.count.query(params);
+  };
+
+  countWords = async (params?: {
+    endDate?: string;
+    range?: [string, string];
+    startDate?: string;
+  }): Promise<number> => {
+    return lambdaClient.message.countWords.query(params);
+  };
+
+  rankModels = async (): Promise<ModelRankItem[]> => {
+    return lambdaClient.message.rankModels.query();
+  };
+
+  getHeatmaps = async (): Promise<HeatmapsProps['data']> => {
+    return lambdaClient.message.getHeatmaps.query();
+  };
+
+  updateMessageError = async (id: string, error: ChatMessageError) => {
+    return lambdaClient.message.update.mutate({ id, value: { error } });
+  };
+
+  updateMessagePluginArguments = async (id: string, value: string | Record<string, any>) => {
+    const args = typeof value === 'string' ? value : JSON.stringify(value);
+    return lambdaClient.message.updateMessagePlugin.mutate({ id, value: { arguments: args } });
+  };
+
+  updateMessage = async (
+    id: string,
+    value: Partial<UpdateMessageParams>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.update.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      value,
+    });
+  };
+
+  updateMessageTranslate = async (id: string, translate: Partial<ChatTranslate> | false) => {
+    return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
+  };
+
+  updateMessageTTS = async (id: string, tts: Partial<ChatTTS> | false) => {
+    return lambdaClient.message.updateTTS.mutate({ id, value: tts });
+  };
+
+  updateMessagePluginState = async (id: string, value: Record<string, any>) => {
+    return lambdaClient.message.updatePluginState.mutate({ id, value });
+  };
+
+  updateMessagePluginError = async (id: string, error: ChatMessagePluginError | null) => {
+    return lambdaClient.message.updatePluginError.mutate({ id, value: error as any });
+  };
+
+  updateMessageRAG = async (id: string, data: UpdateMessageRAGParams): Promise<void> => {
+    return lambdaClient.message.updateMessageRAG.mutate({ id, value: data });
+  };
+
+  removeMessage = async (id: string) => {
+    return lambdaClient.message.removeMessage.mutate({ id });
+  };
+
+  removeMessages = async (ids: string[]) => {
+    return lambdaClient.message.removeMessages.mutate({ ids });
+  };
+
+  removeMessagesByAssistant = async (sessionId: string, topicId?: string) => {
+    return lambdaClient.message.removeMessagesByAssistant.mutate({
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+    });
+  };
+
+  removeMessagesByGroup = async (groupId: string, topicId?: string) => {
+    return lambdaClient.message.removeMessagesByGroup.mutate({
+      groupId,
+      topicId,
+    });
+  };
+
+  removeAllMessages = async () => {
+    return lambdaClient.message.removeAllMessages.mutate();
+  };
+
+  private toDbSessionId = (sessionId: string | undefined) => {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  };
+
+  hasMessages = async (): Promise<boolean> => {
+    const number = await this.countMessages();
+    return number > 0;
+  };
+
+  messageCountToCheckTrace = async (): Promise<boolean> => {
+    const number = await this.countMessages();
+    return number >= 4;
+  };
+}
+
+export const messageService = new MessageService();

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();