6600141503

Committed 21 Oct 2023 11:01PM UTC coverage: 90.939% (-0.3%) from 91.209%

Build # 6600141503

Build Type

push

github

Committed by

fmrsabino

Commit Message

Wip

Run Details

1329 of 1587 branches covered (0.0%)

Branch coverage included in aggregate %.

17 of 45 new or added lines in 5 files covered. (37.78%)

4 existing lines in 1 file now uncovered.

4843 of 5200 relevant lines covered (93.13%)

153.1 hits per line

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

10.81

/src/datasources/email/email.repository.ts

import { Inject, Injectable } from '@nestjs/common';
import * as postgres from 'postgres';

interface Email {
  id: number;
  chain_id: number;
  email_address: string;
  safe_address: string;
  signer: string;
  verified: boolean;
}

interface VerificationStatus {
  id: number;
  verification_code: string;
  sent_on: Date;
}

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

  async saveEmail(args: {
    chainId: string;
    safeAddress: string;
    emailAddress: string;
    signer: string;
  }): Promise<{ emailAddress: string; verificationCode: string }> {
    return await this.sql.begin(async (sql) => {
      const [email] = await sql<Email[]>`
          INSERT INTO emails.signer_emails (chain_id, email_address, safe_address, signer)
          VALUES (${args.chainId}, ${args.emailAddress}, ${args.safeAddress}, ${args.signer})
          RETURNING *
      `;

      // TODO proper code generation
      const code = Math.floor(Math.random() * 100_000);

      const [verificationCode] = await sql<VerificationStatus[]>`
          INSERT INTO emails.verification (id, verification_code)
          VALUES (${email.id}, ${code})
          RETURNING *
      `;

      return {
        emailAddress: email.email_address,
        verificationCode: verificationCode.verification_code,
      };
    });
  }

  // TODO this call should be throttled
  async updateVerificationCode(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
  }) {
    const code = Math.floor(Math.random() * 100_000);

    const [email] = await this.sql<Email[]>`SELECT *
                                            FROM emails.signer_emails
                                            WHERE chain_id = ${args.chainId}
                                              and safe_address = ${args.safeAddress}
                                              and signer = ${args.signer}
    `;

    if (!email) {
      // TODO different error since this exposes the non-existence of an email address
      throw new Error('Email address does not exist');
    }

    if (email.verified) {
      throw new Error('Email is already verified');
    }

    const [verificationCode] = await this.sql<VerificationStatus[]>`
        INSERT INTO emails.verification (id, verification_code)
        VALUES (${email.id}, ${code})
        ON CONFLICT (id) DO UPDATE SET verification_code = ${code},
                                       sent_on           = now()
        RETURNING *
    `;

    return {
      emailAddress: email.email_address,
      verificationCode: verificationCode.verification_code,
    };
  }

  async verifyEmail(args: {
    chainId: string;
    safeAddress: string;
    signer: string;
    code: string;
  }) {
    return await this.sql.begin(async (sql) => {
      const [email] = await this.sql`SELECT id
                                     FROM emails.signer_emails
                                     WHERE chain_id = ${args.chainId}
                                       and safe_address = ${args.safeAddress}
                                       and signer = ${args.signer}
      `;

      // Get verification status for that email. Provided code needs to match
      const [verificationStatus] = await this.sql<VerificationStatus[]>`SELECT *
                                                                        from emails.verification
                                                                        WHERE id = ${email.id}
                                                                          and verification_code = ${args.code}`;

      if (!verificationStatus) {
        throw Error('Invalid verification code');
      }

      // TODO date comparison
      const date = new Date();
      const dateUtc = Date.UTC(
        date.getUTCFullYear(),
        date.getUTCMonth(),
        date.getUTCDate(),
        date.getUTCHours(),
        date.getUTCMinutes(),
        date.getUTCSeconds(),
      );
      const timeDiffSeconds =
        (dateUtc - verificationStatus.sent_on.getTime()) / 1_000;

      if (timeDiffSeconds > 20) {
        throw Error('Code is no longer invalid. Please request new one');
      }

      // Deletes email verification entry
      await this.sql`DELETE
                     FROM emails.verification
                     WHERE id = ${email.id}
      `;

      // Sets email as verified
      await sql`
          UPDATE emails.signer_emails
          SET verified = true
          WHERE id = ${email.id}
      `;
    });
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	54✔
2	import * as postgres from 'postgres';	54✔
3
4	interface Email {
5	id: number;
6	chain_id: number;
7	email_address: string;
8	safe_address: string;
9	signer: string;
10	verified: boolean;
11	}
12
13	interface VerificationStatus {
14	id: number;
15	verification_code: string;
16	sent_on: Date;
17	}
18
19	@Injectable()
20	export class EmailRepository {	54✔
21	constructor(@Inject('DB_INSTANCE') private readonly sql: postgres.Sql) {}	434✔
22
23	async saveEmail(args: {
24	chainId: string;
25	safeAddress: string;
26	emailAddress: string;
27	signer: string;
28	}): Promise<{ emailAddress: string; verificationCode: string }> {
NEW 29	return await this.sql.begin(async (sql) => {	×
NEW 30	const [email] = await sql<Email[]>`	×
31	INSERT INTO emails.signer_emails (chain_id, email_address, safe_address, signer)
32	VALUES (${args.chainId}, ${args.emailAddress}, ${args.safeAddress}, ${args.signer})
33	RETURNING *
34	`;
35
36	// TODO proper code generation
NEW 37	const code = Math.floor(Math.random() * 100_000);	×
38
NEW 39	const [verificationCode] = await sql<VerificationStatus[]>`	×
40	INSERT INTO emails.verification (id, verification_code)
41	VALUES (${email.id}, ${code})
42	RETURNING *
43	`;
44
NEW 45	return {	×
46	emailAddress: email.email_address,
47	verificationCode: verificationCode.verification_code,
48	};
49	});
50	}
51
52	// TODO this call should be throttled
53	async updateVerificationCode(args: {
54	chainId: string;
55	safeAddress: string;
56	signer: string;
57	}) {
NEW 58	const code = Math.floor(Math.random() * 100_000);	×
59
NEW 60	const [email] = await this.sql<Email[]>`SELECT *	×
61	FROM emails.signer_emails
62	WHERE chain_id = ${args.chainId}
63	and safe_address = ${args.safeAddress}
64	and signer = ${args.signer}
65	`;
66
NEW 67	if (!email) {	×
68	// TODO different error since this exposes the non-existence of an email address
NEW 69	throw new Error('Email address does not exist');	×
70	}
71
NEW 72	if (email.verified) {	×
NEW 73	throw new Error('Email is already verified');	×
74	}
75
NEW 76	const [verificationCode] = await this.sql<VerificationStatus[]>`	×
77	INSERT INTO emails.verification (id, verification_code)
78	VALUES (${email.id}, ${code})
79	ON CONFLICT (id) DO UPDATE SET verification_code = ${code},
80	sent_on = now()
81	RETURNING *
82	`;
83
NEW 84	return {	×
85	emailAddress: email.email_address,
86	verificationCode: verificationCode.verification_code,
87	};
88	}
89
90	async verifyEmail(args: {
91	chainId: string;
92	safeAddress: string;
93	signer: string;
94	code: string;
95	}) {
NEW 96	return await this.sql.begin(async (sql) => {	×
NEW 97	const [email] = await this.sql`SELECT id	×
98	FROM emails.signer_emails
99	WHERE chain_id = ${args.chainId}
100	and safe_address = ${args.safeAddress}
101	and signer = ${args.signer}
102	`;
103
104	// Get verification status for that email. Provided code needs to match
NEW 105	const [verificationStatus] = await this.sql<VerificationStatus[]>`SELECT *	×
106	from emails.verification
107	WHERE id = ${email.id}
108	and verification_code = ${args.code}`;
109
NEW 110	if (!verificationStatus) {	×
NEW 111	throw Error('Invalid verification code');	×
112	}
113
114	// TODO date comparison
NEW 115	const date = new Date();	×
NEW 116	const dateUtc = Date.UTC(	×
117	date.getUTCFullYear(),
118	date.getUTCMonth(),
119	date.getUTCDate(),
120	date.getUTCHours(),
121	date.getUTCMinutes(),
122	date.getUTCSeconds(),
123	);
124	const timeDiffSeconds =
NEW 125	(dateUtc - verificationStatus.sent_on.getTime()) / 1_000;	×
126
NEW 127	if (timeDiffSeconds > 20) {	×
NEW 128	throw Error('Code is no longer invalid. Please request new one');	×
129	}
130
131	// Deletes email verification entry
NEW 132	await this.sql`DELETE	×
133	FROM emails.verification
134	WHERE id = ${email.id}
135	`;
136
137	// Sets email as verified
NEW 138	await sql`	×
139	UPDATE emails.signer_emails
140	SET verified = true
141	WHERE id = ${email.id}
142	`;
143	});
144	}
145	}

safe-global / safe-client-gateway / 6600141503

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