[FSSDK-9621] remove duplicate reactNativeAsyncStorageCache imlementations and refactor

Author: raju-opti

lib/modules/datafile-manager/datafileManager.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PersistentKeyValueCache from './persistentKeyValueCache';
+import PersistentKeyValueCache from '../../plugins/key_value_cache/persistentKeyValueCache';
 
 export interface DatafileUpdate {
   datafile: string;

lib/modules/datafile-manager/httpPollingDatafileManager.ts

@@ -21,7 +21,7 @@ import EventEmitter, { Disposer } from './eventEmitter';
 import { AbortableRequest, Response, Headers } from './http';
 import { DEFAULT_UPDATE_INTERVAL, MIN_UPDATE_INTERVAL, DEFAULT_URL_TEMPLATE, UPDATE_INTERVAL_BELOW_MINIMUM_MESSAGE } from './config';
 import BackoffController from './backoffController';
-import PersistentKeyValueCache from './persistentKeyValueCache';
+import PersistentKeyValueCache from '../../plugins/key_value_cache/persistentKeyValueCache';
 
 import { NotificationRegistry } from './../../core/notification_center/notification_registry';
 import { NOTIFICATION_TYPES } from '../../utils/enums';
@@ -35,8 +35,8 @@ function isSuccessStatusCode(statusCode: number): boolean {
 }
 
 const noOpKeyValueCache: PersistentKeyValueCache = {
-  get(): Promise<string> {
-    return Promise.resolve('');
+  get(): Promise<string | undefined> {
+    return Promise.resolve(undefined);
   },
 
   set(): Promise<void> {
@@ -47,8 +47,8 @@ const noOpKeyValueCache: PersistentKeyValueCache = {
     return Promise.resolve(false);
   },
 
-  remove(): Promise<void> {
-    return Promise.resolve();
+  remove(): Promise<boolean> {
+    return Promise.resolve(false);
   },
 };
 
@@ -339,7 +339,7 @@ export default abstract class HttpPollingDatafileManager implements DatafileMana
 
   setDatafileFromCacheIfAvailable(): void {
     this.cache.get(this.cacheKey).then(datafile => {
-      if (this.isStarted && !this.isReadyPromiseSettled && datafile !== '') {
+      if (this.isStarted && !this.isReadyPromiseSettled && datafile) {
         logger.debug('Using datafile from cache');
         this.currentDatafile = datafile;
         this.resolveReadyPromise();

lib/modules/datafile-manager/persistentKeyValueCache.ts

@@ -18,7 +18,7 @@ import { makeGetRequest } from './browserRequest';
 import HttpPollingDatafileManager from './httpPollingDatafileManager';
 import { Headers, AbortableRequest } from './http';
 import { DatafileManagerConfig } from './datafileManager';
-import ReactNativeAsyncStorageCache from './reactNativeAsyncStorageCache';
+import ReactNativeAsyncStorageCache from '../../plugins/key_value_cache/reactNativeAsyncStorageCache';
 
 export default class ReactNativeDatafileManager extends HttpPollingDatafileManager {
   protected makeGetRequest(reqUrl: string, headers: Headers): AbortableRequest {

lib/modules/datafile-manager/reactNativeAsyncStorageCache.ts

@@ -18,7 +18,7 @@ import { getLogger } from '../logging'
 import { objectValues } from "../../utils/fns"
 
 import { Synchronizer } from './synchronizer'
-import ReactNativeAsyncStorageCache from './reactNativeAsyncStorageCache'
+import ReactNativeAsyncStorageCache from '../../plugins/key_value_cache/reactNativeAsyncStorageCache';
 
 const logger = getLogger('ReactNativeEventsStore')
 
@@ -38,10 +38,11 @@ export class ReactNativeEventsStore<T> {
 
   public async set(key: string, event: T): Promise<string> {
     await this.synchronizer.getLock()
-    const eventsMap: {[key: string]: T} = await this.cache.get(this.storeKey) || {}    
+    const eventsMap: {[key: string]: T} = await this.getEventsMap();
+    // const eventsMap: {[key: string]: T} = await this.cache.get(this.storeKey) || {}    
     if (Object.keys(eventsMap).length < this.maxSize) {
       eventsMap[key] = event
-      await this.cache.set(this.storeKey, eventsMap)
+      await this.cache.set(this.storeKey, JSON.stringify(eventsMap))
     } else {
       logger.warn('React native events store is full. Store key: %s', this.storeKey)
     }
@@ -51,27 +52,28 @@ export class ReactNativeEventsStore<T> {
 
   public async get(key: string): Promise<T> {
     await this.synchronizer.getLock()
-    const eventsMap: {[key: string]: T} = await this.cache.get(this.storeKey) || {}
+    const eventsMap: {[key: string]: T} = await this.getEventsMap()
     this.synchronizer.releaseLock()
     return eventsMap[key]
   }
 
   public async getEventsMap(): Promise<{[key: string]: T}> {
-    return await this.cache.get(this.storeKey) || {}
+    const cachedValue = await this.cache.get(this.storeKey) || '{}';
+    return JSON.parse(cachedValue)
   }
 
   public async getEventsList(): Promise<T[]> {
     await this.synchronizer.getLock()
-    const eventsMap: {[key: string]: T} = await this.cache.get(this.storeKey) || {}
+    const eventsMap: {[key: string]: T} = await this.getEventsMap()
     this.synchronizer.releaseLock()
     return objectValues(eventsMap)
   }
 
   public async remove(key: string): Promise<void> {
     await this.synchronizer.getLock()
-    const eventsMap: {[key: string]: T} = await this.cache.get(this.storeKey) || {}
+    const eventsMap: {[key: string]: T} = await this.getEventsMap()
     eventsMap[key] && delete eventsMap[key]
-    await this.cache.set(this.storeKey, eventsMap)
+    await this.cache.set(this.storeKey, JSON.stringify(eventsMap))
     this.synchronizer.releaseLock()
   }
 

lib/modules/datafile-manager/reactNativeDatafileManager.ts

@@ -34,14 +34,14 @@ export default class BrowserAsyncStorageCache implements PersistentKeyValueCache
     });
   }
 
-  async get(key: string): Promise<string | null | undefined> {
-    return tryWithLocalStorage<string | null | undefined>({
+  async get(key: string): Promise<string | undefined> {
+    return tryWithLocalStorage<string | undefined>({
       browserCallback: (localStorage?: Storage) => {
-        return localStorage?.getItem(key);
+        return (localStorage?.getItem(key) || undefined);
       },
       nonBrowserCallback: () => {
         this.logger.error(ERROR_MESSAGES.LOCAL_STORAGE_DOES_NOT_EXIST);
-        return null;
+        return undefined;
       },
     });
   }

lib/modules/event_processor/persistentKeyValueCache.ts

@@ -15,9 +15,9 @@
  */
 
 /**
- * An Interface to implement a persistent key value cache which supports strings as keys and value objects.
+ * An Interface to implement a persistent key value cache which supports strings as keys.
  */
-export default interface PersistentKeyValueCache {
+export default interface PersistentKeyValueCache<V = string> {
   /**
    * Checks if a key exists in the cache
    * @param key
@@ -37,8 +37,7 @@ export default interface PersistentKeyValueCache {
    * 2. undefined if the key does not exist in the cache.
    * Rejects the promise in case of an error
    */
-  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  get(key: string): Promise<any>;
+  get(key: string): Promise<V | undefined>;
 
   /**
    * Removes the key value pair from cache.
@@ -59,6 +58,5 @@ export default interface PersistentKeyValueCache {
    * Resolves promise without a value if successful
    * Rejects the promise in case of an error
    */
-  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  set(key: string, val: any): Promise<void>;
+  set(key: string, val: V): Promise<void>;
 }

lib/modules/event_processor/reactNativeAsyncStorageCache.ts

@@ -22,8 +22,8 @@ export default class ReactNativeAsyncStorageCache implements PersistentKeyValueC
     return await AsyncStorage.getItem(key) !== null;
   }
 
-  async get(key: string): Promise<string | null> {
-    return await AsyncStorage.getItem(key);
+  async get(key: string): Promise<string | undefined> {
+    return (await AsyncStorage.getItem(key) || undefined);
   }
 
   async remove(key: string): Promise<boolean> {

lib/modules/event_processor/reactNativeEventsStore.ts

@@ -63,10 +63,10 @@ describe('BrowserAsyncStorageCache', () => {
       expect(foundValue).toEqual(VALUE_FOR_KEY_THAT_EXISTS);
     });
 
-    it('should return empty string if item is not found in cache', async () => {
+    it('should return undefined if item is not found in cache', async () => {
       const json = await cacheInstance.get(NONEXISTENT_KEY);
 
-      expect(json).toBeNull();
+      expect(json).toBeUndefined();
     });
   });