Added persistent settings store for dynamic settings configuration

package.json

@@ -24,6 +24,7 @@
     "body-parser": "^1.14.2",
     "colors": "^1.1.2",
     "commander": "^2.9.0",
+    "deep-equal": "^1.0.1",
     "deepcopy": "^0.6.1",
     "express": "^4.13.4",
     "intersect": "^1.0.1",

spec/PersistentSettingsStore.spec.js

@@ -0,0 +1,134 @@
+'use strict';
+
+var PersistentSettingsStore = require('../src/PersistentSettingsStore').default;
+var DatabaseAdapter = require('../src/DatabaseAdapter');
+var appId = 'test';
+var collectionPrefix = 'test_';
+var store;
+var settingsCollection;
+
+describe('PersistentSettingsStore', function () {
+  beforeEach(function () {
+    store = PersistentSettingsStore({
+      freshness: 0.1
+    }, {
+      defined: 0
+    });
+  });
+
+  describe('mocked db', function () {
+    beforeEach(function () {
+      settingsCollection = jasmine.createSpyObj('settingsCollection', ['find', 'upsertOne']);
+      settingsCollection.find.and.returnValue(Promise.resolve([]));
+      settingsCollection.upsertOne.and.returnValue(Promise.resolve());
+
+      spyOn(DatabaseAdapter, 'getDatabaseConnection').and.returnValue({
+        adaptiveCollection: _ => {
+          return Promise.resolve(settingsCollection);
+        }
+      });
+    });
+
+    it('does not persist locked settings', function() {
+      store.set(appId, {
+        applicationId: appId
+      });
+
+      expect(store.get(appId, 'persisted').applicationId).toBeUndefined;
+      expect(store.get(appId, 'locked').applicationId).toEqual(appId);
+    });
+
+    it('does not persist defined settings by default', function() {
+      store.set(appId, {
+        defined: 0
+      });
+
+      expect(store.get(appId, 'persisted').defined).toBeUndefined;
+      expect(store.get(appId, 'locked').defined).toBeDefined;
+    });
+
+    it('persists defined settings if lockDefinedSettings false', function() {
+      store = PersistentSettingsStore({
+        lockDefinedSettings: false
+      }, {
+        defined: 0
+      });
+
+      store.set(appId, {
+        defined: 0
+      });
+
+      expect(store.get(appId, 'persisted').defined).toBeDefined;
+      expect(store.get(appId, 'locked').defined).toBeUndefined;
+    });
+
+    it('does not allow modification of locked settings', function() {
+      store.set(appId, {
+        defined: 0
+      });
+
+      store.get(appId).defined = 2;
+
+      expect(store.get(appId).defined).toEqual(0);
+    });
+
+    it('allows modification of persisted settings', function() {
+      store.set(appId, {
+        modifiable: 0
+      });
+
+      store.get(appId).modifiable = 2;
+      expect(store.get(appId).modifiable).toEqual(2);
+    });
+
+    it('respects freshness option', function(done) {
+      // freshness 100 ms
+      store.set(appId, {
+        modifiable: 0
+      });
+
+      function get() {
+        store.get(appId);
+      }
+      setTimeout(get, 50);
+      // freshness expires
+      setTimeout(get, 150);
+      setTimeout(get, 200);
+      // freshness expires
+      setTimeout(get, 300)
+      setTimeout(function () {
+        // three calls: one for initial pull, two from expired freshness
+        expect(settingsCollection.find.calls.count()).toEqual(3);
+        done();
+      }, 350);
+    });
+
+    it('pushes on setting change', function(done) {
+      store.set(appId, {
+        applicationId: appId,
+        modifiable: 0
+      });
+
+      setTimeout(function () {
+        store.get(appId).modifiable = 2;
+      }, 100);
+
+      setTimeout(function () {
+        var calls = settingsCollection.upsertOne.calls;
+        expect(calls.count()).toEqual(2);
+        expect(calls.argsFor(0)[1]).toEqual({
+          applicationId: appId,
+          persisted: {
+            modifiable: 0
+          }
+        });
+        expect(calls.argsFor(1)[1]).toEqual({
+          $set: {
+            'persisted.modifiable': 2
+          }
+        });
+        done();
+      }, 200);
+    });
+  });
+});

src/Config.js

@@ -49,6 +49,7 @@ export class Config {
     this.liveQueryController = cacheInfo.liveQueryController;
     this.sessionLength = cacheInfo.sessionLength;
     this.generateSessionExpiresAt = this.generateSessionExpiresAt.bind(this);
+    this.settingsCacheOptions = cacheInfo.settingsCacheOptions;
   }
 
   static validate(options) {

src/ParseServer.js

@@ -15,6 +15,7 @@ var batch = require('./batch'),
 import { logger,
       configureLogger }       from './logger';
 import cache                    from './cache';
+import PersistentSettingsStore  from './PersistentSettingsStore';
 import Config                   from './Config';
 import parseServerPackage       from '../package.json';
 import PromiseRouter            from './PromiseRouter';
@@ -81,43 +82,48 @@ addParseCloud();
 
 class ParseServer {
 
-  constructor({
-    appId = requiredParameter('You must provide an appId!'),
-    masterKey = requiredParameter('You must provide a masterKey!'),
-    appName,
-    databaseAdapter,
-    filesAdapter,
-    push,
-    loggerAdapter,
-    logsFolder,
-    databaseURI = DatabaseAdapter.defaultDatabaseURI,
-    databaseOptions,
-    cloud,
-    collectionPrefix = '',
-    clientKey,
-    javascriptKey,
-    dotNetKey,
-    restAPIKey,
-    fileKey = 'invalid-file-key',
-    facebookAppIds = [],
-    enableAnonymousUsers = true,
-    allowClientClassCreation = true,
-    oauth = {},
-    serverURL = requiredParameter('You must provide a serverURL!'),
-    maxUploadSize = '20mb',
-    verifyUserEmails = false,
-    emailAdapter,
-    publicServerURL,
-    customPages = {
-      invalidLink: undefined,
-      verifyEmailSuccess: undefined,
-      choosePassword: undefined,
-      passwordResetSuccess: undefined
-    },
-    liveQuery = {},
-    sessionLength = 31536000, // 1 Year in seconds
-    verbose = false,
-  }) {
+  constructor(definedOptions = {}) {
+    let {
+      appId = requiredParameter('You must provide an appId!'),
+      masterKey = requiredParameter('You must provide a masterKey!'),
+      appName,
+      databaseAdapter,
+      filesAdapter,
+      push,
+      loggerAdapter,
+      logsFolder,
+      databaseURI = DatabaseAdapter.defaultDatabaseURI,
+      databaseOptions,
+      cloud,
+      collectionPrefix = '',
+      clientKey,
+      javascriptKey,
+      dotNetKey,
+      restAPIKey,
+      fileKey = 'invalid-file-key',
+      facebookAppIds = [],
+      enableAnonymousUsers = true,
+      allowClientClassCreation = true,
+      oauth = {},
+      serverURL = requiredParameter('You must provide a serverURL!'),
+      maxUploadSize = '20mb',
+      verifyUserEmails = false,
+      emailAdapter,
+      publicServerURL,
+      customPages = {
+        invalidLink: undefined,
+        verifyEmailSuccess: undefined,
+        choosePassword: undefined,
+        passwordResetSuccess: undefined
+      },
+      liveQuery = {},
+      sessionLength = 31536000, // 1 Year in seconds
+      verbose = false,
+      settingsCacheOptions = {
+        lockDefinedSettings: true,
+        freshness: 15
+      }
+    } = definedOptions;
     // Initialize the node client SDK automatically
     Parse.initialize(appId, javascriptKey || 'unused', masterKey);
     Parse.serverURL = serverURL;
@@ -171,7 +177,11 @@ class ParseServer {
     const userController = new UserController(emailControllerAdapter, appId, { verifyUserEmails });
     const liveQueryController = new LiveQueryController(liveQuery);
 
+    if (settingsCacheOptions) {
+      cache.apps = PersistentSettingsStore(settingsCacheOptions, definedOptions);
+    }
     cache.apps.set(appId, {
+      applicationId: appId,
       masterKey: masterKey,
       serverURL: serverURL,
       collectionPrefix: collectionPrefix,
@@ -195,6 +205,7 @@ class ParseServer {
       maxUploadSize: maxUploadSize,
       liveQueryController: liveQueryController,
       sessionLength : Number(sessionLength),
+      settingsCacheOptions: settingsCacheOptions
     });
 
     // To maintain compatibility. TODO: Remove in some version that breaks backwards compatability