8094940198

Committed 29 Feb 2024 11:00AM UTC coverage: 93.734% (+0.5%) from 93.246%

Build # 8094940198

Build Type

Pull #1225

github

Committed by

hectorgomezv

Commit Message

PR comments

Pull Request Pull Request #1225: Extend ICacheService interface by storing incrementable numeric values

Run Details

1683 of 2007 branches covered (83.86%)

Branch coverage included in aggregate %.

14 of 14 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

6171 of 6372 relevant lines covered (96.85%)

349.24 hits per line

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

94.0

/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 set(
    cacheDir: CacheDir,
    value: string,
    expireTimeSeconds: number | undefined,
  ): Promise<void> {
    if (!expireTimeSeconds || expireTimeSeconds <= 0) {
      return;
    }

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

    try {
      await this.client.hSet(key, cacheDir.field, value);
      // NX - Set expiry only when the key has no expiry
      // See https://redis.io/commands/expire/
      await this.client.expire(key, expireTimeSeconds, 'NX');
    } 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.set(
      new CacheDir(`invalidationTimeMs:${key}`, ''),
      Date.now().toString(),
      this.defaultExpirationTimeInSeconds,
    );
    return result;
  }

  async incrementAndGet(
    cacheKey: string,
    expireTimeSeconds: number | undefined,
  ): Promise<number> {
    const result = await this.client.incr(cacheKey);
    if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {
      await this.client.expire(cacheKey, expireTimeSeconds, 'NX');
    }
    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 set(
35	cacheDir: CacheDir,
36	value: string,
37	expireTimeSeconds: number \| undefined,
38	): Promise<void> {
39	if (!expireTimeSeconds \|\| expireTimeSeconds <= 0) {	26✔
40	return;	4✔
41	}
42
43	const key = this._prefixKey(cacheDir.key);	22✔
44
45	try {	22✔
46	await this.client.hSet(key, cacheDir.field, value);	22✔
47	// NX - Set expiry only when the key has no expiry
48	// See https://redis.io/commands/expire/
49	await this.client.expire(key, expireTimeSeconds, 'NX');	22✔
50	} catch (error) {
51	await this.client.hDel(key, cacheDir.field);	2✔
52	throw error;	2✔
53	}
54	}
55
56	async get(cacheDir: CacheDir): Promise<string \| undefined> {
57	const key = this._prefixKey(cacheDir.key);	32✔
58	return await this.client.hGet(key, cacheDir.field);	32✔
59	}
60
61	async deleteByKey(key: string): Promise<number> {
62	const keyWithPrefix = this._prefixKey(key);	4✔
63	// see https://redis.io/commands/unlink/
64	const result = await this.client.unlink(keyWithPrefix);	4✔
65	await this.set(	4✔
66	new CacheDir(`invalidationTimeMs:${key}`, ''),
67	Date.now().toString(),
68	this.defaultExpirationTimeInSeconds,
69	);
70	return result;	4✔
71	}
72
73	async incrementAndGet(
74	cacheKey: string,
75	expireTimeSeconds: number \| undefined,
76	): Promise<number> {
77	const result = await this.client.incr(cacheKey);	22✔
78	if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {	22✔
79	await this.client.expire(cacheKey, expireTimeSeconds, 'NX');	12✔
80	}
81	return result;	22✔
82	}
83
84	/**
85	* Constructs a prefixed key string.
86	*
87	* This function takes a key string as an input and prefixes it with `this.keyPrefix`.
88	* If `this.keyPrefix` is empty, it returns the original key without any prefix.
89	*
90	* @param key - The original key string that needs to be prefixed.
91	* @returns A string that combines `this.keyPrefix` and the original `key` with a hyphen.
92	* If `this.keyPrefix` is empty, the original `key` is returned without any modification.
93	* @private
94	*/
95	private _prefixKey(key: string): string {
96	if (this.keyPrefix.length === 0) {	58✔
97	return key;	10✔
98	}
99
100	return `${this.keyPrefix}-${key}`;	48✔
101	}
102
103	/**
104	* Closes the connection to Redis when the module associated with this service
105	* is destroyed. This tries to gracefully close the connection. If the Redis
106	* instance is not responding it invokes {@link forceQuit}.
107	*/
108	async onModuleDestroy(): Promise<void> {
109	this.loggingService.info('Closing Redis connection');	16✔
110	const forceQuitTimeout = setTimeout(	16✔
111	this.forceQuit.bind(this),
112	this.quitTimeoutInSeconds * 1000,
113	);
114	await this.client.quit();	16✔
115	clearTimeout(forceQuitTimeout);	16✔
116	this.loggingService.info('Redis connection closed');	16✔
117	}
118
119	/**
120	* Forces the closing of the Redis connection associated with this service.
121	*/
122	private async forceQuit(): Promise<void> {
UNCOV 123	this.loggingService.warn('Forcing Redis connection close');	×
124	await this.client.disconnect();	×
125	this.loggingService.warn('Redis connection closed');	×
126	}
127	}

safe-global / safe-client-gateway / 8094940198

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