10062091355

Committed 23 Jul 2024 03:45PM UTC coverage: 48.47% (+0.02%) from 48.454%

Build # 10062091355

Build Type

Pull #1777

github

Committed by

hectorgomezv

Commit Message

Add TestCacheModule to PostgresDatabaseModule tests

Pull Request Pull Request #1777: Extract getFromCacheOrExecuteAndCache utility function

Run Details

437 of 2633 branches covered (16.6%)

Branch coverage included in aggregate %.

10 of 28 new or added lines in 4 files covered. (35.71%)

1 existing line in 1 file now uncovered.

4332 of 7206 relevant lines covered (60.12%)

13.04 hits per line

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

17.19

/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 { 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,
  OnModuleInit,
  UnprocessableEntityException,
} from '@nestjs/common';
import postgres from 'postgres';

@Injectable()
export class AccountsDatasource implements IAccountsDatasource, OnModuleInit {
  private readonly defaultExpirationTimeInSeconds: 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',
      );
  }

  /**
   * 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(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}`,
        );
        throw new UnprocessableEntityException('Error creating account.');
      },
    );
    const cacheDir = CacheRouter.getAccountCacheDir(address);
    await this.cacheService.set(
      cacheDir,
      JSON.stringify([account]),
      this.defaultExpirationTimeInSeconds,
    );
    return account;
  }

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

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 { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
14	import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
15	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
16	import { asError } from '@/logging/utils';	16✔
17	import {	16✔
18	Inject,
19	Injectable,
20	NotFoundException,
21	OnModuleInit,
22	UnprocessableEntityException,
23	} from '@nestjs/common';
24	import postgres from 'postgres';	16✔
25
26	@Injectable()
27	export class AccountsDatasource implements IAccountsDatasource, OnModuleInit {	16✔
28	private readonly defaultExpirationTimeInSeconds: number;
29
30	constructor(
31	@Inject(CacheService) private readonly cacheService: ICacheService,	×
32	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	×
33	@Inject(ICachedQueryResolver)
NEW 34	private readonly cachedQueryResolver: CachedQueryResolver,	×
UNCOV 35	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
36	@Inject(IConfigurationService)
37	private readonly configurationService: IConfigurationService,	×
38	) {
39	this.defaultExpirationTimeInSeconds =	×
40	this.configurationService.getOrThrow<number>(
41	'expirationTimeInSeconds.default',
42	);
43	}
44
45	/**
46	* Function executed when the module is initialized.
47	* It deletes the cache for persistent keys.
48	*/
49	async onModuleInit(): Promise<void> {
50	await this.cacheService.deleteByKey(	×
51	CacheRouter.getAccountDataTypesCacheDir().key,
52	);
53	}
54
55	async createAccount(address: `0x${string}`): Promise<Account> {
56	const [account] = await this.sql<[Account]>`	×
57	INSERT INTO accounts (address) VALUES (${address}) RETURNING *`.catch(
58	(e) => {
59	this.loggingService.warn(	×
60	`Error creating account: ${asError(e).message}`,
61	);
62	throw new UnprocessableEntityException('Error creating account.');	×
63	},
64	);
65	const cacheDir = CacheRouter.getAccountCacheDir(address);	×
66	await this.cacheService.set(	×
67	cacheDir,
68	JSON.stringify([account]),
69	this.defaultExpirationTimeInSeconds,
70	);
71	return account;	×
72	}
73
74	async getAccount(address: `0x${string}`): Promise<Account> {
75	const cacheDir = CacheRouter.getAccountCacheDir(address);	×
NEW 76	const [account] = await this.cachedQueryResolver.get<Account[]>({	×
77	cacheDir,
78	query: this.sql<
79	Account[]
80	>`SELECT * FROM accounts WHERE address = ${address}`,
81	ttl: this.defaultExpirationTimeInSeconds,
82	});
83
84	if (!account) {	×
85	throw new NotFoundException('Error getting account.');	×
86	}
87
88	return account;	×
89	}
90
91	async deleteAccount(address: `0x${string}`): Promise<void> {
92	try {	×
93	const { count } = await this	×
94	.sql`DELETE FROM accounts WHERE address = ${address}`;
95	if (count === 0) {	×
96	this.loggingService.debug(	×
97	`Error deleting account ${address}: not found`,
98	);
99	}
100	} finally {
101	const keys = [	×
102	CacheRouter.getAccountCacheDir(address).key,
103	CacheRouter.getAccountDataSettingsCacheDir(address).key,
104	CacheRouter.getCounterfactualSafesCacheDir(address).key,
105	];
106	await Promise.all(keys.map((key) => this.cacheService.deleteByKey(key)));	×
107	}
108	}
109
110	async getDataTypes(): Promise<AccountDataType[]> {
111	const cacheDir = CacheRouter.getAccountDataTypesCacheDir();	×
NEW 112	return this.cachedQueryResolver.get<AccountDataType[]>({	×
113	cacheDir,
114	query: this.sql<AccountDataType[]>`SELECT * FROM account_data_types`,
115	ttl: MAX_TTL,
116	});
117	}
118
119	async getAccountDataSettings(
120	address: `0x${string}`,
121	): Promise<AccountDataSetting[]> {
122	const account = await this.getAccount(address);	×
123	const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(address);	×
NEW 124	return this.cachedQueryResolver.get<AccountDataSetting[]>({	×
125	cacheDir,
126	query: this.sql<AccountDataSetting[]>`
127	SELECT ads.* FROM account_data_settings ads INNER JOIN account_data_types adt
128	ON ads.account_data_type_id = adt.id
129	WHERE ads.account_id = ${account.id} AND adt.is_active IS TRUE;`,
130	ttl: this.defaultExpirationTimeInSeconds,
131	});
132	}
133
134	/**
135	* Adds or updates the existing account data settings for a given address/account.
136	* Requirements:
137	* - The account must exist.
138	* - The data type must exist.
139	* - The data type must be active.
140	*
141	* @param address - account address.
142	* @param upsertAccountDataSettings {@link UpsertAccountDataSettingsDto} object.
143	* @returns {Array<AccountDataSetting>} inserted account data settings.
144	*/
145	async upsertAccountDataSettings(args: {
146	address: `0x${string}`;
147	upsertAccountDataSettingsDto: UpsertAccountDataSettingsDto;
148	}): Promise<AccountDataSetting[]> {
149	const { accountDataSettings } = args.upsertAccountDataSettingsDto;	×
150	await this.checkDataTypes(accountDataSettings);	×
151	const account = await this.getAccount(args.address);	×
152
153	const result = await this.sql.begin(async (sql) => {	×
154	await Promise.all(	×
155	accountDataSettings.map(async (accountDataSetting) => {
156	return sql`	×
157	INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
158	VALUES (${account.id}, ${accountDataSetting.dataTypeId}, ${accountDataSetting.enabled})
159	ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
160	`.catch((e) => {
161	throw new UnprocessableEntityException(	×
162	`Error updating data settings: ${asError(e).message}`,
163	);
164	});
165	}),
166	);
167	return sql<[AccountDataSetting]>`	×
168	SELECT * FROM account_data_settings WHERE account_id = ${account.id}`;
169	});
170
171	const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(args.address);	×
172	await this.cacheService.set(	×
173	cacheDir,
174	JSON.stringify(result),
175	this.defaultExpirationTimeInSeconds,
176	);
177	return result;	×
178	}
179
180	private async checkDataTypes(
181	accountDataSettings: UpsertAccountDataSettingsDto['accountDataSettings'],
182	): Promise<void> {
183	const dataTypes = await this.getDataTypes();	×
184	const activeDataTypeIds = dataTypes	×
185	.filter((dt) => dt.is_active)	×
186	.map((ads) => ads.id);	×
187	if (	×
188	!accountDataSettings.every((ads) =>
189	activeDataTypeIds.includes(Number(ads.dataTypeId)),	×
190	)
191	) {
192	throw new UnprocessableEntityException(	×
193	`Data types not found or not active.`,
194	);
195	}
196	}
197	}

safe-global / safe-client-gateway / 10062091355

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