@lobehub/chat 0.161.9 → 0.161.10

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

@@ -0,0 +1,100 @@
+import { DeepPartial } from 'utility-types';
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { UserModel } from '@/database/client/models/user';
+import { GlobalSettings } from '@/types/settings';
+import { UserPreference } from '@/types/user';
+import { AsyncLocalStorage } from '@/utils/localStorage';
+
+import { ClientService } from './client';
+
+vi.mock('@/database/client/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 GlobalSettings,
+  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,
+      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: DeepPartial<GlobalSettings> = { themeMode: 'dark' };
+    (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/client.ts

@@ -1,27 +1,33 @@
 import { DeepPartial } from 'utility-types';
 
+import { MessageModel } from '@/database/client/models/message';
 import { UserModel } from '@/database/client/models/user';
-import { IUserService } from '@/services/user/type';
 import { GlobalSettings } from '@/types/settings';
-import { UserPreference } from '@/types/user';
+import { UserInitializationState, UserPreference } from '@/types/user';
 import { AsyncLocalStorage } from '@/utils/localStorage';
 
-export interface UserConfig {
-  avatar?: string;
-  settings: DeepPartial<GlobalSettings>;
-  uuid: string;
-}
+import { IUserService } from './type';
 
 export class ClientService implements IUserService {
   private preferenceStorage: AsyncLocalStorage<UserPreference>;
+
   constructor() {
     this.preferenceStorage = new AsyncLocalStorage('LOBE_PREFERENCE');
   }
 
-  getUserConfig = async () => {
+  async getUserState(): Promise<UserInitializationState> {
     const user = await UserModel.getUser();
-    return user as unknown as UserConfig;
-  };
+    const messageCount = await MessageModel.count();
+
+    return {
+      avatar: user.avatar,
+      canEnableTrace: messageCount >= 4,
+      isOnboard: true,
+      preference: await this.preferenceStorage.getFromLocalStorage(),
+      settings: user.settings as GlobalSettings,
+      userId: user.uuid,
+    };
+  }
 
   updateUserSettings = async (patch: DeepPartial<GlobalSettings>) => {
     return UserModel.updateSettings(patch);
@@ -35,10 +41,6 @@ export class ClientService implements IUserService {
     return UserModel.updateAvatar(avatar);
   }
 
-  async getPreference() {
-    return this.preferenceStorage.getFromLocalStorage();
-  }
-
   async updatePreference(preference: UserPreference) {
     await this.preferenceStorage.saveToLocalStorage(preference);
   }

package/src/services/user/index.ts

@@ -8,6 +8,4 @@
 // export const userService = ENABLED_SERVER_SERVICE ? new ServerService() : new ClientService();
 import { ClientService } from './client';
 
-export type { UserConfig } from './client';
-
 export const userService = new ClientService();

package/src/services/user/type.ts

@@ -1,12 +1,10 @@
 import { DeepPartial } from 'utility-types';
 
-import { UserConfig } from '@/services/user/client';
 import { GlobalSettings } from '@/types/settings';
-import { UserPreference } from '@/types/user';
+import { UserInitializationState, UserPreference } from '@/types/user';
 
 export interface IUserService {
-  getPreference: () => Promise<UserPreference>;
-  getUserConfig: () => Promise<UserConfig>;
+  getUserState: () => Promise<UserInitializationState>;
   resetUserSettings: () => Promise<any>;
   updateAvatar: (avatar: string) => Promise<any>;
   updatePreference: (preference: UserPreference) => Promise<any>;

package/src/store/user/initialState.ts

@@ -1,13 +1,22 @@
 import { UserAuthState, initialAuthState } from './slices/auth/initialState';
+import { CommonState, initialCommonState } from './slices/common/initialState';
+import { ModelListState, initialModelListState } from './slices/modelList/initialState';
 import { UserPreferenceState, initialPreferenceState } from './slices/preference/initialState';
 import { UserSettingsState, initialSettingsState } from './slices/settings/initialState';
 import { UserSyncState, initialSyncState } from './slices/sync/initialState';
 
-export type UserState = UserSyncState & UserSettingsState & UserPreferenceState & UserAuthState;
+export type UserState = UserSyncState &
+  UserSettingsState &
+  UserPreferenceState &
+  UserAuthState &
+  ModelListState &
+  CommonState;
 
 export const initialState: UserState = {
   ...initialSyncState,
   ...initialSettingsState,
   ...initialPreferenceState,
   ...initialAuthState,
+  ...initialCommonState,
+  ...initialModelListState,
 };

package/src/store/user/selectors.ts

@@ -1,9 +1,5 @@
 export { authSelectors, userProfileSelectors } from './slices/auth/selectors';
+export { modelConfigSelectors, modelProviderSelectors } from './slices/modelList/selectors';
 export { preferenceSelectors } from './slices/preference/selectors';
-export {
-  modelConfigSelectors,
-  modelProviderSelectors,
-  settingsSelectors,
-  syncSettingsSelectors,
-  systemAgentSelectors,
-} from './slices/settings/selectors';
+export { settingsSelectors, systemAgentSelectors } from './slices/settings/selectors';
+export { syncSettingsSelectors } from './slices/sync/selectors';

package/src/store/user/slices/auth/action.test.ts

@@ -9,10 +9,6 @@ import { switchLang } from '@/utils/client/switchLang';
 
 vi.mock('zustand/traditional');
 
-vi.mock('@/utils/client/switchLang', () => ({
-  switchLang: vi.fn(),
-}));
-
 vi.mock('swr', async (importOriginal) => {
   const modules = await importOriginal();
   return {
@@ -54,93 +50,15 @@ vi.mock('next-auth/react', async () => {
 });
 
 describe('createAuthSlice', () => {
-  describe('refreshUserConfig', () => {
+  describe('refreshUserState', () => {
     it('should refresh user config', async () => {
       const { result } = renderHook(() => useUserStore());
 
       await act(async () => {
-        await result.current.refreshUserConfig();
+        await result.current.refreshUserState();
       });
 
-      expect(mutate).toHaveBeenCalledWith(['fetchUserConfig', true]);
-    });
-  });
-
-  describe('useFetchUserConfig', () => {
-    it('should not fetch user config if initServer is false', async () => {
-      const mockUserConfig: any = undefined; // 模拟未初始化服务器的情况
-      vi.spyOn(userService, 'getUserConfig').mockResolvedValueOnce(mockUserConfig);
-
-      const { result } = renderHook(() => useUserStore().useFetchUserConfig(false), {
-        wrapper: withSWR,
-      });
-
-      // 因为 initServer 为 false，所以不会触发 getUserConfig 的调用
-      expect(userService.getUserConfig).not.toHaveBeenCalled();
-      // 确保状态未改变
-      expect(result.current.data).toBeUndefined();
-    });
-
-    it('should fetch user config correctly when initServer is true', async () => {
-      const mockUserConfig: any = {
-        avatar: 'new-avatar-url',
-        settings: {
-          language: 'en',
-        },
-      };
-      vi.spyOn(userService, 'getUserConfig').mockResolvedValueOnce(mockUserConfig);
-
-      const { result } = renderHook(() => useUserStore().useFetchUserConfig(true), {
-        wrapper: withSWR,
-      });
-
-      // 等待 SWR 完成数据获取
-      await waitFor(() => expect(result.current.data).toEqual(mockUserConfig));
-
-      // 验证状态是否正确更新
-      expect(useUserStore.getState().avatar).toBe(mockUserConfig.avatar);
-      expect(useUserStore.getState().settings).toEqual(mockUserConfig.settings);
-
-      // 验证是否正确处理了语言设置
-      expect(switchLang).not.toHaveBeenCalledWith('auto');
-    });
-    it('should call switch language when language is auto', async () => {
-      const mockUserConfig: any = {
-        avatar: 'new-avatar-url',
-        settings: {
-          language: 'auto',
-        },
-      };
-      vi.spyOn(userService, 'getUserConfig').mockResolvedValueOnce(mockUserConfig);
-
-      const { result } = renderHook(() => useUserStore().useFetchUserConfig(true), {
-        wrapper: withSWR,
-      });
-
-      // 等待 SWR 完成数据获取
-      await waitFor(() => expect(result.current.data).toEqual(mockUserConfig));
-
-      // 验证状态是否正确更新
-      expect(useUserStore.getState().avatar).toBe(mockUserConfig.avatar);
-      expect(useUserStore.getState().settings).toEqual(mockUserConfig.settings);
-
-      // 验证是否正确处理了语言设置
-      expect(switchLang).toHaveBeenCalledWith('auto');
-    });
-
-    it('should handle the case when user config is null', async () => {
-      vi.spyOn(userService, 'getUserConfig').mockResolvedValueOnce(null as any);
-
-      const { result } = renderHook(() => useUserStore().useFetchUserConfig(true), {
-        wrapper: withSWR,
-      });
-
-      // 等待 SWR 完成数据获取
-      await waitFor(() => expect(result.current.data).toBeNull());
-
-      // 验证状态未被错误更新
-      expect(useUserStore.getState().avatar).toBeUndefined();
-      expect(useUserStore.getState().settings).toEqual({});
+      expect(mutate).toHaveBeenCalledWith('initUserState');
     });
   });
 
@@ -174,7 +92,7 @@ describe('createAuthSlice', () => {
     });
 
     it('should call next-auth signOut when NextAuth is enabled', async () => {
-      useUserStore.setState({ enabledNextAuth: () => true });
+      useUserStore.setState({ enabledNextAuth: true });
 
       const { result } = renderHook(() => useUserStore());
 
@@ -228,7 +146,7 @@ describe('createAuthSlice', () => {
     });
 
     it('should call next-auth signIn when NextAuth is enabled', async () => {
-      useUserStore.setState({ enabledNextAuth: () => true });
+      useUserStore.setState({ enabledNextAuth: true });
 
       const { result } = renderHook(() => useUserStore());
 

package/src/store/user/slices/auth/action.ts

@@ -1,21 +1,11 @@
-import useSWR, { SWRResponse, mutate } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
 import { enableClerk } from '@/const/auth';
-import { UserConfig, userService } from '@/services/user';
-import { switchLang } from '@/utils/client/switchLang';
-import { setNamespace } from '@/utils/storeDebug';
 
 import { UserStore } from '../../store';
-import { settingsSelectors } from '../settings/selectors';
-
-const n = setNamespace('auth');
-const USER_CONFIG_FETCH_KEY = 'fetchUserConfig';
 
 export interface UserAuthAction {
   enableAuth: () => boolean;
-  enabledNextAuth: () => boolean;
-  getUserConfig: () => void;
   /**
    * universal logout method
    */
@@ -25,9 +15,6 @@ export interface UserAuthAction {
    */
   openLogin: () => Promise<void>;
   openUserProfile: () => Promise<void>;
-
-  refreshUserConfig: () => Promise<void>;
-  useFetchUserConfig: (initServer: boolean) => SWRResponse<UserConfig | undefined>;
 }
 
 export const createAuthSlice: StateCreator<
@@ -37,13 +24,7 @@ export const createAuthSlice: StateCreator<
   UserAuthAction
 > = (set, get) => ({
   enableAuth: () => {
-    return enableClerk || get()?.enabledNextAuth();
-  },
-  enabledNextAuth: () => {
-    return !!get()?.serverConfig.enabledOAuthSSO;
-  },
-  getUserConfig: () => {
-    console.log(n('userconfig'));
+    return enableClerk || get()?.enabledNextAuth || false;
   },
   logout: async () => {
     if (enableClerk) {
@@ -52,7 +33,7 @@ export const createAuthSlice: StateCreator<
       return;
     }
 
-    const enableNextAuth = get().enabledNextAuth();
+    const enableNextAuth = get().enabledNextAuth;
     if (enableNextAuth) {
       const { signOut } = await import('next-auth/react');
       signOut();
@@ -60,14 +41,12 @@ export const createAuthSlice: StateCreator<
   },
   openLogin: async () => {
     if (enableClerk) {
-      console.log('fallbackRedirectUrl:', location.toString());
-
       get().clerkSignIn?.({ fallbackRedirectUrl: location.toString() });
 
       return;
     }
 
-    const enableNextAuth = get().enabledNextAuth();
+    const enableNextAuth = get().enabledNextAuth;
     if (enableNextAuth) {
       const { signIn } = await import('next-auth/react');
       signIn();
@@ -81,38 +60,4 @@ export const createAuthSlice: StateCreator<
       return;
     }
   },
-  refreshUserConfig: async () => {
-    await mutate([USER_CONFIG_FETCH_KEY, true]);
-
-    // when get the user config ,refresh the model provider list to the latest
-    get().refreshModelProviderList();
-  },
-  useFetchUserConfig: (initServer) =>
-    useSWR<UserConfig | undefined>(
-      [USER_CONFIG_FETCH_KEY, initServer],
-      async () => {
-        if (!initServer) return;
-        return userService.getUserConfig();
-      },
-      {
-        onSuccess: (data) => {
-          if (!data) return;
-
-          set(
-            { avatar: data.avatar, settings: data.settings, userId: data.uuid },
-            false,
-            n('fetchUserConfig', data),
-          );
-
-          // when get the user config ,refresh the model provider list to the latest
-          get().refreshDefaultModelProviderList({ trigger: 'fetchUserConfig' });
-
-          const { language } = settingsSelectors.currentSettings(get());
-          if (language === 'auto') {
-            switchLang('auto');
-          }
-        },
-        revalidateOnFocus: false,
-      },
-    ),
 });

package/src/store/user/slices/auth/initialState.ts

@@ -15,12 +15,13 @@ export interface UserAuthState {
    * @deprecated
    */
   avatar?: string;
-
   clerkOpenUserProfile?: (props?: UserProfileProps) => void;
+
   clerkSession?: ActiveSessionResource;
   clerkSignIn?: (props?: SignInProps) => void;
   clerkSignOut?: SignOut;
   clerkUser?: UserResource;
+  enabledNextAuth?: boolean;
 
   isLoaded?: boolean;
   isSignedIn?: boolean;