Merge branch 'main' of https://github.com/lobehub/lobe-chat

Author: actions-user

.github/ISSUE_TEMPLATE/1_bug_report_cn.yml

@@ -2,7 +2,15 @@ name: '🐛 反馈缺陷'
 description: '反馈一个问题缺陷'
 title: '[Bug] '
 labels: ['🐛 Bug']
+type: Bug
 body:
+  - type: markdown
+    attributes:
+      value: |
+        在创建新的 Issue 之前，请先[搜索已有问题](https://github.com/lobehub/lobe-chat/issues)，如果发现已有类似的问题，请给它 **👍 点赞**，这样可以帮助我们更快地解决问题。  
+        如果你在使用过程中遇到问题，可以尝试以下方式获取帮助：  
+        - 在 [GitHub Discussions](https://github.com/lobehub/lobe-chat/discussions) 的版块发起讨论。  
+        - 在 [LobeChat 社区](https://discord.gg/AYFPHvv2jT) 提问，与其他用户交流。 
   - type: dropdown
     attributes:
       label: '📦 部署环境'

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,7 @@
 contact_links:
-  - name: Questions and ideas | 问题和想法
+  - name: Ask a question for self-hosting | 咨询自部署问题
+    url: https://github.com/lobehub/lobe-chat/discussions/new?category=self-hosting-%E7%A7%81%E6%9C%89%E5%8C%96%E9%83%A8%E7%BD%B2
+    about: Please post questions, and ideas in discussions. | 请在讨论区发布问题和想法。
+  - name: Questions and ideas | 其他问题和想法
     url: https://github.com/lobehub/lobe-chat/discussions/new/choose
     about: Please post questions, and ideas in discussions. | 请在讨论区发布问题和想法。

src/server/services/nextAuthUser/index.test.ts

@@ -0,0 +1,109 @@
+// @vitest-environment node
+import { NextResponse } from 'next/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { UserItem } from '@/database/schemas';
+import { serverDB } from '@/database/server';
+import { UserModel } from '@/database/server/models/user';
+import { pino } from '@/libs/logger';
+import { LobeNextAuthDbAdapter } from '@/libs/next-auth/adapter';
+
+import { NextAuthUserService } from './index';
+
+vi.mock('@/libs/logger', () => ({
+  pino: {
+    info: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+
+vi.mock('@/database/server/models/user');
+vi.mock('@/database/server');
+
+describe('NextAuthUserService', () => {
+  let service: NextAuthUserService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new NextAuthUserService();
+  });
+
+  describe('safeUpdateUser', () => {
+    const mockUser = {
+      id: 'user-123',
+      email: '[email protected]',
+    };
+
+    const mockAccount = {
+      provider: 'github',
+      providerAccountId: '12345',
+    };
+
+    const mockUpdateData: Partial<UserItem> = {
+      avatar: 'https://example.com/avatar.jpg',
+      email: '[email protected]',
+      fullName: 'Test User',
+    };
+
+    it('should update user when user is found', async () => {
+      const mockUserModel = {
+        updateUser: vi.fn().mockResolvedValue({}),
+      };
+
+      vi.mocked(UserModel).mockImplementation(() => mockUserModel as any);
+
+      // Mock the adapter directly on the service instance
+      service.adapter = {
+        getUserByAccount: vi.fn().mockResolvedValue(mockUser),
+      };
+
+      const response = await service.safeUpdateUser(mockAccount, mockUpdateData);
+
+      expect(pino.info).toHaveBeenCalledWith(
+        `updating user "${JSON.stringify(mockAccount)}" due to webhook`,
+      );
+
+      expect(service.adapter.getUserByAccount).toHaveBeenCalledWith(mockAccount);
+      expect(UserModel).toHaveBeenCalledWith(serverDB, mockUser.id);
+      expect(mockUserModel.updateUser).toHaveBeenCalledWith(mockUpdateData);
+
+      expect(response).toBeInstanceOf(NextResponse);
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({ message: 'user updated', success: true });
+    });
+
+    it('should handle case when user is not found', async () => {
+      // Mock the adapter directly on the service instance
+      service.adapter = {
+        getUserByAccount: vi.fn().mockResolvedValue(null),
+      };
+
+      const response = await service.safeUpdateUser(mockAccount, mockUpdateData);
+
+      expect(pino.warn).toHaveBeenCalledWith(
+        `[${mockAccount.provider}]: Webhooks handler user "${JSON.stringify(mockAccount)}" update for "${JSON.stringify(mockUpdateData)}", but no user was found by the providerAccountId.`,
+      );
+
+      expect(UserModel).not.toHaveBeenCalled();
+
+      expect(response).toBeInstanceOf(NextResponse);
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({ message: 'user updated', success: true });
+    });
+
+    it('should handle errors during user update', async () => {
+      const mockError = new Error('Database error');
+
+      // Mock the adapter directly on the service instance
+      service.adapter = {
+        getUserByAccount: vi.fn().mockRejectedValue(mockError),
+      };
+
+      await expect(service.safeUpdateUser(mockAccount, mockUpdateData)).rejects.toThrow(mockError);
+
+      expect(UserModel).not.toHaveBeenCalled();
+    });
+  });
+});

src/services/user/client.test.ts

@@ -95,4 +95,14 @@ describe('ClientService', () => {
     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();
+  });
 });

src/services/user/server.test.ts

@@ -0,0 +1,149 @@
+import { DeepPartial } from 'utility-types';
+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: DeepPartial<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();
+  });
+});