feat: enforce maximum TTL in RedisCacheService to prevent overflow errors

Author: PooyaRaki

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

@@ -137,21 +137,6 @@ describe('RedisCacheService', () => {
     expect(ttl).toBeLessThanOrEqual(maxDeviation);
   });
 
-  it('Setting key throws on expire', async () => {
-    const cacheDir = new CacheDir(
-      faker.string.alphanumeric(),
-      faker.string.sample(),
-    );
-
-    // Expiration time out of range to force an error
-    await expect(
-      redisCacheService.hSet(cacheDir, '', Number.MAX_VALUE + 1),
-    ).rejects.toThrow();
-
-    const storedValue = await redisClient.hGet(cacheDir.key, cacheDir.field);
-    expect(storedValue).toBeNull();
-  });
-
   it('Getting key gets the stored value', async () => {
     const cacheDir = new CacheDir(
       faker.string.alphanumeric(),
@@ -298,4 +283,44 @@ describe('RedisCacheService', () => {
     expect(ttl).toBeGreaterThan(0);
     expect(ttl).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
   });
+
+  it('Setting key with TTL larger than MAX_TTL enforces MAX_TTL limit', async () => {
+    const cacheDir = new CacheDir(
+      faker.string.alphanumeric(),
+      faker.string.sample(),
+    );
+    const value = fakeJson();
+    const expireTime = MAX_TTL + faker.number.int({ min: 1000, max: 10000 });
+
+    await redisCacheService.hSet(cacheDir, value, expireTime, 0);
+
+    const storedValue = await redisClient.hGet(cacheDir.key, cacheDir.field);
+    const ttl = await redisClient.ttl(cacheDir.key);
+    expect(storedValue).toEqual(value);
+    expect(ttl).toBeGreaterThan(0);
+    expect(ttl).toBeLessThanOrEqual(MAX_TTL);
+  });
+
+  it('Increment with TTL larger than MAX_TTL enforces MAX_TTL limit', async () => {
+    const key = faker.string.alphanumeric();
+    const expireTime = MAX_TTL + faker.number.int({ min: 1000, max: 10000 });
+
+    await redisCacheService.increment(key, expireTime, 0);
+
+    const ttl = await redisClient.ttl(key);
+    expect(ttl).toBeGreaterThan(0);
+    expect(ttl).toBeLessThanOrEqual(MAX_TTL);
+  });
+
+  it('SetCounter with TTL larger than MAX_TTL enforces MAX_TTL limit', async () => {
+    const key = faker.string.alphanumeric();
+    const value = faker.number.int({ min: 1, max: 100 });
+    const expireTime = MAX_TTL + faker.number.int({ min: 1000, max: 10000 });
+
+    await redisCacheService.setCounter(key, value, expireTime, 0);
+
+    const ttl = await redisClient.ttl(key);
+    expect(ttl).toBeGreaterThan(0);
+    expect(ttl).toBeLessThanOrEqual(MAX_TTL);
+  });
 });

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

@@ -5,7 +5,7 @@ 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';
+import { CacheKeyPrefix, MAX_TTL } from '@/datasources/cache/constants';
 import { LogType } from '@/domain/common/entities/log-type.entity';
 import { deviateRandomlyByPercentage } from '@/domain/common/utils/number';
 
@@ -59,9 +59,11 @@ export class RedisCacheService
     }
 
     const key = this._prefixKey(cacheDir.key);
-    const expirationTime = deviateRandomlyByPercentage(
-      expireTimeSeconds,
-      expireDeviatePercent ?? this.defaultExpirationDeviatePercent,
+    const expirationTime = this.enforceMaxRedisTTL(
+      deviateRandomlyByPercentage(
+        expireTimeSeconds,
+        expireDeviatePercent ?? this.defaultExpirationDeviatePercent,
+      ),
     );
 
     try {
@@ -106,9 +108,11 @@ export class RedisCacheService
   ): Promise<number> {
     const transaction = this.client.multi().incr(cacheKey);
     if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {
-      const expirationTime = deviateRandomlyByPercentage(
-        expireTimeSeconds,
-        expireDeviatePercent ?? this.defaultExpirationDeviatePercent,
+      const expirationTime = this.enforceMaxRedisTTL(
+        deviateRandomlyByPercentage(
+          expireTimeSeconds,
+          expireDeviatePercent ?? this.defaultExpirationDeviatePercent,
+        ),
       );
 
       transaction.expire(cacheKey, expirationTime, 'NX');
@@ -123,9 +127,11 @@ export class RedisCacheService
     expireTimeSeconds: number,
     expireDeviatePercent?: number,
   ): Promise<void> {
-    const expirationTime = deviateRandomlyByPercentage(
-      expireTimeSeconds,
-      expireDeviatePercent ?? this.defaultExpirationDeviatePercent,
+    const expirationTime = this.enforceMaxRedisTTL(
+      deviateRandomlyByPercentage(
+        expireTimeSeconds,
+        expireDeviatePercent ?? this.defaultExpirationDeviatePercent,
+      ),
     );
 
     await this.client.set(key, value, {
@@ -182,4 +188,15 @@ export class RedisCacheService
     });
     await this.client.disconnect();
   }
+
+  /**
+   * Enforces the maximum TTL for Redis to prevent overflow errors.
+   *
+   * @param {number} ttl - The TTL to enforce.
+   *
+   * @returns {number} The TTL if it is less than or equal to MAX_TTL, otherwise MAX_TTL.
+   */
+  private enforceMaxRedisTTL(ttl: number): number {
+    return ttl > MAX_TTL ? MAX_TTL : ttl;
+  }
 }