Skip to content

The open alternative to Salesforce, designed for AI.

26.7 KB
Raw Blame
import { BadRequestException, UseFilters, UseGuards } from '@nestjs/common';
import { Args, Mutation, Parent, Query, ResolveField } from '@nestjs/graphql';
import { InjectRepository } from '@nestjs/typeorm';

import crypto from 'crypto';

import { msg } from '@lingui/core/macro';
import { GraphQLJSONObject } from 'graphql-type-json';
import { PermissionFlagType } from 'twenty-shared/constants';
import { isDefined } from 'twenty-shared/utils';
import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
import { In, Repository } from 'typeorm';

import { SupportDriver } from 'src/engine/core-modules/twenty-config/interfaces/support.interface';

import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
import {
  AuthException,
  AuthExceptionCode,
} from 'src/engine/core-modules/auth/auth.exception';
import { AvailableWorkspaces } from 'src/engine/core-modules/auth/dto/available-workspaces.dto';
import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
import { type RawAuthContext } from 'src/engine/core-modules/auth/types/raw-auth-context.type';
import { OnboardingStatus } from 'src/engine/core-modules/onboarding/enums/onboarding-status.enum';
import {
  OnboardingService,
  OnboardingStepKeys,
} from 'src/engine/core-modules/onboarding/onboarding.service';
import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { buildTwoFactorAuthenticationMethodSummary } from 'src/engine/core-modules/two-factor-authentication/utils/two-factor-authentication-method.presenter';
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { UserWorkspaceService } from 'src/engine/core-modules/user-workspace/user-workspace.service';
import { DeletedWorkspaceMemberDTO } from 'src/engine/core-modules/user/dtos/deleted-workspace-member.dto';
import { UpdateUserEmailInput } from 'src/engine/core-modules/user/dtos/update-user-email.input';
import { UpdateWorkspaceMemberSettingsInput } from 'src/engine/core-modules/user/dtos/update-workspace-member-settings.input';
import { WorkspaceMemberDTO } from 'src/engine/core-modules/user/dtos/workspace-member.dto';
import { UserService } from 'src/engine/core-modules/user/services/user.service';
import {
  type ToWorkspaceMemberDtoArgs,
  WorkspaceMemberTranspiler,
} from 'src/engine/core-modules/user/services/workspace-member-transpiler.service';
import { UserVarsService } from 'src/engine/core-modules/user/user-vars/services/user-vars.service';
import { UserEntity } from 'src/engine/core-modules/user/user.entity';
import { userValidator } from 'src/engine/core-modules/user/user.validate';
import { assertWorkspaceMemberUpdateUsesNonCustomFieldsOnly } from 'src/engine/core-modules/user/utils/assert-workspace-member-update-non-custom-fields.util';
import { assertWorkspaceMemberUpdateValuesAreValid } from 'src/engine/core-modules/user/utils/assert-workspace-member-update-values-are-valid.util';
import { AuthProviderEnum } from 'src/engine/core-modules/workspace/types/workspace.type';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthApiKey } from 'src/engine/decorators/auth/auth-api-key.decorator';
import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { AuthAuthenticatedAt } from 'src/engine/decorators/auth/auth-authenticated-at.decorator';
import { AuthProvider } from 'src/engine/decorators/auth/auth-provider.decorator';
import { AuthImpersonationContext } from 'src/engine/decorators/auth/auth-impersonation-context.decorator';
import { canCredentialAutoLoginIntoWorkspaces } from 'src/engine/core-modules/auth/utils/can-credential-auto-login-into-workspaces.util';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
import { EmailVerificationExceptionFilter } from 'src/engine/core-modules/email-verification/email-verification-exception-filter.util';
import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
import { AuthIsUserSession } from 'src/engine/decorators/auth/auth-is-user-session.decorator';
import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
import { AuthWorkspaceMemberId } from 'src/engine/decorators/auth/auth-workspace-member-id.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { AllowSuspendedWorkspace } from 'src/engine/decorators/auth/allow-suspended-workspace.decorator';
import { CustomPermissionGuard } from 'src/engine/guards/custom-permission.guard';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { buildUserSessionRequiredError } from 'src/engine/guards/utils/is-user-session-principal.util';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import {
  PermissionsException,
  PermissionsExceptionCode,
  PermissionsExceptionMessage,
} from 'src/engine/permissions/permissions.exception';
import { PermissionsService } from 'src/engine/permissions/permissions.service';
import { type UserWorkspacePermissions } from 'src/engine/permissions/types/user-workspace-permissions.type';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/permissions/utils/permissions-graphql-api-exception.filter';
import { fromUserWorkspacePermissionsToUserWorkspacePermissionsDto } from 'src/engine/metadata-modules/role/utils/fromUserWorkspacePermissionsToUserWorkspacePermissionsDto';
import { UserRoleService } from 'src/engine/permissions/role-assignment/user-role.service';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { AccountsToReconnectKeys } from 'src/modules/connected-account/types/accounts-to-reconnect-key-value.type';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';

const getHMACKey = (email?: string, key?: string | null) => {
  if (!email || !key) return null;

  const hmac = crypto.createHmac('sha256', key);

  return hmac.update(email).digest('hex');
};

@MetadataResolver(() => UserEntity)
@UseFilters(PermissionsGraphqlApiExceptionFilter, AuthGraphqlApiExceptionFilter)
export class UserResolver {
  constructor(
    @InjectRepository(UserEntity)
    private readonly userRepository: Repository<UserEntity>,
    private readonly userService: UserService,
    private readonly twentyConfigService: TwentyConfigService,
    private readonly onboardingService: OnboardingService,
    private readonly userVarService: UserVarsService,
    @InjectRepository(UserWorkspaceEntity)
    private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
    private readonly userRoleService: UserRoleService,
    private readonly permissionsService: PermissionsService,
    private readonly workspaceMemberTranspiler: WorkspaceMemberTranspiler,
    private readonly userWorkspaceService: UserWorkspaceService,
    private readonly workspaceOrmManager: WorkspaceOrmManager,
  ) {}

  private async getUserWorkspacePermissions({
    currentUserWorkspace,
    workspace,
  }: {
    workspace: WorkspaceEntity;
    currentUserWorkspace: UserWorkspaceEntity;
  }): Promise<UserWorkspacePermissions> {
    const workspaceIsPendingOrOngoingCreation = [
      WorkspaceActivationStatus.PENDING_CREATION,
      WorkspaceActivationStatus.ONGOING_CREATION,
    ].includes(workspace.activationStatus);

    if (workspaceIsPendingOrOngoingCreation) {
      return this.permissionsService.getDefaultUserWorkspacePermissions();
    }

    return await this.permissionsService.getUserWorkspacePermissions({
      userWorkspaceId: currentUserWorkspace.id,
      workspaceId: workspace.id,
    });
  }

  @Query(() => UserEntity)
  @UseGuards(
    AuthPrincipalGuard({
      userSession: true,
      apiKey: false,
      oauthClient: { withUser: true, withoutUser: false },
      application: { withUser: true, withoutUser: false },
    }),
    NoPermissionGuard,
  )
  @AllowSuspendedWorkspace()
  async currentUser(
    @AuthUser() { id: userId }: AuthContextUser,
    @AuthWorkspace({ allowUndefined: true }) workspace: WorkspaceEntity,
    @AuthImpersonationContext()
    impersonationContext: RawAuthContext['impersonationContext'],
    @AuthIsUserSession() isUserSession: boolean,
  ): Promise<UserEntity> {
    const user = await this.userRepository.findOne({
      where: {
        id: userId,
      },
      relations: {
        userWorkspaces: {
          twoFactorAuthenticationMethods: true,
        },
      },
    });

    userValidator.assertIsDefinedOrThrow(
      user,
      new AuthException(
        'UserEntity not found',
        AuthExceptionCode.USER_NOT_FOUND,
      ),
    );

    if (!workspace) {
      return user;
    }

    // The auth context workspace can be a stale cache snapshot right after activateWorkspace ran on another instance (#20322)
    const refreshedWorkspace =
      await this.userService.refreshWorkspaceIfPendingOrOngoingCreation(
        workspace,
      );

    const currentUserWorkspace = user.userWorkspaces.find(
      (userWorkspace) => userWorkspace.workspaceId === refreshedWorkspace.id,
    );

    if (!isDefined(currentUserWorkspace)) {
      throw new Error('Current user workspace not found');
    }

    const userWorkspacePermissions =
      fromUserWorkspacePermissionsToUserWorkspacePermissionsDto(
        await this.getUserWorkspacePermissions({
          currentUserWorkspace,
          workspace: refreshedWorkspace,
        }),
      );

    const twoFactorAuthenticationMethodSummary = isUserSession
      ? buildTwoFactorAuthenticationMethodSummary(
          currentUserWorkspace.twoFactorAuthenticationMethods,
        )
      : undefined;

    return {
      ...user,
      currentUserWorkspace: {
        ...currentUserWorkspace,
        ...userWorkspacePermissions,
        twoFactorAuthenticationMethodSummary,
        isImpersonating: isDefined(impersonationContext),
      },
      currentWorkspace: refreshedWorkspace,
    };
  }

  @ResolveField(() => GraphQLJSONObject, {
    nullable: true,
  })
  async userVars(
    @Parent() user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<Record<string, unknown>> {
    if (!workspace) return {};
    const userVars = await this.userVarService.getAll({
      userId: user.id,
      workspaceId: workspace.id,
    });

    const userVarAllowList: string[] = [
      OnboardingStepKeys.ONBOARDING_CONNECT_ACCOUNT_PENDING,
      OnboardingStepKeys.ONBOARDING_BOOK_CALL_PENDING,
      AccountsToReconnectKeys.ACCOUNTS_TO_RECONNECT_INSUFFICIENT_PERMISSIONS,
      AccountsToReconnectKeys.ACCOUNTS_TO_RECONNECT_EMAIL_ALIASES,
    ];

    const filteredMap = new Map(
      [...userVars].filter(([key]) => userVarAllowList.includes(key)),
    );

    return Object.fromEntries(filteredMap);
  }

  @ResolveField(() => WorkspaceMemberDTO, {
    nullable: true,
  })
  async workspaceMember(
    @Parent() user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<WorkspaceMemberDTO | null> {
    if (!workspace) return null;

    const workspaceMemberEntity = await this.userService.loadWorkspaceMember(
      user,
      workspace,
    );

    if (!isDefined(workspaceMemberEntity)) {
      return null;
    }

    const workspaceId = workspace.id;
    const userWorkspace =
      await this.userWorkspaceService.getUserWorkspaceForUserOrThrow({
        userId: workspaceMemberEntity.userId,
        workspaceId: workspace.id,
      });

    const roleOfUserWorkspace =
      await this.userRoleService.getRolesByUserWorkspaces({
        userWorkspaceIds: [userWorkspace.id],
        workspaceId,
      });

    const userWorkspaceRoles = roleOfUserWorkspace.get(userWorkspace.id);

    if (!isDefined(userWorkspaceRoles)) {
      throw new Error('UserEntity workspace roles not found');
    }

    return this.workspaceMemberTranspiler.toWorkspaceMemberDto({
      workspaceMemberEntity,
      userWorkspace,
      userWorkspaceRoles,
    });
  }

  @ResolveField(() => [WorkspaceMemberDTO], {
    nullable: true,
  })
  async workspaceMembers(
    @Parent() _user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<WorkspaceMemberDTO[]> {
    if (!workspace) return [];

    const workspaceMemberEntities = await this.userService.loadWorkspaceMembers(
      workspace,
      false,
    );

    const userWorkspaces = await this.userWorkspaceRepository.find({
      where: {
        userId: In(workspaceMemberEntities.map((entity) => entity.userId)),
        workspaceId: workspace.id,
      },
    });

    const userWorkspacesByUserIdMap = new Map<string, UserWorkspaceEntity>(
      userWorkspaces.map((userWorkspace) => [
        userWorkspace.userId,
        userWorkspace,
      ]),
    );

    const rolesByUserWorkspacesMap =
      await this.userRoleService.getRolesByUserWorkspaces({
        userWorkspaceIds: userWorkspaces.map(
          (userWorkspace) => userWorkspace.id,
        ),
        workspaceId: workspace.id,
      });

    const toWorkspaceMemberDtoArgs =
      workspaceMemberEntities.map<ToWorkspaceMemberDtoArgs>(
        (workspaceMemberEntity) => {
          const userWorkspace = userWorkspacesByUserIdMap.get(
            workspaceMemberEntity.userId,
          );

          if (!isDefined(userWorkspace)) {
            throw new Error('UserEntity workspace not found');
          }

          const userWorkspaceRoles = rolesByUserWorkspacesMap.get(
            userWorkspace.id,
          );

          if (!isDefined(userWorkspaceRoles)) {
            throw new Error('UserEntity workspace roles not found');
          }

          return {
            userWorkspace,
            userWorkspaceRoles,
            workspaceMemberEntity,
          };
        },
      );

    return this.workspaceMemberTranspiler.toWorkspaceMemberDtos(
      toWorkspaceMemberDtoArgs,
    );
  }

  @ResolveField(() => [DeletedWorkspaceMemberDTO], {
    nullable: true,
  })
  async deletedWorkspaceMembers(
    @Parent() _user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<DeletedWorkspaceMemberDTO[]> {
    if (!workspace) return [];

    const workspaceMemberEntities =
      await this.userService.loadDeletedWorkspaceMembersOnly(workspace);

    return this.workspaceMemberTranspiler.toDeletedWorkspaceMemberDtos(
      workspaceMemberEntities,
      workspace.id,
    );
  }

  @ResolveField(() => Boolean, {
    name: 'hasPassword',
  })
  hasPassword(@Parent() user: UserEntity): boolean {
    return isDefined(user.passwordHash);
  }

  @ResolveField(() => String, {
    nullable: true,
  })
  supportUserHash(
    @Parent() parent: UserEntity,
    @AuthIsUserSession() isUserSession: boolean,
  ): string | null {
    if (!isUserSession) {
      throw buildUserSessionRequiredError();
    }

    if (
      this.twentyConfigService.get('SUPPORT_DRIVER') !== SupportDriver.FRONT
    ) {
      return null;
    }
    const key = this.twentyConfigService.get('SUPPORT_FRONT_HMAC_KEY');

    return getHMACKey(parent.email, key);
  }

  @Mutation(() => UserEntity)
  @UseGuards(
    AuthPrincipalGuard({
      userSession: true,
      apiKey: false,
      oauthClient: false,
      application: false,
    }),
    NoPermissionGuard,
  )
  @AllowSuspendedWorkspace()
  async deleteUser(@AuthUser() { id: userId }: AuthContextUser) {
    return this.userService.deleteUser(userId);
  }

  @Mutation(() => UserWorkspaceEntity)
  @UseGuards(
    AuthPrincipalGuard({
      userSession: true,
      apiKey: false,
      oauthClient: { withUser: true, withoutUser: false },
      application: { withUser: true, withoutUser: false },
    }),
    CustomPermissionGuard,
  )
  @AllowSuspendedWorkspace()
  async deleteUserFromWorkspace(
    @Args('workspaceMemberIdToDelete') workspaceMemberIdToDelete: string,
    @AuthUser() { id: userId }: AuthContextUser,
    @AuthUserWorkspaceId() userWorkspaceId: string,
    @AuthWorkspace()
    workspace: WorkspaceEntity,
    @AuthApiKey() apiKey: ApiKeyEntity | undefined,
    @AuthIsUserSession() isUserSession: boolean,
    @AuthApplication({ allowUndefined: true })
    application: FlatApplication | undefined,
  ) {
    if (!workspace) {
      throw new AuthException(
        'Workspace not found',
        AuthExceptionCode.WORKSPACE_NOT_FOUND,
      );
    }

    const authContext = buildSystemAuthContext(workspace.id);

    const workspaceMemberToDelete =
      await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
        const workspaceMemberRepository =
          this.workspaceOrmManager.getRepositoryWithoutPermissionChecks<WorkspaceMemberWorkspaceEntity>(
            'workspaceMember',
          );

        return workspaceMemberRepository.findOne({
          where: {
            id: workspaceMemberIdToDelete,
          },
        });
      }, authContext);

    if (!isDefined(workspaceMemberToDelete)) {
      throw new BadRequestException(
        'Workspace member to delete not found in workspace',
      );
    }

    const workspaceMemberToDeleteIsAuthenticatedUser =
      workspaceMemberToDelete.userId === userId;

    // Removing oneself may delete the account, so only the person can do it, not an application.
    if (workspaceMemberToDeleteIsAuthenticatedUser && !isUserSession) {
      throw buildUserSessionRequiredError();
    }

    const canDeleteUserFromWorkspace =
      workspaceMemberToDeleteIsAuthenticatedUser ||
      (await this.permissionsService.userHasWorkspaceSettingPermission({
        userWorkspaceId,
        workspaceId: workspace.id,
        setting: PermissionFlagType.WORKSPACE_MEMBERS,
        apiKeyId: apiKey?.id,
        applicationId: application?.id,
        agentId: undefined,
      }));

    if (!canDeleteUserFromWorkspace) {
      throw new PermissionsException(
        PermissionsExceptionMessage.PERMISSION_DENIED,
        PermissionsExceptionCode.PERMISSION_DENIED,
        {
          userFriendlyMessage: msg`You do not have permission to delete this user from the workspace. Please contact your workspace administrator for access.`,
        },
      );
    }

    return this.userService.deleteUserWorkspaceAndPotentiallyDeleteUser({
      userId: workspaceMemberToDelete.userId,
      workspaceId: workspace.id,
      actingUserWorkspaceId: userWorkspaceId,
    });
  }

  @Mutation(() => Boolean)
  @UseGuards(
    AuthPrincipalGuard({
      userSession: {
        standard: true,
        impersonated: true,
        playground: true,
        workspaceAgnostic: false,
      },
      apiKey: true,
      oauthClient: true,
      application: true,
    }),
    CustomPermissionGuard,
  )
  @AllowSuspendedWorkspace()
  async updateWorkspaceMemberSettings(
    @Args('input') input: UpdateWorkspaceMemberSettingsInput,
    @AuthWorkspace() workspace: WorkspaceEntity,
    @AuthUserWorkspaceId({ allowUndefined: true }) userWorkspaceId?: string,
    @AuthApiKey() apiKey?: ApiKeyEntity,
    @AuthWorkspaceMemberId() authenticatedWorkspaceMemberId?: string,
    @AuthUser({ allowUndefined: true }) user?: AuthContextUser | null,
    @AuthApplication({ allowUndefined: true })
    application?: FlatApplication,
  ): Promise<boolean> {
    let isUpdatingSelf =
      isDefined(authenticatedWorkspaceMemberId) &&
      authenticatedWorkspaceMemberId === input.workspaceMemberId;

    // for signup
    if (!isUpdatingSelf && isDefined(user?.id) && !isDefined(apiKey)) {
      const targetWorkspaceMember =
        await this.userWorkspaceService.getWorkspaceMemberOrThrow({
          workspaceMemberId: input.workspaceMemberId,
          workspaceId: workspace.id,
        });

      isUpdatingSelf = targetWorkspaceMember.userId === user.id;
    }

    const canUpdateWorkspaceMember =
      isUpdatingSelf ||
      (await this.permissionsService.userHasWorkspaceSettingPermission({
        userWorkspaceId,
        workspaceId: workspace.id,
        setting: PermissionFlagType.WORKSPACE_MEMBERS,
        apiKeyId: apiKey?.id,
        applicationId: application?.id,
        agentId: undefined,
      }));

    if (!canUpdateWorkspaceMember) {
      throw new PermissionsException(
        PermissionsExceptionMessage.PERMISSION_DENIED,
        PermissionsExceptionCode.PERMISSION_DENIED,
        {
          userFriendlyMessage: msg`You do not have permission to update this workspace member.`,
        },
      );
    }

    assertWorkspaceMemberUpdateUsesNonCustomFieldsOnly({
      update: input.update,
    });

    assertWorkspaceMemberUpdateValuesAreValid({
      update: input.update,
    });

    const workspaceMemberRepository =
      await this.workspaceOrmManager.executeInWorkspaceContext(async () =>
        this.workspaceOrmManager.getRepositoryWithoutPermissionChecks<WorkspaceMemberWorkspaceEntity>(
          'workspaceMember',
        ),
      );

    const workspaceMember =
      await this.workspaceOrmManager.executeInWorkspaceContext(() =>
        workspaceMemberRepository.findOne({
          where: {
            id: input.workspaceMemberId,
          },
        }),
      );

    if (!isDefined(workspaceMember)) {
      throw new BadRequestException('Workspace member not found');
    }

    const workspaceMemberUpdatePayload: Partial<WorkspaceMemberWorkspaceEntity> =
      {
        id: workspaceMember.id,
        ...(input.update as Partial<WorkspaceMemberWorkspaceEntity>),
      };

    await this.workspaceOrmManager.executeInWorkspaceContext(() =>
      workspaceMemberRepository.save(workspaceMemberUpdatePayload),
    );

    await this.onboardingService.completeOnboardingProfileStepIfNameProvided({
      userId: workspaceMember.userId,
      workspaceId: workspace.id,
      firstName: workspaceMemberUpdatePayload.name?.firstName,
      lastName: workspaceMemberUpdatePayload.name?.lastName,
    });

    const targetUserWorkspace =
      await this.userWorkspaceService.getUserWorkspaceForUserOrThrow({
        userId: workspaceMember.userId,
        workspaceId: workspace.id,
      });

    if (isDefined(input.update.locale)) {
      await this.userWorkspaceService.updateUserWorkspaceLocaleForUserWorkspace(
        {
          locale: input.update.locale as UserWorkspaceEntity['locale'],
          userWorkspaceId: targetUserWorkspace.id,
        },
      );
    }

    return true;
  }

  @ResolveField(() => OnboardingStatus, {
    nullable: true,
  })
  async onboardingStatus(
    @Parent() user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<OnboardingStatus | null> {
    if (!workspace) return null;

    return this.onboardingService.getOnboardingStatus({
      userId: user.id,
      workspaceId: workspace.id,
    });
  }

  @ResolveField(() => OnboardingStatus, {
    nullable: true,
  })
  async previousOnboardingStatus(
    @Parent() user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<OnboardingStatus | null> {
    if (!workspace) return null;

    return this.onboardingService.getPreviousReversibleOnboardingStatus({
      userId: user.id,
      workspaceId: workspace.id,
    });
  }

  @ResolveField(() => Boolean, {
    nullable: true,
  })
  async isWorkspaceCreator(
    @Parent() user: UserEntity,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ): Promise<boolean | null> {
    if (!workspace) return null;

    return this.userWorkspaceService.isWorkspaceCreator({
      userId: user.id,
      workspaceId: workspace.id,
    });
  }

  @ResolveField(() => WorkspaceEntity, {
    nullable: true,
  })
  async currentWorkspace(
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
  ) {
    if (!isDefined(workspace)) {
      return null;
    }

    return this.userService.refreshWorkspaceIfPendingOrOngoingCreation(
      workspace,
    );
  }

  @ResolveField(() => [UserWorkspaceEntity], {
    nullable: false,
  })
  async workspaces(
    @Parent() user: UserEntity,
    @AuthIsUserSession() isUserSession: boolean,
  ) {
    if (!isUserSession) {
      throw buildUserSessionRequiredError();
    }

    return user.userWorkspaces;
  }

  // Same rows as the workspaces field under the entity's own name, so guarding only one leaves the other answering.
  @ResolveField(() => [UserWorkspaceEntity], {
    name: 'userWorkspaces',
    nullable: false,
  })
  async userWorkspacesField(
    @Parent() user: UserEntity,
    @AuthIsUserSession() isUserSession: boolean,
  ) {
    if (!isUserSession) {
      throw buildUserSessionRequiredError();
    }

    return user.userWorkspaces;
  }

  @ResolveField(() => AvailableWorkspaces)
  async availableWorkspaces(
    @AuthUser() user: AuthContextUser,
    @AuthProvider() authProvider: AuthProviderEnum,
    @AuthWorkspace({ allowUndefined: true })
    workspace: WorkspaceEntity | undefined,
    @AuthAuthenticatedAt() authenticatedAt: Date | undefined,
    @AuthIsUserSession() isUserSession: boolean,
  ): Promise<AvailableWorkspaces> {
    if (!isUserSession) {
      throw buildUserSessionRequiredError();
    }

    return this.userWorkspaceService.setLoginTokenToAvailableWorkspacesWhenAuthProviderMatch(
      await this.userWorkspaceService.findAvailableWorkspacesByEmail(
        user.email,
      ),
      user,
      authProvider,
      canCredentialAutoLoginIntoWorkspaces({
        isWorkspaceScopedCredential: isDefined(workspace),
        authenticatedAt,
        autoLoginWindow: this.twentyConfigService.get(
          'WORKSPACE_AUTO_LOGIN_WINDOW',
        ),
        now: new Date(),
      }),
    );
  }

  @Mutation(() => Boolean)
  @UseGuards(
    AuthPrincipalGuard({
      userSession: {
        standard: true,
        impersonated: true,
        playground: true,
        workspaceAgnostic: false,
      },
      apiKey: false,
      oauthClient: false,
      application: false,
    }),
    SettingsPermissionGuard(PermissionFlagType.PROFILE_INFORMATION),
  )
  @UseFilters(EmailVerificationExceptionFilter)
  async updateUserEmail(
    @Args() { newEmail, verifyEmailRedirectPath }: UpdateUserEmailInput,
    @AuthUser() user: AuthContextUser,
    @AuthWorkspace() workspace: WorkspaceEntity,
  ) {
    const editableFields = workspace.editableProfileFields || [];

    if (!editableFields.includes('email')) {
      throw new PermissionsException(
        PermissionsExceptionMessage.PERMISSION_DENIED,
        PermissionsExceptionCode.PERMISSION_DENIED,
      );
    }

    await this.userService.updateUserEmail({
      user,
      workspace,
      newEmail,
      verifyEmailRedirectPath,
    });

    return true;
  }
}