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

package/src/services/topic/type.ts

@@ -1,40 +0,0 @@
-/* eslint-disable typescript-sort-keys/interface */
-import { BatchTaskResult } from '@/types/service';
-import { ChatTopic, TopicRankItem } from '@/types/topic';
-
-export interface CreateTopicParams {
-  favorite?: boolean;
-  groupId?: string | null;
-  messages?: string[];
-  sessionId?: string | null;
-  title: string;
-}
-
-export interface QueryTopicParams {
-  current?: number;
-  containerId?: string | null; // sessionId or groupId
-  pageSize?: number;
-}
-
-export interface ITopicService {
-  createTopic(params: CreateTopicParams): Promise<string>;
-  batchCreateTopics(importTopics: ChatTopic[]): Promise<BatchTaskResult>;
-  cloneTopic(id: string, newTitle?: string): Promise<string>;
-
-  getTopics(params: QueryTopicParams): Promise<ChatTopic[]>;
-  getAllTopics(): Promise<ChatTopic[]>;
-  countTopics(params?: {
-    endDate?: string;
-    range?: [string, string];
-    startDate?: string;
-  }): Promise<number>;
-  rankTopics(limit?: number): Promise<TopicRankItem[]>;
-  searchTopics(keyword: string, sessionId?: string, groupId?: string): Promise<ChatTopic[]>;
-
-  updateTopic(id: string, data: Partial<ChatTopic>): Promise<any>;
-
-  removeTopic(id: string): Promise<any>;
-  removeTopics(sessionId: string): Promise<any>;
-  batchRemoveTopics(topics: string[]): Promise<any>;
-  removeAllTopic(): Promise<any>;
-}

package/src/services/user/_deprecated.test.ts

@@ -1,101 +0,0 @@
-import type { PartialDeep } from 'type-fest';
-import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { UserModel } from '@/database/_deprecated/models/user';
-import { UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
-
-import { ClientService } from './_deprecated';
-
-vi.mock('@/database/_deprecated/models/user', () => ({
-  UserModel: {
-    getUser: vi.fn(),
-    updateSettings: vi.fn(),
-    resetSettings: vi.fn(),
-    updateAvatar: vi.fn(),
-  },
-}));
-
-const mockUser = {
-  avatar: 'avatar.png',
-  settings: { themeMode: 'light' } as unknown as UserSettings,
-  uuid: 'user-id',
-};
-
-const mockPreference = {
-  useCmdEnterToSend: true,
-} as UserPreference;
-
-describe('ClientService', () => {
-  let clientService: ClientService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    clientService = new ClientService();
-  });
-
-  it('should get user state correctly', async () => {
-    (UserModel.getUser as Mock).mockResolvedValue(mockUser);
-    const spyOn = vi
-      .spyOn(clientService['preferenceStorage'], 'getFromLocalStorage')
-      .mockResolvedValue(mockPreference);
-
-    const userState = await clientService.getUserState();
-
-    expect(userState).toEqual({
-      avatar: mockUser.avatar,
-      isOnboard: true,
-      canEnablePWAGuide: false,
-      hasConversation: false,
-      canEnableTrace: false,
-      preference: mockPreference,
-      settings: mockUser.settings,
-      userId: mockUser.uuid,
-    });
-    expect(UserModel.getUser).toHaveBeenCalledTimes(1);
-    expect(spyOn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should update user settings correctly', async () => {
-    const settingsPatch: PartialDeep<UserSettings> = { general: { fontSize: 12 } };
-    (UserModel.updateSettings as Mock).mockResolvedValue(undefined);
-
-    await clientService.updateUserSettings(settingsPatch);
-
-    expect(UserModel.updateSettings).toHaveBeenCalledWith(settingsPatch);
-    expect(UserModel.updateSettings).toHaveBeenCalledTimes(1);
-  });
-
-  it('should reset user settings correctly', async () => {
-    (UserModel.resetSettings as Mock).mockResolvedValue(undefined);
-
-    await clientService.resetUserSettings();
-
-    expect(UserModel.resetSettings).toHaveBeenCalledTimes(1);
-  });
-
-  it('should update user avatar correctly', async () => {
-    const newAvatar = 'new-avatar.png';
-    (UserModel.updateAvatar as Mock).mockResolvedValue(undefined);
-
-    await clientService.updateAvatar(newAvatar);
-
-    expect(UserModel.updateAvatar).toHaveBeenCalledWith(newAvatar);
-    expect(UserModel.updateAvatar).toHaveBeenCalledTimes(1);
-  });
-
-  it('should update user preference correctly', async () => {
-    const newPreference = {
-      useCmdEnterToSend: false,
-    } as UserPreference;
-
-    const spyOn = vi
-      .spyOn(clientService['preferenceStorage'], 'saveToLocalStorage')
-      .mockResolvedValue(undefined);
-
-    await clientService.updatePreference(newPreference);
-
-    expect(spyOn).toHaveBeenCalledWith(newPreference);
-    expect(spyOn).toHaveBeenCalledTimes(1);
-  });
-});

package/src/services/user/_deprecated.ts

@@ -1,70 +0,0 @@
-import type { PartialDeep } from 'type-fest';
-
-import { MessageModel } from '@/database/_deprecated/models/message';
-import { SessionModel } from '@/database/_deprecated/models/session';
-import { UserModel } from '@/database/_deprecated/models/user';
-import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
-import { AsyncLocalStorage } from '@/utils/localStorage';
-
-import { IUserService } from './type';
-
-export class ClientService implements IUserService {
-  private preferenceStorage: AsyncLocalStorage<UserPreference>;
-
-  constructor() {
-    this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
-  }
-
-  getUserRegistrationDuration = async () => {
-    throw new Error('Method not implemented.');
-  };
-
-  async getUserState(): Promise<UserInitializationState> {
-    const user = await UserModel.getUser();
-    const messageCount = await MessageModel.count();
-    const sessionCount = await SessionModel.count();
-
-    return {
-      avatar: user.avatar,
-      canEnablePWAGuide: messageCount >= 4,
-      canEnableTrace: messageCount >= 4,
-      hasConversation: messageCount > 0 || sessionCount > 0,
-      isOnboard: true,
-      preference: await this.preferenceStorage.getFromLocalStorage(),
-      settings: user.settings as UserSettings,
-      userId: user.uuid,
-    };
-  }
-
-  getUserSSOProviders = async () => {
-    // Account not exist on next-auth in client mode, no need to implement this method
-    return [];
-  };
-
-  unlinkSSOProvider = async () => {
-    // Account not exist on next-auth in client mode, no need to implement this method
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  updateUserSettings = async (patch: PartialDeep<UserSettings>, _?: any) => {
-    return UserModel.updateSettings(patch);
-  };
-
-  resetUserSettings = async () => {
-    return UserModel.resetSettings();
-  };
-
-  async updateAvatar(avatar: string) {
-    await UserModel.updateAvatar(avatar);
-  }
-
-  async updatePreference(preference: Partial<UserPreference>) {
-    await this.preferenceStorage.saveToLocalStorage(preference);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars,unused-imports/no-unused-vars
-  async updateGuide(guide: Partial<UserGuide>) {
-    throw new Error('Method not implemented.');
-  }
-}

package/src/services/user/client.test.ts

@@ -1,108 +0,0 @@
-import { eq } from 'drizzle-orm';
-import type { PartialDeep } from 'type-fest';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { clientDB, initializeDB } from '@/database/client/db';
-import { userSettings, users } from '@/database/schemas';
-import { UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
-
-import { ClientService } from './client';
-
-const mockUser = {
-  avatar: 'avatar.png',
-  settings: { themeMode: 'light' } as unknown as UserSettings,
-  uuid: 'user-id',
-};
-
-const mockPreference = {
-  useCmdEnterToSend: true,
-} as UserPreference;
-const clientService = new ClientService(mockUser.uuid);
-
-beforeEach(async () => {
-  vi.clearAllMocks();
-
-  await initializeDB();
-  await clientDB.delete(users);
-
-  await clientDB.insert(users).values({ id: mockUser.uuid, avatar: 'avatar.png' });
-  await clientDB
-    .insert(userSettings)
-    .values({ id: mockUser.uuid, general: { themeMode: 'light' } });
-});
-
-describe('ClientService', () => {
-  it('should get user state correctly', async () => {
-    const spyOn = vi
-      .spyOn(clientService['preferenceStorage'], 'getFromLocalStorage')
-      .mockResolvedValue(mockPreference);
-
-    const userState = await clientService.getUserState();
-
-    expect(userState).toMatchObject({
-      avatar: mockUser.avatar,
-      isOnboard: true,
-      canEnablePWAGuide: false,
-      hasConversation: false,
-      canEnableTrace: false,
-      preference: mockPreference,
-      settings: { general: { themeMode: 'light' } },
-      userId: mockUser.uuid,
-    });
-    expect(spyOn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should update user settings correctly', async () => {
-    const settingsPatch: PartialDeep<UserSettings> = { general: { fontSize: 12 } };
-
-    await clientService.updateUserSettings(settingsPatch);
-
-    const result = await clientDB.query.userSettings.findFirst({
-      where: eq(userSettings.id, mockUser.uuid),
-    });
-
-    expect(result).toMatchObject(settingsPatch);
-  });
-
-  it('should reset user settings correctly', async () => {
-    await clientService.resetUserSettings();
-
-    const result = await clientDB.query.userSettings.findFirst({
-      where: eq(userSettings.id, mockUser.uuid),
-    });
-
-    expect(result).toBeUndefined();
-  });
-
-  it('should update user avatar correctly', async () => {
-    const newAvatar = 'new-avatar.png';
-
-    await clientService.updateAvatar(newAvatar);
-  });
-
-  it('should update user preference correctly', async () => {
-    const newPreference = {
-      useCmdEnterToSend: false,
-    } as UserPreference;
-
-    const spyOn = vi
-      .spyOn(clientService['preferenceStorage'], 'saveToLocalStorage')
-      .mockResolvedValue(undefined);
-
-    await clientService.updatePreference(newPreference);
-
-    expect(spyOn).toHaveBeenCalledWith(newPreference);
-    expect(spyOn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should return empty array for getUserSSOProviders', async () => {
-    const providers = await clientService.getUserSSOProviders();
-    expect(providers).toEqual([]);
-  });
-
-  it('should do nothing when unlinkSSOProvider is called', async () => {
-    const result = await clientService.unlinkSSOProvider('google', '123');
-    expect(result).toBeUndefined();
-  });
-});

package/src/services/user/client.ts

@@ -1,104 +0,0 @@
-import { clientDB } from '@/database/client/db';
-import { MessageModel } from '@/database/models/message';
-import { SessionModel } from '@/database/models/session';
-import { UserModel } from '@/database/models/user';
-import { users } from '@/database/schemas';
-import { BaseClientService } from '@/services/baseClientService';
-import { UserPreference } from '@/types/user';
-import { AsyncLocalStorage } from '@/utils/localStorage';
-
-import { IUserService } from './type';
-
-export class ClientService extends BaseClientService implements IUserService {
-  private preferenceStorage: AsyncLocalStorage<UserPreference>;
-
-  private get userModel(): UserModel {
-    return new UserModel(clientDB as any, this.userId);
-  }
-  private get messageModel(): MessageModel {
-    return new MessageModel(clientDB as any, this.userId);
-  }
-  private get sessionModel(): SessionModel {
-    return new SessionModel(clientDB as any, this.userId);
-  }
-
-  constructor(userId?: string) {
-    super(userId);
-    this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
-  }
-
-  getUserRegistrationDuration: IUserService['getUserRegistrationDuration'] = async () => {
-    return this.userModel.getUserRegistrationDuration();
-  };
-
-  getUserState: IUserService['getUserState'] = async () => {
-    // if user not exist in the db, create one to make sure the user exist
-    await this.makeSureUserExist();
-
-    const state = await this.userModel.getUserState((encryptKeyVaultsStr) =>
-      encryptKeyVaultsStr ? JSON.parse(encryptKeyVaultsStr) : {},
-    );
-
-    const messageCount = await this.messageModel.count();
-    const sessionCount = await this.sessionModel.count();
-
-    return {
-      ...state,
-      avatar: state.avatar ?? '',
-      canEnablePWAGuide: messageCount >= 4,
-      canEnableTrace: messageCount >= 4,
-      firstName: state.firstName,
-      fullName: state.fullName,
-      hasConversation: messageCount > 0 || sessionCount > 0,
-      isOnboard: true,
-      lastName: state.lastName,
-      preference: await this.preferenceStorage.getFromLocalStorage(),
-      username: state.username,
-    };
-  };
-
-  getUserSSOProviders: IUserService['getUserSSOProviders'] = async () => {
-    // Account not exist on next-auth in client mode, no need to implement this method
-    return [];
-  };
-
-  unlinkSSOProvider: IUserService['unlinkSSOProvider'] = async () => {
-    // Account not exist on next-auth in client mode, no need to implement this method
-  };
-
-  updateUserSettings: IUserService['updateUserSettings'] = async (value) => {
-    const { keyVaults, ...res } = value;
-
-    return this.userModel.updateSetting({ ...res, keyVaults: JSON.stringify(keyVaults) });
-  };
-
-  resetUserSettings: IUserService['resetUserSettings'] = async () => {
-    return this.userModel.deleteSetting();
-  };
-
-  updateAvatar = async (avatar: string) => {
-    await this.userModel.updateUser({ avatar });
-  };
-
-  updatePreference: IUserService['updatePreference'] = async (preference) => {
-    await this.preferenceStorage.saveToLocalStorage(preference);
-  };
-
-  updateGuide: IUserService['updateGuide'] = async () => {
-    throw new Error('Method not implemented.');
-  };
-
-  makeSureUserExist = async () => {
-    const existUsers = await clientDB.query.users.findMany();
-
-    let user: { id: string };
-    if (existUsers.length === 0) {
-      const result = await clientDB.insert(users).values({ id: this.userId }).returning();
-      user = result[0];
-    } else {
-      user = existUsers[0];
-    }
-
-    return user;
-  };
-}

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

@@ -1,149 +0,0 @@
-import type { PartialDeep } from 'type-fest';
-import { describe, expect, it, vi } from 'vitest';
-
-import { lambdaClient } from '@/libs/trpc/client';
-import { UserInitializationState, UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
-
-import { ServerService } from './server';
-
-vi.mock('@/libs/trpc/client', () => ({
-  lambdaClient: {
-    user: {
-      getUserRegistrationDuration: {
-        query: vi.fn(),
-      },
-      getUserState: {
-        query: vi.fn(),
-      },
-      getUserSSOProviders: {
-        query: vi.fn(),
-      },
-      unlinkSSOProvider: {
-        mutate: vi.fn(),
-      },
-      makeUserOnboarded: {
-        mutate: vi.fn(),
-      },
-      updatePreference: {
-        mutate: vi.fn(),
-      },
-      updateGuide: {
-        mutate: vi.fn(),
-      },
-      updateSettings: {
-        mutate: vi.fn(),
-      },
-      resetSettings: {
-        mutate: vi.fn(),
-      },
-    },
-  },
-}));
-
-describe('ServerService', () => {
-  const service = new ServerService();
-
-  it('should get user registration duration', async () => {
-    const mockData = {
-      createdAt: '2023-01-01',
-      duration: 100,
-      updatedAt: '2023-01-02',
-    };
-    vi.mocked(lambdaClient.user.getUserRegistrationDuration.query).mockResolvedValue(mockData);
-
-    const result = await service.getUserRegistrationDuration();
-    expect(result).toEqual(mockData);
-  });
-
-  it('should get user state', async () => {
-    const mockState: UserInitializationState = {
-      isOnboard: true,
-      preference: {
-        telemetry: true,
-      },
-      settings: {},
-    };
-    vi.mocked(lambdaClient.user.getUserState.query).mockResolvedValue(mockState);
-
-    const result = await service.getUserState();
-    expect(result).toEqual(mockState);
-  });
-
-  it('should get user SSO providers', async () => {
-    const mockProviders = [
-      {
-        provider: 'google',
-        providerAccountId: '123',
-        userId: 'user1',
-        type: 'oauth' as const,
-        access_token: 'token',
-        token_type: 'bearer' as const,
-        expires_at: 123,
-        scope: 'email profile',
-      },
-    ];
-    vi.mocked(lambdaClient.user.getUserSSOProviders.query).mockResolvedValue(mockProviders);
-
-    const result = await service.getUserSSOProviders();
-    expect(result).toEqual(mockProviders);
-  });
-
-  it('should unlink SSO provider', async () => {
-    const provider = 'google';
-    const providerAccountId = '123';
-    await service.unlinkSSOProvider(provider, providerAccountId);
-
-    expect(lambdaClient.user.unlinkSSOProvider.mutate).toHaveBeenCalledWith({
-      provider,
-      providerAccountId,
-    });
-  });
-
-  it('should make user onboarded', async () => {
-    await service.makeUserOnboarded();
-    expect(lambdaClient.user.makeUserOnboarded.mutate).toHaveBeenCalled();
-  });
-
-  it('should update user preference', async () => {
-    const preference: Partial<UserPreference> = {
-      telemetry: true,
-      useCmdEnterToSend: true,
-    };
-    await service.updatePreference(preference);
-    expect(lambdaClient.user.updatePreference.mutate).toHaveBeenCalledWith(preference);
-  });
-
-  it('should update user guide', async () => {
-    const guide = {
-      moveSettingsToAvatar: true,
-      topic: false,
-      uploadFileInKnowledgeBase: true,
-    };
-    await service.updateGuide(guide);
-    expect(lambdaClient.user.updateGuide.mutate).toHaveBeenCalledWith(guide);
-  });
-
-  it('should update user settings', async () => {
-    const settings: PartialDeep<UserSettings> = {
-      defaultAgent: {
-        config: {
-          model: 'gpt-4',
-          provider: 'openai',
-        },
-        meta: {
-          avatar: 'avatar',
-          description: 'test agent',
-        },
-      },
-    };
-    const signal = new AbortController().signal;
-    await service.updateUserSettings(settings, signal);
-    expect(lambdaClient.user.updateSettings.mutate).toHaveBeenCalledWith(settings, { signal });
-  });
-
-  it('should reset user settings', async () => {
-    await service.resetUserSettings();
-    expect(lambdaClient.user.resetSettings.mutate).toHaveBeenCalled();
-  });
-});

package/src/services/user/server.ts

@@ -1,47 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import { IUserService } from '@/services/user/type';
-
-export class ServerService implements IUserService {
-  getUserRegistrationDuration: IUserService['getUserRegistrationDuration'] = async () => {
-    return lambdaClient.user.getUserRegistrationDuration.query();
-  };
-
-  getUserState: IUserService['getUserState'] = async () => {
-    return lambdaClient.user.getUserState.query();
-  };
-
-  getUserSSOProviders: IUserService['getUserSSOProviders'] = async () => {
-    return lambdaClient.user.getUserSSOProviders.query();
-  };
-
-  unlinkSSOProvider: IUserService['unlinkSSOProvider'] = async (
-    provider: string,
-    providerAccountId: string,
-  ) => {
-    return lambdaClient.user.unlinkSSOProvider.mutate({ provider, providerAccountId });
-  };
-
-  makeUserOnboarded = async () => {
-    return lambdaClient.user.makeUserOnboarded.mutate();
-  };
-
-  updateAvatar: IUserService['updateAvatar'] = async (avatar) => {
-    return lambdaClient.user.updateAvatar.mutate(avatar);
-  };
-
-  updatePreference: IUserService['updatePreference'] = async (preference) => {
-    return lambdaClient.user.updatePreference.mutate(preference);
-  };
-
-  updateGuide: IUserService['updateGuide'] = async (guide) => {
-    return lambdaClient.user.updateGuide.mutate(guide);
-  };
-
-  updateUserSettings: IUserService['updateUserSettings'] = async (value, signal) => {
-    return lambdaClient.user.updateSettings.mutate(value, { signal });
-  };
-
-  resetUserSettings: IUserService['resetUserSettings'] = async () => {
-    return lambdaClient.user.resetSettings.mutate();
-  };
-}

package/src/services/user/type.ts

@@ -1,21 +0,0 @@
-import type { AdapterAccount } from 'next-auth/adapters';
-import type { PartialDeep } from 'type-fest';
-
-import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
-import { UserSettings } from '@/types/user/settings';
-
-export interface IUserService {
-  getUserRegistrationDuration: () => Promise<{
-    createdAt: string;
-    duration: number;
-    updatedAt: string;
-  }>;
-  getUserSSOProviders: () => Promise<AdapterAccount[]>;
-  getUserState: () => Promise<UserInitializationState>;
-  resetUserSettings: () => Promise<any>;
-  unlinkSSOProvider: (provider: string, providerAccountId: string) => Promise<any>;
-  updateAvatar: (avatar: string) => Promise<any>;
-  updateGuide: (guide: Partial<UserGuide>) => Promise<any>;
-  updatePreference: (preference: Partial<UserPreference>) => Promise<any>;
-  updateUserSettings: (value: PartialDeep<UserSettings>, signal?: AbortSignal) => Promise<any>;
-}