9858819355

Committed 09 Jul 2024 02:20PM UTC coverage: 48.124% (-0.1%) from 48.237%

Build # 9858819355

Build Type

push

github

Committed by

web-flow

Commit Message

Implement PUT /v1/accounts/:address/data-settings (#1715)

- The endpoint PUT /v1/accounts/:address/data-settings was added to AccountsController, protected by AuthGuard.
- Associated tests and domain classes were added.

Run Details

412 of 2597 branches covered (15.86%)

Branch coverage included in aggregate %.

22 of 58 new or added lines in 9 files covered. (37.93%)

2 existing lines in 2 files now uncovered.

4244 of 7078 relevant lines covered (59.96%)

13.05 hits per line

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

10.64

/src/datasources/accounts/accounts.datasource.ts

import { AccountDataSetting } from '@/domain/accounts/entities/account-data-setting.entity';
import { AccountDataType } from '@/domain/accounts/entities/account-data-type.entity';
import { Account } from '@/domain/accounts/entities/account.entity';
import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { asError } from '@/logging/utils';
import {
  Inject,
  Injectable,
  NotFoundException,
  UnprocessableEntityException,
} from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
export class AccountsDatasource implements IAccountsDatasource {
  constructor(
    @Inject('DB_INSTANCE') private readonly sql: postgres.Sql,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {}

  async createAccount(address: `0x${string}`): Promise<Account> {
    const [account] = await this.sql<
      [Account]
    >`INSERT INTO accounts (address) VALUES (${address}) RETURNING *`.catch(
      (e) => {
        this.loggingService.warn(
          `Error creating account: ${asError(e).message}`,
        );
        return [];
      },
    );

    if (!account) {
      throw new UnprocessableEntityException('Error creating account.');
    }

    return account;
  }

  async getAccount(address: `0x${string}`): Promise<Account> {
    const [account] = await this.sql<
      [Account]
    >`SELECT * FROM accounts WHERE address = ${address}`.catch((e) => {
      this.loggingService.info(`Error getting account: ${asError(e).message}`);
      return [];
    });

    if (!account) {
      throw new NotFoundException('Error getting account.');
    }

    return account;
  }

  async deleteAccount(address: `0x${string}`): Promise<void> {
    const { count } = await this
      .sql`DELETE FROM accounts WHERE address = ${address}`;

    if (count === 0) {
      this.loggingService.debug(`Error deleting account ${address}: not found`);
    }
  }

  async getDataTypes(): Promise<AccountDataType[]> {
    // TODO: add caching with clearing mechanism.
    return this.sql<[AccountDataType]>`SELECT * FROM account_data_types`;
  }

  async getAccountDataSettings(
    address: `0x${string}`,
  ): Promise<AccountDataSetting[]> {
    const account = await this.getAccount(address);
    return this.sql<[AccountDataSetting]>`
      SELECT * FROM account_data_settings WHERE account_id = ${account.id}
    `;
  }

  /**
   * Adds or updates the existing account data settings for a given address/account.
   * Requirements:
   * - The account must exist.
   * - The data type must exist.
   * - The data type must be active.
   *
   * @param address - account address.
   * @param upsertAccountDataSettings {@link UpsertAccountDataSettingsDto} object.
   * @returns {Array<AccountDataSetting>} inserted account data settings.
   */
  async upsertAccountDataSettings(
    address: `0x${string}`,
    upsertAccountDataSettings: UpsertAccountDataSettingsDto,
  ): Promise<AccountDataSetting[]> {
    const { accountDataSettings } = upsertAccountDataSettings;
    await this.checkDataTypes(accountDataSettings);
    const account = await this.getAccount(address);
    return this.sql.begin(async (sql) => {
      await Promise.all(
        accountDataSettings.map(async (accountDataSetting) => {
          return sql`
            INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
            VALUES (${account.id}, ${accountDataSetting.id}, ${accountDataSetting.enabled})
            ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
          `.catch((e) => {
            throw new UnprocessableEntityException(
              `Error updating data settings: ${asError(e).message}`,
            );
          });
        }),
      );
      return sql<[AccountDataSetting]>`
        SELECT * FROM account_data_settings WHERE account_id = ${account.id}`;
    });
  }

  private getActiveDataTypes(): Promise<AccountDataType[]> {
    // TODO: add caching with clearing mechanism.
    return this.sql<[AccountDataType]>`
      SELECT * FROM account_data_types WHERE is_active = true
    `;
  }

  private async checkDataTypes(
    accountDataSettings: UpsertAccountDataSettingsDto['accountDataSettings'],
  ): Promise<void> {
    const activeDataTypes = await this.getActiveDataTypes();
    const activeDataTypeIds = activeDataTypes.map((ads) => ads.id);
    if (
      !accountDataSettings.every((ads) =>
        activeDataTypeIds.includes(Number(ads.id)),
      )
    ) {
      throw new UnprocessableEntityException(
        `Data types not found or not active.`,
      );
    }
  }
}

1	import { AccountDataSetting } from '@/domain/accounts/entities/account-data-setting.entity';
2	import { AccountDataType } from '@/domain/accounts/entities/account-data-type.entity';
3	import { Account } from '@/domain/accounts/entities/account.entity';
4	import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
5	import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
6	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
7	import { asError } from '@/logging/utils';	16✔
8	import {	16✔
9	Inject,
10	Injectable,
11	NotFoundException,
12	UnprocessableEntityException,
13	} from '@nestjs/common';
14	import postgres from 'postgres';	16✔
15
16	@Injectable()
17	export class AccountsDatasource implements IAccountsDatasource {	16✔
18	constructor(
19	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	×
20	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
21	) {}
22
23	async createAccount(address: `0x${string}`): Promise<Account> {
24	const [account] = await this.sql<	×
25	[Account]
26	>`INSERT INTO accounts (address) VALUES (${address}) RETURNING *`.catch(
27	(e) => {
28	this.loggingService.warn(	×
29	`Error creating account: ${asError(e).message}`,
30	);
31	return [];	×
32	},
33	);
34
35	if (!account) {	×
36	throw new UnprocessableEntityException('Error creating account.');	×
37	}
38
39	return account;	×
40	}
41
42	async getAccount(address: `0x${string}`): Promise<Account> {
43	const [account] = await this.sql<	×
44	[Account]
45	>`SELECT * FROM accounts WHERE address = ${address}`.catch((e) => {
46	this.loggingService.info(`Error getting account: ${asError(e).message}`);	×
47	return [];	×
48	});
49
50	if (!account) {	×
51	throw new NotFoundException('Error getting account.');	×
52	}
53
54	return account;	×
55	}
56
57	async deleteAccount(address: `0x${string}`): Promise<void> {
58	const { count } = await this	×
59	.sql`DELETE FROM accounts WHERE address = ${address}`;
60
61	if (count === 0) {	×
62	this.loggingService.debug(`Error deleting account ${address}: not found`);	×
63	}
64	}
65
66	async getDataTypes(): Promise<AccountDataType[]> {
67	// TODO: add caching with clearing mechanism.
UNCOV 68	return this.sql<[AccountDataType]>`SELECT * FROM account_data_types`;	×
69	}
70
71	async getAccountDataSettings(
72	address: `0x${string}`,
73	): Promise<AccountDataSetting[]> {
NEW 74	const account = await this.getAccount(address);	×
NEW 75	return this.sql<[AccountDataSetting]>`	×
76	SELECT * FROM account_data_settings WHERE account_id = ${account.id}
77	`;
78	}
79
80	/**
81	* Adds or updates the existing account data settings for a given address/account.
82	* Requirements:
83	* - The account must exist.
84	* - The data type must exist.
85	* - The data type must be active.
86	*
87	* @param address - account address.
88	* @param upsertAccountDataSettings {@link UpsertAccountDataSettingsDto} object.
89	* @returns {Array<AccountDataSetting>} inserted account data settings.
90	*/
91	async upsertAccountDataSettings(
92	address: `0x${string}`,
93	upsertAccountDataSettings: UpsertAccountDataSettingsDto,
94	): Promise<AccountDataSetting[]> {
NEW 95	const { accountDataSettings } = upsertAccountDataSettings;	×
NEW 96	await this.checkDataTypes(accountDataSettings);	×
NEW 97	const account = await this.getAccount(address);	×
NEW 98	return this.sql.begin(async (sql) => {	×
NEW 99	await Promise.all(	×
100	accountDataSettings.map(async (accountDataSetting) => {
NEW 101	return sql`	×
102	INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
103	VALUES (${account.id}, ${accountDataSetting.id}, ${accountDataSetting.enabled})
104	ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
105	`.catch((e) => {
NEW 106	throw new UnprocessableEntityException(	×
107	`Error updating data settings: ${asError(e).message}`,
108	);
109	});
110	}),
111	);
NEW 112	return sql<[AccountDataSetting]>`	×
113	SELECT * FROM account_data_settings WHERE account_id = ${account.id}`;
114	});
115	}
116
117	private getActiveDataTypes(): Promise<AccountDataType[]> {
118	// TODO: add caching with clearing mechanism.
NEW 119	return this.sql<[AccountDataType]>`	×
120	SELECT * FROM account_data_types WHERE is_active = true
121	`;
122	}
123
124	private async checkDataTypes(
125	accountDataSettings: UpsertAccountDataSettingsDto['accountDataSettings'],
126	): Promise<void> {
NEW 127	const activeDataTypes = await this.getActiveDataTypes();	×
NEW 128	const activeDataTypeIds = activeDataTypes.map((ads) => ads.id);	×
NEW 129	if (	×
130	!accountDataSettings.every((ads) =>
NEW 131	activeDataTypeIds.includes(Number(ads.id)),	×
132	)
133	) {
NEW 134	throw new UnprocessableEntityException(	×
135	`Data types not found or not active.`,
136	);
137	}
138	}
139	}

safe-global / safe-client-gateway / 9858819355

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