feat: datafile accessor (#535)

Summary:

Add a getDatafile method to the OptimizelyConfig object, that returns a string version of the datafile currently being used by the instance.

- toDatafile function added in project_config module to encapsulate conversion of project config to datafile string
- Parsing & validation code updated (in both optimizely-sdk and updated datafile-manager version) to only call JSON.parse at most once.

Test Plan:

Manual testing
Passing new FSC datafile accessor tests
Updated unit tests

Co-authored-by: Matt Carroll <matt.carroll@optimizely.com>
Co-authored-by: Sohail Hussain <mirza.sohailhussain@gmail.com>
Co-authored-by: muhammadnoman <muhammadnoman@folio3.com>

Author: 4 people

packages/optimizely-sdk/.eslintrc.js

@@ -14,7 +14,9 @@ module.exports = {
     Promise: 'readonly',
   },
   parserOptions: {
-    ecmaVersion: 6,
+    // Note: The TS compiler determines what syntax is accepted. We're using TS version 3.3.3333.
+    // This seems to roughly correspond to "2018" for this setting.
+    ecmaVersion: 2018,
     sourceType: 'module',
   },
   overrides: [

packages/optimizely-sdk/lib/core/optimizely_config/index.js

@@ -110,12 +110,26 @@ function getFeaturesMap(configObj, allExperiments) {
   }, {});
 }
 
-export var getOptimizelyConfig = function(configObj) {
-  // Fetch all feature variables from feature flags to merge them with variation variables
-  var experimentsMap = getExperimentsMap(configObj);
-  return {
-    experimentsMap: experimentsMap,
-    featuresMap: getFeaturesMap(configObj, experimentsMap),
-    revision: configObj.revision,
-  };
-};
+/**
+ * The OptimizelyConfig class
+ * @param {Object} configObj
+ * @param {string} datafile
+ */
+export function OptimizelyConfig(configObj, datafile) {
+  this.experimentsMap = getExperimentsMap(configObj);
+  this.featuresMap = getFeaturesMap(configObj, this.experimentsMap);
+  this.revision = configObj.revision;
+  this.__datafile = datafile;
+}
+
+/**
+ * Get the datafile
+ * @returns {string} JSON string representation of the datafile that was used to create the current config object
+ */
+OptimizelyConfig.prototype.getDatafile = function() {
+  return this.__datafile;
+}
+
+export default {
+  OptimizelyConfig: OptimizelyConfig
+}

packages/optimizely-sdk/lib/core/optimizely_config/index.tests.js

@@ -16,7 +16,7 @@
 import { assert } from 'chai';
 import { cloneDeep } from 'lodash';
 
-import { getOptimizelyConfig } from './index';
+import { OptimizelyConfig } from './index';
 import { createProjectConfig } from '../project_config';
 import { getTestProjectConfigWithFeatures } from '../../tests/test_data';
 
@@ -41,7 +41,7 @@ describe('lib/core/optimizely_config', function() {
     var projectConfigObject;
     beforeEach(function() {
       projectConfigObject = createProjectConfig(cloneDeep(datafile));
-      optimizelyConfigObject = getOptimizelyConfig(projectConfigObject);
+      optimizelyConfigObject = new OptimizelyConfig(projectConfigObject, JSON.stringify(datafile));
     });
 
     it('should return all experiments except rollouts', function() {

packages/optimizely-sdk/lib/core/project_config/index.js

@@ -18,8 +18,8 @@ import { sprintf, objectValues } from '@optimizely/js-sdk-utils';
 import { assign, keyBy } from '../../utils/fns';
 import {
   ERROR_MESSAGES,
-  LOG_MESSAGES,
   LOG_LEVEL,
+  LOG_MESSAGES,
   FEATURE_VARIABLE_TYPES,
 } from '../../utils/enums';
 import configValidator from '../../utils/config_validator';
@@ -58,11 +58,14 @@ function createMutationSafeDatafileCopy(datafile) {
 
 /**
  * Creates projectConfig object to be used for quick project property lookup
- * @param  {Object} datafile JSON datafile representing the project
- * @return {Object} Object representing project configuration
+ * @param  {Object}   datafileObj   JSON datafile representing the project
+ * @param  {string=}  datafileStr   JSON string representation of the datafile
+ * @return {Object}   Object representing project configuration
  */
-export var createProjectConfig = function(datafile) {
-  var projectConfig = createMutationSafeDatafileCopy(datafile);
+export var createProjectConfig = function(datafileObj, datafileStr=null) {
+  var projectConfig = createMutationSafeDatafileCopy(datafileObj);
+
+  projectConfig.__datafileStr = datafileStr === null ? JSON.stringify(datafileObj) : datafileStr;
 
   /*
    * Conditions of audiences in projectConfig.typedAudiences are not
@@ -512,7 +515,7 @@ export var getTypeCastValue = function(variableValue, variableType, logger) {
 /**
  * Returns an object containing all audiences in the project config. Keys are audience IDs
  * and values are audience objects.
- * @param projectConfig
+ * @param   {Object} projectConfig
  * @returns {Object}
  */
 export var getAudiencesById = function(projectConfig) {
@@ -521,44 +524,83 @@ export var getAudiencesById = function(projectConfig) {
 
 /**
  * Returns true if an event with the given key exists in the datafile, and false otherwise
- * @param {Object} projectConfig
- * @param {string} eventKey
+ * @param   {Object} projectConfig
+ * @param   {string} eventKey
  * @returns {boolean}
  */
 export var eventWithKeyExists = function(projectConfig, eventKey) {
   return projectConfig.eventKeyMap.hasOwnProperty(eventKey);
 };
 
 /**
- *
+ * Returns true if experiment belongs to any feature, false otherwise.
  * @param {Object} projectConfig
  * @param {string} experimentId
- * @returns {boolean} Returns true if experiment belongs to
- * any feature, false otherwise.
+ * @returns {boolean} 
  */
 export var isFeatureExperiment = function(projectConfig, experimentId) {
   return projectConfig.experimentFeatureMap.hasOwnProperty(experimentId);
 };
 
+/**
+ * Returns the JSON string representation of the datafile
+ * @param   {Object} projectConfig
+ * @returns {string}
+ */
+export var toDatafile = function(projectConfig) {
+  return projectConfig.__datafileStr;
+}
+
+/**
+ * @typedef   {Object}      TryCreatingProjectConfigResult
+ * @property  {Object|null} configObj
+ * @property  {Error|null}  error
+ */
+
 /**
  * Try to create a project config object from the given datafile and
  * configuration properties.
- * If successful, return the project config object, otherwise throws an error
- * @param  {Object} config
- * @param  {Object} config.datafile
- * @param  {Object} config.jsonSchemaValidator
- * @param  {Object} config.logger
- * @return {Object} Project config object
+ * Returns an object with configObj and error properties.
+ * If successful, configObj is the project config object, and error is null.
+ * Otherwise, configObj is null and error is an error with more information.
+ * @param   {Object}         config
+ * @param   {Object|string}  config.datafile
+ * @param   {Object}         config.jsonSchemaValidator
+ * @param   {Object}         config.logger
+ * @returns {TryCreatingProjectConfigResult}
  */
 export var tryCreatingProjectConfig = function(config) {
-  configValidator.validateDatafile(config.datafile);
-  if (!config.jsonSchemaValidator) {
-    config.logger.log(LOG_LEVEL.INFO, sprintf(LOG_MESSAGES.SKIPPING_JSON_VALIDATION, MODULE_NAME));
+
+  var newDatafileObj;
+  try {
+    newDatafileObj = configValidator.validateDatafile(config.datafile);
+  } catch (error) {
+    return { configObj: null, error };
+  }
+
+  if (config.jsonSchemaValidator) {
+    try {
+      config.jsonSchemaValidator.validate(newDatafileObj);
+      config.logger.log(LOG_LEVEL.INFO, sprintf(LOG_MESSAGES.VALID_DATAFILE, MODULE_NAME));
+    } catch (error) {
+      return { configObj: null, error };
+    }
   } else {
-    config.jsonSchemaValidator.validate(config.datafile);
-    config.logger.log(LOG_LEVEL.INFO, sprintf(LOG_MESSAGES.VALID_DATAFILE, MODULE_NAME));
+    config.logger.log(LOG_LEVEL.INFO, sprintf(LOG_MESSAGES.SKIPPING_JSON_VALIDATION, MODULE_NAME));
+  }
+
+  var createProjectConfigArgs = [newDatafileObj];
+  if (typeof config.datafile === 'string') {
+    // Since config.datafile was validated above, we know that it is a valid JSON string
+    createProjectConfigArgs.push(config.datafile);
   }
-  return this.createProjectConfig(config.datafile);
+
+  var newConfigObj = createProjectConfig(...createProjectConfigArgs);
+
+  return {
+    configObj: newConfigObj,
+    error: null,
+  };
 };
 
 export default {
@@ -583,5 +625,6 @@ export default {
   getAudiencesById: getAudiencesById,
   eventWithKeyExists: eventWithKeyExists,
   isFeatureExperiment: isFeatureExperiment,
+  toDatafile: toDatafile,
   tryCreatingProjectConfig: tryCreatingProjectConfig,
 };

packages/optimizely-sdk/lib/core/project_config/index.tests.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import sinon from 'sinon';
-import { assert } from 'chai';
+import { assert, expect, config } from 'chai';
 import { forEach, cloneDeep } from 'lodash';
 import { getLogger } from '@optimizely/js-sdk-logging';
 import { sprintf } from '@optimizely/js-sdk-utils';
@@ -712,75 +712,91 @@ describe('lib/core/project_config', function() {
       stubJsonSchemaValidator = {
         validate: sinon.stub().returns(true),
       };
-      sinon.stub(projectConfig, 'createProjectConfig').returns({});
       sinon.stub(configValidator, 'validateDatafile').returns(true);
       sinon.spy(logger, 'error');
     });
 
     afterEach(function() {
-      projectConfig.createProjectConfig.restore();
       configValidator.validateDatafile.restore();
       logger.error.restore();
     });
 
     it('returns a project config object created by createProjectConfig when all validation is applied and there are no errors', function() {
-      configValidator.validateDatafile.returns(true);
-      stubJsonSchemaValidator.validate.returns(true);
+      var configDatafile = {
+        foo: 'bar',
+        experiments: [
+          {key: 'a'},
+          {key: 'b'}
+        ]
+      }
+      configValidator.validateDatafile.returns(configDatafile);
       var configObj = {
         foo: 'bar',
         experimentKeyMap: {
-          a: { key: 'a' },
-          b: { key: 'b' },
+          "a": { key: "a", variationKeyMap: {} },
+          "b": { key: "b", variationKeyMap: {} }
         },
       };
-      projectConfig.createProjectConfig.returns(configObj);
+
+      stubJsonSchemaValidator.validate.returns(true);
+
       var result = projectConfig.tryCreatingProjectConfig({
-        datafile: { foo: 'bar' },
+        datafile: configDatafile,
         jsonSchemaValidator: stubJsonSchemaValidator,
         logger: logger,
       });
-      assert.deepEqual(result, configObj);
+
+      assert.deepInclude(result.configObj, configObj)
     });
 
-    it('throws an error when validateDatafile throws', function() {
+    it('returns an error when validateDatafile throws', function() {
       configValidator.validateDatafile.throws();
       stubJsonSchemaValidator.validate.returns(true);
-      assert.throws(function() {
-        projectConfig.tryCreatingProjectConfig({
-          datafile: { foo: 'bar' },
-          jsonSchemaValidator: stubJsonSchemaValidator,
-          logger: logger,
-        });
+      var { error } = projectConfig.tryCreatingProjectConfig({
+        datafile: { foo: 'bar' },
+        jsonSchemaValidator: stubJsonSchemaValidator,
+        logger: logger,
       });
+      assert.isNotNull(error);
     });
 
-    it('throws an error when jsonSchemaValidator.validate throws', function() {
+    it('returns an error when jsonSchemaValidator.validate throws', function() {
       configValidator.validateDatafile.returns(true);
       stubJsonSchemaValidator.validate.throws();
-      assert.throws(function() {
-        var result = projectConfig.tryCreatingProjectConfig({
-          datafile: { foo: 'bar' },
-          jsonSchemaValidator: stubJsonSchemaValidator,
-          logger: logger,
-        });
+      var { error } = projectConfig.tryCreatingProjectConfig({
+        datafile: { foo: 'bar' },
+        jsonSchemaValidator: stubJsonSchemaValidator,
+        logger: logger,
       });
+    assert.isNotNull(error);
     });
 
     it('skips json validation when jsonSchemaValidator is not provided', function() {
-      configValidator.validateDatafile.returns(true);
+
+      var configDatafile = {
+        foo: 'bar',
+        experiments: [
+          {key: 'a'},
+          {key: 'b'}
+        ]
+      }
+
+      configValidator.validateDatafile.returns(configDatafile);
+
       var configObj = {
         foo: 'bar',
         experimentKeyMap: {
-          a: { key: 'a' },
-          b: { key: 'b' },
+          a: { key: 'a', variationKeyMap: {} },
+          b: { key: 'b', variationKeyMap: {} },
         },
       };
-      projectConfig.createProjectConfig.returns(configObj);
+
       var result = projectConfig.tryCreatingProjectConfig({
-        datafile: { foo: 'bar' },
+        datafile: configDatafile,
         logger: logger,
       });
-      assert.deepEqual(result, configObj);
+
+      assert.deepInclude(result.configObj, configObj);
       sinon.assert.notCalled(logger.error);
     });
   });