9936800916

Committed 15 Jul 2024 09:15AM UTC coverage: 48.164% (-0.02%) from 48.183%

Build # 9936800916

Build Type

push

github

Committed by

hectorgomezv

Commit Message

Add cache management for AccountDataSettings

Run Details

415 of 2593 branches covered (16.0%)

Branch coverage included in aggregate %.

1 of 8 new or added lines in 2 files covered. (12.5%)

1 existing line in 1 file now uncovered.

4267 of 7128 relevant lines covered (59.86%)

13.01 hits per line

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

10.67

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

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

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

  /**
   * 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}`,
        );
        return [];
      },
    );

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

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

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

  /**
   * 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 { key } = CacheRouter.getAccountDataSettingsCacheDir(address);
    await this.cacheService.deleteByKey(key);
    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.`,
      );
    }
  }

  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 });
    const result = await query;
    if (result.count > 0) {
      await this.cacheService.set(cacheDir, JSON.stringify(result), ttl);
    }
    return result;
  }
}

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

safe-global / safe-client-gateway / 9936800916

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