The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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;
}
}