@lobehub/chat 0.162.25 → 0.163.0

package/src/services/import/server.ts

@@ -0,0 +1,115 @@
+import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
+
+import { edgeClient, lambdaClient } from '@/libs/trpc/client';
+import { useUserStore } from '@/store/user';
+import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
+import { UserSettings } from '@/types/user/settings';
+import { uuid } from '@/utils/uuid';
+
+export class ServerService {
+  importSettings = async (settings: UserSettings) => {
+    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, duration);
+      } catch (e) {
+        handleError(e);
+      }
+
+      return;
+    }
+
+    // if the data is too large, upload it to S3 and upload by file
+    const filename = `${uuid()}.json`;
+
+    const pathname = `import_config/${filename}`;
+
+    const url = await edgeClient.upload.createS3PreSignedUrl.mutate({ pathname });
+
+    try {
+      callbacks?.onStageChange?.(ImportStage.Uploading);
+      await this.uploadWithProgress(url, data, callbacks?.onFileUploading);
+    } 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, duration);
+    } catch (e) {
+      handleError(e);
+    }
+  };
+
+  private uploadWithProgress = async (
+    url: string,
+    data: object,
+    onProgress: OnImportCallbacks['onFileUploading'],
+  ) => {
+    const xhr = new XMLHttpRequest();
+
+    let startTime = Date.now();
+    xhr.upload.addEventListener('progress', (event) => {
+      if (event.lengthComputable) {
+        const progress = Number(((event.loaded / event.total) * 100).toFixed(1));
+
+        const speedInByte = event.loaded / ((Date.now() - startTime) / 1000);
+
+        onProgress?.({
+          // if the progress is 100, it means the file is uploaded
+          // but the server is still processing it
+          // so make it as 99.5 and let users think it's still uploading
+          progress: progress === 100 ? 99.5 : progress,
+          restTime: (event.total - event.loaded) / speedInByte,
+          speed: speedInByte / 1024,
+        });
+      }
+    });
+
+    xhr.open('PUT', url);
+    xhr.setRequestHeader('Content-Type', 'application/json');
+
+    return new Promise((resolve, reject) => {
+      xhr.addEventListener('load', () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve(xhr.response);
+        } else {
+          reject(xhr.statusText);
+        }
+      });
+      xhr.addEventListener('error', () => reject(xhr.statusText));
+      xhr.send(JSON.stringify(data));
+    });
+  };
+}

package/src/services/message/index.ts

@@ -1,12 +1,8 @@
-// import { getClientConfig } from '@/config/client';
-// import { ServerService } from './server';
-// import { ClientService } from './client';
-//
-// const { ENABLED_SERVER_SERVICE } = getClientConfig();
-//
-// export const messageService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
+import { isServerMode } from '@/const/version';
+
 import { ClientService } from './client';
+import { ServerService } from './server';
 
 export type { CreateMessageParams } from './type';
 
-export const messageService = new ClientService();
+export const messageService = isServerMode ? new ServerService() : new ClientService();

package/src/services/message/server.ts

@@ -0,0 +1,93 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { ChatMessage, ChatMessageError, ChatTTS, ChatTranslate } from '@/types/message';
+
+import { CreateMessageParams, IMessageService } from './type';
+
+export class ServerService implements IMessageService {
+  createMessage({ sessionId, ...params }: CreateMessageParams): Promise<string> {
+    return lambdaClient.message.createMessage.mutate({
+      ...params,
+      sessionId: this.toDbSessionId(sessionId),
+    });
+  }
+
+  batchCreateMessages(messages: ChatMessage[]): Promise<any> {
+    return lambdaClient.message.batchCreateMessages.mutate(messages);
+  }
+
+  getMessages(sessionId?: string, topicId?: string | undefined): Promise<ChatMessage[]> {
+    return lambdaClient.message.getMessages.query({
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+    });
+  }
+
+  getAllMessages(): Promise<ChatMessage[]> {
+    return lambdaClient.message.getAllMessages.query();
+  }
+  getAllMessagesInSession(sessionId: string): Promise<ChatMessage[]> {
+    return lambdaClient.message.getAllMessagesInSession.query({
+      sessionId: this.toDbSessionId(sessionId),
+    });
+  }
+
+  countMessages(): Promise<number> {
+    return lambdaClient.message.count.query();
+  }
+  countTodayMessages(): Promise<number> {
+    return lambdaClient.message.countToday.query();
+  }
+
+  updateMessageError(id: string, error: ChatMessageError): Promise<any> {
+    return lambdaClient.message.update.mutate({ id, value: { error } });
+  }
+
+  updateMessage(id: string, message: Partial<ChatMessage>): Promise<any> {
+    return lambdaClient.message.update.mutate({ id, value: message });
+  }
+
+  updateMessageTranslate(id: string, translate: Partial<ChatTranslate> | false): Promise<any> {
+    return lambdaClient.message.updateTranslate.mutate({ id, value: translate as ChatTranslate });
+  }
+
+  updateMessageTTS(id: string, tts: Partial<ChatTTS> | false): Promise<any> {
+    return lambdaClient.message.updateTTS.mutate({ id, value: tts });
+  }
+
+  updateMessagePluginState(id: string, value: any): Promise<any> {
+    return lambdaClient.message.updatePluginState.mutate({ id, value });
+  }
+
+  bindMessagesToTopic(topicId: string, messageIds: string[]): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  removeMessage(id: string): Promise<any> {
+    return lambdaClient.message.removeMessage.mutate({ id });
+  }
+  removeMessages(sessionId: string, topicId?: string | undefined): Promise<any> {
+    return lambdaClient.message.removeMessages.mutate({
+      sessionId: this.toDbSessionId(sessionId),
+      topicId,
+    });
+  }
+  removeAllMessages(): Promise<any> {
+    return lambdaClient.message.removeAllMessages.mutate();
+  }
+
+  private toDbSessionId(sessionId: string | undefined) {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  }
+
+  async hasMessages() {
+    const number = await this.countMessages();
+    return number > 0;
+  }
+
+  async messageCountToCheckTrace() {
+    const number = await this.countMessages();
+    return number >= 4;
+  }
+}

package/src/services/plugin/index.ts

@@ -1,11 +1,6 @@
-// import { getClientConfig } from '@/config/client';
-import { ClientService } from './client';
+import { isServerMode } from '@/const/version';
 
-// import { ServerService } from './server';
-//
-// export type { InstallPluginParams } from './client';
-//
-// const { ENABLED_SERVER_SERVICE } = getClientConfig();
+import { ClientService } from './client';
+import { ServerService } from './server';
 
-// export const pluginService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
-export const pluginService = new ClientService();
+export const pluginService = isServerMode ? new ServerService() : new ClientService();

package/src/services/plugin/server.ts

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

package/src/services/session/index.ts

@@ -1,10 +1,6 @@
-// import { getClientConfig } from '@/config/client';
-//
-import { ClientService } from './client';
-
-// import { ServerService } from './server';
+import { isServerMode } from '@/const/version';
 
-// const { ENABLED_SERVER_SERVICE } = getClientConfig();
+import { ClientService } from './client';
+import { ServerService } from './server';
 
-// export const sessionService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
-export const sessionService = new ClientService();
+export const sessionService = isServerMode ? new ServerService() : new ClientService();

package/src/services/session/server.ts

@@ -0,0 +1,148 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { DeepPartial } from 'utility-types';
+
+import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import { lambdaClient } from '@/libs/trpc/client';
+import { useUserStore } from '@/store/user';
+import { authSelectors } from '@/store/user/selectors';
+import { LobeAgentChatConfig, LobeAgentConfig } from '@/types/agent';
+import { MetaData } from '@/types/meta';
+import { BatchTaskResult } from '@/types/service';
+import {
+  ChatSessionList,
+  LobeAgentSession,
+  LobeSessionType,
+  LobeSessions,
+  SessionGroupId,
+  SessionGroupItem,
+  SessionGroups,
+} from '@/types/session';
+
+import { ISessionService } from './type';
+
+export class ServerService implements ISessionService {
+  async hasSessions() {
+    return (await this.countSessions()) === 0;
+  }
+
+  createSession(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,
+    });
+  }
+
+  async batchCreateSessions(importSessions: LobeSessions): Promise<BatchTaskResult> {
+    // TODO: remove any
+    const data = await lambdaClient.session.batchCreateSessions.mutate(importSessions as any);
+    console.log(data);
+    return data;
+  }
+
+  cloneSession(id: string, newTitle: string): Promise<string | undefined> {
+    return lambdaClient.session.cloneSession.mutate({ id, newTitle });
+  }
+
+  getGroupedSessions(): Promise<ChatSessionList> {
+    return lambdaClient.session.getGroupedSessions.query();
+  }
+
+  countSessions(): Promise<number> {
+    return lambdaClient.session.countSessions.query();
+  }
+
+  updateSession(
+    id: string,
+    data: Partial<{ group?: SessionGroupId; meta?: any; pinned?: boolean }>,
+  ): Promise<any> {
+    const { group, pinned, meta } = data;
+    return lambdaClient.session.updateSession.mutate({
+      id,
+      value: { groupId: group === 'default' ? null : group, pinned, ...meta },
+    });
+  }
+
+  async getSessionConfig(id: string): Promise<LobeAgentConfig> {
+    const isLogin = authSelectors.isLogin(useUserStore.getState());
+    if (!isLogin) return DEFAULT_AGENT_CONFIG;
+
+    // TODO: Need to be fixed
+    // @ts-ignore
+    return lambdaClient.session.getSessionConfig.query({ id });
+  }
+
+  updateSessionConfig(
+    id: string,
+    config: DeepPartial<LobeAgentConfig>,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return lambdaClient.session.updateSessionConfig.mutate({ id, value: config }, { signal });
+  }
+
+  updateSessionMeta(id: string, meta: Partial<MetaData>, signal?: AbortSignal): Promise<any> {
+    return lambdaClient.session.updateSessionConfig.mutate({ id, value: meta }, { signal });
+  }
+
+  updateSessionChatConfig(
+    id: string,
+    value: DeepPartial<LobeAgentChatConfig>,
+    signal?: AbortSignal,
+  ): Promise<any> {
+    return lambdaClient.session.updateSessionChatConfig.mutate({ id, value }, { signal });
+  }
+
+  getSessionsByType(type: 'agent' | 'group' | 'all' = 'all'): Promise<LobeSessions> {
+    // TODO: need be fixed
+    // @ts-ignore
+    return lambdaClient.session.getSessions.query({});
+  }
+
+  searchSessions(keywords: string): Promise<LobeSessions> {
+    return lambdaClient.session.searchSessions.query({ keywords });
+  }
+
+  removeSession(id: string): Promise<any> {
+    return lambdaClient.session.removeSession.mutate({ id });
+  }
+
+  removeAllSessions(): Promise<any> {
+    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();
+  }
+
+  batchCreateSessionGroups(groups: SessionGroups): Promise<BatchTaskResult> {
+    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
+  }
+
+  removeSessionGroup(id: string, removeChildren?: boolean): Promise<any> {
+    return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
+  }
+
+  removeSessionGroups(): Promise<any> {
+    return lambdaClient.sessionGroup.removeAllSessionGroups.mutate();
+  }
+
+  updateSessionGroup(id: string, value: Partial<SessionGroupItem>): Promise<any> {
+    // TODO: need be fixed
+    // @ts-ignore
+    return lambdaClient.sessionGroup.updateSessionGroup.mutate({ id, value });
+  }
+
+  updateSessionGroupOrder(sortMap: { id: string; sort: number }[]): Promise<any> {
+    return lambdaClient.sessionGroup.updateSessionGroupOrder.mutate({ sortMap });
+  }
+}

package/src/services/topic/index.ts

@@ -1,11 +1,6 @@
-// import { getClientConfig } from '@/config/client';
-//
-// import { ClientService } from './client';
-// import { ServerService } from './server';
-//
-// const { ENABLED_SERVER_SERVICE } = getClientConfig();
-//
-// export const topicService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
+import { isServerMode } from '@/const/version';
+
 import { ClientService } from './client';
+import { ServerService } from './server';
 
-export const topicService = new ClientService();
+export const topicService = isServerMode ? new ServerService() : new ClientService();

package/src/services/topic/server.ts

@@ -0,0 +1,68 @@
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { CreateTopicParams, ITopicService, QueryTopicParams } from '@/services/topic/type';
+import { BatchTaskResult } from '@/types/service';
+import { ChatTopic } from '@/types/topic';
+
+export class ServerService implements ITopicService {
+  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 | undefined): Promise<string> {
+    return lambdaClient.topic.cloneTopic.mutate({ id, newTitle });
+  }
+
+  getTopics(params: QueryTopicParams): Promise<ChatTopic[]> {
+    return lambdaClient.topic.getTopics.query({
+      ...params,
+      sessionId: this.toDbSessionId(params.sessionId),
+    }) as any;
+  }
+
+  getAllTopics(): Promise<ChatTopic[]> {
+    return lambdaClient.topic.getAllTopics.query() as any;
+  }
+
+  async countTopics() {
+    return lambdaClient.topic.countTopics.query();
+  }
+
+  searchTopics(keywords: string, sessionId?: string | undefined): Promise<ChatTopic[]> {
+    return lambdaClient.topic.searchTopics.query({
+      keywords,
+      sessionId: this.toDbSessionId(sessionId),
+    }) as any;
+  }
+
+  updateTopic(id: string, data: Partial<ChatTopic>): Promise<any> {
+    return lambdaClient.topic.updateTopic.mutate({ id, value: data });
+  }
+
+  removeTopic(id: string): Promise<any> {
+    return lambdaClient.topic.removeTopic.mutate({ id });
+  }
+
+  removeTopics(sessionId: string): Promise<any> {
+    return lambdaClient.topic.batchDeleteBySessionId.mutate({ id: this.toDbSessionId(sessionId) });
+  }
+
+  batchRemoveTopics(topics: string[]): Promise<any> {
+    return lambdaClient.topic.batchDelete.mutate({ ids: topics });
+  }
+
+  removeAllTopic(): Promise<any> {
+    return lambdaClient.topic.removeAllTopics.mutate();
+  }
+
+  private toDbSessionId(sessionId?: string | null) {
+    return sessionId === INBOX_SESSION_ID ? null : sessionId;
+  }
+}

package/src/services/user/index.ts

@@ -1,11 +1,6 @@
-// import { getClientConfig } from '@/config/client';
-//
-// import { ClientService } from './client';
-// import { ServerService } from './server';
-//
-// const { ENABLED_SERVER_SERVICE } = getClientConfig();
-//
-// export const userService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
+import { isServerMode } from '@/const/version';
+
 import { ClientService } from './client';
+import { ServerService } from './server';
 
-export const userService = new ClientService();
+export const userService = isServerMode ? new ServerService() : new ClientService();

package/src/services/user/server.ts

@@ -0,0 +1,28 @@
+import { DeepPartial } from 'utility-types';
+
+import { lambdaClient } from '@/libs/trpc/client';
+import { IUserService } from '@/services/user/type';
+import { UserInitializationState, UserPreference } from '@/types/user';
+import { UserSettings } from '@/types/user/settings';
+
+export class ServerService implements IUserService {
+  getUserState = async (): Promise<UserInitializationState> => {
+    return lambdaClient.user.getUserState.query();
+  };
+
+  async makeUserOnboarded() {
+    return lambdaClient.user.makeUserOnboarded.mutate();
+  }
+
+  async updatePreference(preference: UserPreference) {
+    return lambdaClient.user.updatePreference.mutate(preference);
+  }
+
+  updateUserSettings = async (value: DeepPartial<UserSettings>, signal?: AbortSignal) => {
+    return lambdaClient.user.updateSettings.mutate(value, { signal });
+  };
+
+  resetUserSettings = async () => {
+    return lambdaClient.user.resetSettings.mutate();
+  };
+}

package/tests/setup-db.ts

@@ -0,0 +1,7 @@
+// import env
+import { Crypto } from '@peculiar/webcrypto';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+global.crypto = new Crypto();

package/vitest.config.ts

@@ -22,12 +22,13 @@ export default defineConfig({
       ],
       provider: 'v8',
       reporter: ['text', 'json', 'lcov', 'text-summary'],
+      reportsDirectory: './coverage/app',
     },
     deps: {
       inline: ['vitest-canvas-mock'],
     },
-    // threads: false,
     environment: 'happy-dom',
+    exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', 'src/database/server/**/**'],
     globals: true,
     setupFiles: './tests/setup.ts',
   },

package/vitest.server.config.ts

@@ -0,0 +1,23 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    alias: {
+      '@': resolve(__dirname, './src'),
+    },
+    coverage: {
+      all: false,
+      exclude: ['src/database/server/core/dbForTest.ts'],
+      provider: 'v8',
+      reporter: ['text', 'json', 'lcov', 'text-summary'],
+      reportsDirectory: './coverage/server',
+    },
+    environment: 'node',
+    include: ['src/database/server/**/**/*.test.ts'],
+    poolOptions: {
+      threads: { singleThread: true },
+    },
+    setupFiles: './tests/setup-db.ts',
+  },
+});