@lobehub/lobehub 2.0.0-next.3 → 2.0.0-next.31

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

@@ -1,260 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { lambdaClient } from '@/libs/trpc/client';
-import { LobeSessionType } from '@/types/session';
-
-import { ServerService } from './server';
-
-vi.mock('@/libs/trpc/client', () => ({
-  lambdaClient: {
-    session: {
-      createSession: { mutate: vi.fn() },
-      batchCreateSessions: { mutate: vi.fn() },
-      cloneSession: { mutate: vi.fn() },
-      getGroupedSessions: { query: vi.fn() },
-      countSessions: { query: vi.fn() },
-      rankSessions: { query: vi.fn() },
-      updateSession: { mutate: vi.fn() },
-      updateSessionConfig: { mutate: vi.fn() },
-      updateSessionChatConfig: { mutate: vi.fn() },
-      getSessions: { query: vi.fn() },
-      searchSessions: { query: vi.fn() },
-      removeSession: { mutate: vi.fn() },
-      removeAllSessions: { mutate: vi.fn() },
-    },
-    agent: {
-      getAgentConfig: { query: vi.fn() },
-    },
-    sessionGroup: {
-      createSessionGroup: { mutate: vi.fn() },
-      getSessionGroup: { query: vi.fn() },
-      removeSessionGroup: { mutate: vi.fn() },
-      removeAllSessionGroups: { mutate: vi.fn() },
-      updateSessionGroup: { mutate: vi.fn() },
-      updateSessionGroupOrder: { mutate: vi.fn() },
-    },
-  },
-}));
-
-describe('ServerService', () => {
-  let service: ServerService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    service = new ServerService();
-  });
-
-  it('hasSessions should return true if count is 0', async () => {
-    vi.mocked(lambdaClient.session.countSessions.query).mockResolvedValue(0);
-    const result = await service.hasSessions();
-    expect(result).toBe(true);
-  });
-
-  it('createSession should call lambdaClient with correct params', async () => {
-    const mockData = {
-      config: {
-        model: 'gpt-3.5',
-        params: {},
-        systemRole: '',
-        chatConfig: {
-          autoCreateTopicThreshold: 2,
-          compressThreshold: 10,
-          enableAutoCreateTopic: true,
-          enableCompressThreshold: true,
-          maxTokens: 2000,
-          model: 'gpt-3.5-turbo',
-          params: {},
-          temperature: 0.7,
-          title: 'test',
-        },
-        tts: {
-          showAllLocaleVoice: false,
-          sttLocale: 'auto',
-          ttsService: 'openai' as const,
-          voice: {
-            model: 'tts-1',
-            name: 'alloy',
-            type: 'tts',
-            openai: 'voice-id',
-          },
-        },
-        openingQuestions: ['Question 1', 'Question 2'],
-        openingMessage: 'Hello, I am [LobeChat](https://github.com/lobehub/lobe-chat).',
-      },
-      group: 'testGroup',
-      meta: { description: 'test' },
-      title: 'Test Session',
-    };
-
-    await service.createSession(LobeSessionType.Agent, mockData);
-
-    expect(lambdaClient.session.createSession.mutate).toBeCalledWith({
-      config: { ...mockData.config, description: 'test' },
-      session: { title: 'Test Session', groupId: 'testGroup' },
-      type: LobeSessionType.Agent,
-    });
-  });
-
-  it('batchCreateSessions should call lambdaClient', async () => {
-    const mockSessions = [
-      {
-        id: '1',
-        title: 'Test',
-        config: {
-          model: 'gpt-3.5',
-          params: {},
-          systemRole: '',
-          chatConfig: {
-            autoCreateTopicThreshold: 2,
-            compressThreshold: 10,
-            enableAutoCreateTopic: true,
-            enableCompressThreshold: true,
-            maxTokens: 2000,
-            model: 'gpt-3.5-turbo',
-            params: {},
-            temperature: 0.7,
-            title: 'test',
-          },
-          tts: {
-            showAllLocaleVoice: false,
-            sttLocale: 'auto',
-            ttsService: 'openai' as const,
-            voice: {
-              model: 'tts-1',
-              name: 'alloy',
-              type: 'tts',
-              openai: 'voice-id',
-            },
-          },
-        },
-        createdAt: new Date(),
-        meta: { description: 'test' },
-        model: 'gpt-3.5',
-        type: LobeSessionType.Agent,
-        updatedAt: new Date(),
-      },
-    ];
-
-    await service.batchCreateSessions(mockSessions as any);
-    expect(lambdaClient.session.batchCreateSessions.mutate).toBeCalledWith(mockSessions);
-  });
-
-  it('cloneSession should call lambdaClient', async () => {
-    await service.cloneSession('123', 'New Title');
-    expect(lambdaClient.session.cloneSession.mutate).toBeCalledWith({
-      id: '123',
-      newTitle: 'New Title',
-    });
-  });
-
-  it('getGroupedSessions should call lambdaClient', async () => {
-    await service.getGroupedSessions();
-    expect(lambdaClient.session.getGroupedSessions.query).toBeCalled();
-  });
-
-  it('countSessions should call lambdaClient with params', async () => {
-    const params = { startDate: '2023-01-01' };
-    await service.countSessions(params);
-    expect(lambdaClient.session.countSessions.query).toBeCalledWith(params);
-  });
-
-  it('rankSessions should call lambdaClient with limit', async () => {
-    await service.rankSessions(10);
-    expect(lambdaClient.session.rankSessions.query).toBeCalledWith(10);
-  });
-
-  it('updateSession should call lambdaClient with correct params', async () => {
-    const mockData = {
-      group: 'default',
-      pinned: true,
-      meta: { description: 'bar' },
-      updatedAt: new Date(),
-    };
-
-    await service.updateSession('123', mockData);
-
-    expect(lambdaClient.session.updateSession.mutate).toBeCalledWith({
-      id: '123',
-      value: {
-        groupId: null,
-        pinned: true,
-        description: 'bar',
-        updatedAt: mockData.updatedAt,
-      },
-    });
-  });
-
-  it('getSessionConfig should call lambdaClient', async () => {
-    await service.getSessionConfig('123');
-    expect(lambdaClient.agent.getAgentConfig.query).toBeCalledWith({ sessionId: '123' });
-  });
-
-  it('updateSessionConfig should call lambdaClient', async () => {
-    const config = { model: 'gpt-4' };
-    const signal = new AbortController().signal;
-    await service.updateSessionConfig('123', config, signal);
-    expect(lambdaClient.session.updateSessionConfig.mutate).toBeCalledWith(
-      { id: '123', value: config },
-      {
-        signal,
-        context: { showNotification: false },
-      },
-    );
-  });
-
-  it('getSessionsByType should call lambdaClient', async () => {
-    await service.getSessionsByType('all');
-    expect(lambdaClient.session.getSessions.query).toBeCalledWith({});
-  });
-
-  it('searchSessions should call lambdaClient with keywords', async () => {
-    await service.searchSessions('test');
-    expect(lambdaClient.session.searchSessions.query).toBeCalledWith({ keywords: 'test' });
-  });
-
-  it('removeSession should call lambdaClient', async () => {
-    await service.removeSession('123');
-    expect(lambdaClient.session.removeSession.mutate).toBeCalledWith({ id: '123' });
-  });
-
-  it('removeAllSessions should call lambdaClient', async () => {
-    await service.removeAllSessions();
-    expect(lambdaClient.session.removeAllSessions.mutate).toBeCalled();
-  });
-
-  it('createSessionGroup should call lambdaClient', async () => {
-    await service.createSessionGroup('Test Group', 1);
-    expect(lambdaClient.sessionGroup.createSessionGroup.mutate).toBeCalledWith({
-      name: 'Test Group',
-      sort: 1,
-    });
-  });
-
-  it('getSessionGroups should call lambdaClient', async () => {
-    await service.getSessionGroups();
-    expect(lambdaClient.sessionGroup.getSessionGroup.query).toBeCalled();
-  });
-
-  it('removeSessionGroup should call lambdaClient', async () => {
-    await service.removeSessionGroup('123', true);
-    expect(lambdaClient.sessionGroup.removeSessionGroup.mutate).toBeCalledWith({
-      id: '123',
-      removeChildren: true,
-    });
-  });
-
-  it('updateSessionGroup should call lambdaClient', async () => {
-    const value = { name: 'Updated Group' };
-    await service.updateSessionGroup('123', value);
-    expect(lambdaClient.sessionGroup.updateSessionGroup.mutate).toBeCalledWith({
-      id: '123',
-      value,
-    });
-  });
-
-  it('updateSessionGroupOrder should call lambdaClient', async () => {
-    const sortMap = [{ id: '123', sort: 1 }];
-    await service.updateSessionGroupOrder(sortMap);
-    expect(lambdaClient.sessionGroup.updateSessionGroupOrder.mutate).toBeCalledWith({ sortMap });
-  });
-});

package/src/services/session/server.ts

@@ -1,125 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { ISessionService } from './type';
-
-export class ServerService implements ISessionService {
-  hasSessions: ISessionService['hasSessions'] = async () => {
-    const result = await this.countSessions();
-    return result === 0;
-  };
-
-  createSession: ISessionService['createSession'] = async (type, data) => {
-    const { config, group, meta, ...session } = data;
-    return lambdaClient.session.createSession.mutate({
-      config: { ...config, ...meta } as any,
-      session: { ...session, groupId: group },
-      type,
-    });
-  };
-
-  batchCreateSessions: ISessionService['batchCreateSessions'] = async (importSessions) => {
-    // TODO: remove any
-    const data = await lambdaClient.session.batchCreateSessions.mutate(importSessions as any);
-    console.log(data);
-    return data;
-  };
-
-  cloneSession: ISessionService['cloneSession'] = (id, newTitle) => {
-    return lambdaClient.session.cloneSession.mutate({ id, newTitle });
-  };
-
-  getGroupedSessions: ISessionService['getGroupedSessions'] = () => {
-    return lambdaClient.session.getGroupedSessions.query();
-  };
-
-  countSessions: ISessionService['countSessions'] = async (params) => {
-    return lambdaClient.session.countSessions.query(params);
-  };
-
-  rankSessions: ISessionService['rankSessions'] = async (limit) => {
-    return lambdaClient.session.rankSessions.query(limit);
-  };
-
-  updateSession: ISessionService['updateSession'] = (id, data) => {
-    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
-  // @ts-ignore
-  getSessionConfig: ISessionService['getSessionConfig'] = async (id) => {
-    return lambdaClient.agent.getAgentConfig.query({ sessionId: id });
-  };
-
-  updateSessionConfig: ISessionService['updateSessionConfig'] = (id, config, signal) => {
-    return lambdaClient.session.updateSessionConfig.mutate(
-      { id, value: config },
-      {
-        context: { showNotification: false },
-        signal,
-      },
-    );
-  };
-
-  updateSessionMeta: ISessionService['updateSessionMeta'] = (id, meta, signal) => {
-    return lambdaClient.session.updateSessionConfig.mutate({ id, value: meta }, { signal });
-  };
-
-  updateSessionChatConfig: ISessionService['updateSessionChatConfig'] = (id, value, signal) => {
-    return lambdaClient.session.updateSessionChatConfig.mutate({ id, value }, { signal });
-  };
-
-  // TODO: need be fixed
-  // @ts-ignore
-  getSessionsByType: ISessionService['getSessionsByType'] = (_type = 'all') => {
-    return lambdaClient.session.getSessions.query({});
-  };
-
-  searchSessions: ISessionService['searchSessions'] = (keywords) => {
-    return lambdaClient.session.searchSessions.query({ keywords });
-  };
-
-  removeSession: ISessionService['removeSession'] = (id) => {
-    return lambdaClient.session.removeSession.mutate({ id });
-  };
-
-  removeAllSessions: ISessionService['removeAllSessions'] = () => {
-    return lambdaClient.session.removeAllSessions.mutate();
-  };
-
-  // ************************************** //
-  // ***********  SessionGroup  *********** //
-  // ************************************** //
-
-  createSessionGroup: ISessionService['createSessionGroup'] = (name, sort) => {
-    return lambdaClient.sessionGroup.createSessionGroup.mutate({ name, sort });
-  };
-
-  getSessionGroups: ISessionService['getSessionGroups'] = () => {
-    return lambdaClient.sessionGroup.getSessionGroup.query();
-  };
-
-  batchCreateSessionGroups: ISessionService['batchCreateSessionGroups'] = (_groups) => {
-    return Promise.resolve({ added: 0, ids: [], skips: [], success: true });
-  };
-
-  removeSessionGroup: ISessionService['removeSessionGroup'] = (id, removeChildren) => {
-    return lambdaClient.sessionGroup.removeSessionGroup.mutate({ id, removeChildren });
-  };
-
-  removeSessionGroups: ISessionService['removeSessionGroups'] = () => {
-    return lambdaClient.sessionGroup.removeAllSessionGroups.mutate();
-  };
-
-  updateSessionGroup: ISessionService['updateSessionGroup'] = (id, value) => {
-    return lambdaClient.sessionGroup.updateSessionGroup.mutate({ id, value });
-  };
-
-  updateSessionGroupOrder: ISessionService['updateSessionGroupOrder'] = (sortMap) => {
-    return lambdaClient.sessionGroup.updateSessionGroupOrder.mutate({ sortMap });
-  };
-}

package/src/services/session/type.ts

@@ -1,82 +0,0 @@
-/* eslint-disable typescript-sort-keys/interface */
-import type { PartialDeep } from 'type-fest';
-
-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 interface ISessionService {
-  hasSessions(): Promise<boolean>;
-  createSession(type: LobeSessionType, defaultValue: Partial<LobeAgentSession>): Promise<string>;
-
-  /**
-   * 需要废弃
-   * @deprecated
-   */
-  batchCreateSessions(importSessions: LobeSessions): Promise<any>;
-  cloneSession(id: string, newTitle: string): Promise<string | undefined>;
-
-  getGroupedSessions(): Promise<ChatSessionList>;
-
-  /**
-   * @deprecated
-   */
-  getSessionsByType(type?: 'agent' | 'group' | 'all'): Promise<LobeSessions>;
-  countSessions(params?: {
-    endDate?: string;
-    range?: [string, string];
-    startDate?: string;
-  }): Promise<number>;
-  rankSessions(limit?: number): Promise<SessionRankItem[]>;
-  searchSessions(keyword: string): Promise<LobeSessions>;
-
-  updateSession(id: string, data: Partial<UpdateSessionParams>): Promise<any>;
-
-  getSessionConfig(id: string): Promise<LobeAgentConfig>;
-  updateSessionConfig(
-    id: string,
-    config: PartialDeep<LobeAgentConfig>,
-    signal?: AbortSignal,
-  ): Promise<any>;
-
-  updateSessionMeta(id: string, meta: Partial<MetaData>, signal?: AbortSignal): Promise<any>;
-
-  updateSessionChatConfig(
-    id: string,
-    config: Partial<LobeAgentChatConfig>,
-    signal?: AbortSignal,
-  ): Promise<any>;
-
-  removeSession(id: string): Promise<any>;
-  removeAllSessions(): Promise<any>;
-
-  // ************************************** //
-  // ***********  SessionGroup  *********** //
-  // ************************************** //
-
-  createSessionGroup(name: string, sort?: number): Promise<string>;
-
-  /**
-   * 需要废弃
-   * @deprecated
-   */
-  batchCreateSessionGroups(groups: SessionGroups): Promise<BatchTaskResult>;
-
-  getSessionGroups(): Promise<SessionGroupItem[]>;
-
-  updateSessionGroup(id: string, data: Partial<SessionGroupItem>): Promise<any>;
-  updateSessionGroupOrder(sortMap: { id: string; sort: number }[]): Promise<any>;
-
-  removeSessionGroup(id: string, removeChildren?: boolean): Promise<any>;
-  removeSessionGroups(): Promise<any>;
-}

package/src/services/thread/client.ts

@@ -1,51 +0,0 @@
-import { INBOX_SESSION_ID } from '@/const/session';
-import { clientDB } from '@/database/client/db';
-import { MessageModel } from '@/database/models/message';
-import { ThreadModel } from '@/database/models/thread';
-import { BaseClientService } from '@/services/baseClientService';
-
-import { IThreadService } from './type';
-
-export class ClientService extends BaseClientService implements IThreadService {
-  private get threadModel(): ThreadModel {
-    return new ThreadModel(clientDB as any, this.userId);
-  }
-
-  private get messageModel(): MessageModel {
-    return new MessageModel(clientDB as any, this.userId);
-  }
-
-  getThreads: IThreadService['getThreads'] = async (topicId) => {
-    return this.threadModel.queryByTopicId(topicId);
-  };
-
-  createThreadWithMessage: IThreadService['createThreadWithMessage'] = async (input) => {
-    const thread = await this.threadModel.create({
-      parentThreadId: input.parentThreadId,
-      sourceMessageId: input.sourceMessageId,
-      title: input.message.content.slice(0, 20),
-      topicId: input.topicId,
-      type: input.type,
-    });
-
-    const message = await this.messageModel.create({
-      ...input.message,
-      sessionId: this.toDbSessionId(input.message.sessionId) as string,
-      threadId: thread?.id,
-    });
-
-    return { messageId: message?.id, threadId: thread?.id };
-  };
-
-  updateThread: IThreadService['updateThread'] = async (id, data) => {
-    return this.threadModel.update(id, data);
-  };
-
-  removeThread: IThreadService['removeThread'] = async (id) => {
-    return this.threadModel.delete(id);
-  };
-
-  private toDbSessionId = (sessionId: string | undefined) => {
-    return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  };
-}

package/src/services/thread/server.ts

@@ -1,32 +0,0 @@
-import { INBOX_SESSION_ID } from '@/const/session';
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IThreadService } from './type';
-
-export class ServerService implements IThreadService {
-  getThreads: IThreadService['getThreads'] = (topicId) => {
-    return lambdaClient.thread.getThreads.query({ topicId });
-  };
-
-  createThreadWithMessage: IThreadService['createThreadWithMessage'] = async ({
-    message,
-    ...params
-  }) => {
-    return lambdaClient.thread.createThreadWithMessage.mutate({
-      ...params,
-      message: { ...message, sessionId: this.toDbSessionId(message.sessionId) },
-    });
-  };
-
-  updateThread: IThreadService['updateThread'] = async (id, data) => {
-    return lambdaClient.thread.updateThread.mutate({ id, value: data });
-  };
-
-  removeThread: IThreadService['removeThread'] = async (id) => {
-    return lambdaClient.thread.removeThread.mutate({ id });
-  };
-
-  private toDbSessionId = (sessionId: string | undefined) => {
-    return sessionId === INBOX_SESSION_ID ? null : sessionId;
-  };
-}

package/src/services/thread/type.ts

@@ -1,21 +0,0 @@
-/* eslint-disable typescript-sort-keys/interface */
-import { CreateMessageParams } from '@lobechat/types';
-
-import { CreateThreadParams, ThreadItem } from '@/types/topic';
-
-interface CreateThreadWithMessageParams extends CreateThreadParams {
-  message: CreateMessageParams;
-}
-
-export interface IThreadService {
-  getThreads(topicId: string): Promise<ThreadItem[]>;
-
-  createThreadWithMessage({
-    message,
-    ...params
-  }: CreateThreadWithMessageParams): Promise<{ messageId: string; threadId: string }>;
-
-  updateThread(id: string, data: Partial<ThreadItem>): Promise<any>;
-  //
-  removeThread(id: string): Promise<any>;
-}