9060122929

Committed 13 May 2024 08:59AM UTC coverage: 93.004% (+0.01%) from 92.994%

Build # 9060122929

Build Type

push

github

Committed by

web-flow

Commit Message

Fix @typescript-eslint/no-misused-promises instances (#1530)

Enable `@typescript-eslint/no-misused-promises` ESLint rule

Run Details

1964 of 2385 branches covered (82.35%)

Branch coverage included in aggregate %.

3 of 4 new or added lines in 2 files covered. (75.0%)

2 existing lines in 1 file now uncovered.

6983 of 7235 relevant lines covered (96.52%)

318.69 hits per line

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

92.31

/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 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);
  }

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

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