@lobehub/lobehub 2.0.0-next.4 → 2.0.0-next.41

package/src/services/session/index.ts

@@ -1,13 +1,146 @@
-import { isDesktop } from '@/const/version';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { PartialDeep } from 'type-fest';
 
-import { ClientService as DeprecatedService } from './_deprecated';
-import { ClientService } from './client';
-import { ServerService } from './server';
+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';
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+export class SessionService {
+  hasSessions = async (): Promise<boolean> => {
+    const result = await this.countSessions();
+    return result === 0;
+  };
 
-export const sessionService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+  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/tableViewer/client.ts

@@ -1,16 +1,13 @@
-import { clientDB } from '@/database/client/db';
-import { TableViewerRepo } from '@/database/repositories/tableViewer';
-import { BaseClientService } from '@/services/baseClientService';
-
-export class ClientService extends BaseClientService {
-  private get tableViewerRepo(): TableViewerRepo {
-    return new TableViewerRepo(clientDB as any, this.userId);
-  }
-
-  getAllTables = async () => this.tableViewerRepo.getAllTables();
-
-  getTableDetails = async (tableName: string) => this.tableViewerRepo.getTableDetails(tableName);
-
-  getTableData = async (tableName: string) =>
-    this.tableViewerRepo.getTableData(tableName, { page: 1, pageSize: 300 });
+export class ClientService {
+  getAllTables = async () => [];
+
+  getTableDetails = async (tableName: string) => {
+    console.log('getTableDetails:', tableName);
+    return [];
+  };
+
+  getTableData = async (tableName: string) => {
+    console.log('getTableData:', tableName);
+    return [];
+  };
 }

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,9 +1,39 @@
-import { isDesktop } from '@/const/version';
+import { CreateMessageParams } from '@lobechat/types';
 
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { INBOX_SESSION_ID } from '@/const/session';
+import { lambdaClient } from '@/libs/trpc/client';
+import { CreateThreadParams, ThreadItem } from '@/types/topic';
 
-export const threadService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : new ClientService();
+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,13 +1,77 @@
-import { isDesktop } from '@/const/version';
+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';
 
-import { ClientService as DeprecatedService } from './_deprecated';
-import { ClientService } from './client';
-import { ServerService } from './server';
+export class TopicService {
+  createTopic = (params: CreateTopicParams): Promise<string> => {
+    return lambdaClient.topic.createTopic.mutate({
+      ...params,
+      sessionId: this.toDbSessionId(params.sessionId),
+    });
+  };
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+  batchCreateTopics = (importTopics: ChatTopic[]): Promise<BatchTaskResult> => {
+    return lambdaClient.topic.batchCreateTopics.mutate(importTopics);
+  };
 
-export const topicService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+  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/upload.ts

@@ -68,13 +68,13 @@ class UploadService {
     const state = getElectronStoreState();
     const isSyncActive = electronSyncSelectors.isSyncActive(state);
 
-    // 桌面端上传逻辑（并且没开启 sync 同步）
+    // Desktop upload logic (when sync is not enabled)
     if (isDesktop && !isSyncActive) {
       const data = await this.uploadToDesktopS3(file, { directory, pathname });
       return { data, success: true };
     }
 
-    // 服务端上传逻辑
+    // Server-side upload logic
     if (isServerMode) {
       // if is server mode, upload to server s3,
 
@@ -83,7 +83,7 @@ class UploadService {
     }
 
     // upload to client s3
-    // 客户端上传逻辑
+    // Client-side upload logic
     if (!skipCheckFileType && !file.type.startsWith('image') && !file.type.startsWith('video')) {
       onNotSupported?.();
       return { data: undefined as unknown as FileMetadata, success: false };
@@ -103,18 +103,18 @@ class UploadService {
     base64Data: string,
     options: UploadFileToS3Options = {},
   ): Promise<UploadBase64ToS3Result> => {
-    // 解析 base64 数据
+    // Parse base64 data
     const { base64, mimeType, type } = parseDataUri(base64Data);
 
     if (!base64 || !mimeType || type !== 'base64') {
       throw new Error('Invalid base64 data for image');
     }
 
-    // 将 base64 转换为 Blob
+    // Convert base64 to Blob
     const byteCharacters = atob(base64);
     const byteArrays = [];
 
-    // 分块处理以避免内存问题
+    // Process in chunks to avoid memory issues
     for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
       const slice = byteCharacters.slice(offset, offset + 1024);
 
@@ -129,14 +129,14 @@ class UploadService {
 
     const blob = new Blob(byteArrays, { type: mimeType });
 
-    // 确定文件扩展名
+    // Determine file extension
     const fileExtension = mimeType.split('/')[1] || 'png';
     const fileName = `${options.filename || `image_${dayjs().format('YYYY-MM-DD-hh-mm-ss')}`}.${fileExtension}`;
 
-    // 创建文件对象
+    // Create file object
     const file = new File([blob], fileName, { type: mimeType });
 
-    // 使用统一的上传方法
+    // Use unified upload method
     const { data: metadata } = await this.uploadFileToS3(file, options);
     const hash = sha256(await file.arrayBuffer());
 
@@ -221,7 +221,7 @@ class UploadService {
     const fileArrayBuffer = await file.arrayBuffer();
     const hash = sha256(fileArrayBuffer);
 
-    // 生成文件路径元数据
+    // Generate file path metadata
     const { pathname } = generateFilePathMetadata(file.name, options);
 
     const { desktopFileAPI } = await import('@/services/electron/file');
@@ -261,7 +261,7 @@ class UploadService {
       preSignUrl: string;
     }
   > => {
-    // 生成文件路径元数据
+    // Generate file path metadata
     const { date, dirname, filename, pathname } = generateFilePathMetadata(file.name, options);
 
     const preSignUrl = await lambdaClient.upload.createS3PreSignedUrl.mutate({ pathname });

package/src/services/usage.ts

@@ -0,0 +1,13 @@
+import { lambdaClient } from "@/libs/trpc/client";
+
+class UsageService {
+    findByMonth = async (mo?: string) => {
+        return lambdaClient.usage.findByMonth.query({ mo });
+    };
+
+    findAndGroupByDay = async (mo?: string) => {
+        return lambdaClient.usage.findAndGroupByDay.query({ mo });
+    }
+}
+
+export const usageService = new UsageService();

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,15 +1,54 @@
-import { isDesktop } from '@/const/version';
+import type { AdapterAccount } from 'next-auth/adapters';
+import type { PartialDeep } from 'type-fest';
 
-import { ClientService as DeprecatedService } from './_deprecated';
-import { ClientService } from './client';
-import { ServerService } from './server';
+import { lambdaClient } from '@/libs/trpc/client';
+import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
+import { UserSettings } from '@/types/user/settings';
 
-const clientService =
-  process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
+export class UserService {
+  getUserRegistrationDuration = async (): Promise<{
+    createdAt: string;
+    duration: number;
+    updatedAt: string;
+  }> => {
+    return lambdaClient.user.getUserRegistrationDuration.query();
+  };
 
-export const userService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
-    ? new ServerService()
-    : clientService;
+  getUserState = async (): Promise<UserInitializationState> => {
+    return lambdaClient.user.getUserState.query();
+  };
 
-export const userClientService = clientService;
+  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/services/utils/abortableRequest.test.ts

@@ -0,0 +1,161 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { abortableRequest } from './abortableRequest';
+
+describe('AbortableRequestManager', () => {
+  beforeEach(() => {
+    abortableRequest.cancelAll();
+  });
+
+  describe('execute', () => {
+    it('should execute request successfully', async () => {
+      const mockFetcher = vi.fn(async (signal: AbortSignal) => {
+        return 'result';
+      });
+
+      const result = await abortableRequest.execute('test-key', mockFetcher);
+
+      expect(result).toBe('result');
+      expect(mockFetcher).toHaveBeenCalledTimes(1);
+      expect(mockFetcher).toHaveBeenCalledWith(expect.any(AbortSignal));
+    });
+
+    it('should cancel previous request when new request with same key is triggered', async () => {
+      let firstRequestAborted = false;
+      let secondRequestAborted = false;
+
+      const firstFetcher = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              firstRequestAborted = true;
+              reject(new Error('Aborted'));
+            });
+            setTimeout(() => resolve('first'), 100);
+          }),
+      );
+
+      const secondFetcher = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              secondRequestAborted = true;
+              reject(new Error('Aborted'));
+            });
+            setTimeout(() => resolve('second'), 100);
+          }),
+      );
+
+      // Start first request
+      const firstPromise = abortableRequest.execute('same-key', firstFetcher);
+
+      // Start second request with same key (should cancel first)
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const secondPromise = abortableRequest.execute('same-key', secondFetcher);
+
+      // First should be aborted
+      await expect(firstPromise).rejects.toThrow('Aborted');
+      expect(firstRequestAborted).toBe(true);
+
+      // Second should succeed
+      const result = await secondPromise;
+      expect(result).toBe('second');
+      expect(secondRequestAborted).toBe(false);
+    });
+
+    it('should allow concurrent requests with different keys', async () => {
+      const fetcher1 = vi.fn(async () => 'result1');
+      const fetcher2 = vi.fn(async () => 'result2');
+
+      const [result1, result2] = await Promise.all([
+        abortableRequest.execute('key1', fetcher1),
+        abortableRequest.execute('key2', fetcher2),
+      ]);
+
+      expect(result1).toBe('result1');
+      expect(result2).toBe('result2');
+      expect(fetcher1).toHaveBeenCalledTimes(1);
+      expect(fetcher2).toHaveBeenCalledTimes(1);
+    });
+
+    it('should clean up controller after request completes', async () => {
+      const fetcher = vi.fn(async () => 'result');
+
+      await abortableRequest.execute('cleanup-test', fetcher);
+
+      // Manually check that controller is cleaned up by starting a new request
+      // and verifying it doesn't abort anything (since map should be empty)
+      let aborted = false;
+      const fetcher2 = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve) => {
+            signal.addEventListener('abort', () => {
+              aborted = true;
+            });
+            setTimeout(() => resolve('result2'), 50);
+          }),
+      );
+
+      await abortableRequest.execute('cleanup-test', fetcher2);
+      expect(aborted).toBe(false);
+    });
+  });
+
+  describe('cancel', () => {
+    it('should cancel specific request by key', async () => {
+      let aborted = false;
+      const fetcher = vi.fn(
+        async (signal: AbortSignal) =>
+          new Promise((resolve, reject) => {
+            signal.addEventListener('abort', () => {
+              aborted = true;
+              reject(new Error('Cancelled'));
+            });
+            setTimeout(() => resolve('result'), 100);
+          }),
+      );
+
+      const promise = abortableRequest.execute('cancel-key', fetcher);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      abortableRequest.cancel('cancel-key');
+
+      await expect(promise).rejects.toThrow('Cancelled');
+      expect(aborted).toBe(true);
+    });
+
+    it('should do nothing when canceling non-existent key', () => {
+      expect(() => abortableRequest.cancel('non-existent')).not.toThrow();
+    });
+  });
+
+  describe('cancelAll', () => {
+    it('should cancel all pending requests', async () => {
+      const results = { req1: false, req2: false, req3: false };
+
+      const createFetcher = (key: keyof typeof results) =>
+        vi.fn(
+          async (signal: AbortSignal) =>
+            new Promise((resolve, reject) => {
+              signal.addEventListener('abort', () => {
+                results[key] = true;
+                reject(new Error('Cancelled'));
+              });
+              setTimeout(() => resolve(`result-${key}`), 100);
+            }),
+        );
+
+      const promise1 = abortableRequest.execute('key1', createFetcher('req1'));
+      const promise2 = abortableRequest.execute('key2', createFetcher('req2'));
+      const promise3 = abortableRequest.execute('key3', createFetcher('req3'));
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      abortableRequest.cancelAll();
+
+      await expect(Promise.all([promise1, promise2, promise3])).rejects.toThrow();
+      expect(results.req1).toBe(true);
+      expect(results.req2).toBe(true);
+      expect(results.req3).toBe(true);
+    });
+  });
+});