@lobehub/lobehub 2.0.0-next.123 → 2.0.0-next.125

package/src/server/services/email/index.test.ts

@@ -0,0 +1,144 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { EmailImplType, createEmailServiceImpl } from './impls';
+import { EmailService } from './index';
+
+// Mock dependencies
+vi.mock('./impls');
+
+describe('EmailService', () => {
+  let emailService: EmailService;
+  let mockEmailImpl: ReturnType<typeof createMockEmailImpl>;
+
+  function createMockEmailImpl() {
+    return {
+      sendMail: vi.fn(),
+      verify: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEmailImpl = createMockEmailImpl();
+    vi.mocked(createEmailServiceImpl).mockReturnValue(mockEmailImpl as any);
+    emailService = new EmailService();
+  });
+
+  describe('constructor', () => {
+    it('should create instance with default email implementation', () => {
+      expect(createEmailServiceImpl).toHaveBeenCalledWith(undefined);
+    });
+
+    it('should create instance with specified implementation type', () => {
+      emailService = new EmailService(EmailImplType.Nodemailer);
+      expect(createEmailServiceImpl).toHaveBeenCalledWith(EmailImplType.Nodemailer);
+    });
+  });
+
+  describe('sendMail', () => {
+    it('should call emailImpl.sendMail with correct payload', async () => {
+      const mockResponse = {
+        messageId: 'test-message-id',
+        previewUrl: 'https://ethereal.email/message/xxx',
+      };
+      mockEmailImpl.sendMail.mockResolvedValue(mockResponse);
+
+      const payload = {
+        from: 'sender@example.com',
+        html: '<p>Hello world</p>',
+        subject: 'Test Email',
+        text: 'Hello world',
+        to: 'recipient@example.com',
+      };
+
+      const result = await emailService.sendMail(payload);
+
+      expect(mockEmailImpl.sendMail).toHaveBeenCalledWith(payload);
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should support multiple recipients', async () => {
+      const mockResponse = {
+        messageId: 'test-message-id',
+      };
+      mockEmailImpl.sendMail.mockResolvedValue(mockResponse);
+
+      const payload = {
+        from: 'sender@example.com',
+        subject: 'Test Email',
+        text: 'Hello world',
+        to: ['recipient1@example.com', 'recipient2@example.com'],
+      };
+
+      await emailService.sendMail(payload);
+
+      expect(mockEmailImpl.sendMail).toHaveBeenCalledWith(payload);
+    });
+
+    it('should support attachments', async () => {
+      const mockResponse = {
+        messageId: 'test-message-id',
+      };
+      mockEmailImpl.sendMail.mockResolvedValue(mockResponse);
+
+      const payload = {
+        attachments: [
+          {
+            content: Buffer.from('test content'),
+            filename: 'test.txt',
+          },
+        ],
+        from: 'sender@example.com',
+        subject: 'Test Email',
+        text: 'Hello world',
+        to: 'recipient@example.com',
+      };
+
+      await emailService.sendMail(payload);
+
+      expect(mockEmailImpl.sendMail).toHaveBeenCalledWith(payload);
+    });
+
+    it('should support reply-to address', async () => {
+      const mockResponse = {
+        messageId: 'test-message-id',
+      };
+      mockEmailImpl.sendMail.mockResolvedValue(mockResponse);
+
+      const payload = {
+        from: 'noreply@example.com',
+        replyTo: 'support@example.com',
+        subject: 'Test Email',
+        text: 'Hello world',
+        to: 'recipient@example.com',
+      };
+
+      await emailService.sendMail(payload);
+
+      expect(mockEmailImpl.sendMail).toHaveBeenCalledWith(payload);
+    });
+  });
+
+  describe('verify', () => {
+    it('should call emailImpl.verify if available', async () => {
+      mockEmailImpl.verify.mockResolvedValue(true);
+
+      const result = await emailService.verify();
+
+      expect(mockEmailImpl.verify).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it('should return true if verify method is not available', async () => {
+      const mockImplWithoutVerify = {
+        sendMail: vi.fn(),
+      };
+      vi.mocked(createEmailServiceImpl).mockReturnValue(mockImplWithoutVerify as any);
+      emailService = new EmailService();
+
+      const result = await emailService.verify();
+
+      expect(result).toBe(true);
+    });
+  });
+});

package/src/server/services/email/index.ts

@@ -0,0 +1,40 @@
+
+import { EmailImplType, EmailPayload, EmailResponse, createEmailServiceImpl } from './impls';
+import type { EmailServiceImpl } from './impls';
+
+/**
+ * Email service class
+ * Provides email sending functionality with multiple provider support
+ */
+export class EmailService {
+  private emailImpl: EmailServiceImpl;
+
+  constructor(implType?: EmailImplType) {
+    this.emailImpl = createEmailServiceImpl(implType);
+  }
+
+  /**
+   * Send an email
+   */
+  async sendMail(payload: EmailPayload): Promise<EmailResponse> {
+    return this.emailImpl.sendMail(payload);
+  }
+
+  /**
+   * Verify the email service configuration
+   * Note: Only available for Nodemailer implementation
+   */
+  async verify(): Promise<boolean> {
+    // Check if the implementation has a verify method
+    if ('verify' in this.emailImpl && typeof this.emailImpl.verify === 'function') {
+      return this.emailImpl.verify();
+    }
+
+    // For implementations without verify, assume it's valid
+    return true;
+  }
+}
+
+// Export types
+export type { EmailPayload, EmailResponse } from './impls';
+export { EmailImplType } from './impls';

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/aiInfra/slices/aiProvider/action.ts

@@ -77,10 +77,10 @@ export const normalizeImageModel = async (
   const fallbackParametersPromise = model.parameters
     ? Promise.resolve<ModelParamsSchema | undefined>(model.parameters)
     : getModelPropertyWithFallback<ModelParamsSchema | undefined>(
-      model.id,
-      'parameters',
-      model.providerId,
-    );
+        model.id,
+        'parameters',
+        model.providerId,
+      );
 
   const modelWithPricing = model as AIImageModelCard;
   const fallbackPricingPromise = modelWithPricing.pricing

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();
+    });
   });
 });