7300367128

Committed 22 Dec 2023 01:22PM UTC coverage: 90.507% (+0.03%) from 90.474%

Build # 7300367128

Build Type

Pull #972

github

Committed by

iamacook

Commit Message

Add package

Pull Request Pull Request #972: Add cron to remove unverified emails

Run Details

1451 of 1726 branches covered (0.0%)

Branch coverage included in aggregate %.

12 of 14 new or added lines in 5 files covered. (85.71%)

1 existing line in 1 file now uncovered.

5452 of 5901 relevant lines covered (92.39%)

153.72 hits per line

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

88.37

/src/datasources/email/email.datasource.ts

import { Inject, Injectable } from '@nestjs/common';
import * as postgres from 'postgres';
import { IEmailDataSource } from '@/domain/interfaces/email.datasource.interface';
import { EmailAddressDoesNotExistError } from '@/datasources/email/errors/email-address-does-not-exist.error';
import {
  Email as DomainEmail,
  EmailAddress,
} from '@/domain/email/entities/email.entity';

interface Email {
  id: number;
  chain_id: number;
  email_address: string;
  safe_address: string;
  account: string;
  verified: boolean;
  verification_code: string | null;
  verification_code_generated_on: Date | null;
  verification_sent_on: Date | null;
}

@Injectable()
export class EmailDataSource implements IEmailDataSource {
  constructor(@Inject('DB_INSTANCE') private readonly sql: postgres.Sql) {}

  async getVerifiedAccountEmailsBySafeAddress(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<{ email: string }[]> {
    const emails = await this.sql<{ email_address: string }[]>`
        SELECT email_address
        FROM emails.account_emails
        WHERE chain_id = ${args.chainId}
          AND safe_address = ${args.safeAddress}
          AND verified is true
        ORDER by id`;

    return emails.map((email) => ({ email: email.email_address }));
  }

  async getEmail(args: {
    chainId: string;
    safeAddress: string;
    account: string;
  }): Promise<DomainEmail> {
    const [email] = await this.sql<Email[]>`SELECT *
                                            FROM emails.account_emails
                                            WHERE chain_id = ${args.chainId}
                                              AND safe_address = ${args.safeAddress}
                                              AND account = ${args.account}`;
    if (!email) {
      throw new EmailAddressDoesNotExistError(
        args.chainId,
        args.safeAddress,
        args.account,
      );
    }

    return <DomainEmail>{
      chainId: email.chain_id.toString(),
      emailAddress: new EmailAddress(email.email_address),
      isVerified: email.verified,
      safeAddress: email.safe_address,
      account: email.account,
      verificationCode: email.verification_code,
      verificationGeneratedOn: email.verification_code_generated_on,
      verificationSentOn: email.verification_sent_on,
    };
  }

  async getUnverifiedEmailsUntil(until: Date): Promise<DomainEmail[]> {
    const emails = await this.sql<Email[]>`SELECT *
                                            FROM emails.account_emails
                                            WHERE verified is false
                                              AND verification_code_generated_on < ${until}
                                            ORDER by id`;

    return emails.map((email) => ({
      chainId: email.chain_id.toString(),
      emailAddress: new EmailAddress(email.email_address),
      isVerified: email.verified,
      safeAddress: email.safe_address,
      account: email.account,
      verificationCode: email.verification_code,
      verificationGeneratedOn: email.verification_code_generated_on,
      verificationSentOn: email.verification_sent_on,
    }));
  }

  async saveEmail(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: EmailAddress;
    account: string;
    code: string;
    codeGenerationDate: Date;
  }): Promise<void> {
    return await this.sql.begin(async (sql) => {
      await sql<Email[]>`
          INSERT INTO emails.account_emails (chain_id, email_address, safe_address, account, verification_code,
                                             verification_code_generated_on)
          VALUES (${args.chainId}, ${args.emailAddress.value}, ${args.safeAddress}, ${args.account}, ${args.code},
                  ${args.codeGenerationDate})
          RETURNING *
      `;
    });
  }

  async setVerificationCode(args: {
    chainId: string;
    safeAddress: string;
    account: string;
    code: string;
    codeGenerationDate: Date;
  }): Promise<void> {
    const [email] = await this.sql<Email[]>`UPDATE emails.account_emails
                                            SET verification_code              = ${args.code},
                                                verification_code_generated_on = ${args.codeGenerationDate}
                                            WHERE chain_id = ${args.chainId}
                                              AND safe_address = ${args.safeAddress}
                                              AND account = ${args.account}
                                            RETURNING *`;

    if (!email) {
      throw new EmailAddressDoesNotExistError(
        args.chainId,
        args.safeAddress,
        args.account,
      );
    }
  }

  async setVerificationSentDate(args: {
    chainId: string;
    safeAddress: string;
    account: string;
    sentOn: Date;
  }): Promise<void> {
    const [email] = await this.sql<Email[]>`UPDATE emails.account_emails
                                            SET verification_sent_on = ${args.sentOn}
                                            WHERE chain_id = ${args.chainId}
                                              AND safe_address = ${args.safeAddress}
                                              AND account = ${args.account}
                                            RETURNING *`;

    if (!email) {
      throw new EmailAddressDoesNotExistError(
        args.chainId,
        args.safeAddress,
        args.account,
      );
    }
  }

  async verifyEmail(args: {
    chainId: string;
    safeAddress: string;
    account: string;
  }): Promise<void> {
    const [email] = await this.sql<Email[]>`UPDATE emails.account_emails
                                            SET verified          = true,
                                                verification_code = null
                                            WHERE chain_id = ${args.chainId}
                                              AND safe_address = ${args.safeAddress}
                                              AND account = ${args.account}
                                            RETURNING *`;

    if (!email) {
      throw new EmailAddressDoesNotExistError(
        args.chainId,
        args.safeAddress,
        args.account,
      );
    }
  }

  async deleteEmail(args: {
    chainId: string;
    safeAddress: string;
    account: string;
  }): Promise<void> {
    const [email] = await this.sql<Email[]>`DELETE
                                            FROM emails.account_emails
                                            WHERE chain_id = ${args.chainId}
                                              AND safe_address = ${args.safeAddress}
                                              AND account = ${args.account}
                                            RETURNING *`;

    if (!email) {
      throw new EmailAddressDoesNotExistError(
        args.chainId,
        args.safeAddress,
        args.account,
      );
    }
  }

  async updateEmail(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: EmailAddress;
    account: string;
    code: string;
    codeGenerationDate: Date;
  }): Promise<void> {
    const [email] = await this.sql<Email[]>`UPDATE emails.account_emails
                                            SET email_address                  = ${args.emailAddress.value},
                                                verified                       = false,
                                                verification_code              = ${args.code},
                                                verification_code_generated_on = ${args.codeGenerationDate}
                                            WHERE chain_id = ${args.chainId}
                                              AND safe_address = ${args.safeAddress}
                                              AND account = ${args.account}
                                            RETURNING *`;

    if (!email) {
      throw new EmailAddressDoesNotExistError(
        args.chainId,
        args.safeAddress,
        args.account,
      );
    }
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	74✔
2	import * as postgres from 'postgres';	74✔
3	import { IEmailDataSource } from '@/domain/interfaces/email.datasource.interface';
4	import { EmailAddressDoesNotExistError } from '@/datasources/email/errors/email-address-does-not-exist.error';	74✔
5	import {	74✔
6	Email as DomainEmail,
7	EmailAddress,
8	} from '@/domain/email/entities/email.entity';
9
10	interface Email {
11	id: number;
12	chain_id: number;
13	email_address: string;
14	safe_address: string;
15	account: string;
16	verified: boolean;
17	verification_code: string \| null;
18	verification_code_generated_on: Date \| null;
19	verification_sent_on: Date \| null;
20	}
21
22	@Injectable()
23	export class EmailDataSource implements IEmailDataSource {	74✔
24	constructor(@Inject('DB_INSTANCE') private readonly sql: postgres.Sql) {}	24✔
25
26	async getVerifiedAccountEmailsBySafeAddress(args: {
27	chainId: string;
28	safeAddress: string;
29	}): Promise<{ email: string }[]> {
30	const emails = await this.sql<{ email_address: string }[]>`	2✔
31	SELECT email_address
32	FROM emails.account_emails
33	WHERE chain_id = ${args.chainId}
34	AND safe_address = ${args.safeAddress}
35	AND verified is true
36	ORDER by id`;
37
38	return emails.map((email) => ({ email: email.email_address }));	4✔
39	}
40
41	async getEmail(args: {
42	chainId: string;
43	safeAddress: string;
44	account: string;
45	}): Promise<DomainEmail> {
46	const [email] = await this.sql<Email[]>`SELECT *	14✔
47	FROM emails.account_emails
48	WHERE chain_id = ${args.chainId}
49	AND safe_address = ${args.safeAddress}
50	AND account = ${args.account}`;
51	if (!email) {	14✔
52	throw new EmailAddressDoesNotExistError(	2✔
53	args.chainId,
54	args.safeAddress,
55	args.account,
56	);
57	}
58
59	return <DomainEmail>{	12✔
60	chainId: email.chain_id.toString(),
61	emailAddress: new EmailAddress(email.email_address),
62	isVerified: email.verified,
63	safeAddress: email.safe_address,
64	account: email.account,
65	verificationCode: email.verification_code,
66	verificationGeneratedOn: email.verification_code_generated_on,
67	verificationSentOn: email.verification_sent_on,
68	};
69	}
70
71	async getUnverifiedEmailsUntil(until: Date): Promise<DomainEmail[]> {
NEW 72	const emails = await this.sql<Email[]>`SELECT *	×
73	FROM emails.account_emails
74	WHERE verified is false
75	AND verification_code_generated_on < ${until}
76	ORDER by id`;
77
NEW 78	return emails.map((email) => ({	×
79	chainId: email.chain_id.toString(),
80	emailAddress: new EmailAddress(email.email_address),
81	isVerified: email.verified,
82	safeAddress: email.safe_address,
83	account: email.account,
84	verificationCode: email.verification_code,
85	verificationGeneratedOn: email.verification_code_generated_on,
86	verificationSentOn: email.verification_sent_on,
87	}));
88	}
89
90	async saveEmail(args: {
91	chainId: string;
92	safeAddress: string;
93	emailAddress: EmailAddress;
94	account: string;
95	code: string;
96	codeGenerationDate: Date;
97	}): Promise<void> {
98	return await this.sql.begin(async (sql) => {	24✔
99	await sql<Email[]>`	24✔
100	INSERT INTO emails.account_emails (chain_id, email_address, safe_address, account, verification_code,
101	verification_code_generated_on)
102	VALUES (${args.chainId}, ${args.emailAddress.value}, ${args.safeAddress}, ${args.account}, ${args.code},
103	${args.codeGenerationDate})
104	RETURNING *
105	`;
106	});
107	}
108
109	async setVerificationCode(args: {
110	chainId: string;
111	safeAddress: string;
112	account: string;
113	code: string;
114	codeGenerationDate: Date;
115	}): Promise<void> {
116	const [email] = await this.sql<Email[]>`UPDATE emails.account_emails	4✔
117	SET verification_code = ${args.code},
118	verification_code_generated_on = ${args.codeGenerationDate}
119	WHERE chain_id = ${args.chainId}
120	AND safe_address = ${args.safeAddress}
121	AND account = ${args.account}
122	RETURNING *`;
123
124	if (!email) {	4✔
125	throw new EmailAddressDoesNotExistError(	2✔
126	args.chainId,
127	args.safeAddress,
128	args.account,
129	);
130	}
131	}
132
133	async setVerificationSentDate(args: {
134	chainId: string;
135	safeAddress: string;
136	account: string;
137	sentOn: Date;
138	}): Promise<void> {
139	const [email] = await this.sql<Email[]>`UPDATE emails.account_emails	2✔
140	SET verification_sent_on = ${args.sentOn}
141	WHERE chain_id = ${args.chainId}
142	AND safe_address = ${args.safeAddress}
143	AND account = ${args.account}
144	RETURNING *`;
145
146	if (!email) {	2!
147	throw new EmailAddressDoesNotExistError(	×
148	args.chainId,
149	args.safeAddress,
150	args.account,
151	);
152	}
153	}
154
155	async verifyEmail(args: {
156	chainId: string;
157	safeAddress: string;
158	account: string;
159	}): Promise<void> {
160	const [email] = await this.sql<Email[]>`UPDATE emails.account_emails	8✔
161	SET verified = true,
162	verification_code = null
163	WHERE chain_id = ${args.chainId}
164	AND safe_address = ${args.safeAddress}
165	AND account = ${args.account}
166	RETURNING *`;
167
168	if (!email) {	8✔
169	throw new EmailAddressDoesNotExistError(	2✔
170	args.chainId,
171	args.safeAddress,
172	args.account,
173	);
174	}
175	}
176
177	async deleteEmail(args: {
178	chainId: string;
179	safeAddress: string;
180	account: string;
181	}): Promise<void> {
182	const [email] = await this.sql<Email[]>`DELETE	4✔
183	FROM emails.account_emails
184	WHERE chain_id = ${args.chainId}
185	AND safe_address = ${args.safeAddress}
186	AND account = ${args.account}
187	RETURNING *`;
188
189	if (!email) {	4✔
190	throw new EmailAddressDoesNotExistError(	2✔
191	args.chainId,
192	args.safeAddress,
193	args.account,
194	);
195	}
196	}
197
198	async updateEmail(args: {
199	chainId: string;
200	safeAddress: string;
201	emailAddress: EmailAddress;
202	account: string;
203	code: string;
204	codeGenerationDate: Date;
205	}): Promise<void> {
206	const [email] = await this.sql<Email[]>`UPDATE emails.account_emails	6✔
207	SET email_address = ${args.emailAddress.value},
208	verified = false,
209	verification_code = ${args.code},
210	verification_code_generated_on = ${args.codeGenerationDate}
211	WHERE chain_id = ${args.chainId}
212	AND safe_address = ${args.safeAddress}
213	AND account = ${args.account}
214	RETURNING *`;
215
216	if (!email) {	6✔
217	throw new EmailAddressDoesNotExistError(	2✔
218	args.chainId,
219	args.safeAddress,
220	args.account,
221	);
222	}
223	}
224	}

safe-global / safe-client-gateway / 7300367128

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