9940981935

Committed 15 Jul 2024 02:10PM UTC coverage: 48.206% (-0.07%) from 48.276%

Build # 9940981935

Build Type

Pull #1760

github

Committed by

web-flow

Commit Message

Merge 7f121c729 into efb87bf55

Pull Request Pull Request #1760: Add Accounts Datasource cache layer

Run Details

417 of 2591 branches covered (16.09%)

Branch coverage included in aggregate %.

9 of 49 new or added lines in 2 files covered. (18.37%)

2 existing lines in 1 file now uncovered.

4271 of 7134 relevant lines covered (59.87%)

13.03 hits per line

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

11.54

/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 { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';
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,
  InternalServerErrorException,
  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(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> {
    const persistentCacheDirs = [
      CacheRouter.getActiveAccountDataTypesCacheDir(),
      CacheRouter.getAccountDataTypesCacheDir(),
    ];
    await Promise.all(
      persistentCacheDirs.map(async (cacheDir) => {
        await this.cacheService.deleteByKey(cacheDir.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.getFromCacheOrExecuteAndCache<Account[]>(
      cacheDir,
      this.sql<Account[]>`SELECT * FROM accounts WHERE address = ${address}`,
      this.defaultExpirationTimeInSeconds,
    );

    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}`;

    const { key } = CacheRouter.getAccountCacheDir(address);
    await this.cacheService.deleteByKey(key);

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

  getActiveDataTypes(): Promise<AccountDataType[]> {
    const cacheDir = CacheRouter.getActiveAccountDataTypesCacheDir();
    return this.getFromCacheOrExecuteAndCache<AccountDataType[]>(
      cacheDir,
      this.sql<
        AccountDataType[]
      >`SELECT * FROM account_data_types WHERE is_active IS TRUE`,
      MAX_TTL,
    );
  }

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

  async getAccountDataSettings(
    address: `0x${string}`,
  ): Promise<AccountDataSetting[]> {
    const account = await this.getAccount(address);
    const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(address);
    return this.getFromCacheOrExecuteAndCache<AccountDataSetting[]>(
      cacheDir,
      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;`,
      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(
    address: `0x${string}`,
    upsertAccountDataSettings: UpsertAccountDataSettingsDto,
  ): Promise<AccountDataSetting[]> {
    const { accountDataSettings } = upsertAccountDataSettings;
    await this.checkDataTypes(accountDataSettings);
    const account = await this.getAccount(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.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}`;
    });

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

  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.`,
      );
    }
  }

  /**
   * Returns the content from cache or executes the query and caches the result.
   * If the specified {@link CacheDir} is empty, the query is executed and the result is cached.
   * If the specified {@link CacheDir} is not empty, the pointed content is returned.
   *
   * @param cacheDir {@link CacheDir} to use for caching
   * @param query query to execute
   * @param ttl time to live for the cache
   * @returns content from cache or query result
   */
  private async getFromCacheOrExecuteAndCache<T extends postgres.MaybeRow[]>(
    cacheDir: CacheDir,
    query: postgres.PendingQuery<T>,
    ttl: number,
  ): Promise<T> {
    const { key, field } = cacheDir;
    const cached = await this.cacheService.get(cacheDir);
    if (cached != null) {
      this.loggingService.debug({ type: 'cache_hit', key, field });
      return JSON.parse(cached);
    }
    this.loggingService.debug({ type: 'cache_miss', key, field });

    // log & hide database errors
    const result = await query.catch((e) => {
      this.loggingService.error(asError(e).message);
      throw new InternalServerErrorException();
    });

    if (result.count > 0) {
      await this.cacheService.set(cacheDir, JSON.stringify(result), ttl);
    }
    return result;
  }
}

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 { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';
9	import { AccountDataSetting } from '@/domain/accounts/entities/account-data-setting.entity';
10	import { AccountDataType } from '@/domain/accounts/entities/account-data-type.entity';
11	import { Account } from '@/domain/accounts/entities/account.entity';
12	import { UpsertAccountDataSettingsDto } from '@/domain/accounts/entities/upsert-account-data-settings.dto.entity';
13	import { IAccountsDatasource } from '@/domain/interfaces/accounts.datasource.interface';
14	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
15	import { asError } from '@/logging/utils';	16✔
16	import {	16✔
17	Inject,
18	Injectable,
19	InternalServerErrorException,
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(
NEW 31	@Inject(CacheService) private readonly cacheService: ICacheService,	×
32	@Inject('DB_INSTANCE') private readonly sql: postgres.Sql,	×
33	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
34	@Inject(IConfigurationService)
NEW 35	private readonly configurationService: IConfigurationService,	×
36	) {
NEW 37	this.defaultExpirationTimeInSeconds =	×
38	this.configurationService.getOrThrow<number>(
39	'expirationTimeInSeconds.default',
40	);
41	}
42
43	/**
44	* Function executed when the module is initialized.
45	* It deletes the cache for persistent keys.
46	*/
47	async onModuleInit(): Promise<void> {
NEW 48	const persistentCacheDirs = [	×
49	CacheRouter.getActiveAccountDataTypesCacheDir(),
50	CacheRouter.getAccountDataTypesCacheDir(),
51	];
NEW 52	await Promise.all(	×
53	persistentCacheDirs.map(async (cacheDir) => {
NEW 54	await this.cacheService.deleteByKey(cacheDir.key);	×
55	}),
56	);
57	}
58
59	async createAccount(address: `0x${string}`): Promise<Account> {
NEW 60	const [account] = await this.sql<[Account]>`	×
61	INSERT INTO accounts (address) VALUES (${address}) RETURNING *`.catch(
62	(e) => {
63	this.loggingService.warn(	×
64	`Error creating account: ${asError(e).message}`,
65	);
NEW 66	throw new UnprocessableEntityException('Error creating account.');	×
67	},
68	);
NEW 69	const cacheDir = CacheRouter.getAccountCacheDir(address);	×
NEW 70	await this.cacheService.set(	×
71	cacheDir,
72	JSON.stringify([account]),
73	this.defaultExpirationTimeInSeconds,
74	);
UNCOV 75	return account;	×
76	}
77
78	async getAccount(address: `0x${string}`): Promise<Account> {
NEW 79	const cacheDir = CacheRouter.getAccountCacheDir(address);	×
NEW 80	const [account] = await this.getFromCacheOrExecuteAndCache<Account[]>(	×
81	cacheDir,
82	this.sql<Account[]>`SELECT * FROM accounts WHERE address = ${address}`,
83	this.defaultExpirationTimeInSeconds,
84	);
85
86	if (!account) {	×
87	throw new NotFoundException('Error getting account.');	×
88	}
89
90	return account;	×
91	}
92
93	async deleteAccount(address: `0x${string}`): Promise<void> {
94	const { count } = await this	×
95	.sql`DELETE FROM accounts WHERE address = ${address}`;
96
NEW 97	const { key } = CacheRouter.getAccountCacheDir(address);	×
NEW 98	await this.cacheService.deleteByKey(key);	×
99
100	if (count === 0) {	×
101	this.loggingService.debug(`Error deleting account ${address}: not found`);	×
102	}
103	}
104
105	getActiveDataTypes(): Promise<AccountDataType[]> {
NEW 106	const cacheDir = CacheRouter.getActiveAccountDataTypesCacheDir();	×
NEW 107	return this.getFromCacheOrExecuteAndCache<AccountDataType[]>(	×
108	cacheDir,
109	this.sql<
110	AccountDataType[]
111	>`SELECT * FROM account_data_types WHERE is_active IS TRUE`,
112	MAX_TTL,
113	);
114	}
115
116	async getDataTypes(): Promise<AccountDataType[]> {
NEW 117	const cacheDir = CacheRouter.getAccountDataTypesCacheDir();	×
NEW 118	return this.getFromCacheOrExecuteAndCache<AccountDataType[]>(	×
119	cacheDir,
120	this.sql<AccountDataType[]>`SELECT * FROM account_data_types`,
121	MAX_TTL,
122	);
123	}
124
125	async getAccountDataSettings(
126	address: `0x${string}`,
127	): Promise<AccountDataSetting[]> {
128	const account = await this.getAccount(address);	×
NEW 129	const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(address);	×
NEW 130	return this.getFromCacheOrExecuteAndCache<AccountDataSetting[]>(	×
131	cacheDir,
132	this.sql<AccountDataSetting[]>`
133	SELECT ads.* FROM account_data_settings ads INNER JOIN account_data_types adt
134	ON ads.account_data_type_id = adt.id
135	WHERE ads.account_id = ${account.id} AND adt.is_active IS TRUE;`,
136	this.defaultExpirationTimeInSeconds,
137	);
138	}
139
140	/**
141	* Adds or updates the existing account data settings for a given address/account.
142	* Requirements:
143	* - The account must exist.
144	* - The data type must exist.
145	* - The data type must be active.
146	*
147	* @param address - account address.
148	* @param upsertAccountDataSettings {@link UpsertAccountDataSettingsDto} object.
149	* @returns {Array<AccountDataSetting>} inserted account data settings.
150	*/
151	async upsertAccountDataSettings(
152	address: `0x${string}`,
153	upsertAccountDataSettings: UpsertAccountDataSettingsDto,
154	): Promise<AccountDataSetting[]> {
155	const { accountDataSettings } = upsertAccountDataSettings;	×
156	await this.checkDataTypes(accountDataSettings);	×
157	const account = await this.getAccount(address);	×
158
NEW 159	const result = await this.sql.begin(async (sql) => {	×
UNCOV 160	await Promise.all(	×
161	accountDataSettings.map(async (accountDataSetting) => {
162	return sql`	×
163	INSERT INTO account_data_settings (account_id, account_data_type_id, enabled)
164	VALUES (${account.id}, ${accountDataSetting.id}, ${accountDataSetting.enabled})
165	ON CONFLICT (account_id, account_data_type_id) DO UPDATE SET enabled = EXCLUDED.enabled
166	`.catch((e) => {
167	throw new UnprocessableEntityException(	×
168	`Error updating data settings: ${asError(e).message}`,
169	);
170	});
171	}),
172	);
173	return sql<[AccountDataSetting]>`	×
174	SELECT * FROM account_data_settings WHERE account_id = ${account.id}`;
175	});
176
NEW 177	const cacheDir = CacheRouter.getAccountDataSettingsCacheDir(address);	×
NEW 178	await this.cacheService.set(	×
179	cacheDir,
180	JSON.stringify(result),
181	this.defaultExpirationTimeInSeconds,
182	);
NEW 183	return result;	×
184	}
185
186	private async checkDataTypes(
187	accountDataSettings: UpsertAccountDataSettingsDto['accountDataSettings'],
188	): Promise<void> {
189	const activeDataTypes = await this.getActiveDataTypes();	×
190	const activeDataTypeIds = activeDataTypes.map((ads) => ads.id);	×
191	if (	×
192	!accountDataSettings.every((ads) =>
193	activeDataTypeIds.includes(Number(ads.id)),	×
194	)
195	) {
196	throw new UnprocessableEntityException(	×
197	`Data types not found or not active.`,
198	);
199	}
200	}
201
202	/**
203	* Returns the content from cache or executes the query and caches the result.
204	* If the specified {@link CacheDir} is empty, the query is executed and the result is cached.
205	* If the specified {@link CacheDir} is not empty, the pointed content is returned.
206	*
207	* @param cacheDir {@link CacheDir} to use for caching
208	* @param query query to execute
209	* @param ttl time to live for the cache
210	* @returns content from cache or query result
211	*/
212	private async getFromCacheOrExecuteAndCache<T extends postgres.MaybeRow[]>(
213	cacheDir: CacheDir,
214	query: postgres.PendingQuery<T>,
215	ttl: number,
216	): Promise<T> {
NEW 217	const { key, field } = cacheDir;	×
NEW 218	const cached = await this.cacheService.get(cacheDir);	×
NEW 219	if (cached != null) {	×
NEW 220	this.loggingService.debug({ type: 'cache_hit', key, field });	×
NEW 221	return JSON.parse(cached);	×
222	}
NEW 223	this.loggingService.debug({ type: 'cache_miss', key, field });	×
224
225	// log & hide database errors
NEW 226	const result = await query.catch((e) => {	×
NEW 227	this.loggingService.error(asError(e).message);	×
NEW 228	throw new InternalServerErrorException();	×
229	});
230
NEW 231	if (result.count > 0) {	×
NEW 232	await this.cacheService.set(cacheDir, JSON.stringify(result), ttl);	×
233	}
NEW 234	return result;	×
235	}
236	}

safe-global / safe-client-gateway / 9940981935

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