@lobehub/chat 0.161.9 → 0.161.11

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;

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

@@ -3,15 +3,20 @@ import { mutate } from 'swr';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { withSWR } from '~test-utils';
 
-import { globalService } from '@/services/global';
-import { messageService } from '@/services/message';
+import { DEFAULT_PREFERENCE } from '@/const/user';
 import { userService } from '@/services/user';
 import { useUserStore } from '@/store/user';
 import { preferenceSelectors } from '@/store/user/selectors';
 import { GlobalServerConfig } from '@/types/serverConfig';
+import { UserInitializationState, UserPreference } from '@/types/user';
+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 {
@@ -30,7 +35,7 @@ describe('createCommonSlice', () => {
       const { result } = renderHook(() => useUserStore());
       const avatar = 'new-avatar';
 
-      const spyOn = vi.spyOn(result.current, 'refreshUserConfig');
+      const spyOn = vi.spyOn(result.current, 'refreshUserState');
       const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar');
 
       await act(async () => {
@@ -42,28 +47,197 @@ describe('createCommonSlice', () => {
     });
   });
 
-  describe('useFetchServerConfig', () => {
-    it('should fetch server config correctly', async () => {
-      const mockServerConfig = {
-        defaultAgent: 'agent1',
-        languageModel: 'model1',
-        telemetry: {},
-      } as GlobalServerConfig;
-      vi.spyOn(globalService, 'getGlobalConfig').mockResolvedValueOnce(mockServerConfig);
+  describe('useInitUserState', () => {
+    const mockServerConfig = {
+      defaultAgent: 'agent1',
+      languageModel: 'model1',
+      telemetry: {},
+    } as GlobalServerConfig;
+
+    it('should not fetch user state if user is not login', async () => {
+      const mockUserConfig: any = undefined; // 模拟未初始化服务器的情况
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserConfig);
+      const successCallback = vi.fn();
+
+      const { result } = renderHook(
+        () =>
+          useUserStore().useInitUserState(false, mockServerConfig, {
+            onSuccess: successCallback,
+          }),
+        { wrapper: withSWR },
+      );
+
+      // 因为 initServer 为 false，所以不会触发 getUserState 的调用
+      expect(userService.getUserState).not.toHaveBeenCalled();
+      // 也不会触发 onSuccess 回调
+      expect(successCallback).not.toHaveBeenCalled();
+      // 确保状态未改变
+      expect(result.current.data).toBeUndefined();
+    });
+
+    it('should fetch user state correctly when user is login', async () => {
+      const mockUserState: UserInitializationState = {
+        userId: 'user-id',
+        isOnboard: true,
+        preference: {
+          telemetry: true,
+        },
+        settings: {
+          language: 'en-US',
+        },
+      };
+
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserState);
+      const successCallback = vi.fn();
+
+      const { result } = renderHook(
+        () =>
+          useUserStore().useInitUserState(true, mockServerConfig, {
+            onSuccess: successCallback,
+          }),
+        {
+          wrapper: withSWR,
+        },
+      );
+
+      // 等待 SWR 完成数据获取
+      await waitFor(() => expect(result.current.data).toEqual(mockUserState));
+
+      // 验证状态是否正确更新
+      expect(useUserStore.getState().avatar).toBe(mockUserState.avatar);
+      expect(useUserStore.getState().settings).toEqual(mockUserState.settings);
+      expect(successCallback).toHaveBeenCalledWith(mockUserState);
+
+      // 验证是否正确处理了语言设置
+      expect(switchLang).not.toHaveBeenCalledWith('auto');
+    });
+
+    it('should call switch language when language is auto', async () => {
+      const mockUserState: UserInitializationState = {
+        userId: 'user-id',
+        isOnboard: true,
+        preference: {
+          telemetry: true,
+        },
+        settings: {},
+      };
+
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserState);
+
+      const { result } = renderHook(() => useUserStore().useInitUserState(true, mockServerConfig), {
+        wrapper: withSWR,
+      });
+
+      // 等待 SWR 完成数据获取
+      await waitFor(() => expect(result.current.data).toEqual(mockUserState));
+
+      // 验证是否正确处理了语言设置
+      expect(switchLang).toHaveBeenCalledWith('auto');
+    });
+
+    it('should fetch use server config correctly', async () => {
+      const mockUserState: UserInitializationState = {
+        userId: 'user-id',
+        isOnboard: true,
+        preference: {
+          telemetry: true,
+        },
+        settings: {},
+      };
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserState);
+
+      const { result } = renderHook(() => useUserStore().useInitUserState(true, mockServerConfig));
+
+      await waitFor(() => expect(result.current.data).toEqual(mockUserState));
+    });
+
+    it('should return saved preference when local storage has data', async () => {
+      const { result } = renderHook(() => useUserStore());
+
+      const savedPreference: UserPreference = {
+        ...DEFAULT_PREFERENCE,
+        hideSyncAlert: true,
+        guide: { topic: false, moveSettingsToAvatar: true },
+      };
+
+      const mockUserState: UserInitializationState = {
+        userId: 'user-id',
+        isOnboard: true,
+        preference: savedPreference,
+        settings: {
+          language: 'en-US',
+        },
+      };
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserState);
+
+      const { result: preference } = renderHook(
+        () => result.current.useInitUserState(true, mockServerConfig),
+        { wrapper: withSWR },
+      );
+
+      await waitFor(() => {
+        expect(preference.current.data.preference).toEqual(savedPreference);
+        expect(result.current.isUserStateInit).toBeTruthy();
+        expect(result.current.preference).toEqual(savedPreference);
+      });
+    });
+
+    it('should handle the case when user config is null', async () => {
+      const { result } = renderHook(() => useUserStore());
+      const mockUserState: UserInitializationState = {
+        userId: 'user-id',
+        isOnboard: true,
+        preference: undefined as any,
+        settings: null as any,
+      };
+
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserState);
+
+      renderHook(() => result.current.useInitUserState(true, mockServerConfig), {
+        wrapper: withSWR,
+      });
+
+      //   等待 SWR 完成数据获取
+      await waitFor(() => {
+        expect(result.current.isUserStateInit).toBeTruthy();
+        // 验证状态未被错误更新
+        expect(result.current.avatar).toBeUndefined();
+        expect(result.current.settings).toEqual({});
+      });
+    });
+
+    it('should return default preference when local storage is empty', async () => {
+      const { result } = renderHook(() => useUserStore());
 
-      const { result } = renderHook(() => useUserStore().useFetchServerConfig());
+      const mockUserState: UserInitializationState = {
+        userId: 'user-id',
+        isOnboard: true,
+        preference: {} as any,
+        settings: {
+          language: 'en-US',
+        },
+      };
 
-      await waitFor(() => expect(result.current.data).toEqual(mockServerConfig));
+      vi.spyOn(userService, 'getUserState').mockResolvedValueOnce(mockUserState);
+
+      renderHook(() => result.current.useInitUserState(true, mockServerConfig), {
+        wrapper: withSWR,
+      });
+
+      await waitFor(() => {
+        expect(result.current.isUserStateInit).toBeTruthy();
+        expect(result.current.preference).toEqual(DEFAULT_PREFERENCE);
+      });
     });
   });
 
   describe('useCheckTrace', () => {
-    it('should return false when shouldFetch is false', async () => {
+    it('should return undefined when shouldFetch is false', async () => {
       const { result } = renderHook(() => useUserStore().useCheckTrace(false), {
         wrapper: withSWR,
       });
 
-      await waitFor(() => expect(result.current.data).toBe(false));
+      await waitFor(() => expect(result.current.data).toBeUndefined());
     });
 
     it('should return false when userAllowTrace is already set', async () => {
@@ -78,16 +252,18 @@ describe('createCommonSlice', () => {
 
     it('should call messageService.messageCountToCheckTrace when needed', async () => {
       vi.spyOn(preferenceSelectors, 'userAllowTrace').mockReturnValueOnce(null);
-      const messageCountToCheckTraceSpy = vi
-        .spyOn(messageService, 'messageCountToCheckTrace')
-        .mockResolvedValueOnce(true);
 
-      const { result } = renderHook(() => useUserStore().useCheckTrace(true), {
+      act(() => {
+        useUserStore.setState({
+          isUserCanEnableTrace: true,
+        });
+      });
+
+      const { result } = renderHook(() => useUserStore.getState().useCheckTrace(true), {
         wrapper: withSWR,
       });
 
       await waitFor(() => expect(result.current.data).toBe(true));
-      expect(messageCountToCheckTraceSpy).toHaveBeenCalled();
     });
   });
 });

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

@@ -1,26 +1,38 @@
-import useSWR, { SWRResponse } from 'swr';
+import useSWR, { SWRResponse, mutate } from 'swr';
 import { DeepPartial } from 'utility-types';
 import type { StateCreator } from 'zustand/vanilla';
 
-import { messageService } from '@/services/message';
+import { DEFAULT_PREFERENCE } from '@/const/user';
 import { userService } from '@/services/user';
 import type { UserStore } from '@/store/user';
 import type { GlobalServerConfig } from '@/types/serverConfig';
 import type { GlobalSettings } from '@/types/settings';
+import { UserInitializationState } from '@/types/user';
+import { switchLang } from '@/utils/client/switchLang';
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
 
 import { preferenceSelectors } from '../preference/selectors';
+import { settingsSelectors } from '../settings/selectors';
 
 const n = setNamespace('common');
 
+const GET_USER_STATE_KEY = 'initUserState';
 /**
  * 设置操作
  */
 export interface CommonAction {
+  refreshUserState: () => Promise<void>;
+
   updateAvatar: (avatar: string) => Promise<void>;
   useCheckTrace: (shouldFetch: boolean) => SWRResponse;
-  useFetchServerConfig: () => SWRResponse;
+  useInitUserState: (
+    isLogin: boolean | undefined,
+    serverConfig: GlobalServerConfig,
+    options?: {
+      onSuccess: (data: UserInitializationState) => void;
+    },
+  ) => SWRResponse;
 }
 
 export const createCommonSlice: StateCreator<
@@ -29,55 +41,72 @@ export const createCommonSlice: StateCreator<
   [],
   CommonAction
 > = (set, get) => ({
+  refreshUserState: async () => {
+    await mutate(GET_USER_STATE_KEY);
+  },
   updateAvatar: async (avatar) => {
     await userService.updateAvatar(avatar);
-    await get().refreshUserConfig();
+    await get().refreshUserState();
   },
 
   useCheckTrace: (shouldFetch) =>
     useSWR<boolean>(
-      ['checkTrace', shouldFetch],
+      shouldFetch ? 'checkTrace' : null,
       () => {
         const userAllowTrace = preferenceSelectors.userAllowTrace(get());
-        // if not init with server side, return false
-        if (!shouldFetch) return Promise.resolve(false);
 
         // if user have set the trace, return false
         if (typeof userAllowTrace === 'boolean') return Promise.resolve(false);
 
-        return messageService.messageCountToCheckTrace();
+        return Promise.resolve(get().isUserCanEnableTrace);
       },
       {
         revalidateOnFocus: false,
       },
     ),
 
-  /**
-   * TODO: need to be removed in the future
-   * the serverConfig should be fetched only in the serverConfigStore
-   * @deprecated
-   */
-  useFetchServerConfig: () =>
-    useSWR<GlobalServerConfig>(
-      'fetchGlobalConfig',
-      async () => {
-        const { globalService } = await import('@/services/global');
-
-        return globalService.getGlobalConfig();
-      },
+  useInitUserState: (isLogin, serverConfig, options) =>
+    useSWR<UserInitializationState>(
+      !!isLogin ? GET_USER_STATE_KEY : null,
+      () => userService.getUserState(),
       {
         onSuccess: (data) => {
+          options?.onSuccess?.(data);
+
           if (data) {
+            // merge settings
             const serverSettings: DeepPartial<GlobalSettings> = {
-              defaultAgent: data.defaultAgent,
-              languageModel: data.languageModel,
+              defaultAgent: serverConfig.defaultAgent,
+              languageModel: serverConfig.languageModel,
             };
-
             const defaultSettings = merge(get().defaultSettings, serverSettings);
 
-            set({ defaultSettings, serverConfig: data }, false, n('initGlobalConfig'));
+            // merge preference
+            const isEmpty = Object.keys(data.preference || {}).length === 0;
+            const preference = isEmpty ? DEFAULT_PREFERENCE : data.preference;
+
+            set(
+              {
+                defaultSettings,
+                enabledNextAuth: serverConfig.enabledOAuthSSO,
+                isUserCanEnableTrace: data.canEnableTrace,
+                isUserStateInit: true,
+                preference,
+                serverLanguageModel: serverConfig.languageModel,
+                settings: data.settings || {},
+                userId: data.userId,
+              },
+              false,
+              n('initUserState'),
+            );
+
+            get().refreshDefaultModelProviderList({ trigger: 'fetchUserState' });
 
-            get().refreshDefaultModelProviderList({ trigger: 'fetchServerConfig' });
+            // auto switch language
+            const { language } = settingsSelectors.currentSettings(get());
+            if (language === 'auto') {
+              switchLang('auto');
+            }
           }
         },
         revalidateOnFocus: false,

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

@@ -0,0 +1,9 @@
+export interface CommonState {
+  isUserCanEnableTrace: boolean;
+  isUserStateInit: boolean;
+}
+
+export const initialCommonState: CommonState = {
+  isUserCanEnableTrace: false,
+  isUserStateInit: false,
+};