7783868123

Committed 05 Feb 2024 11:35AM UTC coverage: 93.164% (-0.2%) from 93.328%

Build # 7783868123

Build Type

Pull #1101

github

Committed by

fmrsabino

Commit Message

PR comments

Pull Request Pull Request #1101: Extract Verification Code table

Run Details

1481 of 1772 branches covered (0.0%)

Branch coverage included in aggregate %.

46 of 59 new or added lines in 4 files covered. (77.97%)

1 existing line in 1 file now uncovered.

5701 of 5937 relevant lines covered (96.02%)

174.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.07

/src/domain/account/account-repository.service.ts

import { IAccountDataSource } from '@/domain/interfaces/account.datasource.interface';
import { Inject, Injectable } from '@nestjs/common';
import codeGenerator from '@/domain/account/code-generator';
import {
  EmailAddress,
  VerificationCode,
} from '@/domain/account/entities/account.entity';
import { IAccountRepository } from '@/domain/account/account.repository.interface';
import { AccountSaveError } from '@/domain/account/errors/account-save.error';
import { ResendVerificationTimespanError } from '@/domain/account/errors/verification-timeframe.error';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { EmailAlreadyVerifiedError } from '@/domain/account/errors/email-already-verified.error';
import { InvalidVerificationCodeError } from '@/domain/account/errors/invalid-verification-code.error';
import { EmailEditMatchesError } from '@/domain/account/errors/email-edit-matches.error';
import { IEmailApi } from '@/domain/interfaces/email-api.interface';
import * as crypto from 'crypto';
import { ISubscriptionRepository } from '@/domain/subscriptions/subscription.repository.interface';
import { SubscriptionRepository } from '@/domain/subscriptions/subscription.repository';
import { AccountDoesNotExistError } from '@/datasources/account/errors/account-does-not-exist.error';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { VerificationCodeDoesNotExistError } from '@/datasources/account/errors/verification-code-does-not-exist.error';

@Injectable()
export class AccountRepository implements IAccountRepository {
  private readonly verificationCodeResendLockWindowMs: number;
  private readonly verificationCodeTtlMs: number;
  private static readonly VERIFICATION_CODE_EMAIL_SUBJECT = 'Verification code';

  constructor(
    @Inject(IAccountDataSource)
    private readonly accountDataSource: IAccountDataSource,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IEmailApi) private readonly emailApi: IEmailApi,
    @Inject(ISubscriptionRepository)
    private readonly subscriptionRepository: ISubscriptionRepository,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {
    this.verificationCodeResendLockWindowMs =
      this.configurationService.getOrThrow(
        'email.verificationCode.resendLockWindowMs',
      );
    this.verificationCodeTtlMs = this.configurationService.getOrThrow(
      'email.verificationCode.ttlMs',
    );
  }

  private _generateCode(): string {
    const verificationCode = codeGenerator();
    // Pads the final verification code to 6 characters
    // The generated code might have less than 6 digits so the version to be
    // validated against should account with the leading zeroes
    return verificationCode.toString().padStart(6, '0');
  }

  async createAccount(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: string;
    signer: string;
  }): Promise<void> {
    const email = new EmailAddress(args.emailAddress);
    const verificationCode = this._generateCode();

    try {
      await this.accountDataSource.createAccount({
        chainId: args.chainId,
        code: verificationCode,
        emailAddress: email,
        safeAddress: args.safeAddress,
        signer: args.signer,
        codeGenerationDate: new Date(),
        unsubscriptionToken: crypto.randomUUID(),
      });
      // New account registrations should be subscribed to the Account Recovery category
      await this.subscriptionRepository.subscribe({
        chainId: args.chainId,
        signer: args.signer,
        safeAddress: args.safeAddress,
        notificationTypeKey: SubscriptionRepository.CATEGORY_ACCOUNT_RECOVERY,
      });
      await this._sendEmailVerification({
        ...args,
        code: verificationCode,
      });
    } catch (e) {
      throw new AccountSaveError(args.chainId, args.safeAddress, args.signer);
    }
  }

  async getVerifiedEmailsBySafeAddress(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<string[]> {
    const emails =
      await this.accountDataSource.getVerifiedAccountEmailsBySafeAddress(args);
    return emails.map(({ email }) => email);
  }

  async resendEmailVerification(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
  }): Promise<void> {
    const account = await this.accountDataSource.getAccount(args);

    // If the account was already verified, we should not send out a new
    // verification code
    if (account.isVerified) {
      throw new EmailAlreadyVerifiedError(args);
    }

    const verificationCode: VerificationCode | null =
      await this.accountDataSource
        .getAccountVerificationCode(args)
        .catch((reason) => {
          this.loggingService.warn(reason);
          return null;
        });

    // If there's a date for when the verification was sent out,
    // check if timespan is still valid.
    if (verificationCode?.sentOn) {
      const timespanMs = Date.now() - verificationCode.sentOn.getTime();
      if (timespanMs < this.verificationCodeResendLockWindowMs) {
        throw new ResendVerificationTimespanError({
          ...args,
          timespanMs,
          lockWindowMs: this.verificationCodeResendLockWindowMs,
        });
      }
    }

    if (!this._isEmailVerificationCodeValid(verificationCode)) {
      // Expired or non-existent code. Generate new one
      await this.accountDataSource.setEmailVerificationCode({
        chainId: args.chainId,
        safeAddress: args.safeAddress,
        signer: args.signer,
        code: this._generateCode(),
        codeGenerationDate: new Date(),
      });
    }

    const currentVerificationCode =
      await this.accountDataSource.getAccountVerificationCode(args);

    await this._sendEmailVerification({
      ...args,
      code: currentVerificationCode.code,
      emailAddress: account.emailAddress.value,
    });
  }

  async verifyEmailAddress(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
    code: string;
  }): Promise<void> {
    const account = await this.accountDataSource.getAccount(args);

    if (account.isVerified) {
      // account is already verified, so we don't need to perform further checks
      return;
    }

    let verificationCode: VerificationCode;
    try {
      verificationCode =
        await this.accountDataSource.getAccountVerificationCode(args);
    } catch (e) {
      // If we attempt to verify an email is done without a verification code in place,
      // Send a new code to the client's email address for verification
      this.loggingService.warn(e);
      if (e instanceof VerificationCodeDoesNotExistError) {
        await this.resendEmailVerification(args);
      }
      // throw an error to the clients informing that the email address needs to be verified with a new code
      throw new Error('Email needs to be verified again');
    }

    if (verificationCode.code !== args.code) {
      throw new InvalidVerificationCodeError(args);
    }

    if (!this._isEmailVerificationCodeValid(verificationCode)) {
      throw new InvalidVerificationCodeError(args);
    }

    // TODO: it is possible that when verifying the email address, a new code generation was triggered
    await this.accountDataSource.verifyEmail(args);
  }

  async deleteAccount(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
  }): Promise<void> {
    try {
      const account = await this.accountDataSource.getAccount(args);
      // If there is an error deleting the email address,
      // do not delete the respective account as we still need to get the email
      // for future deletions requests
      await this.emailApi.deleteEmailAddress({
        emailAddress: account.emailAddress.value,
      });
      await this.accountDataSource.deleteAccount(args);
    } catch (error) {
      this.loggingService.warn(error);
      // If there is no account, do not throw in order not to signal its existence
      if (!(error instanceof AccountDoesNotExistError)) {
        throw error;
      }
    }
  }

  async editEmail(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: string;
    signer: string;
  }): Promise<void> {
    const account = await this.accountDataSource.getAccount(args);
    const newEmail = new EmailAddress(args.emailAddress);

    if (newEmail.value === account.emailAddress.value) {
      throw new EmailEditMatchesError(args);
    }

    const newVerificationCode = this._generateCode();

    await this.accountDataSource.updateAccountEmail({
      chainId: args.chainId,
      emailAddress: newEmail,
      safeAddress: args.safeAddress,
      signer: args.signer,
      unsubscriptionToken: crypto.randomUUID(),
    });
    await this.accountDataSource.setEmailVerificationCode({
      chainId: args.chainId,
      code: newVerificationCode,
      signer: args.signer,
      codeGenerationDate: new Date(),
      safeAddress: args.safeAddress,
    });
    // TODO if the following throws we should not throw
    await this._sendEmailVerification({
      ...args,
      code: newVerificationCode,
    });
  }

  private _isEmailVerificationCodeValid(
    verificationCode: VerificationCode | null,
  ): boolean {
    if (!verificationCode || !verificationCode.generatedOn) return false;
    const window = Date.now() - verificationCode.generatedOn.getTime();
    return window < this.verificationCodeTtlMs;
  }

  private async _sendEmailVerification(args: {
    signer: string;
    chainId: string;
    code: string;
    emailAddress: string;
    safeAddress: string;
  }): Promise<void> {
    await this.emailApi.createMessage({
      to: [args.emailAddress],
      template: this.configurationService.getOrThrow(
        'email.templates.verificationCode',
      ),
      subject: AccountRepository.VERIFICATION_CODE_EMAIL_SUBJECT,
      substitutions: { verificationCode: args.code },
    });

    // Update verification-sent date on a successful response
    await this.accountDataSource.setEmailVerificationSentDate({
      chainId: args.chainId,
      safeAddress: args.safeAddress,
      signer: args.signer,
      sentOn: new Date(),
    });
  }
}

1	import { IAccountDataSource } from '@/domain/interfaces/account.datasource.interface';	74✔
2	import { Inject, Injectable } from '@nestjs/common';	74✔
3	import codeGenerator from '@/domain/account/code-generator';	74✔
4	import {	74✔
5	EmailAddress,
6	VerificationCode,
7	} from '@/domain/account/entities/account.entity';
8	import { IAccountRepository } from '@/domain/account/account.repository.interface';
9	import { AccountSaveError } from '@/domain/account/errors/account-save.error';	74✔
10	import { ResendVerificationTimespanError } from '@/domain/account/errors/verification-timeframe.error';	74✔
11	import { IConfigurationService } from '@/config/configuration.service.interface';	74✔
12	import { EmailAlreadyVerifiedError } from '@/domain/account/errors/email-already-verified.error';	74✔
13	import { InvalidVerificationCodeError } from '@/domain/account/errors/invalid-verification-code.error';	74✔
14	import { EmailEditMatchesError } from '@/domain/account/errors/email-edit-matches.error';	74✔
15	import { IEmailApi } from '@/domain/interfaces/email-api.interface';	74✔
16	import * as crypto from 'crypto';	74✔
17	import { ISubscriptionRepository } from '@/domain/subscriptions/subscription.repository.interface';	74✔
18	import { SubscriptionRepository } from '@/domain/subscriptions/subscription.repository';	74✔
19	import { AccountDoesNotExistError } from '@/datasources/account/errors/account-does-not-exist.error';	74✔
20	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	74✔
21	import { VerificationCodeDoesNotExistError } from '@/datasources/account/errors/verification-code-does-not-exist.error';	74✔
22
23	@Injectable()
24	export class AccountRepository implements IAccountRepository {	74✔
25	private readonly verificationCodeResendLockWindowMs: number;
26	private readonly verificationCodeTtlMs: number;
27	private static readonly VERIFICATION_CODE_EMAIL_SUBJECT = 'Verification code';	74✔
28
29	constructor(
30	@Inject(IAccountDataSource)
31	private readonly accountDataSource: IAccountDataSource,	566✔
32	@Inject(IConfigurationService)
33	private readonly configurationService: IConfigurationService,	566✔
34	@Inject(IEmailApi) private readonly emailApi: IEmailApi,	566✔
35	@Inject(ISubscriptionRepository)
36	private readonly subscriptionRepository: ISubscriptionRepository,	566✔
37	@Inject(LoggingService) private readonly loggingService: ILoggingService,	566✔
38	) {
39	this.verificationCodeResendLockWindowMs =	566✔
40	this.configurationService.getOrThrow(
41	'email.verificationCode.resendLockWindowMs',
42	);
43	this.verificationCodeTtlMs = this.configurationService.getOrThrow(	566✔
44	'email.verificationCode.ttlMs',
45	);
46	}
47
48	private _generateCode(): string {
49	const verificationCode = codeGenerator();	8✔
50	// Pads the final verification code to 6 characters
51	// The generated code might have less than 6 digits so the version to be
52	// validated against should account with the leading zeroes
53	return verificationCode.toString().padStart(6, '0');	8✔
54	}
55
56	async createAccount(args: {
57	chainId: string;
58	safeAddress: string;
59	emailAddress: string;
60	signer: string;
61	}): Promise<void> {
62	const email = new EmailAddress(args.emailAddress);	2✔
63	const verificationCode = this._generateCode();	2✔
64
65	try {	2✔
66	await this.accountDataSource.createAccount({	2✔
67	chainId: args.chainId,
68	code: verificationCode,
69	emailAddress: email,
70	safeAddress: args.safeAddress,
71	signer: args.signer,
72	codeGenerationDate: new Date(),
73	unsubscriptionToken: crypto.randomUUID(),
74	});
75	// New account registrations should be subscribed to the Account Recovery category
76	await this.subscriptionRepository.subscribe({	2✔
77	chainId: args.chainId,
78	signer: args.signer,
79	safeAddress: args.safeAddress,
80	notificationTypeKey: SubscriptionRepository.CATEGORY_ACCOUNT_RECOVERY,
81	});
82	await this._sendEmailVerification({	2✔
83	...args,
84	code: verificationCode,
85	});
86	} catch (e) {
87	throw new AccountSaveError(args.chainId, args.safeAddress, args.signer);	×
88	}
89	}
90
91	async getVerifiedEmailsBySafeAddress(args: {
92	chainId: string;
93	safeAddress: string;
94	}): Promise<string[]> {
95	const emails =
96	await this.accountDataSource.getVerifiedAccountEmailsBySafeAddress(args);	48✔
97	return emails.map(({ email }) => email);	56✔
98	}
99
100	async resendEmailVerification(args: {
101	chainId: string;
102	safeAddress: string;
103	signer: string;
104	}): Promise<void> {
105	const account = await this.accountDataSource.getAccount(args);	8✔
106
107	// If the account was already verified, we should not send out a new
108	// verification code
109	if (account.isVerified) {	8✔
110	throw new EmailAlreadyVerifiedError(args);	2✔
111	}
112
113	const verificationCode: VerificationCode \| null =
114	await this.accountDataSource	6✔
115	.getAccountVerificationCode(args)
116	.catch((reason) => {
NEW 117	this.loggingService.warn(reason);	×
NEW 118	return null;	×
119	});
120
121	// If there's a date for when the verification was sent out,
122	// check if timespan is still valid.
123	if (verificationCode?.sentOn) {	6✔
124	const timespanMs = Date.now() - verificationCode.sentOn.getTime();	6✔
125	if (timespanMs < this.verificationCodeResendLockWindowMs) {	6✔
126	throw new ResendVerificationTimespanError({	2✔
127	...args,
128	timespanMs,
129	lockWindowMs: this.verificationCodeResendLockWindowMs,
130	});
131	}
132	}
133
134	if (!this._isEmailVerificationCodeValid(verificationCode)) {	4✔
135	// Expired or non-existent code. Generate new one
136	await this.accountDataSource.setEmailVerificationCode({	2✔
137	chainId: args.chainId,
138	safeAddress: args.safeAddress,
139	signer: args.signer,
140	code: this._generateCode(),
141	codeGenerationDate: new Date(),
142	});
143	}
144
145	const currentVerificationCode =
146	await this.accountDataSource.getAccountVerificationCode(args);	4✔
147
148	await this._sendEmailVerification({	4✔
149	...args,
150	code: currentVerificationCode.code,
151	emailAddress: account.emailAddress.value,
152	});
153	}
154
155	async verifyEmailAddress(args: {
156	chainId: string;
157	safeAddress: string;
158	signer: string;
159	code: string;
160	}): Promise<void> {
161	const account = await this.accountDataSource.getAccount(args);	8✔
162
163	if (account.isVerified) {	8✔
164	// account is already verified, so we don't need to perform further checks
165	return;	2✔
166	}
167
168	let verificationCode: VerificationCode;
169	try {	6✔
170	verificationCode =	6✔
171	await this.accountDataSource.getAccountVerificationCode(args);
172	} catch (e) {
173	// If we attempt to verify an email is done without a verification code in place,
174	// Send a new code to the client's email address for verification
NEW 175	this.loggingService.warn(e);	×
NEW 176	if (e instanceof VerificationCodeDoesNotExistError) {	×
NEW 177	await this.resendEmailVerification(args);	×
178	}
179	// throw an error to the clients informing that the email address needs to be verified with a new code
NEW 180	throw new Error('Email needs to be verified again');	×
181	}
182
183	if (verificationCode.code !== args.code) {	6✔
184	throw new InvalidVerificationCodeError(args);	2✔
185	}
186
187	if (!this._isEmailVerificationCodeValid(verificationCode)) {	4✔
188	throw new InvalidVerificationCodeError(args);	2✔
189	}
190
191	// TODO: it is possible that when verifying the email address, a new code generation was triggered
192	await this.accountDataSource.verifyEmail(args);	2✔
193	}
194
195	async deleteAccount(args: {
196	chainId: string;
197	safeAddress: string;
198	signer: string;
199	}): Promise<void> {
200	try {	6✔
201	const account = await this.accountDataSource.getAccount(args);	6✔
202	// If there is an error deleting the email address,
203	// do not delete the respective account as we still need to get the email
204	// for future deletions requests
205	await this.emailApi.deleteEmailAddress({	4✔
206	emailAddress: account.emailAddress.value,
207	});
208	await this.accountDataSource.deleteAccount(args);	2✔
209	} catch (error) {
210	this.loggingService.warn(error);	4✔
211	// If there is no account, do not throw in order not to signal its existence
212	if (!(error instanceof AccountDoesNotExistError)) {	4✔
213	throw error;	2✔
214	}
215	}
216	}
217
218	async editEmail(args: {
219	chainId: string;
220	safeAddress: string;
221	emailAddress: string;
222	signer: string;
223	}): Promise<void> {
224	const account = await this.accountDataSource.getAccount(args);	8✔
225	const newEmail = new EmailAddress(args.emailAddress);	6✔
226
227	if (newEmail.value === account.emailAddress.value) {	6✔
228	throw new EmailEditMatchesError(args);	2✔
229	}
230
231	const newVerificationCode = this._generateCode();	4✔
232
233	await this.accountDataSource.updateAccountEmail({	4✔
234	chainId: args.chainId,
235	emailAddress: newEmail,
236	safeAddress: args.safeAddress,
237	signer: args.signer,
238	unsubscriptionToken: crypto.randomUUID(),
239	});
240	await this.accountDataSource.setEmailVerificationCode({	2✔
241	chainId: args.chainId,
242	code: newVerificationCode,
243	signer: args.signer,
244	codeGenerationDate: new Date(),
245	safeAddress: args.safeAddress,
246	});
247	// TODO if the following throws we should not throw
248	await this._sendEmailVerification({	2✔
249	...args,
250	code: newVerificationCode,
251	});
252	}
253
254	private _isEmailVerificationCodeValid(
255	verificationCode: VerificationCode \| null,
256	): boolean {
257	if (!verificationCode \|\| !verificationCode.generatedOn) return false;	8!
258	const window = Date.now() - verificationCode.generatedOn.getTime();	8✔
259	return window < this.verificationCodeTtlMs;	8✔
260	}
261
262	private async _sendEmailVerification(args: {
263	signer: string;
264	chainId: string;
265	code: string;
266	emailAddress: string;
267	safeAddress: string;
268	}): Promise<void> {
269	await this.emailApi.createMessage({	8✔
270	to: [args.emailAddress],
271	template: this.configurationService.getOrThrow(
272	'email.templates.verificationCode',
273	),
274	subject: AccountRepository.VERIFICATION_CODE_EMAIL_SUBJECT,
275	substitutions: { verificationCode: args.code },
276	});
277
278	// Update verification-sent date on a successful response
279	await this.accountDataSource.setEmailVerificationSentDate({	8✔
280	chainId: args.chainId,
281	safeAddress: args.safeAddress,
282	signer: args.signer,
283	sentOn: new Date(),
284	});
285	}
286	}

safe-global / safe-client-gateway / 7783868123

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous