7757224827

Committed 02 Feb 2024 02:19PM UTC coverage: 93.138% (-0.1%) from 93.263%

Build # 7757224827

Build Type

Pull #1101

github

Committed by

fmrsabino

Commit Message

Extract Verification Code table

The verification code related data was extracted from the Accounts' table. Verification Codes are temporary data that should only be present while an account is being verified.

Previously, after an account was verified, most of the data tied to the verification process was set to `null` as it was still part of the `accounts` table. By extracting the verification code related data, we can now delete the respective rows instead of holding null values that were mostly used for temporary purposes.

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%)

2 existing lines in 2 files now uncovered.

5699 of 5937 relevant lines covered (95.99%)

175.16 hits per line

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

90.99

/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,
      code: newVerificationCode,
      emailAddress: newEmail,
      safeAddress: args.safeAddress,
      signer: args.signer,
      codeGenerationDate: new Date(),
      unsubscriptionToken: crypto.randomUUID(),
    });
    // 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({
      ...args,
      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	code: newVerificationCode,
236	emailAddress: newEmail,
237	safeAddress: args.safeAddress,
238	signer: args.signer,
239	codeGenerationDate: new Date(),
240	unsubscriptionToken: crypto.randomUUID(),
241	});
242	// TODO if the following throws we should not throw
243	await this._sendEmailVerification({	2✔
244	...args,
245	code: newVerificationCode,
246	});
247	}
248
249	private _isEmailVerificationCodeValid(
250	verificationCode: VerificationCode \| null,
251	): boolean {
252	if (!verificationCode \|\| !verificationCode.generatedOn) return false;	8!
253	const window = Date.now() - verificationCode.generatedOn.getTime();	8✔
254	return window < this.verificationCodeTtlMs;	8✔
255	}
256
257	private async _sendEmailVerification(args: {
258	signer: string;
259	chainId: string;
260	code: string;
261	emailAddress: string;
262	safeAddress: string;
263	}): Promise<void> {
264	await this.emailApi.createMessage({	8✔
265	to: [args.emailAddress],
266	template: this.configurationService.getOrThrow(
267	'email.templates.verificationCode',
268	),
269	subject: AccountRepository.VERIFICATION_CODE_EMAIL_SUBJECT,
270	substitutions: { verificationCode: args.code },
271	});
272
273	// Update verification-sent date on a successful response
274	await this.accountDataSource.setEmailVerificationSentDate({	8✔
275	...args,
276	sentOn: new Date(),
277	});
278	}
279	}

safe-global / safe-client-gateway / 7757224827

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