Reuse StorageController for LDS

integration/test/ParseLocalDatastoreTest.js

@@ -2688,6 +2688,7 @@ describe('Parse LocalDatastore', () => {
   beforeEach((done) => {
     Parse.initialize('integration', null, 'notsosecret');
     Parse.CoreManager.set('SERVER_URL', 'http://localhost:1337/parse');
+    Parse.CoreManager.getInstallationController()._setInstallationIdCache('1234');
     Parse.enableLocalDatastore();
     Parse.User.enableUnsafeCurrentUser();
     Parse.Storage._clear();
@@ -2697,8 +2698,7 @@ describe('Parse LocalDatastore', () => {
   });
 
   const controllers = [
-    { name: 'Default', file: '../../lib/node/LocalDatastoreController.default' },
-    { name: 'Browser', file: '../../lib/node/LocalDatastoreController.browser' },
+    { name: 'Default', file: '../../lib/node/LocalDatastoreController' },
     { name: 'React-Native', file: '../../lib/node/LocalDatastoreController.react-native' },
   ];
 

src/CoreManager.js

@@ -338,12 +338,14 @@ module.exports = {
         'getItemAsync',
         'setItemAsync',
         'removeItemAsync',
+        'getAllKeysAsync'
       ], controller);
     } else {
       requireMethods('A synchronous StorageController', [
         'getItem',
         'setItem',
         'removeItem',
+        'getAllKeys'
       ], controller);
     }
     config['StorageController'] = controller;

src/LocalDatastore.js

@@ -406,11 +406,7 @@ module.exports = LocalDatastore;
 
 if (process.env.PARSE_BUILD === 'react-native') {
   CoreManager.setLocalDatastoreController(require('./LocalDatastoreController.react-native'));
-} else if (process.env.PARSE_BUILD === 'browser') {
-  CoreManager.setLocalDatastoreController(require('./LocalDatastoreController.browser'));
-} else if (process.env.PARSE_BUILD === 'weapp') {
-  CoreManager.setLocalDatastoreController(require('./LocalDatastoreController.weapp'));
 } else {
-  CoreManager.setLocalDatastoreController(require('./LocalDatastoreController.default'));
+  CoreManager.setLocalDatastoreController(require('./LocalDatastoreController'));
 }
 CoreManager.setLocalDatastore(LocalDatastore);

src/LocalDatastoreController.browser.js → src/LocalDatastoreController.js

@@ -8,13 +8,12 @@
  *
  * @flow
  */
-
-/* global localStorage */
 import { isLocalDatastoreKey } from './LocalDatastoreUtils';
+import Storage from './Storage';
 
 const LocalDatastoreController = {
-  fromPinWithName(name: string): Array<Object> {
-    const values = localStorage.getItem(name);
+  async fromPinWithName(name: string): Array<Object> {
+    const values = await Storage.getItemAsync(name);
     if (!values) {
       return [];
     }
@@ -23,49 +22,46 @@ const LocalDatastoreController = {
   },
 
   pinWithName(name: string, value: any) {
-    try {
-      const values = JSON.stringify(value);
-      localStorage.setItem(name, values);
-    } catch (e) {
-      // Quota exceeded, possibly due to Safari Private Browsing mode
-      console.log(e.message);
-    }
+    const values = JSON.stringify(value);
+    return Storage.setItemAsync(name, values);
   },
 
   unPinWithName(name: string) {
-    localStorage.removeItem(name);
+    return Storage.removeItemAsync(name);
   },
 
-  getAllContents(): Object {
-    const LDS = {};
-    for (let i = 0; i < localStorage.length; i += 1) {
-      const key = localStorage.key(i);
+  async getAllContents(): Object {
+    const keys = await Storage.getAllKeysAsync();
+    return keys.reduce(async (previousPromise, key) => {
+      const LDS = await previousPromise;
       if (isLocalDatastoreKey(key)) {
-        const value = localStorage.getItem(key);
+        const value = await Storage.getItemAsync(key);
         try {
           LDS[key] = JSON.parse(value);
         } catch (error) {
           console.error('Error getAllContents: ', error);
         }
       }
-    }
-    return LDS;
+      return LDS;
+    }, Promise.resolve({}));
   },
 
-  getRawStorage(): Object {
-    const storage = {};
-    for (let i = 0; i < localStorage.length; i += 1) {
-      const key = localStorage.key(i);
-      const value = localStorage.getItem(key);
-      storage[key] = value;
-    }
-    return storage;
+  // Used for testing
+  async getRawStorage(): Object {
+    const keys = await Storage.getAllKeysAsync();
+    return keys.reduce(async (previousPromise, key) => {
+      const LDS = await previousPromise;
+      const value = await Storage.getItemAsync(key);
+      LDS[key] = value;
+      return LDS;
+    }, Promise.resolve({}));
   },
 
-  clear(): Promise {
+  async clear(): Promise {
+    const keys = await Storage.getAllKeysAsync();
+
     const toRemove = [];
-    for (let i = 0; i < localStorage.length; i += 1) {
-      const key = localStorage.key(i);
+    for(const key of keys){
       if (isLocalDatastoreKey(key)) {
         toRemove.push(key);
       }

src/LocalDatastoreController.react-native.js

@@ -37,7 +37,7 @@ const LocalDatastoreController = {
   },
 
   async getAllContents(): Promise<Object> {
-    const keys = await RNStorage.getAllKeys();
+    const keys = await RNStorage.getAllKeysAsync();
     const batch = [];
     for (let i = 0; i < keys.length; i += 1) {
       const key = keys[i];
@@ -64,8 +64,9 @@ const LocalDatastoreController = {
     return LDS;
   },
 
+  // Used for testing
   async getRawStorage(): Promise<Object> {
-    const keys = await RNStorage.getAllKeys();
+    const keys = await RNStorage.getAllKeysAsync();
     const storage = {};
     const results = await RNStorage.multiGet(keys);
     results.map((pair) => {
@@ -76,7 +77,7 @@ const LocalDatastoreController = {
   },
 
   async clear(): Promise<void> {
-    const keys = await RNStorage.getAllKeys();
+    const keys = await RNStorage.getAllKeysAsync();
     const batch = [];
     for (let i = 0; i < keys.length; i += 1) {
       const key = keys[i];

src/Storage.js

@@ -71,6 +71,24 @@ const Storage = {
     return Promise.resolve(controller.removeItem(path));
   },
 
+  getAllKeys(): Array<string> {
+    const controller = CoreManager.getStorageController();
+    if (controller.async === 1) {
+      throw new Error(
+        'Synchronous storage is not supported by the current storage controller'
+      );
+    }
+    return controller.getAllKeys();
+  },
+
+  getAllKeysAsync(): Promise<Array<string>> {
+    const controller = CoreManager.getStorageController();
+    if (controller.async === 1) {
+      return controller.getAllKeysAsync();
+    }
+    return Promise.resolve(controller.getAllKeys());
+  },
+
   generatePath(path: string): string {
     if (!CoreManager.get('APPLICATION_ID')) {
       throw new Error('You need to call Parse.initialize before using Parse.');

src/StorageController.browser.js

@@ -21,13 +21,22 @@ const StorageController = {
       localStorage.setItem(path, value);
     } catch (e) {
       // Quota exceeded, possibly due to Safari Private Browsing mode
+      console.log(e.message);
     }
   },
 
   removeItem(path: string) {
     localStorage.removeItem(path);
   },
 
+  getAllKeys() {
+    const keys = [];
+    for (let i = 0; i < localStorage.length; i += 1) {
+      keys.push(localStorage.key(i));
+    }
+    return keys;
+  },
+
   clear() {
     localStorage.clear();
   }

src/StorageController.default.js

@@ -29,6 +29,10 @@ const StorageController = {
     delete memMap[path];
   },
 
+  getAllKeys() {
+    return Object.keys(memMap);
+  },
+
   clear() {
     for (const key in memMap) {
       if (memMap.hasOwnProperty(key)) {

src/StorageController.react-native.js

@@ -54,7 +54,7 @@ const StorageController = {
     });
   },
 
-  getAllKeys(): Promise {
+  getAllKeysAsync(): Promise {
     return new Promise((resolve, reject) => {
       this.getAsyncStorage().getAllKeys(function(err, keys) {
         if (err) {

src/StorageController.weapp.js

@@ -27,6 +27,11 @@ const StorageController = {
     wx.removeStorageSync(path);
   },
 
+  getAllKeys() {
+    const res = wx.getStorageInfoSync();
+    return res.keys;
+  },
+
   clear() {
     wx.clearStorageSync();
   }