prepare 3.5.0 release (#55)

Author: LaunchDarklyReleaseBot

src/PersistentFlagStore.js

@@ -0,0 +1,48 @@
+import * as utils from './utils';
+
+export default function PersistentFlagStore(storage, environment, hash, ident) {
+  const store = {};
+
+  function getFlagsKey() {
+    let key = '';
+    const user = ident.getUser();
+    if (user) {
+      key = hash || utils.btoa(JSON.stringify(user));
+    }
+    return 'ld:' + environment + ':' + key;
+  }
+
+  // Returns a Promise which will be resolved with a parsed JSON value if a stored value was available,
+  // or resolved with null if there was no value or if storage was not available.
+  store.loadFlags = () =>
+    storage.get(getFlagsKey()).then(dataStr => {
+      if (dataStr === null || dataStr === undefined) {
+        return null;
+      }
+      try {
+        let data = JSON.parse(dataStr);
+        if (data) {
+          const schema = data.$schema;
+          if (schema === undefined || schema < 1) {
+            data = utils.transformValuesToVersionedValues(data);
+          } else {
+            delete data['$schema'];
+          }
+        }
+        return data;
+      } catch (ex) {
+        return store.clearFlags().then(() => null);
+      }
+    });
+
+  // Resolves with true if successful, or false if storage is unavailable. Never rejects.
+  store.saveFlags = flags => {
+    const data = utils.extend({}, flags, { $schema: 1 });
+    return storage.set(getFlagsKey(), JSON.stringify(data));
+  };
+
+  // Resolves with true if successful, or false if storage is unavailable. Never rejects.
+  store.clearFlags = () => storage.clear(getFlagsKey());
+
+  return store;
+}

src/PersistentStorage.js

@@ -0,0 +1,79 @@
+import * as messages from './messages';
+
+// The localStorageProvider is provided by the platform object. It should have the following
+// methods, each of which should return a Promise:
+// - get(key): Gets the string value, if any, for the given key
+// - set(key, value): Stores a string value for the given key
+// - remove(key): Removes the given key
+//
+// Storage is just a light wrapper of the localStorageProvider, adding error handling and
+// ensuring that we don't call it if it's unavailable. The get method will simply resolve
+// with an undefined value if there is an error or if there is no localStorageProvider.
+// None of the promises returned by Storage will ever be rejected.
+//
+// It is always possible that the underlying platform storage mechanism might fail or be
+// disabled. If so, it's likely that it will keep failing, so we will only log one warning
+// instead of repetitive warnings.
+export default function PersistentStorage(localStorageProvider, logger) {
+  const storage = {};
+  let loggedError = false;
+
+  const logError = err => {
+    if (!loggedError) {
+      loggedError = true;
+      logger.warn(messages.localStorageUnavailable(err));
+    }
+  };
+
+  storage.isEnabled = () => !!localStorageProvider;
+
+  // Resolves with a value, or undefined if storage is unavailable. Never rejects.
+  storage.get = key =>
+    new Promise(resolve => {
+      if (!localStorageProvider) {
+        resolve(undefined);
+        return;
+      }
+      localStorageProvider
+        .get(key)
+        .then(resolve)
+        .catch(err => {
+          logError(err);
+          resolve(undefined);
+        });
+    });
+
+  // Resolves with true if successful, or false if storage is unavailable. Never rejects.
+  storage.set = (key, value) =>
+    new Promise(resolve => {
+      if (!localStorageProvider) {
+        resolve(false);
+        return;
+      }
+      localStorageProvider
+        .set(key, value)
+        .then(() => resolve(true))
+        .catch(err => {
+          logError(err);
+          resolve(false);
+        });
+    });
+
+  // Resolves with true if successful, or false if storage is unavailable. Never rejects.
+  storage.clear = key =>
+    new Promise(resolve => {
+      if (!localStorageProvider) {
+        resolve(false);
+        return;
+      }
+      localStorageProvider
+        .clear(key)
+        .then(() => resolve(true))
+        .catch(err => {
+          logError(err);
+          resolve(false);
+        });
+    });
+
+  return storage;
+}

src/Store.js

@@ -12,23 +12,13 @@ import * as utils from './utils';
 
 const ldUserIdKey = 'ld:$anonUserId';
 
-export default function UserValidator(localStorageProvider, logger) {
+export default function UserValidator(persistentStorage) {
   function getCachedUserId() {
-    if (localStorageProvider) {
-      return localStorageProvider.get(ldUserIdKey).catch(() => null);
-      // Not logging errors here, because if local storage fails for the get, it will presumably fail for the set,
-      // so we will end up logging an error in setCachedUserId anyway.
-    }
-    return Promise.resolve(null);
+    return persistentStorage.get(ldUserIdKey);
   }
 
   function setCachedUserId(id) {
-    if (localStorageProvider) {
-      return localStorageProvider.set(ldUserIdKey, id).catch(() => {
-        logger.warn(messages.localStorageUnavailableForUserId());
-      });
-    }
-    return Promise.resolve();
+    return persistentStorage.set(ldUserIdKey, id);
   }
 
   const ret = {};

src/UserValidator.js

@@ -86,20 +86,22 @@ describe('LDClient local storage', () => {
     });
 
     it('should handle localStorage.get returning an error', async () => {
-      platform.localStorage.get = () => Promise.reject(new Error());
+      const myError = new Error('deliberate error');
+      platform.localStorage.get = () => Promise.reject(myError);
       const flags = { 'enable-foo': { value: true } };
 
       await withServer(async server => {
         server.byDefault(respondJson(flags));
         await withClient(user, { baseUrl: server.url }, async client => {
           await client.waitForInitialization();
-          expect(platform.testing.logger.output.warn).toEqual([messages.localStorageUnavailable()]);
+          expect(platform.testing.logger.output.warn).toEqual([messages.localStorageUnavailable(myError)]);
         });
       });
     });
 
     it('should handle localStorage.set returning an error', async () => {
-      platform.localStorage.set = () => Promise.reject(new Error());
+      const myError = new Error('deliberate error');
+      platform.localStorage.set = () => Promise.reject(myError);
       const flags = { 'enable-foo': { value: true } };
 
       await withServer(async server => {
@@ -109,7 +111,7 @@ describe('LDClient local storage', () => {
 
           await sleepAsync(0); // allow any pending async tasks to complete
 
-          expect(platform.testing.logger.output.warn).toEqual([messages.localStorageUnavailable()]);
+          expect(platform.testing.logger.output.warn).toEqual([messages.localStorageUnavailable(myError)]);
         });
       });
     });