changed safeEvictionKeys to evictableKeys

Author: kubabutkiewicz

API-INTERNAL.md

@@ -26,7 +26,7 @@
 <dt><a href="#setSkippableCollectionMemberIDs">setSkippableCollectionMemberIDs()</a></dt>
 <dd><p>Setter - sets the skippable collection member IDs.</p>
 </dd>
-<dt><a href="#initStoreValues">initStoreValues(keys, initialKeyStates, safeEvictionKeys)</a></dt>
+<dt><a href="#initStoreValues">initStoreValues(keys, initialKeyStates, evictableKeys)</a></dt>
 <dd><p>Sets the initial values for the Onyx store</p>
 </dd>
 <dt><a href="#maybeFlushBatchUpdates">maybeFlushBatchUpdates()</a></dt>
@@ -213,7 +213,7 @@ Setter - sets the skippable collection member IDs.
 **Kind**: global function  
 <a name="initStoreValues"></a>
 
-## initStoreValues(keys, initialKeyStates, safeEvictionKeys)
+## initStoreValues(keys, initialKeyStates, evictableKeys)
 Sets the initial values for the Onyx store
 
 **Kind**: global function  
@@ -222,7 +222,7 @@ Sets the initial values for the Onyx store
 | --- | --- |
 | keys | `ONYXKEYS` constants object from Onyx.init() |
 | initialKeyStates | initial data to set when `init()` and `clear()` are called |
-| safeEvictionKeys | This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal. |
+| evictableKeys | This is an array of keys (individual or collection patterns) that are eligible for automatic removal when storage limits are reached. |
 
 <a name="maybeFlushBatchUpdates"></a>
 

README.md

@@ -388,14 +388,14 @@ Different platforms come with varying storage capacities and Onyx has a way to g
 By default, Onyx will not evict anything from storage and will presume all keys are "unsafe" to remove unless explicitly told otherwise.
 
 **To flag a key as safe for removal:**
-- Add the key to the `safeEvictionKeys` option in `Onyx.init(options)`
+- Add the key to the `evictableKeys` option in `Onyx.init(options)`
 - Implement `canEvict` in the Onyx config for each component subscribing to a key
 - The key will only be deleted when all subscribers return `true` for `canEvict`
 
 e.g.
 ```js
 Onyx.init({
-    safeEvictionKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
+    evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
 });
 ```
 
@@ -423,7 +423,7 @@ Provide the `captureMetrics` boolean flag to `Onyx.init` to capture call statist
 ```js
 Onyx.init({
     keys: ONYXKEYS,
-    safeEvictionKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
+    evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
     captureMetrics: Config.BENCHMARK_ONYX,
 });
 ```

lib/Onyx.ts

@@ -39,7 +39,7 @@ import decorateWithMetrics from './metrics';
 function init({
     keys = {},
     initialKeyStates = {},
-    safeEvictionKeys = [],
+    evictableKeys = [],
     maxCachedKeysCount = 1000,
     shouldSyncMultipleInstances = Boolean(global.localStorage),
     debugSetState = false,
@@ -71,7 +71,7 @@ function init({
         cache.setRecentKeysLimit(maxCachedKeysCount);
     }
 
-    OnyxUtils.initStoreValues(keys, initialKeyStates, safeEvictionKeys);
+    OnyxUtils.initStoreValues(keys, initialKeyStates, evictableKeys);
 
     // Initialize all of our keys with data provided then give green light to any pending connections
     Promise.all([cache.addAllSafeEvictionKeysToRecentlyAccessedList(OnyxUtils.isCollectionKey), OnyxUtils.initializeWithDefaultKeyStates()]).then(OnyxUtils.getDeferredInitTask().resolve);

lib/OnyxCache.ts

@@ -4,6 +4,7 @@ import type {ValueOf} from 'type-fest';
 import utils from './utils';
 import type {OnyxKey, OnyxValue} from './types';
 import Storage from './storage';
+import * as Str from './Str';
 
 // Task constants
 const TASK = {
@@ -319,10 +320,8 @@ class OnyxCache {
      * @param key - Key to test against the pattern
      */
     private isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean {
-        // Use a consistent way to determine if a key is a collection key by checking
-        // if it ends with an underscore (_)
         const isCollectionKey = configKey.endsWith('_');
-        return isCollectionKey ? key.startsWith(configKey) : configKey === key;
+        return isCollectionKey ? Str.startsWith(key, configKey) : configKey === key;
     }
 
     /**

lib/OnyxUtils.ts

@@ -138,9 +138,9 @@ function setSkippableCollectionMemberIDs(ids: Set<string>): void {
  *
  * @param keys - `ONYXKEYS` constants object from Onyx.init()
  * @param initialKeyStates - initial data to set when `init()` and `clear()` are called
- * @param safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
+ * @param evictableKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
  */
-function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<KeyValueMapping>, safeEvictionKeys: OnyxKey[]): void {
+function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<KeyValueMapping>, evictableKeys: OnyxKey[]): void {
     // We need the value of the collection keys later for checking if a
     // key is a collection. We store it in a map for faster lookup.
     const collectionValues = Object.values(keys.COLLECTION ?? {}) as string[];
@@ -155,7 +155,7 @@ function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Pa
     DevTools.initState(initialKeyStates);
 
     // Let Onyx know about which keys are safe to evict
-    cache.setEvictionAllowList(safeEvictionKeys);
+    cache.setEvictionAllowList(evictableKeys);
 
     if (typeof keys.COLLECTION === 'object' && typeof keys.COLLECTION.SNAPSHOT === 'string') {
         snapshotKey = keys.COLLECTION.SNAPSHOT;

lib/types.ts

@@ -451,7 +451,7 @@ type InitOptions = {
      * This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged
      * as "safe" for removal. Any components subscribing to these keys must also implement a canEvict option. See the README for more info.
      */
-    safeEvictionKeys?: OnyxKey[];
+    evictableKeys?: OnyxKey[];
 
     /**
      * Sets how many recent keys should we try to keep in cache

lib/useOnyx.ts

@@ -210,7 +210,7 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
         }
 
         if (!OnyxCache.isSafeEvictionKey(key)) {
-            throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({safeEvictionKeys: []}).`);
+            throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({evictableKeys: []}).`);
         }
 
         if (options.canEvict) {

lib/withOnyx/index.tsx

@@ -290,7 +290,7 @@ export default function <TComponentProps, TOnyxProps>(
                     const key = Str.result(mapping.key as GenericFunction, this.props);
 
                     if (!cache.isSafeEvictionKey(key)) {
-                        throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({safeEvictionKeys: []}).`);
+                        throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({evictableKeys: []}).`);
                     }
 
                     if (canEvict) {

tests/unit/cacheEvictionTest.ts

@@ -19,7 +19,7 @@ test('Cache eviction', () => {
             // When we initialize Onyx and mark the set collection key as a safeEvictionKey
             Onyx.init({
                 keys: ONYX_KEYS,
-                safeEvictionKeys: [ONYX_KEYS.COLLECTION.TEST_KEY],
+                evictableKeys: [ONYX_KEYS.COLLECTION.TEST_KEY],
             });
 
             // And connect to this key

tests/unit/onyxCacheTest.tsx

@@ -444,7 +444,7 @@ describe('Onyx', () => {
         function initOnyx(overrides?: Partial<InitOptions>) {
             Onyx.init({
                 keys: ONYX_KEYS,
-                safeEvictionKeys: [ONYX_KEYS.COLLECTION.MOCK_COLLECTION],
+                evictableKeys: [ONYX_KEYS.COLLECTION.MOCK_COLLECTION],
                 maxCachedKeysCount: 10,
                 ...overrides,
             });
@@ -677,7 +677,7 @@ describe('Onyx', () => {
                 });
         });
 
-        it('Should prioritize eviction of safeEvictionKeys over non-safe keys when cache limit is reached', () => {
+        it('Should prioritize eviction of evictableKeys over non-evictable keys when cache limit is reached', () => {
             const testKeys = {
                 ...ONYX_KEYS,
                 SAFE_FOR_EVICTION: 'evictable_',
@@ -710,7 +710,7 @@ describe('Onyx', () => {
             return initOnyx({
                 keys: testKeys,
                 maxCachedKeysCount: 3, // Only allow 3 keys in cache
-                safeEvictionKeys: [testKeys.SAFE_FOR_EVICTION],
+                evictableKeys: [testKeys.SAFE_FOR_EVICTION],
             })
                 .then(() => {
                     // Connect to non-evictable keys first (oldest in LRU queue)
@@ -746,7 +746,7 @@ describe('Onyx', () => {
                 });
         });
 
-        it('Should fall back to LRU order for all keys once all safeEvictionKeys are evicted', () => {
+        it('Should fall back to LRU order for all keys once all evictableKeys are evicted', () => {
             const testKeys = {
                 ...ONYX_KEYS,
                 SAFE_FOR_EVICTION: 'evictable_',
@@ -775,7 +775,7 @@ describe('Onyx', () => {
             return initOnyx({
                 keys: testKeys,
                 maxCachedKeysCount: 2, // Only allow 2 keys in cache
-                safeEvictionKeys: [testKeys.SAFE_FOR_EVICTION],
+                evictableKeys: [testKeys.SAFE_FOR_EVICTION],
             })
                 .then(() => {
                     // Connect to keys in LRU order (oldest first)