8067280560

Committed 27 Feb 2024 03:31PM UTC coverage: 93.644% (-0.04%) from 93.682%

Build # 8067280560

Build Type

Pull #1215

github

Committed by

hectorgomezv

Commit Message

PR comment

Pull Request Pull Request #1215: Refactor cache-write functions

Run Details

1659 of 1981 branches covered (83.75%)

Branch coverage included in aggregate %.

12 of 14 new or added lines in 4 files covered. (85.71%)

4 existing lines in 1 file now uncovered.

6091 of 6295 relevant lines covered (96.76%)

343.25 hits per line

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

89.36

/src/datasources/cache/redis.cache.service.ts

import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common';
import { RedisClientType } from '@/datasources/cache/cache.module';
import { ICacheService } from '@/datasources/cache/cache.service.interface';
import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';
import { ICacheReadiness } from '@/domain/interfaces/cache-readiness.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheKeyPrefix } from '@/datasources/cache/constants';

@Injectable()
export class RedisCacheService
  implements ICacheService, ICacheReadiness, OnModuleDestroy
{
  private readonly quitTimeoutInSeconds: number = 2;
  private readonly defaultExpirationTimeInSeconds: number;

  constructor(
    @Inject('RedisClient') private readonly client: RedisClientType,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(CacheKeyPrefix) private readonly keyPrefix: string,
  ) {
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
  }

  async ping(): Promise<unknown> {
    return this.client.ping();
  }

  async setWithExpiration(
    cacheDir: CacheDir,
    value: string,
    expireTimeSeconds?: number,
  ): Promise<void> {
    if (!expireTimeSeconds || expireTimeSeconds <= 0) {
      return;
    }

    const key = this._prefixKey(cacheDir.key);

    try {
      await this.client.hSet(key, cacheDir.field, value);
      await this.client.expire(key, expireTimeSeconds);
    } catch (error) {
      await this.client.hDel(key, cacheDir.field);
      throw error;
    }
  }

  async set(cacheDir: CacheDir, value: string): Promise<void> {
    const key = this._prefixKey(cacheDir.key);

    try {
      await this.client.hSet(key, cacheDir.field, value);
    } catch (error) {
      await this.client.hDel(key, cacheDir.field);
      throw error;
    }
  }

  async get(cacheDir: CacheDir): Promise<string | undefined> {
    const key = this._prefixKey(cacheDir.key);
    return await this.client.hGet(key, cacheDir.field);
  }

  async deleteByKey(key: string): Promise<number> {
    const keyWithPrefix = this._prefixKey(key);
    // see https://redis.io/commands/unlink/
    const result = await this.client.unlink(keyWithPrefix);
    await this.setWithExpiration(
      new CacheDir(`invalidationTimeMs:${key}`, ''),
      Date.now().toString(),
      this.defaultExpirationTimeInSeconds,
    );
    return result;
  }

  /**
   * Constructs a prefixed key string.
   *
   * This function takes a key string as an input and prefixes it with `this.keyPrefix`.
   * If `this.keyPrefix` is empty, it returns the original key without any prefix.
   *
   * @param key - The original key string that needs to be prefixed.
   * @returns A string that combines `this.keyPrefix` and the original `key` with a hyphen.
   *          If `this.keyPrefix` is empty, the original `key` is returned without any modification.
   * @private
   */
  private _prefixKey(key: string): string {
    if (this.keyPrefix.length === 0) {
      return key;
    }

    return `${this.keyPrefix}-${key}`;
  }

  /**
   * Closes the connection to Redis when the module associated with this service
   * is destroyed. This tries to gracefully close the connection. If the Redis
   * instance is not responding it invokes {@link forceQuit}.
   */
  async onModuleDestroy(): Promise<void> {
    this.loggingService.info('Closing Redis connection');
    const forceQuitTimeout = setTimeout(
      this.forceQuit.bind(this),
      this.quitTimeoutInSeconds * 1000,
    );
    await this.client.quit();
    clearTimeout(forceQuitTimeout);
    this.loggingService.info('Redis connection closed');
  }

  /**
   * Forces the closing of the Redis connection associated with this service.
   */
  private async forceQuit(): Promise<void> {
    this.loggingService.warn('Forcing Redis connection close');
    await this.client.disconnect();
    this.loggingService.warn('Redis connection closed');
  }
}

1	import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common';	86✔
2	import { RedisClientType } from '@/datasources/cache/cache.module';
3	import { ICacheService } from '@/datasources/cache/cache.service.interface';
4	import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';	86✔
5	import { ICacheReadiness } from '@/domain/interfaces/cache-readiness.interface';
6	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	86✔
7	import { IConfigurationService } from '@/config/configuration.service.interface';	86✔
8	import { CacheKeyPrefix } from '@/datasources/cache/constants';	86✔
9
10	@Injectable()
11	export class RedisCacheService	86✔
12	implements ICacheService, ICacheReadiness, OnModuleDestroy
13	{
14	private readonly quitTimeoutInSeconds: number = 2;	36✔
15	private readonly defaultExpirationTimeInSeconds: number;
16
17	constructor(
18	@Inject('RedisClient') private readonly client: RedisClientType,	36✔
19	@Inject(LoggingService) private readonly loggingService: ILoggingService,	36✔
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	36✔
22	@Inject(CacheKeyPrefix) private readonly keyPrefix: string,	36✔
23	) {
24	this.defaultExpirationTimeInSeconds =	36✔
25	this.configurationService.getOrThrow<number>(
26	'expirationTimeInSeconds.default',
27	);
28	}
29
30	async ping(): Promise<unknown> {
31	return this.client.ping();	2✔
32	}
33
34	async setWithExpiration(
35	cacheDir: CacheDir,
36	value: string,
37	expireTimeSeconds?: number,
38	): Promise<void> {
39	if (!expireTimeSeconds \|\| expireTimeSeconds <= 0) {	28✔
40	return;	4✔
41	}
42
43	const key = this._prefixKey(cacheDir.key);	24✔
44
45	try {	24✔
46	await this.client.hSet(key, cacheDir.field, value);	24✔
47	await this.client.expire(key, expireTimeSeconds);	24✔
48	} catch (error) {
49	await this.client.hDel(key, cacheDir.field);	2✔
50	throw error;	2✔
51	}
52	}
53
54	async set(cacheDir: CacheDir, value: string): Promise<void> {
55	const key = this._prefixKey(cacheDir.key);	4✔
56
57	try {	4✔
58	await this.client.hSet(key, cacheDir.field, value);	4✔
59	} catch (error) {
NEW 60	await this.client.hDel(key, cacheDir.field);	×
NEW 61	throw error;	×
62	}
63	}
64
65	async get(cacheDir: CacheDir): Promise<string \| undefined> {
66	const key = this._prefixKey(cacheDir.key);	32✔
67	return await this.client.hGet(key, cacheDir.field);	32✔
68	}
69
70	async deleteByKey(key: string): Promise<number> {
71	const keyWithPrefix = this._prefixKey(key);	4✔
72	// see https://redis.io/commands/unlink/
73	const result = await this.client.unlink(keyWithPrefix);	4✔
74	await this.setWithExpiration(	4✔
75	new CacheDir(`invalidationTimeMs:${key}`, ''),
76	Date.now().toString(),
77	this.defaultExpirationTimeInSeconds,
78	);
79	return result;	4✔
80	}
81
82	/**
83	* Constructs a prefixed key string.
84	*
85	* This function takes a key string as an input and prefixes it with `this.keyPrefix`.
86	* If `this.keyPrefix` is empty, it returns the original key without any prefix.
87	*
88	* @param key - The original key string that needs to be prefixed.
89	* @returns A string that combines `this.keyPrefix` and the original `key` with a hyphen.
90	* If `this.keyPrefix` is empty, the original `key` is returned without any modification.
91	* @private
92	*/
93	private _prefixKey(key: string): string {
94	if (this.keyPrefix.length === 0) {	64✔
95	return key;	16✔
96	}
97
98	return `${this.keyPrefix}-${key}`;	48✔
99	}
100
101	/**
102	* Closes the connection to Redis when the module associated with this service
103	* is destroyed. This tries to gracefully close the connection. If the Redis
104	* instance is not responding it invokes {@link forceQuit}.
105	*/
106	async onModuleDestroy(): Promise<void> {
107	this.loggingService.info('Closing Redis connection');	16✔
108	const forceQuitTimeout = setTimeout(	16✔
109	this.forceQuit.bind(this),
110	this.quitTimeoutInSeconds * 1000,
111	);
112	await this.client.quit();	16✔
113	clearTimeout(forceQuitTimeout);	16✔
114	this.loggingService.info('Redis connection closed');	16✔
115	}
116
117	/**
118	* Forces the closing of the Redis connection associated with this service.
119	*/
120	private async forceQuit(): Promise<void> {
121	this.loggingService.warn('Forcing Redis connection close');	×
122	await this.client.disconnect();	×
123	this.loggingService.warn('Redis connection closed');	×
124	}
125	}

safe-global / safe-client-gateway / 8067280560

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