11015818795

Committed 24 Sep 2024 02:22PM UTC coverage: 90.762% (-0.003%) from 90.765%

Build # 11015818795

Build Type

Pull #1948

github

Committed by

hectorgomezv

Commit Message

PR comments

Pull Request Pull Request #1948: Rename ICacheService get and set methods

Run Details

2558 of 3194 branches covered (80.09%)

Branch coverage included in aggregate %.

33 of 35 new or added lines in 13 files covered. (94.29%)

2 existing lines in 1 file now uncovered.

8328 of 8800 relevant lines covered (94.64%)

446.13 hits per line

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

91.67

/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 getCounter(key: string): Promise<number | null> {
    const value = await this.client.get(this._prefixKey(key));
    return value ? Number(value) || null : null;
  }

  async hSet(
    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 hGet(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.hSet(
      new CacheDir(`invalidationTimeMs:${key}`, ''),
      Date.now().toString(),
      this.defaultExpirationTimeInSeconds,
    );
    return result;
  }

  async increment(
    cacheKey: string,
    expireTimeSeconds: number | undefined,
  ): Promise<number> {
    const transaction = this.client.multi().incr(cacheKey);
    if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {
      transaction.expire(cacheKey, expireTimeSeconds, 'NX');
    }
    const [incrRes] = await transaction.get(cacheKey).exec();
    return Number(incrRes);
  }

  async setCounter(
    key: string,
    value: number,
    expireTimeSeconds: number,
  ): Promise<void> {
    await this.client.set(key, value, { EX: expireTimeSeconds, NX: true });
  }

  /**
   * 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';	106✔
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';	106✔
5	import { ICacheReadiness } from '@/domain/interfaces/cache-readiness.interface';
6	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	106✔
7	import { IConfigurationService } from '@/config/configuration.service.interface';	106✔
8	import { CacheKeyPrefix } from '@/datasources/cache/constants';	106✔
9
10	@Injectable()
11	export class RedisCacheService	106✔
12	implements ICacheService, ICacheReadiness, OnModuleDestroy
13	{
14	private readonly quitTimeoutInSeconds: number = 2;	46✔
15	private readonly defaultExpirationTimeInSeconds: number;
16
17	constructor(
18	@Inject('RedisClient') private readonly client: RedisClientType,	46✔
19	@Inject(LoggingService) private readonly loggingService: ILoggingService,	46✔
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	46✔
22	@Inject(CacheKeyPrefix) private readonly keyPrefix: string,	46✔
23	) {
24	this.defaultExpirationTimeInSeconds =	46✔
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 getCounter(key: string): Promise<number \| null> {
35	const value = await this.client.get(this._prefixKey(key));	6✔
36	return value ? Number(value) \|\| null : null;	6!
37	}
38
39	async hSet(
40	cacheDir: CacheDir,
41	value: string,
42	expireTimeSeconds: number \| undefined,
43	): Promise<void> {
44	if (!expireTimeSeconds \|\| expireTimeSeconds <= 0) {	302✔
45	return;	4✔
46	}
47
48	const key = this._prefixKey(cacheDir.key);	298✔
49
50	try {	298✔
51	await this.client.hSet(key, cacheDir.field, value);	298✔
52	// NX - Set expiry only when the key has no expiry
53	// See https://redis.io/commands/expire/
54	await this.client.expire(key, expireTimeSeconds, 'NX');	298✔
55	} catch (error) {
56	await this.client.hDel(key, cacheDir.field);	2✔
57	throw error;	2✔
58	}
59	}
60
61	async hGet(cacheDir: CacheDir): Promise<string \| undefined> {
62	const key = this._prefixKey(cacheDir.key);	74✔
63	return await this.client.hGet(key, cacheDir.field);	74✔
64	}
65
66	async deleteByKey(key: string): Promise<number> {
67	const keyWithPrefix = this._prefixKey(key);	276✔
68	// see https://redis.io/commands/unlink/
69	const result = await this.client.unlink(keyWithPrefix);	276✔
70	await this.hSet(	276✔
71	new CacheDir(`invalidationTimeMs:${key}`, ''),
72	Date.now().toString(),
73	this.defaultExpirationTimeInSeconds,
74	);
75	return result;	276✔
76	}
77
78	async increment(
79	cacheKey: string,
80	expireTimeSeconds: number \| undefined,
81	): Promise<number> {
82	const transaction = this.client.multi().incr(cacheKey);	18✔
83	if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {	18✔
84	transaction.expire(cacheKey, expireTimeSeconds, 'NX');	2✔
85	}
86	const [incrRes] = await transaction.get(cacheKey).exec();	18✔
87	return Number(incrRes);	18✔
88	}
89
90	async setCounter(
91	key: string,
92	value: number,
93	expireTimeSeconds: number,
94	): Promise<void> {
95	await this.client.set(key, value, { EX: expireTimeSeconds, NX: true });	4✔
96	}
97
98	/**
99	* Constructs a prefixed key string.
100	*
101	* This function takes a key string as an input and prefixes it with `this.keyPrefix`.
102	* If `this.keyPrefix` is empty, it returns the original key without any prefix.
103	*
104	* @param key - The original key string that needs to be prefixed.
105	* @returns A string that combines `this.keyPrefix` and the original `key` with a hyphen.
106	* If `this.keyPrefix` is empty, the original `key` is returned without any modification.
107	* @private
108	*/
109	private _prefixKey(key: string): string {
110	if (this.keyPrefix.length === 0) {	654✔
111	return key;	18✔
112	}
113
114	return `${this.keyPrefix}-${key}`;	636✔
115	}
116
117	/**
118	* Closes the connection to Redis when the module associated with this service
119	* is destroyed. This tries to gracefully close the connection. If the Redis
120	* instance is not responding it invokes {@link forceQuit}.
121	*/
122	async onModuleDestroy(): Promise<void> {
123	this.loggingService.info('Closing Redis connection');	18✔
124	const forceQuitTimeout = setTimeout(() => {	18✔
UNCOV 125	this.forceQuit.bind(this);	×
126	}, this.quitTimeoutInSeconds * 1000);
127	await this.client.quit();	18✔
128	clearTimeout(forceQuitTimeout);	18✔
129	this.loggingService.info('Redis connection closed');	18✔
130	}
131
132	/**
133	* Forces the closing of the Redis connection associated with this service.
134	*/
135	private async forceQuit(): Promise<void> {
UNCOV 136	this.loggingService.warn('Forcing Redis connection close');	×
137	await this.client.disconnect();	×
138	this.loggingService.warn('Redis connection closed');	×
139	}
140	}

safe-global / safe-client-gateway / 11015818795

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