@splitsoftware/splitio-commons 1.1.0 → 1.1.1-rc.0

package/CHANGES.txt

@@ -1,3 +1,6 @@
+1.1.1 (XXX)
+ - Added support to SDK clients on browser to optionally bind attributes to the client, keeping these loaded within the SDK along with the user ID, for easier usage when requesting flag.
+
 1.1.0 (January 11, 2022)
  - Added support for the SDK to run in "consumer" and "partial consumer" modes, with a pluggable implementation of it's internal storage, enabling
   customers to implement this caching with any storage technology of choice and connect it to the SDK instance to be used instead of its default in-memory storage.

package/cjs/sdkClient/clientAttributesDecoration.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientAttributesDecoration = void 0;
+var AttributesCacheInMemory_1 = require("../storages/inMemory/AttributesCacheInMemory");
+var attributes_1 = require("../utils/inputValidation/attributes");
+var objectAssign_1 = require("../utils/lang/objectAssign");
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+function clientAttributesDecoration(log, client) {
+    var attributeStorage = new AttributesCacheInMemory_1.AttributesCacheInMemory();
+    // Keep a reference to the original methods
+    var clientGetTreatment = client.getTreatment;
+    var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+    var clientGetTreatments = client.getTreatments;
+    var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+    var clientTrack = client.track;
+    function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
+        return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
+        return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+    }
+    function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
+        return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
+        return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+    }
+    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+    }
+    function combineAttributes(maybeAttributes) {
+        var storedAttributes = attributeStorage.getAll();
+        if (Object.keys(storedAttributes).length > 0) {
+            return objectAssign_1.objectAssign({}, storedAttributes, maybeAttributes);
+        }
+        return maybeAttributes;
+    }
+    return objectAssign_1.objectAssign(client, {
+        getTreatment: getTreatment,
+        getTreatmentWithConfig: getTreatmentWithConfig,
+        getTreatments: getTreatments,
+        getTreatmentsWithConfig: getTreatmentsWithConfig,
+        track: track,
+        /**
+         * 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
+         */
+        setAttribute: function (attributeName, attributeValue) {
+            var attribute = {};
+            attribute[attributeName] = attributeValue;
+            if (!attributes_1.validateAttributesDeep(log, attribute, 'setAttribute'))
+                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
+         */
+        getAttribute: function (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
+         */
+        setAttributes: function (attributes) {
+            if (!attributes_1.validateAttributesDeep(log, attributes, 'setAttributes'))
+                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
+         */
+        getAttributes: function () {
+            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
+         */
+        removeAttribute: function (attributeName) {
+            log.debug("removed attribute " + attributeName);
+            return attributeStorage.removeAttribute(attributeName + '');
+        },
+        /**
+         * Remove all the stored attributes in the client's in memory attribute storage
+         */
+        clearAttributes: function () {
+            return attributeStorage.clear();
+        }
+    });
+}
+exports.clientAttributesDecoration = clientAttributesDecoration;

package/cjs/sdkClient/clientCS.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientCSDecorator = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
+var clientAttributesDecoration_1 = require("./clientAttributesDecoration");
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
  *
@@ -9,15 +10,16 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-function clientCSDecorator(client, key, trafficType) {
-    return objectAssign_1.objectAssign(client, {
+function clientCSDecorator(log, client, key, trafficType) {
+    var clientCS = clientAttributesDecoration_1.clientAttributesDecoration(log, client);
+    return objectAssign_1.objectAssign(clientCS, {
         // In the client-side API, we bind a key to the client `getTreatment*` methods
-        getTreatment: client.getTreatment.bind(client, key),
-        getTreatmentWithConfig: client.getTreatmentWithConfig.bind(client, key),
-        getTreatments: client.getTreatments.bind(client, key),
-        getTreatmentsWithConfig: client.getTreatmentsWithConfig.bind(client, key),
+        getTreatment: clientCS.getTreatment.bind(clientCS, key),
+        getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
+        getTreatments: clientCS.getTreatments.bind(clientCS, key),
+        getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
         // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-        track: trafficType ? client.track.bind(client, key, trafficType) : client.track.bind(client, key)
+        track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key)
     });
 }
 exports.clientCSDecorator = clientCSDecorator;

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -23,7 +23,7 @@ function sdkClientMethodCSFactory(params) {
     // `false` value is used as binded key of the default client, but trafficType is ignored
     // @TODO handle as a non-recoverable error
     var validKey = key_1.validateKey(log, key, method);
-    var mainClientInstance = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(params), // @ts-ignore
     validKey);
     var parsedDefaultKey = key_2.keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -58,7 +58,7 @@ function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
+            clientInstances[instanceId] = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/cjs/sdkClient/sdkClientMethodCSWithTT.js

@@ -29,7 +29,7 @@ function sdkClientMethodCSFactory(params) {
     if (trafficType !== undefined) {
         validTrafficType = trafficType_1.validateTrafficType(log, trafficType, method);
     }
-    var mainClientInstance = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(params), // @ts-ignore
     validKey, validTrafficType);
     var parsedDefaultKey = key_2.keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
@@ -71,7 +71,7 @@ function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCS_1.clientCSDecorator(sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
+            clientInstances[instanceId] = clientCS_1.clientCSDecorator(log, sdkClient_1.sdkClientFactory(objectAssign_1.objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/cjs/storages/inMemory/AttributesCacheInMemory.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributesCacheInMemory = void 0;
+var objectAssign_1 = require("../../utils/lang/objectAssign");
+var AttributesCacheInMemory = /** @class */ (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
+     */
+    AttributesCacheInMemory.prototype.setAttribute = function (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
+     */
+    AttributesCacheInMemory.prototype.getAttribute = function (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
+     */
+    AttributesCacheInMemory.prototype.setAttributes = function (attributes) {
+        this.attributesCache = objectAssign_1.objectAssign(this.attributesCache, attributes);
+        return true;
+    };
+    /**
+     * Retrieve the full attributes map
+     *
+     * @returns {Map<string, Object>} stored attributes
+     */
+    AttributesCacheInMemory.prototype.getAll = function () {
+        return this.attributesCache;
+    };
+    /**
+     * Removes a given attribute from the map
+     *
+     * @param {string} attributeName attribute to remove
+     * @returns {boolean} attribute removed
+     */
+    AttributesCacheInMemory.prototype.removeAttribute = function (attributeName) {
+        if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+            delete this.attributesCache[attributeName];
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Clears all attributes stored in the SDK
+     *
+     */
+    AttributesCacheInMemory.prototype.clear = function () {
+        this.attributesCache = {};
+        return true;
+    };
+    return AttributesCacheInMemory;
+}());
+exports.AttributesCacheInMemory = AttributesCacheInMemory;

package/cjs/utils/inputValidation/attribute.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAttribute = void 0;
+var lang_1 = require("../../utils/lang");
+function validateAttribute(log, attributeKey, attributeValue, method) {
+    if (!lang_1.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 = lang_1.isString(attributeValue);
+    var isFiniteVal = lang_1.isFiniteNumber(attributeValue);
+    var isBoolVal = lang_1.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;
+}
+exports.validateAttribute = validateAttribute;

package/cjs/utils/inputValidation/attributes.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateAttributes = void 0;
+exports.validateAttributesDeep = exports.validateAttributes = void 0;
 var lang_1 = require("../lang");
+var attribute_1 = require("./attribute");
 var constants_1 = require("../../logger/constants");
 function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
@@ -11,3 +12,14 @@ function validateAttributes(log, maybeAttrs, method) {
     return false;
 }
 exports.validateAttributes = validateAttributes;
+function validateAttributesDeep(log, maybeAttributes, method) {
+    if (!validateAttributes(log, maybeAttributes, method))
+        return false;
+    var result = true;
+    Object.keys(maybeAttributes).forEach(function (attributeKey) {
+        if (!attribute_1.validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+            result = false;
+    });
+    return result;
+}
+exports.validateAttributesDeep = validateAttributesDeep;

package/esm/sdkClient/clientAttributesDecoration.js

@@ -0,0 +1,104 @@
+import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import { objectAssign } from '../utils/lang/objectAssign';
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+export function clientAttributesDecoration(log, client) {
+    var attributeStorage = new AttributesCacheInMemory();
+    // Keep a reference to the original methods
+    var clientGetTreatment = client.getTreatment;
+    var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+    var clientGetTreatments = client.getTreatments;
+    var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+    var clientTrack = client.track;
+    function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
+        return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
+        return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+    }
+    function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
+        return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+    }
+    function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
+        return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+    }
+    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+    }
+    function combineAttributes(maybeAttributes) {
+        var storedAttributes = attributeStorage.getAll();
+        if (Object.keys(storedAttributes).length > 0) {
+            return objectAssign({}, storedAttributes, maybeAttributes);
+        }
+        return maybeAttributes;
+    }
+    return objectAssign(client, {
+        getTreatment: getTreatment,
+        getTreatmentWithConfig: getTreatmentWithConfig,
+        getTreatments: getTreatments,
+        getTreatmentsWithConfig: getTreatmentsWithConfig,
+        track: track,
+        /**
+         * 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
+         */
+        setAttribute: function (attributeName, attributeValue) {
+            var attribute = {};
+            attribute[attributeName] = attributeValue;
+            if (!validateAttributesDeep(log, attribute, 'setAttribute'))
+                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
+         */
+        getAttribute: function (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
+         */
+        setAttributes: function (attributes) {
+            if (!validateAttributesDeep(log, attributes, 'setAttributes'))
+                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
+         */
+        getAttributes: function () {
+            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
+         */
+        removeAttribute: function (attributeName) {
+            log.debug("removed attribute " + attributeName);
+            return attributeStorage.removeAttribute(attributeName + '');
+        },
+        /**
+         * Remove all the stored attributes in the client's in memory attribute storage
+         */
+        clearAttributes: function () {
+            return attributeStorage.clear();
+        }
+    });
+}

package/esm/sdkClient/clientCS.js

@@ -1,4 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { clientAttributesDecoration } from './clientAttributesDecoration';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
  *
@@ -6,14 +7,15 @@ import { objectAssign } from '../utils/lang/objectAssign';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(client, key, trafficType) {
-    return objectAssign(client, {
+export function clientCSDecorator(log, client, key, trafficType) {
+    var clientCS = clientAttributesDecoration(log, client);
+    return objectAssign(clientCS, {
         // In the client-side API, we bind a key to the client `getTreatment*` methods
-        getTreatment: client.getTreatment.bind(client, key),
-        getTreatmentWithConfig: client.getTreatmentWithConfig.bind(client, key),
-        getTreatments: client.getTreatments.bind(client, key),
-        getTreatmentsWithConfig: client.getTreatmentsWithConfig.bind(client, key),
+        getTreatment: clientCS.getTreatment.bind(clientCS, key),
+        getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
+        getTreatments: clientCS.getTreatments.bind(clientCS, key),
+        getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
         // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-        track: trafficType ? client.track.bind(client, key, trafficType) : client.track.bind(client, key)
+        track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key)
     });
 }

package/esm/sdkClient/sdkClientMethodCS.js

@@ -20,7 +20,7 @@ export function sdkClientMethodCSFactory(params) {
     // `false` value is used as binded key of the default client, but trafficType is ignored
     // @TODO handle as a non-recoverable error
     var validKey = validateKey(log, key, method);
-    var mainClientInstance = clientCSDecorator(sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
     validKey);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -55,7 +55,7 @@ export function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCSDecorator(sdkClientFactory(objectAssign({}, params, {
+            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -26,7 +26,7 @@ export function sdkClientMethodCSFactory(params) {
     if (trafficType !== undefined) {
         validTrafficType = validateTrafficType(log, trafficType, method);
     }
-    var mainClientInstance = clientCSDecorator(sdkClientFactory(params), // @ts-ignore
+    var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
     validKey, validTrafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
@@ -68,7 +68,7 @@ export function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCSDecorator(sdkClientFactory(objectAssign({}, params, {
+            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,

package/esm/storages/inMemory/AttributesCacheInMemory.js

@@ -0,0 +1,67 @@
+import { objectAssign } from '../../utils/lang/objectAssign';
+var AttributesCacheInMemory = /** @class */ (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
+     */
+    AttributesCacheInMemory.prototype.setAttribute = function (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
+     */
+    AttributesCacheInMemory.prototype.getAttribute = function (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
+     */
+    AttributesCacheInMemory.prototype.setAttributes = function (attributes) {
+        this.attributesCache = objectAssign(this.attributesCache, attributes);
+        return true;
+    };
+    /**
+     * Retrieve the full attributes map
+     *
+     * @returns {Map<string, Object>} stored attributes
+     */
+    AttributesCacheInMemory.prototype.getAll = function () {
+        return this.attributesCache;
+    };
+    /**
+     * Removes a given attribute from the map
+     *
+     * @param {string} attributeName attribute to remove
+     * @returns {boolean} attribute removed
+     */
+    AttributesCacheInMemory.prototype.removeAttribute = function (attributeName) {
+        if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+            delete this.attributesCache[attributeName];
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Clears all attributes stored in the SDK
+     *
+     */
+    AttributesCacheInMemory.prototype.clear = function () {
+        this.attributesCache = {};
+        return true;
+    };
+    return AttributesCacheInMemory;
+}());
+export { AttributesCacheInMemory };

package/esm/utils/inputValidation/attribute.js

@@ -0,0 +1,16 @@
+import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
+export function validateAttribute(log, 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;
+    }
+    var isStringVal = isString(attributeValue);
+    var isFiniteVal = isFiniteNumber(attributeValue);
+    var isBoolVal = 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/esm/utils/inputValidation/attributes.js

@@ -1,4 +1,5 @@
 import { isObject } from '../lang';
+import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 export function validateAttributes(log, maybeAttrs, method) {
     // Attributes are optional
@@ -7,3 +8,13 @@ export function validateAttributes(log, maybeAttrs, method) {
     log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
     return false;
 }
+export function validateAttributesDeep(log, maybeAttributes, method) {
+    if (!validateAttributes(log, maybeAttributes, method))
+        return false;
+    var result = true;
+    Object.keys(maybeAttributes).forEach(function (attributeKey) {
+        if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+            result = false;
+    });
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.1.0",
+  "version": "1.1.1-rc.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",