@lobehub/lobehub 2.0.0-next.124 → 2.0.0-next.126

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

@@ -1,8 +1,168 @@
-import { describe } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { testService } from '~test-utils';
 
-import { UserService } from './index';
+import { UserService, userService } from './index';
+
+const mockLambdaClient = vi.hoisted(() => ({
+  user: {
+    getUserRegistrationDuration: { query: vi.fn() },
+    getUserState: { query: vi.fn() },
+    getUserSSOProviders: { query: vi.fn() },
+    unlinkSSOProvider: { mutate: vi.fn() },
+    makeUserOnboarded: { mutate: vi.fn() },
+    updateAvatar: { mutate: vi.fn() },
+    updateFullName: { mutate: vi.fn() },
+    updatePreference: { mutate: vi.fn() },
+    updateGuide: { mutate: vi.fn() },
+    updateSettings: { mutate: vi.fn() },
+    resetSettings: { mutate: vi.fn() },
+  },
+}));
+
+vi.mock('@/libs/trpc/client', () => ({
+  lambdaClient: mockLambdaClient,
+}));
 
 describe('UserService', () => {
   testService(UserService);
+
+  describe('getUserRegistrationDuration', () => {
+    it('should call lambdaClient.user.getUserRegistrationDuration.query', async () => {
+      const mockResult = { createdAt: '2024-01-01', duration: 100, updatedAt: '2024-01-02' };
+      mockLambdaClient.user.getUserRegistrationDuration.query.mockResolvedValueOnce(mockResult);
+
+      const result = await userService.getUserRegistrationDuration();
+
+      expect(mockLambdaClient.user.getUserRegistrationDuration.query).toHaveBeenCalled();
+      expect(result).toEqual(mockResult);
+    });
+  });
+
+  describe('getUserState', () => {
+    it('should call lambdaClient.user.getUserState.query', async () => {
+      const mockState = { isOnboarded: true, preference: {}, settings: {} };
+      mockLambdaClient.user.getUserState.query.mockResolvedValueOnce(mockState);
+
+      const result = await userService.getUserState();
+
+      expect(mockLambdaClient.user.getUserState.query).toHaveBeenCalled();
+      expect(result).toEqual(mockState);
+    });
+  });
+
+  describe('getUserSSOProviders', () => {
+    it('should call lambdaClient.user.getUserSSOProviders.query', async () => {
+      const mockProviders = [
+        { provider: 'github', email: 'test@example.com', providerAccountId: '123' },
+      ];
+      mockLambdaClient.user.getUserSSOProviders.query.mockResolvedValueOnce(mockProviders);
+
+      const result = await userService.getUserSSOProviders();
+
+      expect(mockLambdaClient.user.getUserSSOProviders.query).toHaveBeenCalled();
+      expect(result).toEqual(mockProviders);
+    });
+  });
+
+  describe('unlinkSSOProvider', () => {
+    it('should call lambdaClient.user.unlinkSSOProvider.mutate with correct params', async () => {
+      mockLambdaClient.user.unlinkSSOProvider.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.unlinkSSOProvider('github', 'account-123');
+
+      expect(mockLambdaClient.user.unlinkSSOProvider.mutate).toHaveBeenCalledWith({
+        provider: 'github',
+        providerAccountId: 'account-123',
+      });
+    });
+  });
+
+  describe('makeUserOnboarded', () => {
+    it('should call lambdaClient.user.makeUserOnboarded.mutate', async () => {
+      mockLambdaClient.user.makeUserOnboarded.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.makeUserOnboarded();
+
+      expect(mockLambdaClient.user.makeUserOnboarded.mutate).toHaveBeenCalled();
+    });
+  });
+
+  describe('updateAvatar', () => {
+    it('should call lambdaClient.user.updateAvatar.mutate with avatar string', async () => {
+      mockLambdaClient.user.updateAvatar.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.updateAvatar('https://example.com/avatar.png');
+
+      expect(mockLambdaClient.user.updateAvatar.mutate).toHaveBeenCalledWith(
+        'https://example.com/avatar.png',
+      );
+    });
+  });
+
+  describe('updateFullName', () => {
+    it('should call lambdaClient.user.updateFullName.mutate with fullName string', async () => {
+      mockLambdaClient.user.updateFullName.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.updateFullName('John Doe');
+
+      expect(mockLambdaClient.user.updateFullName.mutate).toHaveBeenCalledWith('John Doe');
+    });
+  });
+
+  describe('updatePreference', () => {
+    it('should call lambdaClient.user.updatePreference.mutate with preference object', async () => {
+      const preference = { hideSyncAlert: true };
+      mockLambdaClient.user.updatePreference.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.updatePreference(preference);
+
+      expect(mockLambdaClient.user.updatePreference.mutate).toHaveBeenCalledWith(preference);
+    });
+  });
+
+  describe('updateGuide', () => {
+    it('should call lambdaClient.user.updateGuide.mutate with guide object', async () => {
+      const guide = { moveSettingsToAvatar: true };
+      mockLambdaClient.user.updateGuide.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.updateGuide(guide);
+
+      expect(mockLambdaClient.user.updateGuide.mutate).toHaveBeenCalledWith(guide);
+    });
+  });
+
+  describe('updateUserSettings', () => {
+    it('should call lambdaClient.user.updateSettings.mutate with settings', async () => {
+      const settings = { general: { fontSize: 14 } };
+      mockLambdaClient.user.updateSettings.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.updateUserSettings(settings);
+
+      expect(mockLambdaClient.user.updateSettings.mutate).toHaveBeenCalledWith(settings, {
+        signal: undefined,
+      });
+    });
+
+    it('should pass abort signal when provided', async () => {
+      const settings = { general: { fontSize: 16 } };
+      const abortController = new AbortController();
+      mockLambdaClient.user.updateSettings.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.updateUserSettings(settings, abortController.signal);
+
+      expect(mockLambdaClient.user.updateSettings.mutate).toHaveBeenCalledWith(settings, {
+        signal: abortController.signal,
+      });
+    });
+  });
+
+  describe('resetUserSettings', () => {
+    it('should call lambdaClient.user.resetSettings.mutate', async () => {
+      mockLambdaClient.user.resetSettings.mutate.mockResolvedValueOnce({ success: true });
+
+      await userService.resetUserSettings();
+
+      expect(mockLambdaClient.user.resetSettings.mutate).toHaveBeenCalled();
+    });
+  });
 });

package/src/services/user/index.ts

@@ -1,8 +1,7 @@
-import type { AdapterAccount } from 'next-auth/adapters';
 import type { PartialDeep } from 'type-fest';
 
 import { lambdaClient } from '@/libs/trpc/client';
-import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
+import { SSOProvider, UserGuide, UserInitializationState, UserPreference } from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
 export class UserService {
@@ -18,7 +17,7 @@ export class UserService {
     return lambdaClient.user.getUserState.query();
   };
 
-  getUserSSOProviders = async (): Promise<AdapterAccount[]> => {
+  getUserSSOProviders = async (): Promise<SSOProvider[]> => {
     return lambdaClient.user.getUserSSOProviders.query();
   };
 
@@ -34,6 +33,10 @@ export class UserService {
     return lambdaClient.user.updateAvatar.mutate(avatar);
   };
 
+  updateFullName = async (fullName: string) => {
+    return lambdaClient.user.updateFullName.mutate(fullName);
+  };
+
   updatePreference = async (preference: Partial<UserPreference>) => {
     return lambdaClient.user.updatePreference.mutate(preference);
   };

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

@@ -14,26 +14,60 @@ vi.mock('swr', async (importOriginal) => {
   };
 });
 
-// 定义一个变量来存储 enableAuth 的值
-let enableClerk = false;
-
-let enableNextAuth = false;
+// Use vi.hoisted to ensure variables exist before vi.mock factory executes
+const { enableClerk, enableNextAuth, enableBetterAuth, enableAuth } = vi.hoisted(() => ({
+  enableClerk: { value: false },
+  enableNextAuth: { value: false },
+  enableBetterAuth: { value: false },
+  enableAuth: { value: true },
+}));
 
-// 模拟 @/const/auth 模块
 vi.mock('@/const/auth', () => ({
   get enableClerk() {
-    return enableClerk;
+    return enableClerk.value;
   },
   get enableNextAuth() {
-    return enableNextAuth;
+    return enableNextAuth.value;
+  },
+  get enableBetterAuth() {
+    return enableBetterAuth.value;
+  },
+  get enableAuth() {
+    return enableAuth.value;
   },
 }));
 
+const mockUserService = vi.hoisted(() => ({
+  getUserSSOProviders: vi.fn().mockResolvedValue([]),
+}));
+
+vi.mock('@/services/user', () => ({
+  userService: mockUserService,
+}));
+
+const mockBetterAuthClient = vi.hoisted(() => ({
+  listAccounts: vi.fn().mockResolvedValue({ data: [] }),
+  accountInfo: vi.fn().mockResolvedValue({ data: { user: {} } }),
+  signOut: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock('@/libs/better-auth/auth-client', () => mockBetterAuthClient);
+
 afterEach(() => {
   vi.restoreAllMocks();
-
-  enableNextAuth = false;
-  enableClerk = false;
+  vi.clearAllMocks();
+
+  enableNextAuth.value = false;
+  enableClerk.value = false;
+  enableBetterAuth.value = false;
+  enableAuth.value = true;
+
+  // Reset store state
+  useUserStore.setState({
+    isLoadedAuthProviders: false,
+    authProviders: [],
+    isEmailPasswordAuth: false,
+  });
 });
 
 /**
@@ -61,7 +95,7 @@ describe('createAuthSlice', () => {
 
   describe('logout', () => {
     it('should call clerkSignOut when Clerk is enabled', async () => {
-      enableClerk = true;
+      enableClerk.value = true;
 
       const clerkSignOutMock = vi.fn();
       useUserStore.setState({ clerkSignOut: clerkSignOutMock });
@@ -89,7 +123,7 @@ describe('createAuthSlice', () => {
     });
 
     it('should call next-auth signOut when NextAuth is enabled', async () => {
-      enableNextAuth = true;
+      enableNextAuth.value = true;
 
       const { result } = renderHook(() => useUserStore());
 
@@ -100,7 +134,7 @@ describe('createAuthSlice', () => {
       const { signOut } = await import('next-auth/react');
 
       expect(signOut).toHaveBeenCalled();
-      enableNextAuth = false;
+      enableNextAuth.value = false;
     });
 
     it('should not call next-auth signOut when NextAuth is disabled', async () => {
@@ -118,7 +152,7 @@ describe('createAuthSlice', () => {
 
   describe('openLogin', () => {
     it('should call clerkSignIn when Clerk is enabled', async () => {
-      enableClerk = true;
+      enableClerk.value = true;
       const clerkSignInMock = vi.fn();
       useUserStore.setState({ clerkSignIn: clerkSignInMock });
 
@@ -144,7 +178,7 @@ describe('createAuthSlice', () => {
     });
 
     it('should call next-auth signIn when NextAuth is enabled', async () => {
-      enableNextAuth = true;
+      enableNextAuth.value = true;
 
       const { result } = renderHook(() => useUserStore());
 
@@ -155,7 +189,7 @@ describe('createAuthSlice', () => {
       const { signIn } = await import('next-auth/react');
 
       expect(signIn).toHaveBeenCalled();
-      enableNextAuth = false;
+      enableNextAuth.value = false;
     });
     it('should not call next-auth signIn when NextAuth is disabled', async () => {
       const { result } = renderHook(() => useUserStore());
@@ -168,5 +202,168 @@ describe('createAuthSlice', () => {
 
       expect(signIn).not.toHaveBeenCalled();
     });
+
+    it('should redirect to signin page when BetterAuth is enabled', async () => {
+      enableBetterAuth.value = true;
+
+      const originalLocation = window.location;
+      Object.defineProperty(window, 'location', {
+        configurable: true,
+        value: { ...originalLocation, href: '', toString: () => 'http://localhost/chat' },
+        writable: true,
+      });
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.openLogin();
+      });
+
+      expect(window.location.href).toContain('/signin');
+      expect(window.location.href).toContain('callbackUrl');
+
+      Object.defineProperty(window, 'location', {
+        configurable: true,
+        value: originalLocation,
+        writable: true,
+      });
+    });
+
+    it('should call signIn with single provider when only one OAuth provider available', async () => {
+      enableNextAuth.value = true;
+      useUserStore.setState({ oAuthSSOProviders: ['github'] });
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.openLogin();
+      });
+
+      const { signIn } = await import('next-auth/react');
+
+      expect(signIn).toHaveBeenCalledWith('github');
+    });
+  });
+
+  describe('enableAuth', () => {
+    it('should return true when auth is enabled', () => {
+      enableAuth.value = true;
+      const { result } = renderHook(() => useUserStore());
+
+      expect(result.current.enableAuth()).toBe(true);
+    });
+
+    it('should return false when auth is disabled', () => {
+      enableAuth.value = false;
+      const { result } = renderHook(() => useUserStore());
+
+      expect(result.current.enableAuth()).toBe(false);
+    });
+  });
+
+  describe('fetchAuthProviders', () => {
+    it('should skip fetching if already loaded', async () => {
+      useUserStore.setState({ isLoadedAuthProviders: true });
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.fetchAuthProviders();
+      });
+
+      expect(mockUserService.getUserSSOProviders).not.toHaveBeenCalled();
+    });
+
+    it('should fetch providers from NextAuth when BetterAuth is disabled', async () => {
+      enableBetterAuth.value = false;
+      const mockProviders = [
+        { provider: 'github', email: 'test@example.com', providerAccountId: '123' },
+      ];
+      mockUserService.getUserSSOProviders.mockResolvedValueOnce(mockProviders);
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.fetchAuthProviders();
+      });
+
+      expect(mockUserService.getUserSSOProviders).toHaveBeenCalled();
+      expect(result.current.isLoadedAuthProviders).toBe(true);
+      expect(result.current.authProviders).toEqual(mockProviders);
+    });
+
+    it('should fetch providers from BetterAuth when enabled', async () => {
+      enableBetterAuth.value = true;
+      mockBetterAuthClient.listAccounts.mockResolvedValueOnce({
+        data: [
+          { providerId: 'github', accountId: 'gh-123' },
+          { providerId: 'credential', accountId: 'cred-1' },
+        ],
+      });
+      mockBetterAuthClient.accountInfo.mockResolvedValueOnce({
+        data: { user: { email: 'test@github.com' } },
+      });
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.fetchAuthProviders();
+      });
+
+      expect(mockBetterAuthClient.listAccounts).toHaveBeenCalled();
+      expect(result.current.isLoadedAuthProviders).toBe(true);
+      expect(result.current.isEmailPasswordAuth).toBe(true);
+    });
+
+    it('should handle fetch error gracefully', async () => {
+      enableBetterAuth.value = false;
+      mockUserService.getUserSSOProviders.mockRejectedValueOnce(new Error('Network error'));
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.fetchAuthProviders();
+      });
+
+      expect(result.current.isLoadedAuthProviders).toBe(true);
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('refreshAuthProviders', () => {
+    it('should refresh providers from NextAuth', async () => {
+      enableBetterAuth.value = false;
+      const mockProviders = [
+        { provider: 'google', email: 'user@gmail.com', providerAccountId: 'g-1' },
+      ];
+      mockUserService.getUserSSOProviders.mockResolvedValueOnce(mockProviders);
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.refreshAuthProviders();
+      });
+
+      expect(mockUserService.getUserSSOProviders).toHaveBeenCalled();
+      expect(result.current.authProviders).toEqual(mockProviders);
+    });
+
+    it('should handle refresh error gracefully', async () => {
+      enableBetterAuth.value = false;
+      mockUserService.getUserSSOProviders.mockRejectedValueOnce(new Error('Refresh failed'));
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const { result } = renderHook(() => useUserStore());
+
+      await act(async () => {
+        await result.current.refreshAuthProviders();
+      });
+
+      // Should not throw
+      consoleSpy.mockRestore();
+    });
   });
 });

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

@@ -1,11 +1,22 @@
+import { SSOProvider } from '@lobechat/types';
 import { StateCreator } from 'zustand/vanilla';
 
-import { enableAuth, enableClerk, enableNextAuth } from '@/const/auth';
+import { enableAuth, enableBetterAuth, enableClerk, enableNextAuth } from '@/const/auth';
+import { userService } from '@/services/user';
 
 import type { UserStore } from '../../store';
 
+interface AuthProvidersData {
+  isEmailPasswordAuth: boolean;
+  providers: SSOProvider[];
+}
+
 export interface UserAuthAction {
   enableAuth: () => boolean;
+  /**
+   * Fetch auth providers (SSO accounts) for the current user
+   */
+  fetchAuthProviders: () => Promise<void>;
   /**
    * universal logout method
    */
@@ -14,8 +25,40 @@ export interface UserAuthAction {
    * universal login method
    */
   openLogin: () => Promise<void>;
+  /**
+   * Refresh auth providers after link/unlink
+   */
+  refreshAuthProviders: () => Promise<void>;
 }
 
+const fetchAuthProvidersData = async (): Promise<AuthProvidersData> => {
+  if (enableBetterAuth) {
+    const { accountInfo, listAccounts } = await import('@/libs/better-auth/auth-client');
+    const result = await listAccounts();
+    const accounts = result.data || [];
+    const isEmailPasswordAuth = accounts.some((account) => account.providerId === 'credential');
+    const providers = await Promise.all(
+      accounts
+        .filter((account) => account.providerId !== 'credential')
+        .map(async (account) => {
+          const info = await accountInfo({
+            query: { accountId: account.accountId },
+          });
+          return {
+            email: info.data?.user?.email ?? undefined,
+            provider: account.providerId,
+            providerAccountId: account.accountId,
+          };
+        }),
+    );
+    return { isEmailPasswordAuth, providers };
+  }
+
+  // Fallback for NextAuth
+  const providers = await userService.getUserSSOProviders();
+  return { isEmailPasswordAuth: false, providers };
+};
+
 export const createAuthSlice: StateCreator<
   UserStore,
   [['zustand/devtools', never]],
@@ -25,6 +68,18 @@ export const createAuthSlice: StateCreator<
   enableAuth: () => {
     return enableAuth;
   },
+  fetchAuthProviders: async () => {
+    // Skip if already loaded
+    if (get().isLoadedAuthProviders) return;
+
+    try {
+      const { isEmailPasswordAuth, providers } = await fetchAuthProvidersData();
+      set({ authProviders: providers, isEmailPasswordAuth, isLoadedAuthProviders: true });
+    } catch (error) {
+      console.error('Failed to fetch auth providers:', error);
+      set({ isLoadedAuthProviders: true });
+    }
+  },
   logout: async () => {
     if (enableClerk) {
       get().clerkSignOut?.({ redirectUrl: location.toString() });
@@ -32,6 +87,21 @@ export const createAuthSlice: StateCreator<
       return;
     }
 
+    if (enableBetterAuth) {
+      const { signOut } = await import('@/libs/better-auth/auth-client');
+      await signOut({
+        fetchOptions: {
+          onSuccess: () => {
+            // Use window.location.href to trigger a full page reload
+            // This ensures all client-side state (React, Zustand, cache) is cleared
+            window.location.href = '/signin';
+          },
+        },
+      });
+
+      return;
+    }
+
     if (enableNextAuth) {
       const { signOut } = await import('next-auth/react');
       signOut();
@@ -49,6 +119,13 @@ export const createAuthSlice: StateCreator<
       return;
     }
 
+    if (enableBetterAuth) {
+      const currentUrl = location.toString();
+      window.location.href = `/signin?callbackUrl=${encodeURIComponent(currentUrl)}`;
+
+      return;
+    }
+
     if (enableNextAuth) {
       const { signIn } = await import('next-auth/react');
       // Check if only one provider is available
@@ -60,4 +137,12 @@ export const createAuthSlice: StateCreator<
       signIn();
     }
   },
+  refreshAuthProviders: async () => {
+    try {
+      const { isEmailPasswordAuth, providers } = await fetchAuthProvidersData();
+      set({ authProviders: providers, isEmailPasswordAuth });
+    } catch (error) {
+      console.error('Failed to refresh auth providers:', error);
+    }
+  },
 });

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

@@ -6,17 +6,25 @@ import {
   UserProfileProps,
   UserResource,
 } from '@clerk/types';
+import { SSOProvider } from '@lobechat/types';
 
+import { enableClerk } from '@/const/auth';
 import { LobeUser } from '@/types/user';
 
 export interface UserAuthState {
+  authProviders?: SSOProvider[];
   clerkOpenUserProfile?: (props?: UserProfileProps) => void;
-
   clerkSession?: SignedInSessionResource;
+
   clerkSignIn?: (props?: SignInProps) => void;
   clerkSignOut?: SignOut;
   clerkUser?: UserResource;
+  /**
+   * Whether user registered with email/password (credential login)
+   */
+  isEmailPasswordAuth?: boolean;
   isLoaded?: boolean;
+  isLoadedAuthProviders?: boolean;
 
   isSignedIn?: boolean;
   nextSession?: Session;
@@ -25,4 +33,7 @@ export interface UserAuthState {
   user?: LobeUser;
 }
 
-export const initialAuthState: UserAuthState = {};
+export const initialAuthState: UserAuthState = {
+  // Clerk doesn't need to fetch auth providers
+  isLoadedAuthProviders: enableClerk ? true : undefined,
+};

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

@@ -1,8 +1,8 @@
 import { BRANDING_NAME, isDesktop } from '@lobechat/const';
-import { LobeUser } from '@lobechat/types';
+import { LobeUser, SSOProvider } from '@lobechat/types';
 import { t } from 'i18next';
 
-import { enableAuth, enableClerk, enableNextAuth } from '@/const/auth';
+import { enableAuth, enableBetterAuth, enableClerk, enableNextAuth } from '@/const/auth';
 import type { UserStore } from '@/store/user';
 
 const DEFAULT_USERNAME = BRANDING_NAME;
@@ -56,9 +56,13 @@ const isLogin = (s: UserStore) => {
 };
 
 export const authSelectors = {
+  authProviders: (s: UserStore): SSOProvider[] => s.authProviders || [],
+  isEmailPasswordAuth: (s: UserStore) => s.isEmailPasswordAuth ?? false,
   isLoaded: (s: UserStore) => s.isLoaded,
+  isLoadedAuthProviders: (s: UserStore) => s.isLoadedAuthProviders ?? false,
   isLogin,
   isLoginWithAuth: (s: UserStore) => s.isSignedIn,
+  isLoginWithBetterAuth: (s: UserStore): boolean => (s.isSignedIn && enableBetterAuth) || false,
   isLoginWithClerk: (s: UserStore): boolean => (s.isSignedIn && enableClerk) || false,
   isLoginWithNextAuth: (s: UserStore): boolean => (s.isSignedIn && !!enableNextAuth) || false,
 };