The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { Logger, UseFilters, UseGuards, UsePipes } from '@nestjs/common';
import { Args, Context, Mutation, Query } from '@nestjs/graphql';
import { InjectRepository } from '@nestjs/typeorm';
import bytes from 'bytes';
import { type Request } from 'express';
import GraphQLUpload from 'graphql-upload/GraphQLUpload.mjs';
import omit from 'lodash.omit';
import { PermissionFlagType } from 'twenty-shared/constants';
import { SOURCE_LOCALE } from 'twenty-shared/translations';
import {
FileFolder,
TwoFactorAuthenticationStrategy,
} from 'twenty-shared/types';
import { assertIsDefinedOrThrow, isDefined } from 'twenty-shared/utils';
import { Repository } from 'typeorm';
import type { FileUpload } from 'graphql-upload/processRequest.mjs';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { settings } from 'src/engine/constants/settings';
import { ApiKeyService } from 'src/engine/core-modules/api-key/services/api-key.service';
import { AppTokenEntity } from 'src/engine/core-modules/app-token/app-token.entity';
import { EventLogEmitterService } from 'src/engine/core-modules/event-logs/emit/event-log-emitter.service';
import { IMPERSONATION_EVENT } from 'src/engine/core-modules/event-logs/emit/events/workspace-event/impersonation/impersonation';
import {
AuthException,
AuthExceptionCode,
} from 'src/engine/core-modules/auth/auth.exception';
import { ApiKeyTokenInput } from 'src/engine/core-modules/auth/dto/api-key-token.input';
import { AppTokenInput } from 'src/engine/core-modules/auth/dto/app-token.input';
import { AuthorizeAppDTO } from 'src/engine/core-modules/auth/dto/authorize-app.dto';
import { AuthorizeAppInput } from 'src/engine/core-modules/auth/dto/authorize-app.input';
import { AvailableWorkspacesAndAccessTokensDTO } from 'src/engine/core-modules/auth/dto/available-workspaces-and-access-tokens.dto';
import { EmailPasswordResetLinkDTO } from 'src/engine/core-modules/auth/dto/email-password-reset-link.dto';
import { EmailPasswordResetLinkInput } from 'src/engine/core-modules/auth/dto/email-password-reset-link.input';
import { GetAuthTokenFromEmailVerificationTokenInput } from 'src/engine/core-modules/auth/dto/get-auth-token-from-email-verification-token.input';
import { GetAuthorizationUrlForSsoDTO } from 'src/engine/core-modules/auth/dto/get-authorization-url-for-sso.dto';
import { GetAuthorizationUrlForSsoInput } from 'src/engine/core-modules/auth/dto/get-authorization-url-for-sso.input';
import { InvalidatePasswordDTO } from 'src/engine/core-modules/auth/dto/invalidate-password.dto';
import { SignUpDTO } from 'src/engine/core-modules/auth/dto/sign-up.dto';
import { TransientTokenDTO } from 'src/engine/core-modules/auth/dto/transient-token.dto';
import { UpdatePasswordViaResetTokenInput } from 'src/engine/core-modules/auth/dto/update-password-via-reset-token.input';
import { ValidatePasswordResetTokenDTO } from 'src/engine/core-modules/auth/dto/validate-password-reset-token.dto';
import { ValidatePasswordResetTokenInput } from 'src/engine/core-modules/auth/dto/validate-password-reset-token.input';
import { VerifyEmailAndGetLoginTokenDTO } from 'src/engine/core-modules/auth/dto/verify-email-and-get-login-token.dto';
import { AuthGraphqlApiExceptionFilter } from 'src/engine/core-modules/auth/filters/auth-graphql-api-exception.filter';
import { ResetPasswordService } from 'src/engine/core-modules/auth/services/reset-password.service';
import { ThrottlerGraphqlApiExceptionFilter } from 'src/engine/core-modules/throttler/filters/throttler-graphql-api-exception.filter';
import { ThrottlerService } from 'src/engine/core-modules/throttler/throttler.service';
import { SignInUpService } from 'src/engine/core-modules/auth/services/sign-in-up.service';
import { AccessTokenService } from 'src/engine/core-modules/auth/token/services/access-token.service';
import { EmailVerificationTokenService } from 'src/engine/core-modules/auth/token/services/email-verification-token.service';
import { LoginTokenService } from 'src/engine/core-modules/auth/token/services/login-token.service';
import { assertLoginTokenIsNotForImpersonation } from 'src/engine/core-modules/auth/utils/assert-login-token-is-not-for-impersonation.util';
import { RefreshTokenService } from 'src/engine/core-modules/auth/token/services/refresh-token.service';
import { RenewTokenService } from 'src/engine/core-modules/auth/token/services/renew-token.service';
import { SsoExchangeTokenService } from 'src/engine/core-modules/auth/token/services/sso-exchange-token.service';
import { TransientTokenService } from 'src/engine/core-modules/auth/token/services/transient-token.service';
import { WorkspaceAgnosticTokenService } from 'src/engine/core-modules/auth/token/services/workspace-agnostic-token.service';
import { AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
import { JwtTokenTypeEnum } from 'src/engine/core-modules/auth/types/jwt-token-type.enum';
import { LoginTokenJwtPayload } from 'src/engine/core-modules/auth/types/login-token-jwt-payload.type';
import { CaptchaGuard } from 'src/engine/core-modules/captcha/captcha.guard';
import { WorkspaceCreationCaptchaGuard } from 'src/engine/core-modules/captcha/workspace-creation-captcha.guard';
import { CaptchaGraphqlApiExceptionFilter } from 'src/engine/core-modules/captcha/filters/captcha-graphql-api-exception.filter';
import { SubdomainAvailabilityDTO } from 'src/engine/core-modules/domain/subdomain-manager/dtos/subdomain-availability.dto';
import { WorkspaceCreationDefaultsDTO } from 'src/engine/core-modules/domain/subdomain-manager/dtos/workspace-creation-defaults.dto';
import { SubdomainManagerService } from 'src/engine/core-modules/domain/subdomain-manager/services/subdomain-manager.service';
import { WorkspaceDomainsService } from 'src/engine/core-modules/domain/workspace-domains/services/workspace-domains.service';
import { EmailVerificationExceptionFilter } from 'src/engine/core-modules/email-verification/email-verification-exception-filter.util';
import { EmailVerificationTrigger } from 'src/engine/core-modules/email-verification/email-verification.constants';
import { EmailVerificationService } from 'src/engine/core-modules/email-verification/services/email-verification.service';
import { FileWithSignedUrlDTO } from 'src/engine/core-modules/file/dtos/file-with-sign-url.dto';
import { FileUploadTargetDTO } from 'src/engine/core-modules/file/file-upload/dtos/file-upload-target.dto';
import { FileUploadGraphqlApiExceptionFilter } from 'src/engine/core-modules/file/file-upload/filters/file-upload-graphql-api-exception.filter';
import { FileCorePictureService } from 'src/engine/core-modules/file/file-core-picture/services/file-core-picture.service';
import { FileUploadService } from 'src/engine/core-modules/file/file-upload/services/file-upload.service';
import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
import { I18nContext } from 'src/engine/core-modules/i18n/types/i18n-context.type';
import { IMPERSONATION_DENIAL_BY_REASON } from 'src/engine/core-modules/impersonation/constants/impersonation-denial-by-reason.constant';
import { IMPERSONATION_DENIAL_LOG_MESSAGE_BY_REASON } from 'src/engine/core-modules/impersonation/constants/impersonation-denial-log-message-by-reason.constant';
import { ImpersonationAuthorizationService } from 'src/engine/core-modules/impersonation/services/impersonation-authorization.service';
import { SsoService } from 'src/engine/core-modules/sso/services/sso.service';
import { TwoFactorAuthenticationRecoveryCodeRedemptionDTO } from 'src/engine/core-modules/two-factor-authentication/dto/two-factor-authentication-recovery-code-redemption.dto';
import { TwoFactorAuthenticationRecoveryCodeVerificationInput } from 'src/engine/core-modules/two-factor-authentication/dto/two-factor-authentication-recovery-code-verification.input';
import { TwoFactorAuthenticationVerificationInput } from 'src/engine/core-modules/two-factor-authentication/dto/two-factor-authentication-verification.input';
import { TwoFactorAuthenticationRecoveryService } from 'src/engine/core-modules/two-factor-authentication/services/two-factor-authentication-recovery.service';
import { TwoFactorAuthenticationExceptionFilter } from 'src/engine/core-modules/two-factor-authentication/two-factor-authentication-exception.filter';
import { TwoFactorAuthenticationService } from 'src/engine/core-modules/two-factor-authentication/two-factor-authentication.service';
import { UserSessionCookieService } from 'src/engine/core-modules/user-session/services/user-session-cookie.service';
import { UserSessionService } from 'src/engine/core-modules/user-session/services/user-session.service';
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 { UserService } from 'src/engine/core-modules/user/services/user.service';
import { UserEntity } from 'src/engine/core-modules/user/user.entity';
import { AuthProviderEnum } from 'src/engine/core-modules/workspace/types/workspace.type';
import { WorkspaceGraphqlApiExceptionFilter } from 'src/engine/core-modules/workspace/filters/workspace-graphql-api-exception.filter';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthProvider } from 'src/engine/decorators/auth/auth-provider.decorator';
import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { AllowSuspendedWorkspace } from 'src/engine/decorators/auth/allow-suspended-workspace.decorator';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { PublicEndpointGuard } from 'src/engine/guards/public-endpoint.guard';
import { AuthPrincipalGuard } from 'src/engine/guards/auth-principal.guard';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/permissions/utils/permissions-graphql-api-exception.filter';
import { getRequestBaseUrl } from 'src/utils/get-request-base-url.util';
import { streamToBuffer } from 'src/utils/stream-to-buffer';
import { ApiKeyToken } from './dto/api-key-token.dto';
import { AuthToken } from './dto/auth-token.dto';
import { AuthTokens } from './dto/auth-tokens.dto';
import { GetAuthTokensFromLoginTokenInput } from './dto/get-auth-tokens-from-login-token.input';
import { GetAuthTokensFromSsoExchangeTokenInput } from './dto/get-auth-tokens-from-sso-exchange-token.input';
import { LoginTokenDTO } from './dto/login-token.dto';
import { SignUpInNewWorkspaceInput } from './dto/sign-up-in-new-workspace.input';
import { SignUpInput } from './dto/sign-up.input';
import { UserCredentialsInput } from './dto/user-credentials.input';
import { CheckUserExistDTO } from './dto/user-exists.dto';
import { EmailAndCaptchaInput } from './dto/user-exists.input';
import { WorkspaceInviteHashValidDTO } from './dto/workspace-invite-hash-valid.dto';
import { WorkspaceInviteHashValidInput } from './dto/workspace-invite-hash.input';
import { AuthService } from './services/auth.service';
const PASSWORD_RESET_EMAIL_RATE_LIMIT_MAX = 3;
const PASSWORD_RESET_EMAIL_RATE_LIMIT_WINDOW_MS = 15 * 60 * 1000;
@UsePipes(ResolverValidationPipe)
@MetadataResolver()
@UseFilters(
CaptchaGraphqlApiExceptionFilter,
AuthGraphqlApiExceptionFilter,
PermissionsGraphqlApiExceptionFilter,
EmailVerificationExceptionFilter,
TwoFactorAuthenticationExceptionFilter,
WorkspaceGraphqlApiExceptionFilter,
FileUploadGraphqlApiExceptionFilter,
ThrottlerGraphqlApiExceptionFilter,
PreventNestToAutoLogGraphqlErrorsFilter,
)
export class AuthResolver {
private readonly logger = new Logger(AuthResolver.name);
constructor(
private readonly throttlerService: ThrottlerService,
@InjectRepository(UserWorkspaceEntity)
private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
@InjectRepository(AppTokenEntity)
private readonly appTokenRepository: Repository<AppTokenEntity>,
private readonly twoFactorAuthenticationService: TwoFactorAuthenticationService,
private readonly twoFactorAuthenticationRecoveryService: TwoFactorAuthenticationRecoveryService,
private authService: AuthService,
private renewTokenService: RenewTokenService,
private userService: UserService,
private apiKeyService: ApiKeyService,
private accessTokenService: AccessTokenService,
private resetPasswordService: ResetPasswordService,
private loginTokenService: LoginTokenService,
private workspaceAgnosticTokenService: WorkspaceAgnosticTokenService,
private ssoExchangeTokenService: SsoExchangeTokenService,
private refreshTokenService: RefreshTokenService,
private signInUpService: SignInUpService,
private transientTokenService: TransientTokenService,
private emailVerificationService: EmailVerificationService,
private workspaceDomainsService: WorkspaceDomainsService,
private userWorkspaceService: UserWorkspaceService,
private emailVerificationTokenService: EmailVerificationTokenService,
private ssoService: SsoService,
private readonly eventLogEmitterService: EventLogEmitterService,
private readonly impersonationAuthorizationService: ImpersonationAuthorizationService,
private readonly subdomainManagerService: SubdomainManagerService,
private readonly fileCorePictureService: FileCorePictureService,
private readonly fileUploadService: FileUploadService,
private readonly userSessionService: UserSessionService,
private readonly userSessionCookieService: UserSessionCookieService,
) {}
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@Query(() => CheckUserExistDTO)
async checkUserExists(
@Args() checkUserExistsInput: EmailAndCaptchaInput,
): Promise<CheckUserExistDTO> {
return await this.authService.checkUserExists(
checkUserExistsInput.email.toLowerCase(),
);
}
@Mutation(() => GetAuthorizationUrlForSsoDTO)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async getAuthorizationUrlForSSO(
@Args('input') params: GetAuthorizationUrlForSsoInput,
) {
return await this.ssoService.getAuthorizationUrlForSSO(
params.identityProviderId,
omit(params, ['identityProviderId']),
);
}
@Query(() => WorkspaceInviteHashValidDTO)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
async checkWorkspaceInviteHashIsValid(
@Args() workspaceInviteHashValidInput: WorkspaceInviteHashValidInput,
): Promise<WorkspaceInviteHashValidDTO> {
return await this.authService.checkWorkspaceInviteHashIsValid(
workspaceInviteHashValidInput.inviteHash,
);
}
@Query(() => WorkspaceEntity)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
async findWorkspaceFromInviteHash(
@Args() workspaceInviteHashValidInput: WorkspaceInviteHashValidInput,
): Promise<WorkspaceEntity> {
return await this.authService.findWorkspaceFromInviteHashOrFail(
workspaceInviteHashValidInput.inviteHash,
);
}
@Mutation(() => LoginTokenDTO)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async getLoginTokenFromCredentials(
@Args()
getLoginTokenFromCredentialsInput: UserCredentialsInput,
@Args('origin') origin: string,
): Promise<LoginTokenDTO> {
const workspace =
await this.workspaceDomainsService.getWorkspaceByOriginOrDefaultWorkspace(
origin,
);
assertIsDefinedOrThrow(
workspace,
new AuthException(
'Workspace not found',
AuthExceptionCode.WORKSPACE_NOT_FOUND,
),
);
const user =
await this.authService.validateLoginWithPasswordAndJoinWorkspaceIfInvited(
getLoginTokenFromCredentialsInput,
workspace,
);
const loginToken = await this.loginTokenService.generateLoginToken(
user.email,
workspace.id,
// email validation is active only for password flow
AuthProviderEnum.Password,
);
return { loginToken };
}
@Mutation(() => AvailableWorkspacesAndAccessTokensDTO)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async signIn(
@Args()
userCredentials: UserCredentialsInput,
@Context() context: { req: Request },
): Promise<AvailableWorkspacesAndAccessTokensDTO> {
const user =
await this.authService.validateLoginWithPassword(userCredentials);
const availableWorkspaces =
await this.userWorkspaceService.findAvailableWorkspacesByEmail(
user.email,
);
const result = {
availableWorkspaces:
await this.userWorkspaceService.setLoginTokenToAvailableWorkspacesWhenAuthProviderMatch(
availableWorkspaces,
user,
AuthProviderEnum.Password,
),
tokens: {
accessOrWorkspaceAgnosticToken:
await this.workspaceAgnosticTokenService.generateWorkspaceAgnosticToken(
{
userId: user.id,
authProvider: AuthProviderEnum.Password,
},
),
refreshToken: await this.refreshTokenService.generateRefreshToken({
userId: user.id,
authProvider: AuthProviderEnum.Password,
targetedTokenType: JwtTokenTypeEnum.WORKSPACE_AGNOSTIC,
}),
},
};
await this.userSessionService.issueSessionForTokenPair({
tokenPair: result.tokens,
request: context.req,
origin: 'sign_in',
});
return result;
}
@Mutation(() => VerifyEmailAndGetLoginTokenDTO)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async verifyEmailAndGetLoginToken(
@Args()
getAuthTokenFromEmailVerificationTokenInput: GetAuthTokenFromEmailVerificationTokenInput,
@Args('origin') origin: string,
) {
const appToken =
await this.emailVerificationTokenService.validateEmailVerificationTokenOrThrow(
getAuthTokenFromEmailVerificationTokenInput,
);
if (
appToken.context?.email &&
appToken.context.email !== appToken.user.email
) {
await this.userService.updateEmailFromVerificationToken(
appToken.user.id,
appToken.context.email,
);
}
const user = await this.userService.markEmailAsVerified(appToken.user.id);
await this.appTokenRepository.remove(appToken);
const workspace =
(await this.workspaceDomainsService.getWorkspaceByOriginOrDefaultWorkspace(
origin,
)) ??
(await this.userWorkspaceService.findFirstWorkspaceByUserId(user.id));
await this.authService.joinWorkspaceIfInvited({ user, workspace });
const loginToken = await this.loginTokenService.generateLoginToken(
user.email,
workspace.id,
AuthProviderEnum.Password,
);
const workspaceUrls =
this.workspaceDomainsService.getWorkspaceUrls(workspace);
return { loginToken, workspaceUrls };
}
@Mutation(() => AvailableWorkspacesAndAccessTokensDTO)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async verifyEmailAndGetWorkspaceAgnosticToken(
@Args()
getAuthTokenFromEmailVerificationTokenInput: GetAuthTokenFromEmailVerificationTokenInput,
@Context() context: { req: Request },
) {
const appToken =
await this.emailVerificationTokenService.validateEmailVerificationTokenOrThrow(
getAuthTokenFromEmailVerificationTokenInput,
);
if (
appToken.context?.email &&
appToken.context.email !== appToken.user.email
) {
await this.userService.updateEmailFromVerificationToken(
appToken.user.id,
appToken.context.email,
);
}
const user = await this.userService.markEmailAsVerified(appToken.user.id);
await this.appTokenRepository.remove(appToken);
const availableWorkspaces =
await this.userWorkspaceService.findAvailableWorkspacesByEmail(
user.email,
);
const result = {
availableWorkspaces:
await this.userWorkspaceService.setLoginTokenToAvailableWorkspacesWhenAuthProviderMatch(
availableWorkspaces,
user,
AuthProviderEnum.Password,
),
tokens: {
accessOrWorkspaceAgnosticToken:
await this.workspaceAgnosticTokenService.generateWorkspaceAgnosticToken(
{
userId: user.id,
authProvider: AuthProviderEnum.Password,
},
),
refreshToken: await this.refreshTokenService.generateRefreshToken({
userId: user.id,
authProvider: AuthProviderEnum.Password,
targetedTokenType: JwtTokenTypeEnum.WORKSPACE_AGNOSTIC,
}),
},
};
await this.userSessionService.issueSessionForTokenPair({
tokenPair: result.tokens,
request: context.req,
origin: 'sign_in',
});
return result;
}
@Mutation(() => AuthTokens)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async getAuthTokensFromOTP(
@Args()
twoFactorAuthenticationVerificationInput: TwoFactorAuthenticationVerificationInput,
@Args('origin') origin: string,
@Context() context: { req: Request },
): Promise<AuthTokens> {
const loginTokenPayload = await this.loginTokenService.verifyLoginToken(
twoFactorAuthenticationVerificationInput.loginToken,
);
assertLoginTokenIsNotForImpersonation(loginTokenPayload);
const { sub: email, authProvider, workspaceId } = loginTokenPayload;
const workspace = await this.validateWorkspaceAccess(origin, workspaceId);
const user = await this.userService.findUserByEmailOrThrow(email);
await this.twoFactorAuthenticationService.validateStrategy(
user.id,
twoFactorAuthenticationVerificationInput.otp,
workspace.id,
TwoFactorAuthenticationStrategy.TOTP,
);
await this.loginTokenService.consumeLoginTokenOrThrow(loginTokenPayload);
const authTokens = await this.authService.verify(
email,
workspace.id,
authProvider,
);
await this.userSessionService.issueSessionForTokenPair({
tokenPair: authTokens.tokens,
request: context.req,
origin: 'sign_in',
});
return authTokens;
}
@Mutation(() => TwoFactorAuthenticationRecoveryCodeRedemptionDTO)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async getAuthTokensFromTwoFactorAuthenticationRecoveryCode(
@Args()
recoveryCodeVerificationInput: TwoFactorAuthenticationRecoveryCodeVerificationInput,
@Args('origin') origin: string,
@Context() context: { req: Request },
): Promise<TwoFactorAuthenticationRecoveryCodeRedemptionDTO> {
const loginTokenPayload = await this.loginTokenService.verifyLoginToken(
recoveryCodeVerificationInput.loginToken,
);
assertLoginTokenIsNotForImpersonation(loginTokenPayload);
const { sub: email, authProvider, workspaceId } = loginTokenPayload;
const workspace = await this.validateWorkspaceAccess(origin, workspaceId);
const user = await this.userService.findUserByEmailOrThrow(email);
const { provisioningUri } =
await this.twoFactorAuthenticationRecoveryService.redeemRecoveryCode({
userId: user.id,
userEmail: email,
workspace,
recoveryCode: recoveryCodeVerificationInput.recoveryCode,
});
if (isDefined(provisioningUri)) {
return { tokens: null, provisioningUri };
}
await this.loginTokenService.consumeLoginTokenOrThrow(loginTokenPayload);
const authTokens = await this.authService.verify(
email,
workspace.id,
authProvider,
);
await this.userSessionService.issueSessionForTokenPair({
tokenPair: authTokens.tokens,
request: context.req,
origin: 'sign_in',
});
return { tokens: authTokens.tokens, provisioningUri: null };
}
@Mutation(() => AvailableWorkspacesAndAccessTokensDTO)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async signUp(
@Args() signUpInput: UserCredentialsInput,
@Context() context: { req: Request },
): Promise<AvailableWorkspacesAndAccessTokensDTO> {
const user = await this.signInUpService.signUpWithoutWorkspace(
{
email: signUpInput.email,
locale: signUpInput.locale,
},
{
provider: AuthProviderEnum.Password,
password: signUpInput.password,
},
);
const availableWorkspaces =
await this.userWorkspaceService.findAvailableWorkspacesByEmail(
user.email,
);
await this.emailVerificationService.sendVerificationEmail({
userId: user.id,
email: user.email,
workspace: undefined,
locale: signUpInput.locale ?? SOURCE_LOCALE,
verifyEmailRedirectPath: signUpInput.verifyEmailRedirectPath,
verificationTrigger: EmailVerificationTrigger.SIGN_UP,
});
const result = {
availableWorkspaces:
await this.userWorkspaceService.setLoginTokenToAvailableWorkspacesWhenAuthProviderMatch(
availableWorkspaces,
user,
AuthProviderEnum.Password,
),
tokens: {
accessOrWorkspaceAgnosticToken:
await this.workspaceAgnosticTokenService.generateWorkspaceAgnosticToken(
{
userId: user.id,
authProvider: AuthProviderEnum.Password,
},
),
refreshToken: await this.refreshTokenService.generateRefreshToken({
userId: user.id,
authProvider: AuthProviderEnum.Password,
targetedTokenType: JwtTokenTypeEnum.WORKSPACE_AGNOSTIC,
}),
},
};
await this.userSessionService.issueSessionForTokenPair({
tokenPair: result.tokens,
request: context.req,
origin: 'sign_in',
});
return result;
}
@Mutation(() => SignUpDTO)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async signUpInWorkspace(
@Args() signUpInput: SignUpInput,
): Promise<SignUpDTO> {
const currentWorkspace = await this.authService.findWorkspaceForSignInUp({
workspaceInviteHash: signUpInput.workspaceInviteHash,
authProvider: AuthProviderEnum.Password,
workspaceId: signUpInput.workspaceId,
});
const invitation =
currentWorkspace && signUpInput.workspacePersonalInviteToken
? await this.authService.findInvitationForSignInUp({
currentWorkspace,
workspacePersonalInviteToken:
signUpInput.workspacePersonalInviteToken,
})
: undefined;
const existingUser = await this.userService.findUserByEmail(
signUpInput.email,
);
const { userData } = this.authService.formatUserDataPayload(
{
email: signUpInput.email,
locale: signUpInput.locale,
},
existingUser,
);
await this.authService.checkAccessForSignIn({
userData,
invitation,
workspaceInviteHash: signUpInput.workspaceInviteHash,
workspace: currentWorkspace,
});
const { user, workspace } = await this.authService.signInUp({
userData,
workspace: currentWorkspace,
invitation,
authParams: {
provider: AuthProviderEnum.Password,
password: signUpInput.password,
},
});
await this.emailVerificationService.sendVerificationEmail({
userId: user.id,
email: user.email,
workspace,
locale: signUpInput.locale ?? SOURCE_LOCALE,
verifyEmailRedirectPath: signUpInput.verifyEmailRedirectPath,
verificationTrigger: EmailVerificationTrigger.SIGN_UP,
});
const loginToken = await this.loginTokenService.generateLoginToken(
user.email,
workspace.id,
AuthProviderEnum.Password,
);
return {
loginToken,
workspace: {
id: workspace.id,
workspaceUrls: this.workspaceDomainsService.getWorkspaceUrls(workspace),
},
};
}
@Query(() => SubdomainAvailabilityDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
async checkWorkspaceSubdomainAvailability(
@Args('subdomain') subdomain: string,
): Promise<SubdomainAvailabilityDTO> {
return this.subdomainManagerService.getSubdomainAvailability(subdomain);
}
@Query(() => WorkspaceCreationDefaultsDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
async getWorkspaceCreationDefaults(
@AuthUser() currentUser: AuthContextUser,
): Promise<WorkspaceCreationDefaultsDTO> {
const user = await this.userService.findUserByIdOrThrow(currentUser.id);
return this.subdomainManagerService.getWorkspaceCreationDefaults(
user.email,
);
}
@Mutation(() => SignUpDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: false,
application: false,
}),
WorkspaceCreationCaptchaGuard,
NoPermissionGuard,
)
@AllowSuspendedWorkspace()
async signUpInNewWorkspace(
@AuthUser() currentUser: AuthContextUser,
@AuthProvider() authProvider: AuthProviderEnum,
@Args('input', { nullable: true }) input?: SignUpInNewWorkspaceInput,
): Promise<SignUpDTO> {
assertIsDefinedOrThrow(
authProvider,
new AuthException(
'Authentication provider is missing',
AuthExceptionCode.UNAUTHENTICATED,
),
);
const fullUser = await this.userService.findUserByIdOrThrow(currentUser.id);
const { user, workspace } = await this.signInUpService.signUpOnNewWorkspace(
{ type: 'existingUser', existingUser: fullUser },
{
displayName: input?.displayName,
subdomain: input?.subdomain,
partner: input?.partner,
},
);
const loginToken = await this.loginTokenService.generateLoginToken(
user.email,
workspace.id,
authProvider,
);
return {
loginToken,
workspace: {
id: workspace.id,
workspaceUrls: this.workspaceDomainsService.getWorkspaceUrls(workspace),
},
};
}
@Mutation(() => FileWithSignedUrlDTO, {
deprecationReason:
'Use createNewWorkspaceLogoUpload and completeNewWorkspaceLogoUpload, which send the logo straight to file storage.',
})
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
@AllowSuspendedWorkspace()
async uploadNewWorkspaceLogo(
@AuthUser() currentUser: AuthContextUser,
@Args('workspaceId') workspaceId: string,
@Args({ name: 'file', type: () => GraphQLUpload })
{ createReadStream, filename }: FileUpload,
): Promise<FileWithSignedUrlDTO> {
const workspace =
await this.fileCorePictureService.getPendingWorkspaceForLogoUploadOrThrow(
{
userId: currentUser.id,
workspaceId,
},
);
const buffer = await streamToBuffer(
createReadStream(),
bytes(settings.storage.maxMultipartFileSize) ?? undefined,
);
return this.fileCorePictureService.uploadWorkspacePicture({
file: buffer,
filename,
workspace,
});
}
@Mutation(() => FileUploadTargetDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
@AllowSuspendedWorkspace()
async createNewWorkspaceLogoUpload(
@AuthUser() currentUser: AuthContextUser,
@Args('workspaceId') workspaceId: string,
@Args({ name: 'filename', type: () => String })
filename: string,
@Args({ name: 'size', type: () => Number })
size: number,
): Promise<FileUploadTargetDTO> {
const workspace =
await this.fileCorePictureService.getPendingWorkspaceForLogoUploadOrThrow(
{
userId: currentUser.id,
workspaceId,
},
);
return this.fileUploadService.createFileUpload({
workspaceId: workspace.id,
filename,
size,
fileFolder: FileFolder.CorePicture,
});
}
@Mutation(() => FileWithSignedUrlDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: { withUser: true, withoutUser: false },
application: { withUser: true, withoutUser: false },
}),
NoPermissionGuard,
)
@AllowSuspendedWorkspace()
async completeNewWorkspaceLogoUpload(
@AuthUser() currentUser: AuthContextUser,
@Args('workspaceId') workspaceId: string,
@Args({ name: 'fileId', type: () => String })
fileId: string,
): Promise<FileWithSignedUrlDTO> {
const workspace =
await this.fileCorePictureService.getPendingWorkspaceForLogoUploadOrThrow(
{
userId: currentUser.id,
workspaceId,
},
);
return this.fileCorePictureService.completeWorkspaceLogoUpload({
workspaceId: workspace.id,
fileId,
});
}
@Mutation(() => TransientTokenDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: false,
application: false,
}),
NoPermissionGuard,
)
async generateTransientToken(
@AuthUser() user: AuthContextUser,
@AuthWorkspace() workspace: WorkspaceEntity,
): Promise<TransientTokenDTO | void> {
const workspaceMember = await this.userService.loadWorkspaceMember(
user,
workspace,
);
if (!workspaceMember) {
return;
}
const transientToken =
await this.transientTokenService.generateTransientToken({
workspaceId: workspace.id,
userId: user.id,
workspaceMemberId: workspaceMember.id,
});
return { transientToken };
}
@Mutation(() => AuthTokens)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async getAuthTokensFromLoginToken(
@Args() getAuthTokensFromLoginTokenInput: GetAuthTokensFromLoginTokenInput,
@Args('origin') origin: string,
@Context() context: { req: Request },
): Promise<AuthTokens> {
const tokenPayload = await this.validateAndDecodeLoginToken(
getAuthTokensFromLoginTokenInput.loginToken,
);
const workspace = await this.validateWorkspaceAccess(
origin,
tokenPayload.workspaceId,
);
const { user, userWorkspace } = await this.validateUserAccess(
tokenPayload.sub,
tokenPayload.workspaceId,
);
let authTokens: AuthTokens;
if (tokenPayload.authProvider === AuthProviderEnum.Impersonation) {
const {
workspaceId,
impersonatorUserWorkspaceId,
impersonatedUserWorkspaceId,
impersonatorUserId,
impersonatedUserId,
} = await this.validateAndLogImpersonation(
tokenPayload,
workspace,
user.email,
);
await this.loginTokenService.consumeLoginTokenOrThrow(tokenPayload);
authTokens =
await this.authService.generateImpersonationAccessTokenAndRefreshToken({
workspaceId,
impersonatorUserWorkspaceId,
impersonatedUserWorkspaceId,
_impersonatorUserId: impersonatorUserId,
impersonatedUserId,
});
} else {
await this.validateRegularAuthentication(workspace, userWorkspace);
await this.loginTokenService.consumeLoginTokenOrThrow(tokenPayload);
authTokens = await this.authService.verify(
user.email,
workspace.id,
tokenPayload.authProvider,
);
}
await this.userSessionService.issueSessionForTokenPair({
tokenPair: authTokens.tokens,
request: context.req,
origin: 'sign_in',
});
return authTokens;
}
@Mutation(() => AuthTokens)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async getAuthTokensFromSSOExchangeToken(
@Args()
{ ssoExchangeToken }: GetAuthTokensFromSsoExchangeTokenInput,
@Context() context: { req: Request },
): Promise<AuthTokens> {
const { userId, authProvider } =
await this.ssoExchangeTokenService.validateAndConsumeSsoExchangeTokenOrThrow(
ssoExchangeToken,
);
const authTokens = {
tokens: {
accessOrWorkspaceAgnosticToken:
await this.workspaceAgnosticTokenService.generateWorkspaceAgnosticToken(
{
userId,
authProvider,
},
),
refreshToken: await this.refreshTokenService.generateRefreshToken({
userId,
authProvider,
targetedTokenType: JwtTokenTypeEnum.WORKSPACE_AGNOSTIC,
}),
},
};
await this.userSessionService.issueSessionForTokenPair({
tokenPair: authTokens.tokens,
request: context.req,
origin: 'sign_in',
});
return authTokens;
}
private async validateAndDecodeLoginToken(
loginToken: string,
): Promise<LoginTokenJwtPayload> {
return await this.loginTokenService.verifyLoginToken(loginToken);
}
private async validateWorkspaceAccess(
origin: string,
tokenWorkspaceId: string,
): Promise<WorkspaceEntity> {
const workspace =
await this.workspaceDomainsService.getWorkspaceByOriginOrDefaultWorkspace(
origin,
);
assertIsDefinedOrThrow(
workspace,
new AuthException(
'Workspace not found',
AuthExceptionCode.WORKSPACE_NOT_FOUND,
),
);
if (tokenWorkspaceId !== workspace.id) {
throw new AuthException(
'Token is not valid for this workspace',
AuthExceptionCode.FORBIDDEN_EXCEPTION,
);
}
return workspace;
}
private async validateUserAccess(
email: string,
workspaceId: string,
): Promise<{ user: UserEntity; userWorkspace: UserWorkspaceEntity }> {
const user = await this.userService.findUserByEmailOrThrow(email);
await this.authService.checkIsEmailVerified(user.isEmailVerified);
const userWorkspace =
await this.userWorkspaceService.getUserWorkspaceForUserOrThrow({
userId: user.id,
workspaceId,
});
return { user, userWorkspace };
}
private async validateRegularAuthentication(
workspace: WorkspaceEntity,
userWorkspace: UserWorkspaceEntity,
): Promise<void> {
await this.twoFactorAuthenticationService.validateTwoFactorAuthenticationRequirement(
workspace,
userWorkspace.twoFactorAuthenticationMethods,
);
}
private async validateAndLogImpersonation(
tokenPayload: LoginTokenJwtPayload,
workspace: WorkspaceEntity,
targetUserEmail: string,
) {
const { impersonatorUserWorkspaceId } = tokenPayload;
const impersonatorUserWorkspace =
await this.userWorkspaceRepository.findOne({
where: { id: impersonatorUserWorkspaceId },
relations: ['user', 'workspace', 'twoFactorAuthenticationMethods'],
});
const toImpersonateUserWorkspace =
await this.userWorkspaceRepository.findOne({
where: {
user: { email: targetUserEmail },
workspaceId: workspace.id,
},
relations: ['user', 'workspace'],
});
if (
!isDefined(impersonatorUserWorkspace) ||
!isDefined(toImpersonateUserWorkspace)
) {
throw new AuthException(
'Impersonator or target user workspace not found',
AuthExceptionCode.FORBIDDEN_EXCEPTION,
);
}
if (
impersonatorUserWorkspace.userId === toImpersonateUserWorkspace.userId
) {
throw new AuthException(
'User cannot impersonate themselves',
AuthExceptionCode.FORBIDDEN_EXCEPTION,
);
}
const eventLogContext = this.eventLogEmitterService.createContext({
workspaceId: workspace.id,
userId: impersonatorUserWorkspace.user.id,
});
const impersonationLevel =
this.impersonationAuthorizationService.getImpersonationLevel(
impersonatorUserWorkspace,
toImpersonateUserWorkspace,
);
void eventLogContext.insertWorkspaceEvent(IMPERSONATION_EVENT, {
level: impersonationLevel,
action: 'token_exchange_attempt',
message: `Impersonation token exchange attempt for ${targetUserEmail} by ${impersonatorUserWorkspace.user.id}`,
});
const authorizationResult =
await this.impersonationAuthorizationService.checkImpersonationAuthorization(
impersonatorUserWorkspace,
toImpersonateUserWorkspace,
);
if (!authorizationResult.allowed) {
void eventLogContext.insertWorkspaceEvent(IMPERSONATION_EVENT, {
level: authorizationResult.level,
action: 'token_exchange_failed',
message: IMPERSONATION_DENIAL_LOG_MESSAGE_BY_REASON[
authorizationResult.reason
]({
targetUserEmail,
impersonatorUserId: impersonatorUserWorkspace.user.id,
}),
});
const { message, exceptionCode, userFriendlyMessage } =
IMPERSONATION_DENIAL_BY_REASON[authorizationResult.reason];
throw new AuthException(message, exceptionCode, { userFriendlyMessage });
}
void eventLogContext.insertWorkspaceEvent(IMPERSONATION_EVENT, {
level: authorizationResult.level,
action: 'token_exchange_success',
message: `Impersonation token exchanged for ${targetUserEmail} by userId ${impersonatorUserWorkspace.user.id}`,
});
return {
workspaceId: workspace.id,
impersonatorUserWorkspaceId: impersonatorUserWorkspace.id,
impersonatedUserWorkspaceId: toImpersonateUserWorkspace.id,
impersonatorUserId: impersonatorUserWorkspace.user.id,
impersonatedUserId: toImpersonateUserWorkspace.user.id,
};
}
@Mutation(() => AuthorizeAppDTO)
@UseGuards(
AuthPrincipalGuard({
userSession: true,
apiKey: false,
oauthClient: false,
application: false,
}),
NoPermissionGuard,
)
async authorizeApp(
@Args() authorizeAppInput: AuthorizeAppInput,
@AuthUser() user: AuthContextUser,
@AuthWorkspace() workspace: WorkspaceEntity,
@Context() context: { req: Request },
): Promise<AuthorizeAppDTO> {
return await this.authService.generateAuthorizationCode({
authorizeAppInput,
user,
workspace,
requestBaseUrl: getRequestBaseUrl(context.req),
});
}
@Mutation(() => AuthTokens)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async renewToken(
@Args() args: AppTokenInput,
@Context() context: { req: Request },
): Promise<AuthTokens> {
const tokens = await this.renewTokenService.generateTokensFromRefreshToken(
args.appToken,
);
await this.userSessionService.issueSessionForTokenPair({
tokenPair: tokens,
request: context.req,
origin: 'renewal_bridge',
});
return { tokens: tokens };
}
@Mutation(() => Boolean)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async signOut(
@Context() context: { req: Request },
@Args('refreshToken', { nullable: true }) refreshToken?: string,
): Promise<boolean> {
try {
await this.userSessionService.signOut({
sessionToken:
this.userSessionCookieService.extractSessionTokenFromRequest(
context.req,
),
refreshToken,
});
} finally {
// Public, and SameSite=Lax keeps the cookie off cross-site POSTs: clearing unconditionally lets any site sign visitors out
if (
isDefined(context.req.res) &&
this.userSessionCookieService.hasSessionCookie(context.req)
) {
this.userSessionCookieService.clearSessionCookie(context.req.res);
}
}
return true;
}
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: false,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
SettingsPermissionGuard([
PermissionFlagType.API_KEYS_AND_WEBHOOKS,
PermissionFlagType.ROLES,
]),
)
@Mutation(() => ApiKeyToken)
async generateApiKeyToken(
@Args() args: ApiKeyTokenInput,
@AuthWorkspace() { id: workspaceId }: WorkspaceEntity,
): Promise<ApiKeyToken | undefined> {
return await this.apiKeyService.generateApiKeyToken(
workspaceId,
args.apiKeyId,
args.expiresAt,
);
}
@UseGuards(
AuthPrincipalGuard({
userSession: {
standard: true,
impersonated: true,
playground: false,
workspaceAgnostic: false,
},
apiKey: false,
oauthClient: false,
application: false,
}),
SettingsPermissionGuard(PermissionFlagType.API_KEYS_AND_WEBHOOKS),
)
@Mutation(() => AuthToken)
async generatePlaygroundToken(
@AuthUser() user: UserEntity,
@AuthWorkspace() workspace: WorkspaceEntity,
@AuthProvider() authProvider: AuthProviderEnum,
): Promise<AuthToken> {
return await this.accessTokenService.generatePlaygroundToken({
userId: user.id,
workspaceId: workspace.id,
authProvider,
});
}
@Mutation(() => EmailPasswordResetLinkDTO)
@UseGuards(CaptchaGuard, PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async emailPasswordResetLink(
@Args() emailPasswordResetInput: EmailPasswordResetLinkInput,
@Context() context: I18nContext,
): Promise<EmailPasswordResetLinkDTO> {
const normalizedEmail = emailPasswordResetInput.email.toLowerCase();
await this.throttlerService.tokenBucketThrottleOrThrow(
`password-reset-email:${normalizedEmail}`,
1,
PASSWORD_RESET_EMAIL_RATE_LIMIT_MAX,
PASSWORD_RESET_EMAIL_RATE_LIMIT_WINDOW_MS,
);
void this.resetPasswordService
.generateAndSendPasswordResetLink({
email: normalizedEmail,
workspaceId: emailPasswordResetInput.workspaceId,
locale: context.req.locale,
})
.catch((error) => {
this.logger.error('Failed to send the password reset link', error);
});
return { success: true };
}
@Mutation(() => InvalidatePasswordDTO)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
@AllowSuspendedWorkspace()
async updatePasswordViaResetToken(
@Args()
{ passwordResetToken, newPassword }: UpdatePasswordViaResetTokenInput,
): Promise<InvalidatePasswordDTO> {
const { id } =
await this.resetPasswordService.validatePasswordResetToken(
passwordResetToken,
);
await this.authService.updatePassword(id, newPassword);
return await this.resetPasswordService.invalidatePasswordResetToken(id);
}
@Query(() => ValidatePasswordResetTokenDTO)
@UseGuards(PublicEndpointGuard, NoPermissionGuard)
async validatePasswordResetToken(
@Args() args: ValidatePasswordResetTokenInput,
): Promise<ValidatePasswordResetTokenDTO> {
return this.resetPasswordService.validatePasswordResetToken(
args.passwordResetToken,
);
}
}