@lobehub/chat 1.36.8 → 1.36.9

package/src/app/(backend)/api/webhooks/clerk/route.ts

@@ -29,13 +29,28 @@ export const POST = async (req: Request): Promise<NextResponse> => {
   switch (type) {
     case 'user.created': {
       pino.info('creating user due to clerk webhook');
-      return userService.createUser(data.id, data);
+      const result = await userService.createUser(data.id, data);
+
+      return NextResponse.json(result, { status: 200 });
     }
+
     case 'user.deleted': {
-      return userService.deleteUser(data.id);
+      if (!data.id) {
+        pino.warn('clerk sent a delete user request, but no user ID was included in the payload');
+        return NextResponse.json({ message: 'ok' }, { status: 200 });
+      }
+
+      pino.info('delete user due to clerk webhook');
+
+      await userService.deleteUser(data.id);
+
+      return NextResponse.json({ message: 'user deleted' }, { status: 200 });
     }
+
     case 'user.updated': {
-      return userService.updateUser(data.id, data);
+      const result = await userService.updateUser(data.id, data);
+
+      return NextResponse.json(result, { status: 200 });
     }
 
     default: {

package/src/database/server/models/__tests__/nextauth.test.ts

@@ -146,6 +146,39 @@ describe('LobeNextAuthDbAdapter', () => {
           await serverDB.query.users.findMany({ where: eq(users.id, anotherUserId) }),
         ).toHaveLength(1);
       });
+
+      it('should create a user if id not exist even email is invalid type', async () => {
+        // In previous version, it will link the account to the existing user if the email is null
+        // issue: https://github.com/lobehub/lobe-chat/issues/4918
+        expect(nextAuthAdapter).toBeDefined();
+        expect(nextAuthAdapter.createUser).toBeDefined();
+
+        const existUserId = 'user-db-1';
+        const existUserName = 'John Doe 1';
+        // @ts-expect-error: createUser is defined
+        await nextAuthAdapter.createUser({
+          ...user,
+          id: existUserId,
+          name: existUserName,
+          email: Object({}), // assign a non-string value
+        });
+
+        const anotherUserId = 'user-db-2';
+        const anotherUserName = 'John Doe 2';
+        // @ts-expect-error: createUser is defined
+        await nextAuthAdapter.createUser({
+          ...user,
+          id: anotherUserId,
+          name: anotherUserName,
+          // @ts-expect-error: try to assign undefined value
+          email: undefined,
+        });
+
+        // Should create a new user if id not exists and email is null
+        expect(
+          await serverDB.query.users.findMany({ where: eq(users.id, anotherUserId) }),
+        ).toHaveLength(1);
+      });
     });
 
     describe('deleteUser', () => {

package/src/libs/next-auth/adapter/index.ts

@@ -53,7 +53,10 @@ export function LobeNextAuthDbAdapter(serverDB: NeonDatabase<typeof schema>): Ad
     async createUser(user): Promise<AdapterUser> {
       const { id, name, email, emailVerified, image, providerAccountId } = user;
       // return the user if it already exists
-      let existingUser = email.trim() ? await UserModel.findByEmail(serverDB, email) : undefined;
+      let existingUser =
+        email && typeof email === 'string' && email.trim()
+          ? await UserModel.findByEmail(serverDB, email)
+          : undefined;
       // If the user is not found by email, try to find by providerAccountId
       if (!existingUser && providerAccountId) {
         existingUser = await UserModel.findById(serverDB, providerAccountId);
@@ -169,7 +172,10 @@ export function LobeNextAuthDbAdapter(serverDB: NeonDatabase<typeof schema>): Ad
     },
 
     async getUserByEmail(email): Promise<AdapterUser | null> {
-      const lobeUser = email.trim() ? await UserModel.findByEmail(serverDB, email) : undefined;
+      const lobeUser =
+        email && typeof email === 'string' && email.trim()
+          ? await UserModel.findByEmail(serverDB, email)
+          : undefined;
       return lobeUser ? mapLobeUserToAdapterUser(lobeUser) : null;
     },
 

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

@@ -0,0 +1,200 @@
+import { UserJSON } from '@clerk/backend';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { UserItem } from '@/database/schemas';
+import { UserModel } from '@/database/server/models/user';
+import { pino } from '@/libs/logger';
+
+import { UserService } from './index';
+
+// Mock dependencies
+vi.mock('@/database/server/models/user', () => {
+  const MockUserModel = vi.fn();
+  // @ts-ignore
+  MockUserModel.findById = vi.fn();
+  // @ts-ignore
+  MockUserModel.createUser = vi.fn();
+  // @ts-ignore
+  MockUserModel.deleteUser = vi.fn();
+
+  // Mock instance methods
+  MockUserModel.prototype.updateUser = vi.fn();
+
+  return { UserModel: MockUserModel };
+});
+
+vi.mock('@/libs/logger', () => ({
+  pino: {
+    info: vi.fn(),
+  },
+}));
+
+let service: UserService;
+const mockUserId = 'test-user-id';
+
+// Mock user data
+const mockUserJSON: UserJSON = {
+  id: mockUserId,
+  email_addresses: [{ id: 'email-1', email_address: 'test@example.com' }],
+  phone_numbers: [{ id: 'phone-1', phone_number: '+1234567890' }],
+  primary_email_address_id: 'email-1',
+  primary_phone_number_id: 'phone-1',
+  image_url: 'https://example.com/avatar.jpg',
+  first_name: 'Test',
+  last_name: 'User',
+  username: 'testuser',
+  created_at: '2023-01-01T00:00:00Z',
+} as unknown as UserJSON;
+
+beforeEach(() => {
+  service = new UserService();
+  vi.clearAllMocks();
+});
+
+describe('UserService', () => {
+  describe('createUser', () => {
+    it('should create a new user when user does not exist', async () => {
+      // Mock user not found
+      vi.mocked(UserModel.findById).mockResolvedValue(null as any);
+
+      await service.createUser(mockUserId, mockUserJSON);
+
+      expect(UserModel.findById).toHaveBeenCalledWith(expect.anything(), mockUserId);
+      expect(UserModel.createUser).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          id: mockUserId,
+          email: 'test@example.com',
+          phone: '+1234567890',
+          firstName: 'Test',
+          lastName: 'User',
+          username: 'testuser',
+          avatar: 'https://example.com/avatar.jpg',
+          clerkCreatedAt: new Date('2023-01-01T00:00:00Z'),
+        }),
+      );
+    });
+
+    it('should not create user if already exists', async () => {
+      // Mock user found
+      vi.mocked(UserModel.findById).mockResolvedValue({ id: mockUserId } as UserItem);
+
+      const result = await service.createUser(mockUserId, mockUserJSON);
+
+      expect(UserModel.findById).toHaveBeenCalledWith(expect.anything(), mockUserId);
+      expect(UserModel.createUser).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        message: 'user not created due to user already existing in the database',
+        success: false,
+      });
+    });
+
+    it('should handle user without primary phone number', async () => {
+      vi.mocked(UserModel.findById).mockResolvedValue(null as any);
+
+      const userWithoutPrimaryPhone = {
+        ...mockUserJSON,
+        primary_phone_number_id: null,
+        phone_numbers: [{ id: 'phone-1', phone_number: '+1234567890' }],
+      } as UserJSON;
+
+      await service.createUser(mockUserId, userWithoutPrimaryPhone);
+
+      expect(UserModel.createUser).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          phone: '+1234567890', // Should use first phone number
+        }),
+      );
+    });
+  });
+
+  describe('deleteUser', () => {
+    it('should delete user', async () => {
+      await service.deleteUser(mockUserId);
+
+      expect(UserModel.deleteUser).toHaveBeenCalledWith(expect.anything(), mockUserId);
+    });
+
+    it('should throw error if deletion fails', async () => {
+      const error = new Error('Deletion failed');
+      vi.mocked(UserModel.deleteUser).mockRejectedValue(error);
+
+      await expect(service.deleteUser(mockUserId)).rejects.toThrow('Deletion failed');
+    });
+  });
+
+  describe('updateUser', () => {
+    it('should update user when user exists', async () => {
+      // Mock user found
+      vi.mocked(UserModel.findById).mockResolvedValue({ id: mockUserId } as UserItem);
+      const mockUpdateUser = vi.mocked(UserModel.prototype.updateUser);
+
+      const result = await service.updateUser(mockUserId, mockUserJSON);
+
+      expect(UserModel.findById).toHaveBeenCalledWith(expect.anything(), mockUserId);
+      expect(pino.info).toHaveBeenCalledWith('updating user due to clerk webhook');
+      expect(mockUpdateUser).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: mockUserId,
+          email: 'test@example.com',
+          phone: '+1234567890',
+          firstName: 'Test',
+          lastName: 'User',
+          username: 'testuser',
+          avatar: 'https://example.com/avatar.jpg',
+        }),
+      );
+      expect(result).toEqual({
+        message: 'user updated',
+        success: true,
+      });
+    });
+
+    it('should not update user when user does not exist', async () => {
+      // Mock user not found
+      vi.mocked(UserModel.findById).mockResolvedValue(null as any);
+      const mockUpdateUser = vi.mocked(UserModel.prototype.updateUser);
+
+      const result = await service.updateUser(mockUserId, mockUserJSON);
+
+      expect(UserModel.findById).toHaveBeenCalledWith(expect.anything(), mockUserId);
+      expect(mockUpdateUser).not.toHaveBeenCalled();
+      expect(result).toEqual({
+        message: "user not updated due to the user don't existing in the database",
+        success: false,
+      });
+    });
+
+    it('should handle user without primary email and phone', async () => {
+      vi.mocked(UserModel.findById).mockResolvedValue({ id: mockUserId } as UserItem);
+      const mockUpdateUser = vi.mocked(UserModel.prototype.updateUser);
+
+      const userWithoutPrimaryContacts = {
+        ...mockUserJSON,
+        primary_email_address_id: null,
+        primary_phone_number_id: null,
+        email_addresses: [{ id: 'email-1', email_address: 'test@example.com' }],
+        phone_numbers: [{ id: 'phone-1', phone_number: '+1234567890' }],
+      } as UserJSON;
+
+      await service.updateUser(mockUserId, userWithoutPrimaryContacts);
+
+      // Verify that the first email and phone are used when primary is not specified
+      expect(mockUpdateUser).toHaveBeenCalledWith(
+        expect.objectContaining({
+          phone: '+1234567890',
+        }),
+      );
+    });
+
+    it('should handle update failure', async () => {
+      vi.mocked(UserModel.findById).mockResolvedValue({ id: mockUserId } as UserItem);
+      const mockUpdateUser = vi.mocked(UserModel.prototype.updateUser);
+      const error = new Error('Update failed');
+      mockUpdateUser.mockRejectedValue(error);
+
+      await expect(service.updateUser(mockUserId, mockUserJSON)).rejects.toThrow('Update failed');
+    });
+  });
+});

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

@@ -1,5 +1,4 @@
 import { UserJSON } from '@clerk/backend';
-import { NextResponse } from 'next/server';
 
 import { serverDB } from '@/database/server';
 import { UserModel } from '@/database/server/models/user';
@@ -12,16 +11,18 @@ export class UserService {
 
     // If user already exists, skip creating a new user
     if (res)
-      return NextResponse.json(
-        {
-          message: 'user not created due to user already existing in the database',
-          success: false,
-        },
-        { status: 200 },
-      );
+      return {
+        message: 'user not created due to user already existing in the database',
+        success: false,
+      };
 
     const email = params.email_addresses.find((e) => e.id === params.primary_email_address_id);
-    const phone = params.phone_numbers.find((e) => e.id === params.primary_phone_number_id);
+
+    const phone = params.phone_numbers.find((e, index) => {
+      if (!!params.primary_phone_number_id) return e.id === params.primary_phone_number_id;
+
+      return index === 0;
+    });
 
     /* ↓ cloud slot ↓ */
 
@@ -43,25 +44,14 @@ export class UserService {
 
     /* ↑ cloud slot ↑ */
 
-    return NextResponse.json({ message: 'user created', success: true }, { status: 200 });
+    return { message: 'user created', success: true };
   };
 
-  deleteUser = async (id?: string) => {
-    if (id) {
-      pino.info('delete user due to clerk webhook');
-
-      await UserModel.deleteUser(serverDB, id);
-
-      return NextResponse.json({ message: 'user deleted' }, { status: 200 });
-    } else {
-      pino.warn('clerk sent a delete user request, but no user ID was included in the payload');
-      return NextResponse.json({ message: 'ok' }, { status: 200 });
-    }
+  deleteUser = async (id: string) => {
+    await UserModel.deleteUser(serverDB, id);
   };
 
   updateUser = async (id: string, params: UserJSON) => {
-    pino.info('updating user due to clerk webhook');
-
     const userModel = new UserModel(serverDB, id);
 
     // Check if user already exists
@@ -69,16 +59,18 @@ export class UserService {
 
     // If user not exists, skip update the user
     if (!res)
-      return NextResponse.json(
-        {
-          message: "user not updated due to the user don't existing in the database",
-          success: false,
-        },
-        { status: 200 },
-      );
+      return {
+        message: "user not updated due to the user don't existing in the database",
+        success: false,
+      };
+
+    pino.info('updating user due to clerk webhook');
 
     const email = params.email_addresses.find((e) => e.id === params.primary_email_address_id);
-    const phone = params.phone_numbers.find((e) => e.id === params.primary_phone_number_id);
+    const phone = params.phone_numbers.find((e, index) => {
+      if (params.primary_phone_number_id) return e.id === params.primary_phone_number_id;
+      return index === 0;
+    });
 
     await userModel.updateUser({
       avatar: params.image_url,
@@ -90,6 +82,6 @@ export class UserService {
       username: params.username,
     });
 
-    return NextResponse.json({ message: 'user updated', success: true }, { status: 200 });
+    return { message: 'user updated', success: true };
   };
 }

package/vitest.config.ts

@@ -31,7 +31,7 @@ export default defineConfig({
       '**/dist/**',
       '**/build/**',
       'src/database/server/**/**',
-      'src/server/services/!(discover)/**/**',
+      'src/server/services/dataImporter/**/**',
     ],
     globals: true,
     server: {