7100044696

Committed 05 Dec 2023 11:25AM UTC coverage: 89.251% (-0.5%) from 89.703%

Build # 7100044696

Build Type

push

github

Committed by

web-flow

Commit Message

Add functionality to resend email verification (#897)

- The `IEmailRepository` was extended to have a function for resending email verifications.
- The email verification can be resent if enough time has passed since this action was last triggered successfully. This timeframe is configurable with `EMAIL_VERIFICATION_CODE_RESEND_LOCK_WINDOW_MS` (default is 30 seconds).
- When resending the verification code, if the current code is still valid, then it is re-sent. If it expired, then a new one is generated, stored and re-sent to the same email address. The expiration time of the code can be set via `EMAIL_VERIFICATION_CODE_TTL_MS`.
- If this action is triggered for verified owners, an `EmailAlreadyVerifiedError` is thrown.
- If this action is triggered within `EMAIL_VERIFICATION_CODE_RESEND_LOCK_WINDOW_MS` from the last successful one, a `ResendVerificationTimespanError` is thrown.
- Else, it attempts to set a new code and send it. If the new code was not set, an `InvalidVerificationCodeError` is thrown.

Run Details

1410 of 1722 branches covered (0.0%)

Branch coverage included in aggregate %.

15 of 32 new or added lines in 4 files covered. (46.88%)

3 existing lines in 2 files now uncovered.

5249 of 5739 relevant lines covered (91.46%)

151.8 hits per line

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

42.31

/src/domain/email/email.repository.ts

import { IEmailDataSource } from '@/domain/interfaces/email.datasource.interface';
import { Inject, Injectable } from '@nestjs/common';
import codeGenerator from '@/domain/email/code-generator';
import { EmailAddress } from '@/domain/email/entities/email.entity';
import { IEmailRepository } from '@/domain/email/email.repository.interface';
import { EmailSaveError } from '@/domain/email/errors/email-save.error';
import { ResendVerificationTimespanError } from '@/domain/email/errors/verification-timeframe.error';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { EmailAlreadyVerifiedError } from '@/domain/email/errors/email-already-verified.error';
import { InvalidVerificationCodeError } from '@/domain/email/errors/invalid-verification-code.error';

@Injectable()
export class EmailRepository implements IEmailRepository {
  private readonly verificationCodeResendLockWindowMs: number;
  private readonly verificationCodeTtlMs: number;

  constructor(
    @Inject(IEmailDataSource)
    private readonly emailDataSource: IEmailDataSource,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.verificationCodeResendLockWindowMs =
      this.configurationService.getOrThrow(
        'email.verificationCode.resendLockWindowMs',
      );
    this.verificationCodeTtlMs = this.configurationService.getOrThrow(
      'email.verificationCode.ttlMs',
    );
  }

  private _generateCode() {
    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 saveEmail(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: string;
    account: string;
  }): Promise<void> {
    const email = new EmailAddress(args.emailAddress);
    const verificationCode = this._generateCode();

    try {
      await this.emailDataSource.saveEmail({
        chainId: args.chainId,
        code: verificationCode,
        emailAddress: email,
        safeAddress: args.safeAddress,
        signer: args.account,
        codeGenerationDate: new Date(),
      });
      await this._sendEmailVerification({
        ...args,
        signer: args.account,
        code: verificationCode,
      });
    } catch (e) {
      throw new EmailSaveError(args.chainId, args.safeAddress, args.account);
    }
  }

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

  async resendEmailVerification(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
  }): Promise<void> {
    let email = await this.emailDataSource.getEmail(args);

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

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

    const isCodeValid = email.verificationGeneratedOn
      ? Date.now() - email.verificationGeneratedOn.getTime() <
        this.verificationCodeTtlMs
      : false;

    if (!isCodeValid) {
      // Expired code. Generate new one
      await this.emailDataSource.setVerificationCode({
        chainId: args.chainId,
        safeAddress: args.safeAddress,
        signer: args.signer,
        code: this._generateCode(),
        codeGenerationDate: new Date(),
      });
    }

    email = await this.emailDataSource.getEmail(args);
    if (!email.verificationCode) {
      throw new InvalidVerificationCodeError(args);
    }

    await this._sendEmailVerification({
      ...args,
      code: email.verificationCode,
    });
  }

  private async _sendEmailVerification(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
    code: string;
  }) {
    // TODO send email via provider
    // Update verification-sent date on a successful response
    await this.emailDataSource.setVerificationSentDate({
      ...args,
      sentOn: new Date(),
    });
  }
}

1	import { IEmailDataSource } from '@/domain/interfaces/email.datasource.interface';	62✔
2	import { Inject, Injectable } from '@nestjs/common';	62✔
3	import codeGenerator from '@/domain/email/code-generator';	62✔
4	import { EmailAddress } from '@/domain/email/entities/email.entity';	62✔
5	import { IEmailRepository } from '@/domain/email/email.repository.interface';
6	import { EmailSaveError } from '@/domain/email/errors/email-save.error';	62✔
7	import { ResendVerificationTimespanError } from '@/domain/email/errors/verification-timeframe.error';	62✔
8	import { IConfigurationService } from '@/config/configuration.service.interface';	62✔
9	import { EmailAlreadyVerifiedError } from '@/domain/email/errors/email-already-verified.error';	62✔
10	import { InvalidVerificationCodeError } from '@/domain/email/errors/invalid-verification-code.error';	62✔
11
12	@Injectable()
13	export class EmailRepository implements IEmailRepository {	62✔
14	private readonly verificationCodeResendLockWindowMs: number;
15	private readonly verificationCodeTtlMs: number;
16
17	constructor(
18	@Inject(IEmailDataSource)
19	private readonly emailDataSource: IEmailDataSource,	474✔
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	474✔
22	) {
23	this.verificationCodeResendLockWindowMs =	474✔
24	this.configurationService.getOrThrow(
25	'email.verificationCode.resendLockWindowMs',
26	);
27	this.verificationCodeTtlMs = this.configurationService.getOrThrow(	474✔
28	'email.verificationCode.ttlMs',
29	);
30	}
31
32	private _generateCode() {
33	const verificationCode = codeGenerator();	2✔
34	// Pads the final verification code to 6 characters
35	// The generated code might have less than 6 digits so the version to be
36	// validated against should account with the leading zeroes
37	return verificationCode.toString().padStart(6, '0');	2✔
38	}
39
40	async saveEmail(args: {
41	chainId: string;
42	safeAddress: string;
43	emailAddress: string;
44	account: string;
45	}): Promise<void> {
46	const email = new EmailAddress(args.emailAddress);	2✔
47	const verificationCode = this._generateCode();	2✔
48
49	try {	2✔
50	await this.emailDataSource.saveEmail({	2✔
51	chainId: args.chainId,
52	code: verificationCode,
53	emailAddress: email,
54	safeAddress: args.safeAddress,
55	signer: args.account,
56	codeGenerationDate: new Date(),
57	});
58	await this._sendEmailVerification({	2✔
59	...args,
60	signer: args.account,
61	code: verificationCode,
62	});
63	} catch (e) {
64	throw new EmailSaveError(args.chainId, args.safeAddress, args.account);	×
65	}
66	}
67
68	async getVerifiedEmailsBySafeAddress(args: {
69	chainId: string;
70	safeAddress: string;
71	}): Promise<string[]> {
72	const emails =
73	await this.emailDataSource.getVerifiedSignerEmailsBySafeAddress(args);	×
74	return emails.map(({ email }) => email);	×
75	}
76
77	async resendEmailVerification(args: {
78	chainId: string;
79	safeAddress: string;
80	signer: string;
81	}): Promise<void> {
NEW 82	let email = await this.emailDataSource.getEmail(args);	×
83
84	// If the email was already verified, we should not send out a new
85	// verification code
NEW 86	if (email.isVerified) {	×
NEW 87	throw new EmailAlreadyVerifiedError(args);	×
88	}
89
90	// If there's a date for when the verification was sent out,
91	// check if timespan is still valid.
NEW 92	if (email.verificationSentOn) {	×
NEW 93	const timespanMs = Date.now() - email.verificationSentOn.getTime();	×
NEW 94	if (timespanMs < this.verificationCodeResendLockWindowMs) {	×
NEW 95	throw new ResendVerificationTimespanError({	×
96	...args,
97	timespanMs,
98	lockWindowMs: this.verificationCodeResendLockWindowMs,
99	});
100	}
101	}
102
NEW 103	const isCodeValid = email.verificationGeneratedOn	×
104	? Date.now() - email.verificationGeneratedOn.getTime() <
105	this.verificationCodeTtlMs
106	: false;
107
NEW 108	if (!isCodeValid) {	×
109	// Expired code. Generate new one
NEW 110	await this.emailDataSource.setVerificationCode({	×
111	chainId: args.chainId,
112	safeAddress: args.safeAddress,
113	signer: args.signer,
114	code: this._generateCode(),
115	codeGenerationDate: new Date(),
116	});
117	}
118
NEW 119	email = await this.emailDataSource.getEmail(args);	×
NEW 120	if (!email.verificationCode) {	×
NEW 121	throw new InvalidVerificationCodeError(args);	×
122	}
123
NEW 124	await this._sendEmailVerification({	×
125	...args,
126	code: email.verificationCode,
127	});
128	}
129
130	private async _sendEmailVerification(args: {
131	chainId: string;
132	safeAddress: string;
133	signer: string;
134	code: string;
135	}) {
136	// TODO send email via provider
137	// Update verification-sent date on a successful response
138	await this.emailDataSource.setVerificationSentDate({	2✔
139	...args,
140	sentOn: new Date(),
141	});
142	}
143	}

safe-global / safe-client-gateway / 7100044696

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