The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
import { type CanActivate, Logger } from '@nestjs/common';
import { Test, type TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
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 { AuthExceptionCode } from 'src/engine/core-modules/auth/auth.exception';
import { EventLogEmitterService } from 'src/engine/core-modules/event-logs/emit/event-log-emitter.service';
import { ImpersonationAuthorizationService } from 'src/engine/core-modules/impersonation/services/impersonation-authorization.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 { RefreshTokenService } from 'src/engine/core-modules/auth/token/services/refresh-token.service';
import { SsoExchangeTokenService } from 'src/engine/core-modules/auth/token/services/sso-exchange-token.service';
import { WorkspaceAgnosticTokenService } from 'src/engine/core-modules/auth/token/services/workspace-agnostic-token.service';
import { CaptchaGuard } from 'src/engine/core-modules/captcha/captcha.guard';
import { WorkspaceCreationCaptchaGuard } from 'src/engine/core-modules/captcha/workspace-creation-captcha.guard';
import { EmailPasswordResetLinkInput } from 'src/engine/core-modules/auth/dto/email-password-reset-link.input';
import { type I18nContext } from 'src/engine/core-modules/i18n/types/i18n-context.type';
import {
ThrottlerException,
ThrottlerExceptionCode,
} from 'src/engine/core-modules/throttler/throttler.exception';
import { ThrottlerService } from 'src/engine/core-modules/throttler/throttler.service';
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 { EmailVerificationService } from 'src/engine/core-modules/email-verification/services/email-verification.service';
import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
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 { 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 { SsoService } from 'src/engine/core-modules/sso/services/sso.service';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { TwoFactorAuthenticationService } from 'src/engine/core-modules/two-factor-authentication/two-factor-authentication.service';
import { TwoFactorAuthenticationRecoveryService } from 'src/engine/core-modules/two-factor-authentication/services/two-factor-authentication-recovery.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 { AccessPolicyService } from 'src/engine/permissions/access-policy/access-policy.service';
import { PermissionsService } from 'src/engine/permissions/permissions.service';
import { AuthResolver } from './auth.resolver';
import { AuthService } from './services/auth.service';
import { ResetPasswordService } from './services/reset-password.service';
import { EmailVerificationTokenService } from './token/services/email-verification-token.service';
import { LoginTokenService } from './token/services/login-token.service';
import { RenewTokenService } from './token/services/renew-token.service';
import { TransientTokenService } from './token/services/transient-token.service';
describe('AuthResolver', () => {
let resolver: AuthResolver;
let appTokenRepository: { remove: jest.Mock };
let authService: {
checkAccessForSignIn: jest.Mock;
findWorkspaceForSignInUp: jest.Mock;
formatUserDataPayload: jest.Mock;
signInUp: jest.Mock;
};
let emailVerificationService: { sendVerificationEmail: jest.Mock };
let emailVerificationTokenService: {
validateEmailVerificationTokenOrThrow: jest.Mock;
};
let loginTokenService: { generateLoginToken: jest.Mock };
let resetPasswordService: ResetPasswordService;
let signInUpService: { signUpOnNewWorkspace: jest.Mock };
let throttlerService: ThrottlerService;
let userService: {
findUserByEmail: jest.Mock;
findUserByIdOrThrow: jest.Mock;
markEmailAsVerified: jest.Mock;
};
let workspaceDomainsService: {
buildWorkspaceURL: jest.Mock;
getWorkspaceByOriginOrDefaultWorkspace: jest.Mock;
getWorkspaceUrls: jest.Mock;
};
const mock_CaptchaGuard: CanActivate = { canActivate: jest.fn(() => true) };
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [
AuthResolver,
{
provide: getRepositoryToken(AppTokenEntity),
useValue: {
remove: jest.fn(),
},
},
{
provide: getRepositoryToken(UserEntity),
useValue: {},
},
{
provide: getRepositoryToken(UserWorkspaceEntity),
useValue: {},
},
{
provide: AuthService,
useValue: {
checkAccessForSignIn: jest.fn(),
findWorkspaceForSignInUp: jest.fn(),
formatUserDataPayload: jest.fn(),
joinWorkspaceIfInvited: jest.fn(),
signInUp: jest.fn(),
},
},
{
provide: RefreshTokenService,
useValue: {},
},
{
provide: UserService,
useValue: {
findUserByEmail: jest.fn(),
findUserByIdOrThrow: jest.fn(),
markEmailAsVerified: jest.fn(),
},
},
{
provide: WorkspaceDomainsService,
useValue: {
buildWorkspaceURL: jest
.fn()
.mockResolvedValue(new URL('http://localhost:3001')),
getWorkspaceByOriginOrDefaultWorkspace: jest.fn(),
getWorkspaceUrls: jest.fn(),
},
},
{
provide: SubdomainManagerService,
useValue: {},
},
{
provide: FileCorePictureService,
useValue: {},
},
{
provide: FileUploadService,
useValue: {},
},
{
provide: UserSessionService,
useValue: {
issueSessionForTokenPair: jest.fn(),
},
},
{
provide: UserSessionCookieService,
useValue: {},
},
{
provide: UserWorkspaceService,
useValue: {
findAvailableWorkspacesByEmail: jest.fn(),
findFirstWorkspaceByUserId: jest.fn(),
setLoginTokenToAvailableWorkspacesWhenAuthProviderMatch: jest.fn(),
},
},
{
provide: RenewTokenService,
useValue: {},
},
{
provide: SignInUpService,
useValue: {
signUpOnNewWorkspace: jest.fn(),
},
},
{
provide: ApiKeyService,
useValue: {},
},
{
provide: AccessTokenService,
useValue: {},
},
{
provide: ResetPasswordService,
useValue: {
generateAndSendPasswordResetLink: jest
.fn()
.mockResolvedValue(undefined),
},
},
{
provide: ThrottlerService,
useValue: {
tokenBucketThrottleOrThrow: jest.fn(),
},
},
{
provide: LoginTokenService,
useValue: {
generateLoginToken: jest.fn(),
},
},
{
provide: WorkspaceAgnosticTokenService,
useValue: {
generateWorkspaceAgnosticToken: jest.fn(),
},
},
{
provide: SsoExchangeTokenService,
useValue: {},
},
{
provide: TransientTokenService,
useValue: {},
},
{
provide: EmailVerificationService,
useValue: {
sendVerificationEmail: jest.fn(),
},
},
{
provide: EmailVerificationTokenService,
useValue: {
validateEmailVerificationTokenOrThrow: jest.fn(),
},
},
{
provide: ImpersonationAuthorizationService,
useValue: {},
},
{
provide: PermissionsService,
useValue: {},
},
AccessPolicyService,
{
provide: FeatureFlagService,
useValue: {},
},
{
provide: SsoService,
useValue: {},
},
{
provide: TwoFactorAuthenticationService,
useValue: {},
},
{
provide: TwoFactorAuthenticationRecoveryService,
useValue: {},
},
{
provide: TwentyConfigService,
useValue: {},
},
{
provide: EventLogEmitterService,
useValue: {
createContext: jest.fn().mockReturnValue({
insertWorkspaceEvent: jest.fn(),
}),
},
},
],
})
.overrideGuard(CaptchaGuard)
.useValue(mock_CaptchaGuard)
.overrideGuard(WorkspaceCreationCaptchaGuard)
.useValue(mock_CaptchaGuard)
.compile();
resolver = module.get<AuthResolver>(AuthResolver);
appTokenRepository = module.get(getRepositoryToken(AppTokenEntity));
authService = module.get(AuthService);
emailVerificationService = module.get(EmailVerificationService);
emailVerificationTokenService = module.get(EmailVerificationTokenService);
loginTokenService = module.get(LoginTokenService);
resetPasswordService =
module.get<ResetPasswordService>(ResetPasswordService);
signInUpService = module.get(SignInUpService);
throttlerService = module.get<ThrottlerService>(ThrottlerService);
userService = module.get(UserService);
workspaceDomainsService = module.get(WorkspaceDomainsService);
});
it('should be defined', () => {
expect(resolver).toBeDefined();
});
describe('password authentication provider propagation', () => {
const user = { id: 'user-id', email: '[email protected]' };
const workspace = { id: 'workspace-id' };
const loginToken = {
token: 'login-token',
expiresAt: new Date('2026-01-01T00:00:00.000Z'),
};
it('uses the password provider when verifying an email on a workspace domain', async () => {
const appToken = { user, context: {} };
emailVerificationTokenService.validateEmailVerificationTokenOrThrow.mockResolvedValue(
appToken,
);
userService.markEmailAsVerified.mockResolvedValue(user);
workspaceDomainsService.getWorkspaceByOriginOrDefaultWorkspace.mockResolvedValue(
workspace,
);
workspaceDomainsService.getWorkspaceUrls.mockReturnValue({
subdomainUrl: 'https://workspace.example.com',
});
loginTokenService.generateLoginToken.mockResolvedValue(loginToken);
await resolver.verifyEmailAndGetLoginToken(
{
email: user.email,
emailVerificationToken: 'email-verification-token',
},
'https://workspace.example.com',
);
expect(loginTokenService.generateLoginToken).toHaveBeenCalledWith(
user.email,
workspace.id,
AuthProviderEnum.Password,
);
expect(appTokenRepository.remove).toHaveBeenCalledWith(appToken);
});
it('uses the password provider when signing up in a workspace', async () => {
authService.findWorkspaceForSignInUp.mockResolvedValue(workspace);
userService.findUserByEmail.mockResolvedValue(null);
authService.formatUserDataPayload.mockReturnValue({
userData: { type: 'newUser' },
});
authService.signInUp.mockResolvedValue({ user, workspace });
loginTokenService.generateLoginToken.mockResolvedValue(loginToken);
workspaceDomainsService.getWorkspaceUrls.mockReturnValue({
subdomainUrl: 'https://workspace.example.com',
});
await resolver.signUpInWorkspace({
email: user.email,
password: 'password',
});
expect(emailVerificationService.sendVerificationEmail).toHaveBeenCalled();
expect(loginTokenService.generateLoginToken).toHaveBeenCalledWith(
user.email,
workspace.id,
AuthProviderEnum.Password,
);
});
it('rejects a missing provider before creating a new workspace', async () => {
let caughtError: unknown;
try {
await resolver.signUpInNewWorkspace(
{ id: user.id } as never,
undefined as never,
);
} catch (error) {
caughtError = error;
}
expect(caughtError).toMatchObject({
code: AuthExceptionCode.UNAUTHENTICATED,
});
expect(userService.findUserByIdOrThrow).not.toHaveBeenCalled();
expect(signInUpService.signUpOnNewWorkspace).not.toHaveBeenCalled();
});
});
describe('emailPasswordResetLink', () => {
const emailPasswordResetInput = {
email: '[email protected]',
workspaceId: 'workspace-id',
} as EmailPasswordResetLinkInput;
const context = { req: { locale: 'en' } } as I18nContext;
it('should send the password reset link and return success', async () => {
const result = await resolver.emailPasswordResetLink(
emailPasswordResetInput,
context,
);
expect(result).toEqual({ success: true });
expect(
resetPasswordService.generateAndSendPasswordResetLink,
).toHaveBeenCalledWith({
email: '[email protected]',
workspaceId: 'workspace-id',
locale: 'en',
});
});
it('should return success without waiting for the link to be sent', async () => {
const loggerErrorSpy = jest
.spyOn(Logger.prototype, 'error')
.mockImplementation();
(
resetPasswordService.generateAndSendPasswordResetLink as jest.Mock
).mockRejectedValue(new Error('database down'));
const result = await resolver.emailPasswordResetLink(
emailPasswordResetInput,
context,
);
expect(result).toEqual({ success: true });
expect(loggerErrorSpy).toHaveBeenCalledWith(
'Failed to send the password reset link',
expect.any(Error),
);
});
it('should throttle and send with a normalized email address', async () => {
await resolver.emailPasswordResetLink(
{
email: '[email protected]',
} as EmailPasswordResetLinkInput,
context,
);
expect(throttlerService.tokenBucketThrottleOrThrow).toHaveBeenCalledWith(
'password-reset-email:[email protected]',
1,
expect.any(Number),
expect.any(Number),
);
expect(
resetPasswordService.generateAndSendPasswordResetLink,
).toHaveBeenCalledWith(
expect.objectContaining({ email: '[email protected]' }),
);
});
it('should surface the throttling error without sending the link', async () => {
(
throttlerService.tokenBucketThrottleOrThrow as jest.Mock
).mockRejectedValue(
new ThrottlerException(
'Limit reached',
ThrottlerExceptionCode.LIMIT_REACHED,
),
);
await expect(
resolver.emailPasswordResetLink(emailPasswordResetInput, context),
).rejects.toThrow(ThrottlerException);
expect(
resetPasswordService.generateAndSendPasswordResetLink,
).not.toHaveBeenCalled();
});
it('should rethrow non throttling errors', async () => {
(
throttlerService.tokenBucketThrottleOrThrow as jest.Mock
).mockRejectedValue(new Error('cache down'));
await expect(
resolver.emailPasswordResetLink(emailPasswordResetInput, context),
).rejects.toThrow('cache down');
expect(
resetPasswordService.generateAndSendPasswordResetLink,
).not.toHaveBeenCalled();
});
});
});