@splitsoftware/splitio 10.16.1 → 10.17.1

package/lib/storage/AttributesCache/InMemory.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var AttributesCacheInMemory = /*#__PURE__*/function () {
+  function AttributesCacheInMemory() {
+    this.attributesCache = {};
+  }
+  /**
+   * Create or update the value for the given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored
+   */
+
+
+  var _proto = AttributesCacheInMemory.prototype;
+
+  _proto.setAttribute = function setAttribute(attributeName, attributeValue) {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+  /**
+   * Retrieves the value of a given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  ;
+
+  _proto.getAttribute = function getAttribute(attributeName) {
+    return this.attributesCache[attributeName];
+  }
+  /**
+   * Create or update all the given attributes
+   *
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  ;
+
+  _proto.setAttributes = function setAttributes(attributes) {
+    this.attributesCache = (0, _objectAssign.default)(this.attributesCache, attributes);
+    return true;
+  }
+  /**
+   * Retrieve the full attributes map
+   *
+   * @returns {Map<string, Object>} stored attributes
+   */
+  ;
+
+  _proto.getAll = function getAll() {
+    return this.attributesCache;
+  }
+  /**
+   * Removes a given attribute from the map
+   *
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  ;
+
+  _proto.removeAttribute = function removeAttribute(attributeName) {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * Clears all attributes stored in the SDK
+   *
+   */
+  ;
+
+  _proto.clear = function clear() {
+    this.attributesCache = {};
+    return true;
+  };
+
+  return AttributesCacheInMemory;
+}();
+
+var _default = AttributesCacheInMemory;
+exports.default = _default;

package/lib/utils/inputValidation/attribute.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.validateAttribute = validateAttribute;
+
+var _lang = require("../lang");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var log = (0, _logger.default)('');
+
+function validateAttribute(attributeKey, attributeValue, method) {
+  if (!(0, _lang.isString)(attributeKey) || attributeKey.length === 0) {
+    log.warn(method + ": you passed an invalid attribute name, attribute name must be a non-empty string.");
+    return false;
+  }
+
+  var isStringVal = (0, _lang.isString)(attributeValue);
+  var isFiniteVal = (0, _lang.numberIsFinite)(attributeValue);
+  var isBoolVal = (0, _lang.isBoolean)(attributeValue);
+  var isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) {
+    // If it's not of valid type.
+    log.warn(method + ": you passed an invalid attribute value for " + attributeKey + ". Acceptable types are: string, number, boolean and array of strings.");
+    return false;
+  }
+
+  return true;
+}

package/lib/utils/inputValidation/attributes.js

@@ -4,11 +4,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 exports.__esModule = true;
 exports.validateAttributes = validateAttributes;
+exports.validateAttributesDeep = validateAttributesDeep;
 
 var _lang = require("../lang");
 
 var _logger = _interopRequireDefault(require("../logger"));
 
+var _attribute = require("./attribute");
+
 var log = (0, _logger.default)('');
 
 function validateAttributes(maybeAttrs, method) {
@@ -17,4 +20,13 @@ function validateAttributes(maybeAttrs, method) {
     return maybeAttrs;
   log.error(method + ": attributes must be a plain object.");
   return false;
+}
+
+function validateAttributesDeep(maybeAttributes, method) {
+  if (!validateAttributes(maybeAttributes, method)) return false;
+  var result = true;
+  Object.keys(maybeAttributes).forEach(function (attributeKey) {
+    if (!(0, _attribute.validateAttribute)(attributeKey, maybeAttributes[attributeKey], method)) result = false;
+  });
+  return result;
 }

package/lib/utils/settings/index.js

@@ -44,7 +44,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 **/
-var version = '10.16.1';
+var version = '10.17.1';
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio",
-  "version": "10.16.1",
+  "version": "10.17.1",
   "description": "Split SDK",
   "files": [
     "README.md",

package/src/client/attributesDecoration.js

@@ -0,0 +1,112 @@
+import ClientInputValidationLayer from './inputValidation';
+import AttributesCacheInMemory from '../storage/AttributesCache/InMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import logFactory from '../utils/logger';
+import objectAssign from 'object-assign';
+const log = logFactory('splitio-client');
+
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
+ */
+export default function ClientAttributesDecorationLayer(context, isKeyBinded, isTTBinded) {
+
+  const client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
+
+  const attributeStorage = new AttributesCacheInMemory();
+
+  // Keep a reference to the original methods
+  const clientGetTreatment = client.getTreatment;
+  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  const clientGetTreatments = client.getTreatments;
+  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+
+  /**
+   * Add an attribute to client's in memory attributes storage
+   * 
+   * @param {string} attributeName Attrinute name
+   * @param {string, number, boolean, list} attributeValue Attribute value
+   * @returns {boolean} true if the attribute was stored and false otherways
+   */
+  client.setAttribute = (attributeName, attributeValue) => {
+    const attribute = {};
+    attribute[attributeName] = attributeValue;
+    if (!validateAttributesDeep(attribute)) return false;
+    log.debug(`stored ${attributeValue} for attribute ${attributeName}`);
+    return attributeStorage.setAttribute(attributeName, attributeValue);
+  };
+
+  /**
+   * Returns the attribute with the given key
+   * 
+   * @param {string} attributeName Attribute name
+   * @returns {Object} Attribute with the given key
+   */
+  client.getAttribute = (attributeName) => {
+    log.debug(`retrieved attribute ${attributeName}`);
+    return attributeStorage.getAttribute(attributeName + '');
+  };
+
+  /**
+   * Add to client's in memory attributes storage the attributes in 'attributes'
+   * 
+   * @param {Object} attributes Object with attributes to store
+   * @returns true if attributes were stored an false otherways
+   */
+  client.setAttributes = (attributes) => {
+    if (!validateAttributesDeep(attributes)) return false;
+    return attributeStorage.setAttributes(attributes);
+  };
+
+  /**
+   * Return all the attributes stored in client's in memory attributes storage
+   * 
+   * @returns {Object} returns all the stored attributes
+   */
+  client.getAttributes = () => {
+    return attributeStorage.getAll();
+  };
+
+  /**
+   * Removes from client's in memory attributes storage the attribute with the given key
+   * 
+   * @param {string} attributeName 
+   * @returns {boolean} true if attribute was removed and false otherways
+   */
+  client.removeAttribute = (attributeName) => {
+    log.debug(`removed attribute ${attributeName}`);
+    return attributeStorage.removeAttribute(attributeName + '');
+  };
+
+  /**
+   * Remove all the stored attributes in the client's in memory attribute storage
+   */
+  client.clearAttributes = () => {
+    return attributeStorage.clear();
+  };
+
+  client.getTreatment = (maybeKey, maybeSplit, maybeAttributes) => {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatmentWithConfig = (maybeKey, maybeSplit, maybeAttributes) => {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatments = (maybeKey, maybeSplits, maybeAttributes) => {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatmentsWithConfig = (maybeKey, maybeSplits, maybeAttributes) => {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  };
+
+  function combineAttributes(maybeAttributes) {
+    const storedAttributes = attributeStorage.getAll();
+    if (Object.keys(storedAttributes).length > 0) {
+      return objectAssign({}, storedAttributes, maybeAttributes);
+    }
+    return maybeAttributes;
+  }
+
+  return client;
+}

package/src/client/browser.js

@@ -1,5 +1,5 @@
 import { get } from '../utils/lang';
-import ClientWithInputValidationLayer from './inputValidation';
+import ClientAttributesDecorationLayer from './attributesDecoration';
 import { LOCALHOST_MODE } from '../utils/constants';
 import {
   validateKey,
@@ -25,7 +25,7 @@ function BrowserClientFactory(context) {
     trackBindings.push(tt);
   }
 
-  const client = ClientWithInputValidationLayer(context, true, trackBindings.length > 1);
+  const client = ClientAttributesDecorationLayer(context, true, trackBindings.length > 1);
   client.isBrowserClient = true;
 
   // In the browser land, we can bind the key and the traffic type (if provided)

package/src/engine/evaluator/index.js

@@ -17,7 +17,6 @@ limitations under the License.
 import Engine from '../';
 import thenable from '../../utils/promise/thenable';
 import * as LabelsConstants from '../../utils/labels';
-import { get } from '../../utils/lang';
 import { CONTROL } from '../../utils/constants';
 
 const treatmentException = {
@@ -103,17 +102,17 @@ function getEvaluation(
     const split = Engine.parse(splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async, evaluation and changeNumber will return a thenable
+    // If the storage is async and the evaluated split uses segment, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();
-        result.config = get(splitJSON, `configurations.${result.treatment}`, null);
+        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
 
         return result;
       });
     } else {
       evaluation.changeNumber = split.getChangeNumber(); // Always sync and optional
-      evaluation.config = get(splitJSON, `configurations.${evaluation.treatment}`, null);
+      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
     }
   }
 

package/src/producer/updater/SplitChanges.js

@@ -120,10 +120,11 @@ export default function SplitChangesUpdaterFactory(context, isNode = false) {
           return false;
         });
 
-      // After triggering the requests, if we have cached splits information let's notify
-      // that asynchronously, to let attach a listener for SDK_READY_FROM_CACHE
+      // After triggering the requests, if we have cached splits information let's notify that.
+      // There is no need to emit the event asynchronously to let attach a listener for SDK_READY_FROM_CACHE,
+      // because the current event-loop callback executes after SplitFactory is created.
       if (startingUp && storage.splits.checkCache()) {
-        setTimeout(splitsEventEmitter.emit(splitsEventEmitter.SDK_SPLITS_CACHE_LOADED), 0);
+        splitsEventEmitter.emit(splitsEventEmitter.SDK_SPLITS_CACHE_LOADED);
       }
 
       return fetcherPromise;

package/src/readiness/index.js

@@ -37,6 +37,7 @@ function GateContext() {
     let status = 0;
 
     gate.on(Events.READINESS_GATE_CHECK_STATE, () => {
+      // @TODO catch and handle user callback errors. Required for localhost and consumer modes. In standalone mode, it is done in 'SplitChangesUpdater'.
       if (status !== SDK_FIRE_UPDATE && splitsStatus + segmentsStatus === SDK_FIRE_READY) {
         status = SDK_FIRE_UPDATE;
         gate.emit(Events.SDK_READY);
@@ -54,7 +55,12 @@ function GateContext() {
     });
 
     splits.once(Events.SDK_SPLITS_CACHE_LOADED, () => {
-      gate.emit(Events.SDK_READY_FROM_CACHE);
+      try {
+        gate.emit(Events.SDK_READY_FROM_CACHE);
+      } catch (e) {
+        // handle user callback errors
+        setTimeout(() => { throw e; }, 0);
+      }
     });
 
     segments.on(Events.SDK_SEGMENTS_ARRIVED, () => {

package/src/storage/AttributesCache/InMemory.js

@@ -0,0 +1,76 @@
+import objectAssign from 'object-assign';
+
+class AttributesCacheInMemory {
+
+  constructor() {
+    this.attributesCache = {};
+  }
+
+  /**
+   * Create or update the value for the given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored
+   */
+  setAttribute(attributeName, attributeValue) {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+
+  /**
+   * Retrieves the value of a given attribute
+   *
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  getAttribute(attributeName) {
+    return this.attributesCache[attributeName];
+  }
+
+  /**
+   * Create or update all the given attributes
+   *
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  setAttributes(attributes) {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+
+  /**
+   * Retrieve the full attributes map
+   *
+   * @returns {Map<string, Object>} stored attributes
+   */
+  getAll() {
+    return this.attributesCache;
+  }
+
+  /**
+   * Removes a given attribute from the map
+   *
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  removeAttribute(attributeName) {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clears all attributes stored in the SDK
+   *
+   */
+  clear() {
+    this.attributesCache = {};
+    return true;
+  }
+
+}
+
+export default AttributesCacheInMemory;

package/src/utils/inputValidation/attribute.js

@@ -0,0 +1,22 @@
+import { isString, numberIsFinite, isBoolean } from '../lang';
+import logFactory from '../logger';
+const log = logFactory('');
+
+export function validateAttribute(attributeKey, attributeValue, method) {
+  if (!isString(attributeKey) || attributeKey.length === 0){
+    log.warn(`${method}: you passed an invalid attribute name, attribute name must be a non-empty string.`);
+    return false;
+  }
+
+  const isStringVal = isString(attributeValue);
+  const isFiniteVal = numberIsFinite(attributeValue);
+  const isBoolVal = isBoolean(attributeValue);
+  const isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
+    log.warn(`${method}: you passed an invalid attribute value for ${attributeKey}. Acceptable types are: string, number, boolean and array of strings.`);
+    return false;
+  }
+
+  return true;
+}

package/src/utils/inputValidation/attributes.js

@@ -1,5 +1,6 @@
 import { isObject } from '../lang';
 import logFactory from '../logger';
+import { validateAttribute } from './attribute';
 const log = logFactory('');
 
 export function validateAttributes(maybeAttrs, method) {
@@ -10,3 +11,16 @@ export function validateAttributes(maybeAttrs, method) {
   log.error(`${method}: attributes must be a plain object.`);
   return false;
 }
+
+export function validateAttributesDeep(maybeAttributes, method) {
+  if (!validateAttributes(maybeAttributes, method)) return false;
+  
+  let result = true;
+  Object.keys(maybeAttributes).forEach(attributeKey => {
+    if (!validateAttribute(attributeKey, maybeAttributes[attributeKey], method))
+      result = false;
+  });
+
+  return result;
+
+}

package/src/utils/settings/index.js

@@ -27,7 +27,7 @@ import { API } from '../../utils/logger';
 import { STANDALONE_MODE, STORAGE_MEMORY, CONSUMER_MODE, OPTIMIZED } from '../../utils/constants';
 import validImpressionsMode from './impressionsMode';
 
-const version = '10.16.1';
+const version = '10.17.1';
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;

package/types/index.d.ts

@@ -24,5 +24,5 @@ declare module JsSdk {
    * The settings parameter should be an object that complies with the SplitIO.IBrowserSettings.
    * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
    */
-  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.ISDK;
+  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.IBrowserSDK;
 }