Added Expiring LRU Cache implementation

Author: maya-the-mango

src/cache/abstract-assignment-cache.ts

@@ -1,6 +1,7 @@
 import { getMD5Hash } from '../obfuscation';
 
-import { LRUCache } from './lru-cache';
+import {ExpiringLRUCache, LRUCache} from './lru-cache';
+import {max} from "lodash";
 
 /**
  * Assignment cache keys are only on the subject and flag level, while the entire value is used
@@ -103,6 +104,7 @@ export class NonExpiringInMemoryAssignmentCache extends AbstractAssignmentCache<
  * The primary use case is for server-side SDKs, where the cache is shared across
  * multiple users. In this case, the cache size should be set to the maximum number
  * of users that can be active at the same time.
+ * @param {number} maxSize - Maximum cache size
  */
 export class LRUInMemoryAssignmentCache extends AbstractAssignmentCache<LRUCache> {
   constructor(maxSize: number) {

src/cache/expiring-lru-in-memory-assignment-cache.spec.ts

@@ -0,0 +1,37 @@
+import { ExpiringLRUInMemoryAssignmentCache } from './expiring-lru-in-memory-assignment-cache';
+
+describe('ExpiringLRUInMemoryAssignmentCache', () => {
+  let cache: ExpiringLRUInMemoryAssignmentCache;
+  const defaultTimout = 60_000; // 10 minutes
+
+  beforeAll(() => {
+    jest.useFakeTimers();
+    cache = new ExpiringLRUInMemoryAssignmentCache(2);
+  });
+
+  it(`assignment cache's timeout should default to 10 minutes `, () => {
+    const key1 = { subjectKey: 'a', flagKey: 'b', banditKey: 'c', actionKey: 'd' };
+    cache.set(key1);
+    jest.advanceTimersByTime(defaultTimout);
+    expect(cache.has(key1)).toBeFalsy();
+  });
+
+  it(`assignment cache's timeout value is used on construction`, () => {
+    const expectedTimout = 88;
+    cache = new ExpiringLRUInMemoryAssignmentCache(2, expectedTimout);
+    const key1 = { subjectKey: 'a', flagKey: 'b', banditKey: 'c', actionKey: 'd' };
+    cache.set(key1);
+    jest.advanceTimersByTime(expectedTimout);
+    expect(cache.has(key1)).toBeFalsy();
+  });
+
+  it(`cache shouldn't be invalidated before timeout`, () => {
+    const key1 = { subjectKey: 'a', flagKey: 'b', banditKey: 'c', actionKey: 'd' };
+    cache.set(key1);
+
+    expect(cache.has(key1)).toBeTruthy();
+
+    jest.advanceTimersByTime(defaultTimout);
+    expect(cache.has(key1)).toBeFalsy();
+  });
+});

src/cache/expiring-lru-in-memory-assignment-cache.ts

@@ -0,0 +1,20 @@
+import { AbstractAssignmentCache } from './abstract-assignment-cache';
+import { ExpiringLRUCache } from './lru-cache';
+
+/**
+ * Variation of LRU caching mechanism that will automatically evict items after
+ * set time of milliseconds.
+ *
+ * It is used to limit the size of the cache.
+ *
+ * The primary use case is for server-side SDKs, where the cache is shared across
+ * multiple users. In this case, the cache size should be set to the maximum number
+ * of users that can be active at the same time.
+ * @param {number} maxSize - Maximum cache size
+ * @param {number} timeout - Time in milliseconds after cache will expire.
+ */
+export class ExpiringLRUInMemoryAssignmentCache extends AbstractAssignmentCache<ExpiringLRUCache> {
+  constructor(maxSize: number, timeout = 60_000) {
+    super(new ExpiringLRUCache(maxSize, timeout));
+  }
+}

src/cache/lru-cache.spec.ts

@@ -1,4 +1,4 @@
-import { LRUCache } from './lru-cache';
+import {ExpiringLRUCache, LRUCache} from './lru-cache';
 
 describe('LRUCache', () => {
   let cache: LRUCache;
@@ -62,3 +62,28 @@ describe('LRUCache', () => {
     expect(oneCache.get('b')).toBe('banana');
   });
 });
+
+describe('Expiring LRU Cache', () => {
+  let cache: ExpiringLRUCache;
+  const expectedCacheTimeoutMs = 50;
+
+  beforeEach(async () => {
+    cache = new ExpiringLRUCache(2, expectedCacheTimeoutMs);
+  });
+
+  afterAll(async () => {
+    jest.restoreAllMocks();
+  });
+
+  it('should evict cache after timeout', async () => {
+    jest.useFakeTimers();
+    jest.spyOn(global, 'setTimeout');
+
+    cache.set('a', 'apple');
+    jest.advanceTimersByTime(expectedCacheTimeoutMs);
+
+    expect(setTimeout).toHaveBeenCalledTimes(1);
+    expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), expectedCacheTimeoutMs);
+    expect(cache.get('a')).toBeUndefined();
+  });
+});

src/cache/lru-cache.ts

@@ -97,3 +97,17 @@ export class LRUCache implements Map<string, string> {
     return this;
   }
 }
+
+export class ExpiringLRUCache extends LRUCache {
+  constructor(readonly maxSize: number, readonly timeout: number) {
+    super(maxSize);
+  }
+
+  set(key: string, value: string): this {
+    const cache = super.set(key, value);
+    setTimeout(() => {
+      this.delete(key);
+    }, this.timeout);
+    return cache;
+  }
+}