10723772953

Committed 05 Sep 2024 03:37PM UTC coverage: 45.927% (+0.03%) from 45.895%

Build # 10723772953

Build Type

push

github

Committed by

hectorgomezv

Commit Message

Use CreateAccountDto on Accounts repository and datasource

Run Details

501 of 3180 branches covered (15.75%)

Branch coverage included in aggregate %.

2 of 10 new or added lines in 2 files covered. (20.0%)

2 existing lines in 1 file now uncovered.

4844 of 8458 relevant lines covered (57.27%)

12.16 hits per line

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

18.39

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

import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { MAX_TTL } from '@/datasources/cache/constants';
import { CachedQueryResolver } from '@/datasources/db/cached-query-resolver';
import { ICachedQueryResolver } from '@/datasources/db/cached-query-resolver.interface';
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 { CreateAccountDto } from '@/domain/accounts/entities/create-account.dto.entity';
import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
import { AccountsCreationRateLimitError } from '@/domain/accounts/errors/accounts-creation-rate-limit.error';
import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { asError } from '@/logging/utils';
import { IpSchema } from '@/validation/entities/schemas/ip.schema';
import {
  Inject,
  Injectable,
  NotFoundException,
  OnModuleInit,
  UnprocessableEntityException,
} from '@nestjs/common';
import crypto from 'crypto';
import { omit } from 'lodash';
import postgres from 'postgres';

@Injectable()
export class AccountsDatasource implements IAccountsDatasource, OnModuleInit {
  private static readonly ACCOUNT_CREATION_CACHE_PREFIX = 'account_creation';
  private readonly defaultExpirationTimeInSeconds: number;
  // Number of seconds for each rate-limit cycle
  private readonly accountCreationRateLimitPeriodSeconds: number;
  // Number of allowed calls on each rate-limit cycle
  private readonly accountCreationRateLimitCalls: number;

  constructor(
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject('DB_INSTANCE') private readonly sql: postgres.Sql,
    @Inject(ICachedQueryResolver)
    private readonly cachedQueryResolver: CachedQueryResolver,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.accountCreationRateLimitPeriodSeconds =
      configurationService.getOrThrow(
        'accounts.creationRateLimitPeriodSeconds',
      );
    this.accountCreationRateLimitCalls = configurationService.getOrThrow(
      'accounts.creationRateLimitCalls',
    );
  }

  /**
   * Function executed when the module is initialized.
   * It deletes the cache for persistent keys.
   */
  async onModuleInit(): Promise<void> {
    await this.cacheService.deleteByKey(
      CacheRouter.getAccountDataTypesCacheDir().key,
    );
  }

  async createAccount(args: {
    createAccountDto: CreateAccountDto;
    clientIp: string;
  }): Promise<Account> {
    await this.checkCreationRateLimit(args.clientIp);
    const { address, name } = args.createAccountDto;
    // TODO: compute the hash
    const nameHash = crypto.randomBytes(32).toString('hex');
    // TODO: encrypt the name
    const [account] = await this.sql<[Account]>`
      INSERT INTO accounts (address, name, name_hash)
        VALUES (${address}, ${name}, ${nameHash})
      RETURNING *
      `.catch((e) => {
      this.loggingService.warn(`Error creating account: ${asError(e).message}`);
      throw new UnprocessableEntityException('Error creating account.');
    });
    const cacheDir = CacheRouter.getAccountCacheDir(address);
    // TODO: decrypt the name
    const result = omit({ ...account, name }, 'name_hash');
    await this.cacheService.set(
      cacheDir,
      JSON.stringify([result]),
      this.defaultExpirationTimeInSeconds,
    );
    return result;
  }

  async getAccount(address: `0x${string}`): Promise<Account> {
    const cacheDir = CacheRouter.getAccountCacheDir(address);
    const [account] = await this.cachedQueryResolver.get<Account[]>({
      cacheDir,
      query: this.sql`SELECT * FROM accounts WHERE address = ${address}`,
      ttl: this.defaultExpirationTimeInSeconds,
    });

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

    return account;
  }

  async deleteAccount(address: `0x${string}`): Promise<void> {
    try {
      const { count } = await this
        .sql`DELETE FROM accounts WHERE address = ${address}`;
      if (count === 0) {
        this.loggingService.debug(
          `Error deleting account ${address}: not found`,
        );
      }
    } finally {
      const keys = [
        CacheRouter.getAccountCacheDir(address).key,
        CacheRouter.getAccountDataSettingsCacheDir(address).key,
        CacheRouter.getCounterfactualSafesCacheDir(address).key,
      ];
      await Promise.all(keys.map((key) => this.cacheService.deleteByKey(key)));
    }
  }

  async getDataTypes(): Promise<AccountDataType[]> {
    const cacheDir = CacheRouter.getAccountDataTypesCacheDir();
    return this.cachedQueryResolver.get<AccountDataType[]>({
      cacheDir,
      query: this.sql`SELECT * FROM account_data_types`,
      ttl: MAX_TTL,
    });
  }

  async getAccountDataSettings(
    address: `0x${string}`,
  ): Promise<AccountDataSetting[]> {
    const account = await this.getAccount(address);
    const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(address);
    return this.cachedQueryResolver.get<AccountDataSetting[]>({
      cacheDir,
      query: this.sql`
        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;`,
      ttl: this.defaultExpirationTimeInSeconds,
    });
  }

  /**
   * 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(args: {
    address: `0x${string}`;
    upsertAccountDataSettingsDto: UpsertAccountDataSettingsDto;
  }): Promise<AccountDataSetting[]> {
    const { accountDataSettings } = args.upsertAccountDataSettingsDto;
    await this.checkDataTypes(accountDataSettings);
    const account = await this.getAccount(args.address);

    const result = await 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.dataTypeId}, ${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}`;
    });

    const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(args.address);
    await this.cacheService.set(
      cacheDir,
      JSON.stringify(result),
      this.defaultExpirationTimeInSeconds,
    );
    return result;
  }

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

  /**
   * Checks if the client IP address has reached the account creation rate limit.
   *
   * NOTE: the rate limit is implemented in the datasource layer for this use case
   * because we need to restrict the actual creation of accounts, not merely
   * the attempts to create them.
   *
   * If the client IP address is invalid, a warning is logged.
   * If the client IP address is valid and rate limit is reached, a {@link AccountsCreationRateLimitError} is thrown.
   *
   * @param clientIp - client IP address.
   */
  private async checkCreationRateLimit(clientIp: string): Promise<void> {
    const { success: isValidIp } = IpSchema.safeParse(clientIp);
    if (!clientIp || !isValidIp) {
      this.loggingService.warn(
        `Invalid client IP while creating account: ${clientIp}`,
      );
    } else {
      const current = await this.cacheService.increment(
        CacheRouter.getRateLimitCacheKey(
          `${AccountsDatasource.ACCOUNT_CREATION_CACHE_PREFIX}_${clientIp}`,
        ),
        this.accountCreationRateLimitPeriodSeconds,
      );
      if (current > this.accountCreationRateLimitCalls) {
        this.loggingService.warn(
          `Limit of ${this.accountCreationRateLimitCalls} reached for IP ${clientIp}`,
        );
        throw new AccountsCreationRateLimitError();
      }
    }
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
2	import { CacheRouter } from '@/datasources/cache/cache.router';	16✔
3	import {	16✔
4	CacheService,
5	ICacheService,
6	} from '@/datasources/cache/cache.service.interface';
7	import { MAX_TTL } from '@/datasources/cache/constants';	16✔
8	import { CachedQueryResolver } from '@/datasources/db/cached-query-resolver';	16✔
9	import { ICachedQueryResolver } from '@/datasources/db/cached-query-resolver.interface';	16✔
10	import { AccountDataSetting } from '@/domain/accounts/entities/account-data-setting.entity';
11	import { AccountDataType } from '@/domain/accounts/entities/account-data-type.entity';
12	import { Account } from '@/domain/accounts/entities/account.entity';
13	import { CreateAccountDto } from '@/domain/accounts/entities/create-account.dto.entity';
14	import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
15	import { AccountsCreationRateLimitError } from '@/domain/accounts/errors/accounts-creation-rate-limit.error';	16✔
16	import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
17	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
18	import { asError } from '@/logging/utils';	16✔
19	import { IpSchema } from '@/validation/entities/schemas/ip.schema';	16✔
20	import {	16✔
21	Inject,
22	Injectable,
23	NotFoundException,
24	OnModuleInit,
25	UnprocessableEntityException,
26	} from '@nestjs/common';
27	import crypto from 'crypto';	16✔
28	import { omit } from 'lodash';	16✔
29	import postgres from 'postgres';	16✔
30
31	@Injectable()
32	export class AccountsDatasource implements IAccountsDatasource, OnModuleInit {	16✔
33	private static readonly ACCOUNT_CREATION_CACHE_PREFIX = 'account_creation';	16✔
34	private readonly defaultExpirationTimeInSeconds: number;
35	// Number of seconds for each rate-limit cycle
36	private readonly accountCreationRateLimitPeriodSeconds: number;
37	// Number of allowed calls on each rate-limit cycle
38	private readonly accountCreationRateLimitCalls: number;
39
40	constructor(
41	@Inject(CacheService) private readonly cacheService: ICacheService,	×
42	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	×
43	@Inject(ICachedQueryResolver)
44	private readonly cachedQueryResolver: CachedQueryResolver,	×
45	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
46	@Inject(IConfigurationService)
47	private readonly configurationService: IConfigurationService,	×
48	) {
49	this.defaultExpirationTimeInSeconds =	×
50	this.configurationService.getOrThrow<number>(
51	'expirationTimeInSeconds.default',
52	);
53	this.accountCreationRateLimitPeriodSeconds =	×
54	configurationService.getOrThrow(
55	'accounts.creationRateLimitPeriodSeconds',
56	);
57	this.accountCreationRateLimitCalls = configurationService.getOrThrow(	×
58	'accounts.creationRateLimitCalls',
59	);
60	}
61
62	/**
63	* Function executed when the module is initialized.
64	* It deletes the cache for persistent keys.
65	*/
66	async onModuleInit(): Promise<void> {
67	await this.cacheService.deleteByKey(	×
68	CacheRouter.getAccountDataTypesCacheDir().key,
69	);
70	}
71
72	async createAccount(args: {
73	createAccountDto: CreateAccountDto;
74	clientIp: string;
75	}): Promise<Account> {
76	await this.checkCreationRateLimit(args.clientIp);	×
NEW 77	const { address, name } = args.createAccountDto;	×
78	// TODO: compute the hash
NEW 79	const nameHash = crypto.randomBytes(32).toString('hex');	×
80	// TODO: encrypt the name
UNCOV 81	const [account] = await this.sql<[Account]>`	×
82	INSERT INTO accounts (address, name, name_hash)
83	VALUES (${address}, ${name}, ${nameHash})
84	RETURNING *
85	`.catch((e) => {
NEW 86	this.loggingService.warn(`Error creating account: ${asError(e).message}`);	×
NEW 87	throw new UnprocessableEntityException('Error creating account.');	×
88	});
NEW 89	const cacheDir = CacheRouter.getAccountCacheDir(address);	×
90	// TODO: decrypt the name
NEW 91	const result = omit({ ...account, name }, 'name_hash');	×
UNCOV 92	await this.cacheService.set(	×
93	cacheDir,
94	JSON.stringify([result]),
95	this.defaultExpirationTimeInSeconds,
96	);
NEW 97	return result;	×
98	}
99
100	async getAccount(address: `0x${string}`): Promise<Account> {
101	const cacheDir = CacheRouter.getAccountCacheDir(address);	×
102	const [account] = await this.cachedQueryResolver.get<Account[]>({	×
103	cacheDir,
104	query: this.sql`SELECT * FROM accounts WHERE address = ${address}`,
105	ttl: this.defaultExpirationTimeInSeconds,
106	});
107
108	if (!account) {	×
109	throw new NotFoundException('Error getting account.');	×
110	}
111
112	return account;	×
113	}
114
115	async deleteAccount(address: `0x${string}`): Promise<void> {
116	try {	×
117	const { count } = await this	×
118	.sql`DELETE FROM accounts WHERE address = ${address}`;
119	if (count === 0) {	×
120	this.loggingService.debug(	×
121	`Error deleting account ${address}: not found`,
122	);
123	}
124	} finally {
125	const keys = [	×
126	CacheRouter.getAccountCacheDir(address).key,
127	CacheRouter.getAccountDataSettingsCacheDir(address).key,
128	CacheRouter.getCounterfactualSafesCacheDir(address).key,
129	];
130	await Promise.all(keys.map((key) => this.cacheService.deleteByKey(key)));	×
131	}
132	}
133
134	async getDataTypes(): Promise<AccountDataType[]> {
135	const cacheDir = CacheRouter.getAccountDataTypesCacheDir();	×
136	return this.cachedQueryResolver.get<AccountDataType[]>({	×
137	cacheDir,
138	query: this.sql`SELECT * FROM account_data_types`,
139	ttl: MAX_TTL,
140	});
141	}
142
143	async getAccountDataSettings(
144	address: `0x${string}`,
145	): Promise<AccountDataSetting[]> {
146	const account = await this.getAccount(address);	×
147	const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(address);	×
148	return this.cachedQueryResolver.get<AccountDataSetting[]>({	×
149	cacheDir,
150	query: this.sql`
151	SELECT ads.* FROM account_data_settings ads
152	INNER JOIN account_data_types adt ON ads.account_data_type_id = adt.id
153	WHERE ads.account_id = ${account.id} AND adt.is_active IS TRUE;`,
154	ttl: this.defaultExpirationTimeInSeconds,
155	});
156	}
157
158	/**
159	* Adds or updates the existing account data settings for a given address/account.
160	* Requirements:
161	* - The account must exist.
162	* - The data type must exist.
163	* - The data type must be active.
164	*
165	* @param address - account address.
166	* @param upsertAccountDataSettings {@link UpsertAccountDataSettingsDto} object.
167	* @returns {Array<AccountDataSetting>} inserted account data settings.
168	*/
169	async upsertAccountDataSettings(args: {
170	address: `0x${string}`;
171	upsertAccountDataSettingsDto: UpsertAccountDataSettingsDto;
172	}): Promise<AccountDataSetting[]> {
173	const { accountDataSettings } = args.upsertAccountDataSettingsDto;	×
174	await this.checkDataTypes(accountDataSettings);	×
175	const account = await this.getAccount(args.address);	×
176
177	const result = await this.sql.begin(async (sql) => {	×
178	await Promise.all(	×
179	accountDataSettings.map(async (accountDataSetting) => {
180	return sql`	×
181	INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
182	VALUES (${account.id}, ${accountDataSetting.dataTypeId}, ${accountDataSetting.enabled})
183	ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
184	`.catch((e) => {
185	throw new UnprocessableEntityException(	×
186	`Error updating data settings: ${asError(e).message}`,
187	);
188	});
189	}),
190	);
191	return sql<[AccountDataSetting]>`	×
192	SELECT * FROM account_data_settings WHERE account_id = ${account.id}`;
193	});
194
195	const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(args.address);	×
196	await this.cacheService.set(	×
197	cacheDir,
198	JSON.stringify(result),
199	this.defaultExpirationTimeInSeconds,
200	);
201	return result;	×
202	}
203
204	private async checkDataTypes(
205	accountDataSettings: UpsertAccountDataSettingsDto['accountDataSettings'],
206	): Promise<void> {
207	const dataTypes = await this.getDataTypes();	×
208	const activeDataTypeIds = dataTypes	×
209	.filter((dt) => dt.is_active)	×
210	.map((ads) => ads.id);	×
211	if (	×
212	!accountDataSettings.every((ads) =>
213	activeDataTypeIds.includes(Number(ads.dataTypeId)),	×
214	)
215	) {
216	throw new UnprocessableEntityException(	×
217	`Data types not found or not active.`,
218	);
219	}
220	}
221
222	/**
223	* Checks if the client IP address has reached the account creation rate limit.
224	*
225	* NOTE: the rate limit is implemented in the datasource layer for this use case
226	* because we need to restrict the actual creation of accounts, not merely
227	* the attempts to create them.
228	*
229	* If the client IP address is invalid, a warning is logged.
230	* If the client IP address is valid and rate limit is reached, a {@link AccountsCreationRateLimitError} is thrown.
231	*
232	* @param clientIp - client IP address.
233	*/
234	private async checkCreationRateLimit(clientIp: string): Promise<void> {
235	const { success: isValidIp } = IpSchema.safeParse(clientIp);	×
236	if (!clientIp \|\| !isValidIp) {	×
237	this.loggingService.warn(	×
238	`Invalid client IP while creating account: ${clientIp}`,
239	);
240	} else {
241	const current = await this.cacheService.increment(	×
242	CacheRouter.getRateLimitCacheKey(
243	`${AccountsDatasource.ACCOUNT_CREATION_CACHE_PREFIX}_${clientIp}`,
244	),
245	this.accountCreationRateLimitPeriodSeconds,
246	);
247	if (current > this.accountCreationRateLimitCalls) {	×
248	this.loggingService.warn(	×
249	`Limit of ${this.accountCreationRateLimitCalls} reached for IP ${clientIp}`,
250	);
251	throw new AccountsCreationRateLimitError();	×
252	}
253	}
254	}
255	}

safe-global / safe-client-gateway / 10723772953

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