renaming classes and file organizing

Author: maya-the-mango

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

@@ -1,4 +1,4 @@
-import { ExpiringLRUCache, LRUCache } from './lru-cache';
+import { LRUCache } from './lru-cache';
 
 describe('LRUCache', () => {
   let cache: LRUCache;
@@ -62,28 +62,3 @@ 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.spec.ts

@@ -99,20 +99,20 @@ export class LRUCache implements Map<string, string> {
 }
 
 /**
- * Variation of LRUCache that expires after set time in milliseconds
+ * Time-aware, least-recently-used (TLRU), variant of LRU where entries have valid lifetime.
  * @param {number} maxSize - Maximum cache size
- * @param {number} timeout - Time in milliseconds after which cache entry will evict itself
+ * @param {number} ttl - Time in milliseconds after which cache entry will evict itself
  **/
-export class ExpiringLRUCache extends LRUCache {
-  constructor(readonly maxSize: number, readonly timeout: number) {
+export class TLRUCache extends LRUCache {
+  constructor(readonly maxSize: number, readonly ttl: number) {
     super(maxSize);
   }
 
   set(key: string, value: string): this {
     const cache = super.set(key, value);
     setTimeout(() => {
       this.delete(key);
-    }, this.timeout);
+    }, this.ttl);
     return cache;
   }
 }

src/cache/lru-cache.ts

@@ -0,0 +1,26 @@
+import { TLRUCache } from './lru-cache';
+
+describe('TLRU Cache', () => {
+  let cache: TLRUCache;
+  const expectedCacheTimeoutMs = 50;
+
+  beforeEach(async () => {
+    cache = new TLRUCache(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/tlru-cache.spec.ts

@@ -0,0 +1,20 @@
+import { LRUCache } from './lru-cache';
+
+/**
+ * Time-aware, least-recently-used (TLRU), variant of LRU where entries have valid lifetime.
+ * @param {number} maxSize - Maximum cache size
+ * @param {number} ttl - Time in milliseconds after which cache entry will evict itself
+ **/
+export class TLRUCache extends LRUCache {
+  constructor(readonly maxSize: number, readonly ttl: number) {
+    super(maxSize);
+  }
+
+  set(key: string, value: string): this {
+    const cache = super.set(key, value);
+    setTimeout(() => {
+      this.delete(key);
+    }, this.ttl);
+    return cache;
+  }
+}

src/cache/tlru-cache.ts

@@ -1,12 +1,12 @@
-import { ExpiringLRUInMemoryAssignmentCache } from './expiring-lru-in-memory-assignment-cache';
+import { TLRUInMemoryAssignmentCache } from './tlru-in-memory-assignment-cache';
 
 describe('ExpiringLRUInMemoryAssignmentCache', () => {
-  let cache: ExpiringLRUInMemoryAssignmentCache;
+  let cache: TLRUInMemoryAssignmentCache;
   const defaultTimout = 60_000; // 10 minutes
 
   beforeAll(() => {
     jest.useFakeTimers();
-    cache = new ExpiringLRUInMemoryAssignmentCache(2);
+    cache = new TLRUInMemoryAssignmentCache(2);
   });
 
   it(`assignment cache's timeout should default to 10 minutes `, () => {
@@ -18,7 +18,7 @@ describe('ExpiringLRUInMemoryAssignmentCache', () => {
 
   it(`assignment cache's timeout value is used on construction`, () => {
     const expectedTimout = 88;
-    cache = new ExpiringLRUInMemoryAssignmentCache(2, expectedTimout);
+    cache = new TLRUInMemoryAssignmentCache(2, expectedTimout);
     const key1 = { subjectKey: 'a', flagKey: 'b', banditKey: 'c', actionKey: 'd' };
     cache.set(key1);
     jest.advanceTimersByTime(expectedTimout);

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

@@ -0,0 +1,17 @@
+import { AbstractAssignmentCache } from './abstract-assignment-cache';
+import { TLRUCache } from './tlru-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.
+ *
+ * @param {number} maxSize - Maximum cache size
+ * @param {number} ttl - Time in milliseconds after cache will expire.
+ */
+export class TLRUInMemoryAssignmentCache extends AbstractAssignmentCache<TLRUCache> {
+  constructor(maxSize: number, ttl = 60_000) {
+    super(new TLRUCache(maxSize, ttl));
+  }
+}

src/cache/tlru-in-memory-assignment-cache.ts

@@ -4,9 +4,9 @@ import { IAssignmentEvent, IAssignmentLogger } from '../assignment-logger';
 import { BanditEvaluator } from '../bandit-evaluator';
 import { IBanditEvent, IBanditLogger } from '../bandit-logger';
 import { AssignmentCache } from '../cache/abstract-assignment-cache';
-import { ExpiringLRUInMemoryAssignmentCache } from '../cache/expiring-lru-in-memory-assignment-cache';
 import { LRUInMemoryAssignmentCache } from '../cache/lru-in-memory-assignment-cache';
 import { NonExpiringInMemoryAssignmentCache } from '../cache/non-expiring-in-memory-cache-assignment';
+import { TLRUInMemoryAssignmentCache } from '../cache/tlru-in-memory-assignment-cache';
 import ConfigurationRequestor from '../configuration-requestor';
 import { IConfigurationStore } from '../configuration-store/configuration-store';
 import {
@@ -983,15 +983,15 @@ export default class EppoClient {
   }
 
   public useLRUInMemoryBanditAssignmentCache(maxSize: number) {
-    this.banditAssignmentCache = new LRUInMemoryAssignmentCache(maxSize);
+    this.banditAssignmentCache = new TLRUInMemoryAssignmentCache(maxSize);
   }
 
   /**
    * @param {number} maxSize - Maximum cache size
    * @param {number} timeout - TTL of cache entries
    */
-  public useExpiringInMemoryBanditAssignmentCache(maxSize: number, timeout?: number) {
-    this.banditAssignmentCache = new ExpiringLRUInMemoryAssignmentCache(maxSize, timeout);
+  public useTLRUInMemoryAssignmentCache(maxSize: number, timeout?: number) {
+    this.banditAssignmentCache = new TLRUInMemoryAssignmentCache(maxSize, timeout);
   }
 
   public useCustomBanditAssignmentCache(cache: AssignmentCache) {