9877597641

Committed 10 Jul 2024 04:03PM UTC coverage: 48.085% (-0.04%) from 48.124%

Build # 9877597641

Build Type

push

github

Committed by

web-flow

Commit Message

Rename AccountDataType.dataTypeId to AccountDataType.id (#1751)

- Rename `AccountDataType.dataTypeId` to `AccountDataType.id`.

Run Details

412 of 2599 branches covered (15.85%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 1 file covered. (50.0%)

32 existing lines in 4 files now uncovered.

4245 of 7086 relevant lines covered (59.91%)

13.07 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 ads.* FROM account_data_settings ads INNER JOIN account_data_types adt
        ON ads.account_data_type_id = adt.id
      WHERE ads.account_id = ${account.id} AND adt.is_active IS TRUE;
    `;
  }

  /**
   * 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 IS 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.
68	return this.sql<[AccountDataType]>`SELECT * FROM account_data_types`;	×
69	}
70
71	async getAccountDataSettings(
72	address: `0x${string}`,
73	): Promise<AccountDataSetting[]> {
74	const account = await this.getAccount(address);	×
75	return this.sql<[AccountDataSetting]>`	×
76	SELECT ads.* FROM account_data_settings ads INNER JOIN account_data_types adt
77	ON ads.account_data_type_id = adt.id
78	WHERE ads.account_id = ${account.id} AND adt.is_active IS TRUE;
79	`;
80	}
81
82	/**
83	* Adds or updates the existing account data settings for a given address/account.
84	* Requirements:
85	* - The account must exist.
86	* - The data type must exist.
87	* - The data type must be active.
88	*
89	* @param address - account address.
90	* @param upsertAccountDataSettings {@link UpsertAccountDataSettingsDto} object.
91	* @returns {Array<AccountDataSetting>} inserted account data settings.
92	*/
93	async upsertAccountDataSettings(
94	address: `0x${string}`,
95	upsertAccountDataSettings: UpsertAccountDataSettingsDto,
96	): Promise<AccountDataSetting[]> {
97	const { accountDataSettings } = upsertAccountDataSettings;	×
98	await this.checkDataTypes(accountDataSettings);	×
99	const account = await this.getAccount(address);	×
UNCOV 100	return this.sql.begin(async (sql) => {	×
101	await Promise.all(	×
102	accountDataSettings.map(async (accountDataSetting) => {
UNCOV 103	return sql`	×
104	INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
105	VALUES (${account.id}, ${accountDataSetting.id}, ${accountDataSetting.enabled})
106	ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
107	`.catch((e) => {
UNCOV 108	throw new UnprocessableEntityException(	×
109	`Error updating data settings: ${asError(e).message}`,
110	);
111	});
112	}),
113	);
UNCOV 114	return sql<[AccountDataSetting]>`	×
115	SELECT * FROM account_data_settings WHERE account_id = ${account.id}`;
116	});
117	}
118
119	private getActiveDataTypes(): Promise<AccountDataType[]> {
120	// TODO: add caching with clearing mechanism.
UNCOV 121	return this.sql<[AccountDataType]>`	×
122	SELECT * FROM account_data_types WHERE is_active IS TRUE;
123	`;
124	}
125
126	private async checkDataTypes(
127	accountDataSettings: UpsertAccountDataSettingsDto['accountDataSettings'],
128	): Promise<void> {
129	const activeDataTypes = await this.getActiveDataTypes();	×
UNCOV 130	const activeDataTypeIds = activeDataTypes.map((ads) => ads.id);	×
131	if (	×
132	!accountDataSettings.every((ads) =>
UNCOV 133	activeDataTypeIds.includes(Number(ads.id)),	×
134	)
135	) {
UNCOV 136	throw new UnprocessableEntityException(	×
137	`Data types not found or not active.`,
138	);
139	}
140	}
141	}

safe-global / safe-client-gateway / 9877597641

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