Reorganized caches into their own files

Author: maya-the-mango

src/cache/abstract-assignment-cache.spec.ts

@@ -1,8 +1,8 @@
 import {
   assignmentCacheKeyToString,
   assignmentCacheValueToString,
-  NonExpiringInMemoryAssignmentCache,
 } from './abstract-assignment-cache';
+import { NonExpiringInMemoryAssignmentCache } from './non-expiring-in-memory-cache-assignment';
 
 describe('NonExpiringInMemoryAssignmentCache', () => {
   it('read and write variation entries', () => {

src/cache/abstract-assignment-cache.ts

@@ -1,8 +1,5 @@
 import { getMD5Hash } from '../obfuscation';
 
-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
  * for uniqueness checking. This way that if an assigned variation or bandit action changes for a
@@ -81,33 +78,3 @@ export abstract class AbstractAssignmentCache<T extends Map<string, string>>
     return this.delegate.entries();
   }
 }
-
-/**
- * A cache that never expires.
- *
- * The primary use case is for client-side SDKs, where the cache is only used
- * for a single user.
- */
-export class NonExpiringInMemoryAssignmentCache extends AbstractAssignmentCache<
-  Map<string, string>
-> {
-  constructor(store = new Map<string, string>()) {
-    super(store);
-  }
-}
-
-/**
- * A cache that uses the LRU algorithm to evict the least recently used items.
- *
- * 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
- */
-export class LRUInMemoryAssignmentCache extends AbstractAssignmentCache<LRUCache> {
-  constructor(maxSize: number) {
-    super(new LRUCache(maxSize));
-  }
-}

src/cache/lru-cache.ts

@@ -97,6 +97,7 @@ export class LRUCache implements Map<string, string> {
     return this;
   }
 }
+
 /**
  * Variation of LRUCache that expires after set time in milliseconds
  * @param {number} maxSize - Maximum cache size

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

@@ -0,0 +1,18 @@
+import { AbstractAssignmentCache } from './abstract-assignment-cache';
+import { LRUCache } from './lru-cache';
+
+/**
+ * A cache that uses the LRU algorithm to evict the least recently used items.
+ *
+ * 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
+ */
+export class LRUInMemoryAssignmentCache extends AbstractAssignmentCache<LRUCache> {
+  constructor(maxSize: number) {
+    super(new LRUCache(maxSize));
+  }
+}

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

@@ -0,0 +1,15 @@
+import { AbstractAssignmentCache } from './abstract-assignment-cache';
+
+/**
+ * A cache that never expires.
+ *
+ * The primary use case is for client-side SDKs, where the cache is only used
+ * for a single user.
+ */
+export class NonExpiringInMemoryAssignmentCache extends AbstractAssignmentCache<
+  Map<string, string>
+> {
+  constructor(store = new Map<string, string>()) {
+    super(store);
+  }
+}

src/client/eppo-client.ts

@@ -3,11 +3,9 @@ import { logger } from '../application-logger';
 import { IAssignmentEvent, IAssignmentLogger } from '../assignment-logger';
 import { BanditEvaluator } from '../bandit-evaluator';
 import { IBanditEvent, IBanditLogger } from '../bandit-logger';
-import {
-  AssignmentCache,
-  LRUInMemoryAssignmentCache,
-  NonExpiringInMemoryAssignmentCache,
-} from '../cache/abstract-assignment-cache';
+import { AssignmentCache } from '../cache/abstract-assignment-cache';
+import { LRUInMemoryAssignmentCache } from '../cache/lru-in-memory-assignment-cache';
+import { NonExpiringInMemoryAssignmentCache } from '../cache/non-expiring-in-memory-cache-assignment';
 import ConfigurationRequestor from '../configuration-requestor';
 import { IConfigurationStore } from '../configuration-store/configuration-store';
 import {
@@ -254,25 +252,6 @@ export default class EppoClient {
     return this.getBooleanAssignment(flagKey, subjectKey, subjectAttributes, defaultValue);
   }
 
-  /**
-   * Maps a subject to a boolean variation for a given experiment.
-   *
-   * @param flagKey feature flag identifier
-   * @param subjectKey an identifier of the experiment subject, for example a user ID.
-   * @param subjectAttributes optional attributes associated with the subject, for example name and email.
-   * @param defaultValue default value to return if the subject is not part of the experiment sample
-   * @returns a boolean variation value if the subject is part of the experiment sample, otherwise the default value
-   */
-  public getBooleanAssignment(
-    flagKey: string,
-    subjectKey: string,
-    subjectAttributes: Attributes,
-    defaultValue: boolean,
-  ): boolean {
-    return this.getBooleanAssignmentDetails(flagKey, subjectKey, subjectAttributes, defaultValue)
-      .variation;
-  }
-
   /**
    * Maps a subject to a boolean variation for a given experiment and provides additional details about the
    * variation assigned and the reason for the assignment.
@@ -657,6 +636,25 @@ export default class EppoClient {
     return result;
   }
 
+  /**
+   * Maps a subject to a boolean variation for a given experiment.
+   *
+   * @param flagKey feature flag identifier
+   * @param subjectKey an identifier of the experiment subject, for example a user ID.
+   * @param subjectAttributes optional attributes associated with the subject, for example name and email.
+   * @param defaultValue default value to return if the subject is not part of the experiment sample
+   * @returns a boolean variation value if the subject is part of the experiment sample, otherwise the default value
+   */
+  public getBooleanAssignment(
+    flagKey: string,
+    subjectKey: string,
+    subjectAttributes: Attributes,
+    defaultValue: boolean,
+  ): boolean {
+    return this.getBooleanAssignmentDetails(flagKey, subjectKey, subjectAttributes, defaultValue)
+      .variation;
+  }
+
   private ensureActionsWithContextualAttributes(
     actions: BanditActions,
   ): Record<string, ContextAttributes> {

src/index.ts

@@ -6,15 +6,15 @@ import { IBanditLogger, IBanditEvent } from './bandit-logger';
 import {
   AbstractAssignmentCache,
   AssignmentCache,
-  NonExpiringInMemoryAssignmentCache,
-  LRUInMemoryAssignmentCache,
   AsyncMap,
   AssignmentCacheKey,
   AssignmentCacheValue,
   AssignmentCacheEntry,
   assignmentCacheKeyToString,
   assignmentCacheValueToString,
 } from './cache/abstract-assignment-cache';
+import { LRUInMemoryAssignmentCache } from './cache/lru-in-memory-assignment-cache';
+import { NonExpiringInMemoryAssignmentCache } from './cache/non-expiring-in-memory-cache-assignment';
 import EppoClient, {
   FlagConfigurationRequestParameters,
   IAssignmentDetails,