@lobehub/chat 1.61.4 → 1.61.6

package/src/app/[variants]/(main)/profile/(home)/features/SSOProvidersList/index.tsx

@@ -0,0 +1,93 @@
+import { ActionIcon, CopyButton, List } from '@lobehub/ui';
+import { RotateCw, Unlink } from 'lucide-react';
+import { CSSProperties, memo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Flexbox } from 'react-layout-kit';
+
+import { modal, notification } from '@/components/AntdStaticMethods';
+import { useOnlyFetchOnceSWR } from '@/libs/swr';
+import { userService } from '@/services/user';
+import { useUserStore } from '@/store/user';
+import { userProfileSelectors } from '@/store/user/selectors';
+
+import AuthIcons from './AuthIcons';
+
+const { Item } = List;
+
+const providerNameStyle: CSSProperties = {
+  textTransform: 'capitalize',
+};
+
+export const SSOProvidersList = memo(() => {
+  const [userProfile] = useUserStore((s) => [userProfileSelectors.userProfile(s)]);
+  const { t } = useTranslation('auth');
+
+  const [allowUnlink, setAllowUnlink] = useState<boolean>(false);
+  const [hoveredIndex, setHoveredIndex] = useState<number | null>(null);
+
+  const { data, isLoading, mutate } = useOnlyFetchOnceSWR('profile-sso-providers', async () => {
+    const list = await userService.getUserSSOProviders();
+    setAllowUnlink(list?.length > 1);
+    return list;
+  });
+
+  const handleUnlinkSSO = async (provider: string, providerAccountId: string) => {
+    if (data?.length === 1 || !data) {
+      // At least one SSO provider should be linked
+      notification.error({
+        message: t('profile.sso.unlink.forbidden'),
+      });
+      return;
+    }
+    modal.confirm({
+      content: t('profile.sso.unlink.description', {
+        email: userProfile?.email || 'None',
+        provider,
+        providerAccountId,
+      }),
+      okButtonProps: {
+        danger: true,
+      },
+      onOk: async () => {
+        await userService.unlinkSSOProvider(provider, providerAccountId);
+        mutate();
+      },
+      title: <span style={providerNameStyle}>{t('profile.sso.unlink.title', { provider })}</span>,
+    });
+  };
+
+  return isLoading ? (
+    <Flexbox align={'center'} gap={4} horizontal>
+      <ActionIcon icon={RotateCw} spin />
+      {t('profile.sso.loading')}
+    </Flexbox>
+  ) : (
+    <Flexbox>
+      {data?.map((item, index) => (
+        <Item
+          actions={
+            <Flexbox gap={4} horizontal>
+              <CopyButton content={item.providerAccountId} size={'small'} />
+              <ActionIcon
+                disable={!allowUnlink}
+                icon={Unlink}
+                onClick={() => handleUnlinkSSO(item.provider, item.providerAccountId)}
+                size={'small'}
+              />
+            </Flexbox>
+          }
+          avatar={AuthIcons(item.provider)}
+          date={item.expires_at}
+          description={item.providerAccountId}
+          key={index}
+          onMouseEnter={() => setHoveredIndex(index)}
+          onMouseLeave={() => setHoveredIndex(null)}
+          showAction={hoveredIndex === index}
+          title={<span style={providerNameStyle}>{item.provider}</span>}
+        />
+      ))}
+    </Flexbox>
+  );
+});
+
+export default SSOProvidersList;

package/src/database/server/models/user.ts

@@ -1,6 +1,7 @@
 import { TRPCError } from '@trpc/server';
 import dayjs from 'dayjs';
 import { eq } from 'drizzle-orm/expressions';
+import type { AdapterAccount } from 'next-auth/adapters';
 import { DeepPartial } from 'utility-types';
 
 import { LobeChatDatabase } from '@/database/type';
@@ -9,7 +10,14 @@ import { UserKeyVaults, UserSettings } from '@/types/user/settings';
 import { merge } from '@/utils/merge';
 import { today } from '@/utils/time';
 
-import { NewUser, UserItem, UserSettingsItem, userSettings, users } from '../../schemas';
+import {
+  NewUser,
+  UserItem,
+  UserSettingsItem,
+  nextauthAccounts,
+  userSettings,
+  users,
+} from '../../schemas';
 
 type DecryptUserKeyVaults = (
   encryptKeyVaultsStr: string | null,
@@ -96,6 +104,21 @@ export class UserModel {
     };
   };
 
+  getUserSSOProviders = async () => {
+    const result = await this.db
+      .select({
+        expiresAt: nextauthAccounts.expires_at,
+        provider: nextauthAccounts.provider,
+        providerAccountId: nextauthAccounts.providerAccountId,
+        scope: nextauthAccounts.scope,
+        type: nextauthAccounts.type,
+        userId: nextauthAccounts.userId,
+      })
+      .from(nextauthAccounts)
+      .where(eq(nextauthAccounts.userId, this.userId));
+    return result as unknown as AdapterAccount[];
+  };
+
   getUserSettings = async () => {
     return this.db.query.userSettings.findFirst({ where: eq(userSettings.id, this.userId) });
   };

package/src/locales/default/auth.ts

@@ -34,6 +34,16 @@ export default {
   profile: {
     avatar: '头像',
     email: '电子邮件地址',
+    sso: {
+      loading: '正在加载已绑定的第三方账户',
+      providers: '连接的帐户',
+      unlink: {
+        description:
+          '解绑后，您将无法使用 {{provider}} 账户“{{providerAccountId}}”登录。如果您需要重新绑定 {{provider}} 账户到当前账户，请确保 {{provider}} 账户的邮件地址为 {{email}} ，我们会在登陆时为你自动绑定到当前登录账户。',
+        forbidden: '您至少需要保留一个第三方账户绑定。',
+        title: '是否解绑该第三方账户 {{provider}} ？',
+      },
+    },
     username: '用户名',
   },
   signout: '退出登录',

package/src/server/globalConfig/index.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { getAppConfig } from '@/config/app';
+import { knowledgeEnv } from '@/config/knowledge';
+import { SystemEmbeddingConfig } from '@/types/knowledgeBase';
+import { FilesConfigItem } from '@/types/user/settings/filesConfig';
+
+import { getServerDefaultAgentConfig, getServerDefaultFilesConfig } from './index';
+import { parseAgentConfig } from './parseDefaultAgent';
+import { parseFilesConfig } from './parseFilesConfig';
+
+vi.mock('@/config/app', () => ({
+  getAppConfig: vi.fn(),
+}));
+
+vi.mock('@/config/knowledge', () => ({
+  knowledgeEnv: {
+    DEFAULT_FILES_CONFIG: 'test_config',
+  },
+}));
+
+vi.mock('./parseDefaultAgent', () => ({
+  parseAgentConfig: vi.fn(),
+}));
+
+vi.mock('./parseFilesConfig', () => ({
+  parseFilesConfig: vi.fn(),
+}));
+
+describe('getServerDefaultAgentConfig', () => {
+  it('should return parsed agent config', () => {
+    const mockConfig = { key: 'value' };
+    vi.mocked(getAppConfig).mockReturnValue({
+      DEFAULT_AGENT_CONFIG: 'test_agent_config',
+    } as any);
+    vi.mocked(parseAgentConfig).mockReturnValue(mockConfig);
+
+    const result = getServerDefaultAgentConfig();
+
+    expect(parseAgentConfig).toHaveBeenCalledWith('test_agent_config');
+    expect(result).toEqual(mockConfig);
+  });
+
+  it('should return empty object if parseAgentConfig returns undefined', () => {
+    vi.mocked(getAppConfig).mockReturnValue({
+      DEFAULT_AGENT_CONFIG: 'test_agent_config',
+    } as any);
+    vi.mocked(parseAgentConfig).mockReturnValue(undefined);
+
+    const result = getServerDefaultAgentConfig();
+
+    expect(result).toEqual({});
+  });
+});
+
+describe('getServerDefaultFilesConfig', () => {
+  it('should return parsed files config', () => {
+    const mockEmbeddingModel: FilesConfigItem = {
+      model: 'test-model',
+      provider: 'test-provider',
+    };
+
+    const mockRerankerModel: FilesConfigItem = {
+      model: 'test-reranker',
+      provider: 'test-provider',
+    };
+
+    const mockConfig: SystemEmbeddingConfig = {
+      embeddingModel: mockEmbeddingModel,
+      queryMode: 'hybrid',
+      rerankerModel: mockRerankerModel,
+    };
+
+    vi.mocked(parseFilesConfig).mockReturnValue(mockConfig);
+
+    const result = getServerDefaultFilesConfig();
+
+    expect(parseFilesConfig).toHaveBeenCalledWith('test_config');
+    expect(result).toEqual(mockConfig);
+  });
+});

package/src/server/routers/lambda/user.test.ts

@@ -0,0 +1,305 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { enableClerk } from '@/const/auth';
+import { serverDB } from '@/database/server';
+import { MessageModel } from '@/database/server/models/message';
+import { SessionModel } from '@/database/server/models/session';
+import { UserModel, UserNotFoundError } from '@/database/server/models/user';
+import { LobeNextAuthDbAdapter } from '@/libs/next-auth/adapter';
+import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
+import { UserService } from '@/server/services/user';
+
+import { userRouter } from './user';
+
+// Mock modules
+vi.mock('@clerk/nextjs/server', () => ({
+  currentUser: vi.fn(),
+}));
+
+vi.mock('@/database/server', () => ({
+  serverDB: {},
+}));
+
+vi.mock('@/database/server/models/message');
+vi.mock('@/database/server/models/session');
+vi.mock('@/database/server/models/user');
+vi.mock('@/libs/next-auth/adapter');
+vi.mock('@/server/modules/KeyVaultsEncrypt');
+vi.mock('@/server/services/user');
+vi.mock('@/const/auth', () => ({
+  enableClerk: true,
+}));
+
+describe('userRouter', () => {
+  const mockUserId = 'test-user-id';
+  const mockCtx = {
+    userId: mockUserId,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getUserRegistrationDuration', () => {
+    it('should return registration duration', async () => {
+      const mockDuration = { duration: 100, createdAt: '2023-01-01', updatedAt: '2023-01-02' };
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            getUserRegistrationDuration: vi.fn().mockResolvedValue(mockDuration),
+          }) as any,
+      );
+
+      const result = await userRouter.createCaller({ ...mockCtx }).getUserRegistrationDuration();
+
+      expect(result).toEqual(mockDuration);
+      expect(UserModel).toHaveBeenCalledWith(serverDB, mockUserId);
+    });
+  });
+
+  describe('getUserSSOProviders', () => {
+    it('should return SSO providers', async () => {
+      const mockProviders = [
+        {
+          provider: 'google',
+          providerAccountId: '123',
+          userId: 'user-1',
+          type: 'oauth',
+        },
+      ];
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            getUserSSOProviders: vi.fn().mockResolvedValue(mockProviders),
+          }) as any,
+      );
+
+      const result = await userRouter.createCaller({ ...mockCtx }).getUserSSOProviders();
+
+      expect(result).toEqual(mockProviders);
+      expect(UserModel).toHaveBeenCalledWith(serverDB, mockUserId);
+    });
+  });
+
+  describe('getUserState', () => {
+    it('should return user state', async () => {
+      const mockState = {
+        isOnboarded: true,
+        preference: { telemetry: true },
+        settings: {},
+        userId: mockUserId,
+      };
+
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            getUserState: vi.fn().mockResolvedValue(mockState),
+          }) as any,
+      );
+
+      vi.mocked(MessageModel).mockImplementation(
+        () =>
+          ({
+            hasMoreThanN: vi.fn().mockResolvedValue(true),
+          }) as any,
+      );
+
+      vi.mocked(SessionModel).mockImplementation(
+        () =>
+          ({
+            hasMoreThanN: vi.fn().mockResolvedValue(true),
+          }) as any,
+      );
+
+      const result = await userRouter.createCaller({ ...mockCtx }).getUserState();
+
+      expect(result).toEqual({
+        isOnboard: true,
+        preference: { telemetry: true },
+        settings: {},
+        hasConversation: true,
+        canEnablePWAGuide: true,
+        canEnableTrace: true,
+        userId: mockUserId,
+      });
+    });
+
+    it('should create new user when user not found (clerk enabled)', async () => {
+      const mockClerkUser = {
+        id: mockUserId,
+        createdAt: new Date(),
+        emailAddresses: [{ id: 'email-1', emailAddress: 'test@example.com' }],
+        firstName: 'Test',
+        lastName: 'User',
+        imageUrl: 'avatar.jpg',
+        phoneNumbers: [],
+        primaryEmailAddressId: 'email-1',
+        primaryPhoneNumberId: null,
+        username: 'testuser',
+      };
+
+      const { currentUser } = await import('@clerk/nextjs/server');
+      vi.mocked(currentUser).mockResolvedValue(mockClerkUser as any);
+
+      vi.mocked(UserService).mockImplementation(
+        () =>
+          ({
+            createUser: vi.fn().mockResolvedValue({ success: true }),
+          }) as any,
+      );
+
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            getUserState: vi
+              .fn()
+              .mockRejectedValueOnce(new UserNotFoundError())
+              .mockResolvedValueOnce({
+                isOnboarded: false,
+                preference: { telemetry: null },
+                settings: {},
+              }),
+          }) as any,
+      );
+
+      vi.mocked(MessageModel).mockImplementation(
+        () =>
+          ({
+            hasMoreThanN: vi.fn().mockResolvedValue(false),
+          }) as any,
+      );
+
+      vi.mocked(SessionModel).mockImplementation(
+        () =>
+          ({
+            hasMoreThanN: vi.fn().mockResolvedValue(false),
+          }) as any,
+      );
+
+      const result = await userRouter.createCaller({ ...mockCtx } as any).getUserState();
+
+      expect(result).toEqual({
+        isOnboard: true,
+        preference: { telemetry: null },
+        settings: {},
+        hasConversation: false,
+        canEnablePWAGuide: false,
+        canEnableTrace: false,
+        userId: mockUserId,
+      });
+    });
+  });
+
+  describe('makeUserOnboarded', () => {
+    it('should update user onboarded status', async () => {
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            updateUser: vi.fn().mockResolvedValue({ rowCount: 1 }),
+          }) as any,
+      );
+
+      await userRouter.createCaller({ ...mockCtx }).makeUserOnboarded();
+
+      expect(UserModel).toHaveBeenCalledWith(serverDB, mockUserId);
+    });
+  });
+
+  describe('unlinkSSOProvider', () => {
+    it('should unlink SSO provider successfully', async () => {
+      const mockInput = {
+        provider: 'google',
+        providerAccountId: '123',
+      };
+
+      const mockAccount = {
+        userId: mockUserId,
+        provider: 'google',
+        providerAccountId: '123',
+        type: 'oauth',
+      };
+
+      vi.mocked(LobeNextAuthDbAdapter).mockReturnValue({
+        getAccount: vi.fn().mockResolvedValue(mockAccount),
+        unlinkAccount: vi.fn().mockResolvedValue(undefined),
+      } as any);
+
+      await expect(
+        userRouter.createCaller({ ...mockCtx }).unlinkSSOProvider(mockInput),
+      ).resolves.not.toThrow();
+    });
+
+    it('should throw error if account does not exist', async () => {
+      const mockInput = {
+        provider: 'google',
+        providerAccountId: '123',
+      };
+
+      vi.mocked(LobeNextAuthDbAdapter).mockReturnValue({
+        getAccount: vi.fn().mockResolvedValue(null),
+        unlinkAccount: vi.fn(),
+      } as any);
+
+      await expect(
+        userRouter.createCaller({ ...mockCtx }).unlinkSSOProvider(mockInput),
+      ).rejects.toThrow('The account does not exist');
+    });
+
+    it('should throw error if adapter methods are not implemented', async () => {
+      const mockInput = {
+        provider: 'google',
+        providerAccountId: '123',
+      };
+
+      vi.mocked(LobeNextAuthDbAdapter).mockReturnValue({} as any);
+
+      await expect(
+        userRouter.createCaller({ ...mockCtx }).unlinkSSOProvider(mockInput),
+      ).rejects.toThrow('The method in LobeNextAuthDbAdapter `unlinkAccount` is not implemented');
+    });
+  });
+
+  describe('updateSettings', () => {
+    it('should update settings with encrypted key vaults', async () => {
+      const mockSettings = {
+        keyVaults: { openai: { key: 'test-key' } },
+        general: { language: 'en-US' },
+      };
+
+      const mockEncryptedVaults = 'encrypted-data';
+      const mockGateKeeper = {
+        encrypt: vi.fn().mockResolvedValue(mockEncryptedVaults),
+      };
+
+      vi.mocked(KeyVaultsGateKeeper.initWithEnvKey).mockResolvedValue(mockGateKeeper as any);
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            updateSetting: vi.fn().mockResolvedValue({ rowCount: 1 }),
+          }) as any,
+      );
+
+      await userRouter.createCaller({ ...mockCtx }).updateSettings(mockSettings);
+
+      expect(mockGateKeeper.encrypt).toHaveBeenCalledWith(JSON.stringify(mockSettings.keyVaults));
+    });
+
+    it('should update settings without key vaults', async () => {
+      const mockSettings = {
+        general: { language: 'en-US' },
+      };
+
+      vi.mocked(UserModel).mockImplementation(
+        () =>
+          ({
+            updateSetting: vi.fn().mockResolvedValue({ rowCount: 1 }),
+          }) as any,
+      );
+
+      await userRouter.createCaller({ ...mockCtx }).updateSettings(mockSettings);
+
+      expect(UserModel).toHaveBeenCalledWith(serverDB, mockUserId);
+    });
+  });
+});

package/src/server/routers/lambda/user.ts

@@ -7,15 +7,24 @@ import { serverDB } from '@/database/server';
 import { MessageModel } from '@/database/server/models/message';
 import { SessionModel } from '@/database/server/models/session';
 import { UserModel, UserNotFoundError } from '@/database/server/models/user';
+import { LobeNextAuthDbAdapter } from '@/libs/next-auth/adapter';
 import { authedProcedure, router } from '@/libs/trpc';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import { UserService } from '@/server/services/user';
-import { UserGuideSchema, UserInitializationState, UserPreference } from '@/types/user';
+import {
+  NextAuthAccountSchame,
+  UserGuideSchema,
+  UserInitializationState,
+  UserPreference,
+} from '@/types/user';
 import { UserSettings } from '@/types/user/settings';
 
 const userProcedure = authedProcedure.use(async (opts) => {
   return opts.next({
-    ctx: { userModel: new UserModel(serverDB, opts.ctx.userId) },
+    ctx: {
+      nextAuthDbAdapter: LobeNextAuthDbAdapter(serverDB),
+      userModel: new UserModel(serverDB, opts.ctx.userId),
+    },
   });
 });
 
@@ -24,6 +33,10 @@ export const userRouter = router({
     return ctx.userModel.getUserRegistrationDuration();
   }),
 
+  getUserSSOProviders: userProcedure.query(async ({ ctx }) => {
+    return ctx.userModel.getUserSSOProviders();
+  }),
+
   getUserState: userProcedure.query(async ({ ctx }): Promise<UserInitializationState> => {
     let state: Awaited<ReturnType<UserModel['getUserState']>> | undefined;
 
@@ -92,6 +105,23 @@ export const userRouter = router({
     return ctx.userModel.deleteSetting();
   }),
 
+  unlinkSSOProvider: userProcedure.input(NextAuthAccountSchame).mutation(async ({ ctx, input }) => {
+    const { provider, providerAccountId } = input;
+    if (
+      ctx.nextAuthDbAdapter?.unlinkAccount &&
+      typeof ctx.nextAuthDbAdapter.unlinkAccount === 'function' &&
+      ctx.nextAuthDbAdapter?.getAccount &&
+      typeof ctx.nextAuthDbAdapter.getAccount === 'function'
+    ) {
+      const account = await ctx.nextAuthDbAdapter.getAccount(providerAccountId, provider);
+      // The userId can either get from ctx.nextAuth?.id or ctx.userId
+      if (!account || account.userId !== ctx.userId) throw new Error('The account does not exist');
+      await ctx.nextAuthDbAdapter.unlinkAccount({ provider, providerAccountId });
+    } else {
+      throw new Error('The method in LobeNextAuthDbAdapter `unlinkAccount` is not implemented');
+    }
+  }),
+
   updateGuide: userProcedure.input(UserGuideSchema).mutation(async ({ ctx, input }) => {
     return ctx.userModel.updateGuide(input);
   }),

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

@@ -17,7 +17,7 @@ export class NextAuthUserService {
     { providerAccountId, provider }: { provider: string; providerAccountId: string },
     data: Partial<UserItem>,
   ) => {
-    pino.info('updating user due to webhook');
+    pino.info(`updating user "${JSON.stringify({ provider, providerAccountId })}" due to webhook`);
     // 1. Find User by account
     // @ts-expect-error: Already impl in `LobeNextauthDbAdapter`
     const user = await this.adapter.getUserByAccount({
@@ -37,7 +37,7 @@ export class NextAuthUserService {
       });
     } else {
       pino.warn(
-        `[${provider}]: Webhooks handler user update for "${JSON.stringify(data)}", but no user was found by the providerAccountId.`,
+        `[${provider}]: Webhooks handler user "${JSON.stringify({ provider, providerAccountId })}" update for "${JSON.stringify(data)}", but no user was found by the providerAccountId.`,
       );
     }
     return NextResponse.json({ message: 'user updated', success: true }, { status: 200 });

package/src/services/user/_deprecated.ts

@@ -37,6 +37,15 @@ export class ClientService implements IUserService {
     };
   }
 
+  getUserSSOProviders = async () => {
+    // Account not exist on next-auth in client mode, no need to implement this method
+    return [];
+  };
+
+  unlinkSSOProvider = async () => {
+    // Account not exist on next-auth in client mode, no need to implement this method
+  };
+
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   updateUserSettings = async (patch: DeepPartial<UserSettings>, _?: any) => {
     return UserModel.updateSettings(patch);

package/src/services/user/client.ts

@@ -54,6 +54,15 @@ export class ClientService extends BaseClientService implements IUserService {
     };
   };
 
+  getUserSSOProviders: IUserService['getUserSSOProviders'] = async () => {
+    // Account not exist on next-auth in client mode, no need to implement this method
+    return [];
+  };
+
+  unlinkSSOProvider: IUserService['unlinkSSOProvider'] = async () => {
+    // Account not exist on next-auth in client mode, no need to implement this method
+  };
+
   updateUserSettings: IUserService['updateUserSettings'] = async (value) => {
     const { keyVaults, ...res } = value;
 

package/src/services/user/server.ts

@@ -10,6 +10,17 @@ export class ServerService implements IUserService {
     return lambdaClient.user.getUserState.query();
   };
 
+  getUserSSOProviders: IUserService['getUserSSOProviders'] = async () => {
+    return lambdaClient.user.getUserSSOProviders.query();
+  };
+
+  unlinkSSOProvider: IUserService['unlinkSSOProvider'] = async (
+    provider: string,
+    providerAccountId: string,
+  ) => {
+    return lambdaClient.user.unlinkSSOProvider.mutate({ provider, providerAccountId });
+  };
+
   makeUserOnboarded = async () => {
     return lambdaClient.user.makeUserOnboarded.mutate();
   };

package/src/services/user/type.ts

@@ -1,3 +1,4 @@
+import type { AdapterAccount } from 'next-auth/adapters';
 import { DeepPartial } from 'utility-types';
 
 import { UserGuide, UserInitializationState, UserPreference } from '@/types/user';
@@ -9,8 +10,10 @@ export interface IUserService {
     duration: number;
     updatedAt: string;
   }>;
+  getUserSSOProviders: () => Promise<AdapterAccount[]>;
   getUserState: () => Promise<UserInitializationState>;
   resetUserSettings: () => Promise<any>;
+  unlinkSSOProvider: (provider: string, providerAccountId: string) => Promise<any>;
   updateGuide: (guide: Partial<UserGuide>) => Promise<any>;
   updatePreference: (preference: Partial<UserPreference>) => Promise<any>;
   updateUserSettings: (value: DeepPartial<UserSettings>, signal?: AbortSignal) => Promise<any>;