@splitsoftware/splitio-commons 1.0.1-rc.4 → 1.1.1-rc.0

package/esm/evaluator/matchers/index.js

@@ -1,44 +1,44 @@
-import allMatcher from './all';
-import segmentMatcher from './segment';
-import whitelistMatcher from './whitelist';
-import eqMatcher from './eq';
-import gteMatcher from './gte';
-import lteMatcher from './lte';
-import betweenMatcher from './between';
-import equalToSetMatcher from './eq_set';
-import containsAllSetMatcher from './cont_all';
-import containsAnySetMatcher from './cont_any';
-import partOfSetMatcher from './part_of';
-import swMatcher from './sw';
-import ewMatcher from './ew';
-import containsStrMatcher from './cont_str';
-import dependencyMatcher from './dependency';
-import booleanMatcher from './boolean';
-import stringMatcher from './string';
+import { allMatcherContext } from './all';
+import { segmentMatcherContext } from './segment';
+import { whitelistMatcherContext } from './whitelist';
+import { equalToMatcherContext } from './eq';
+import { greaterThanEqualMatcherContext } from './gte';
+import { lessThanEqualMatcherContext } from './lte';
+import { betweenMatcherContext } from './between';
+import { equalToSetMatcherContext } from './eq_set';
+import { containsAnySetMatcherContext } from './cont_any';
+import { containsAllSetMatcherContext } from './cont_all';
+import { partOfSetMatcherContext } from './part_of';
+import { endsWithMatcherContext } from './ew';
+import { startsWithMatcherContext } from './sw';
+import { containsStringMatcherContext } from './cont_str';
+import { dependencyMatcherContext } from './dependency';
+import { booleanMatcherContext } from './boolean';
+import { stringMatcherContext } from './string';
 var matchers = [
     undefined,
-    allMatcher,
-    segmentMatcher,
-    whitelistMatcher,
-    eqMatcher,
-    gteMatcher,
-    lteMatcher,
-    betweenMatcher,
-    equalToSetMatcher,
-    containsAnySetMatcher,
-    containsAllSetMatcher,
-    partOfSetMatcher,
-    ewMatcher,
-    swMatcher,
-    containsStrMatcher,
-    dependencyMatcher,
-    booleanMatcher,
-    stringMatcher // MATCHES_STRING: 17
+    allMatcherContext,
+    segmentMatcherContext,
+    whitelistMatcherContext,
+    equalToMatcherContext,
+    greaterThanEqualMatcherContext,
+    lessThanEqualMatcherContext,
+    betweenMatcherContext,
+    equalToSetMatcherContext,
+    containsAnySetMatcherContext,
+    containsAllSetMatcherContext,
+    partOfSetMatcherContext,
+    endsWithMatcherContext,
+    startsWithMatcherContext,
+    containsStringMatcherContext,
+    dependencyMatcherContext,
+    booleanMatcherContext,
+    stringMatcherContext // MATCHES_STRING: 17
 ];
 /**
  * Matcher factory.
  */
-export default function matcherFactory(log, matcherDto, storage) {
+export function matcherFactory(log, matcherDto, storage) {
     var type = matcherDto.type, value = matcherDto.value;
     var matcherFn;
     // @ts-ignore

package/esm/evaluator/matchers/lte.js

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_LESS } from '../../logger/constants';
-export default function lessThanEqualMatcherContext(log, ruleAttr) {
+export function lessThanEqualMatcherContext(log, ruleAttr) {
     return function lessThanEqualMatcher(runtimeAttr) {
         var isLessEqualThan = runtimeAttr <= ruleAttr;
         log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessEqualThan]);

package/esm/evaluator/matchers/part_of.js

@@ -1,6 +1,6 @@
 import { findIndex } from '../../utils/lang';
 import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
-export default function partOfMatcherContext(log, ruleAttr) {
+export function partOfSetMatcherContext(log, ruleAttr) {
     return function partOfMatcher(runtimeAttr) {
         // To be part of the length should be minor or equal.
         var isPartOf = runtimeAttr.length <= ruleAttr.length;

package/esm/evaluator/matchers/segment.js

@@ -1,6 +1,6 @@
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
-export default function matcherSegmentContext(log, segmentName, storage) {
+export function segmentMatcherContext(log, segmentName, storage) {
     return function segmentMatcher(key) {
         var isInSegment = storage.segments.isInSegment(segmentName, key);
         if (thenable(isInSegment)) {

package/esm/evaluator/matchers/string.js

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
-export default function stringMatcherContext(log, ruleAttr) {
+export function stringMatcherContext(log, ruleAttr) {
     return function stringMatcher(runtimeAttr) {
         var re;
         try {

package/esm/evaluator/matchers/sw.js

@@ -1,6 +1,6 @@
 import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
 import { startsWith } from '../../utils/lang';
-export default function startsWithMatcherContext(log, ruleAttr) {
+export function startsWithMatcherContext(log, ruleAttr) {
     return function startsWithMatcher(runtimeAttr) {
         var matches = ruleAttr.some(function (e) { return startsWith(runtimeAttr, e); });
         log.debug(ENGINE_MATCHER_STARTS_WITH, [runtimeAttr, ruleAttr, matches]);

package/esm/evaluator/matchers/whitelist.js

@@ -1,6 +1,6 @@
 import { setToArray } from '../../utils/lang/sets';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
-export default function whitelistMatcherContext(log, ruleAttr) {
+export function whitelistMatcherContext(log, ruleAttr) {
     return function whitelistMatcher(runtimeAttr) {
         var isInWhitelist = ruleAttr.has(runtimeAttr);
         log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]);

package/esm/evaluator/matchersTransform/index.js

@@ -1,14 +1,14 @@
 import { findIndex } from '../../utils/lang';
 import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
-import segmentTransform from './segment';
-import whitelistTransform from './whitelist';
-import setTransform from './set';
-import numericTransform from './unaryNumeric';
+import { segmentTransform } from './segment';
+import { whitelistTransform } from './whitelist';
+import { setTransform } from './set';
+import { numericTransform } from './unaryNumeric';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
-export default function matchersTransform(matchers) {
+export function matchersTransform(matchers) {
     var parsedMatchers = matchers.map(function (matcher) {
         var matcherType = matcher.matcherType /* string */, negate = matcher.negate /* boolean */, keySelector = matcher.keySelector /* keySelectorObject */, segmentObject = matcher.userDefinedSegmentMatcherData /* segmentObject */, whitelistObject = matcher.whitelistMatcherData /* whiteListObject, provided by 'WHITELIST', set and string matchers */, unaryNumericObject = matcher.unaryNumericMatcherData /* unaryNumericObject */, betweenObject = matcher.betweenMatcherData /* betweenObject */, dependencyObject = matcher.dependencyMatcherData /* dependencyObject */, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData;
         var attribute = keySelector && keySelector.attribute;

package/esm/evaluator/matchersTransform/segment.js

@@ -1,6 +1,6 @@
 /**
  * Extract segment name as a plain string.
  */
-export default function transform(segment) {
+export function segmentTransform(segment) {
     return segment ? segment.segmentName : undefined;
 }

package/esm/evaluator/matchersTransform/set.js

@@ -1,6 +1,6 @@
 /**
  * Extract whitelist array. Used by set and string matchers
  */
-export default function transform(whitelistObject) {
+export function setTransform(whitelistObject) {
     return whitelistObject.whitelist;
 }

package/esm/evaluator/matchersTransform/unaryNumeric.js

@@ -1,6 +1,6 @@
 /**
  * Extract value from unary matcher data.
  */
-export default function transform(unaryNumericObject) {
+export function numericTransform(unaryNumericObject) {
     return unaryNumericObject.value;
 }

package/esm/evaluator/matchersTransform/whitelist.js

@@ -2,6 +2,6 @@ import { _Set } from '../../utils/lang/sets';
 /**
  * Extract whitelist as a set. Used by 'WHITELIST' matcher.
  */
-export default function transform(whitelistObject) {
+export function whitelistTransform(whitelistObject) {
     return new _Set(whitelistObject.whitelist);
 }

package/esm/evaluator/parser/index.js

@@ -1,12 +1,12 @@
-import matchersTransform from '../matchersTransform';
-import Treatments from '../treatments';
-import matcherFactory from '../matchers';
-import sanitizeValue from '../value';
-import conditionFactory from '../condition';
-import ifElseIfCombiner from '../combiners/ifelseif';
-import andCombiner from '../combiners/and';
-import thenable from '../../utils/promise/thenable';
-export default function parser(log, conditions, storage) {
+import { matchersTransform } from '../matchersTransform';
+import { Treatments } from '../treatments';
+import { matcherFactory } from '../matchers';
+import { sanitizeValue } from '../value';
+import { conditionContext } from '../condition';
+import { ifElseIfCombinerContext } from '../combiners/ifelseif';
+import { andCombinerContext } from '../combiners/and';
+import { thenable } from '../../utils/promise/thenable';
+export function parser(log, conditions, storage) {
     var predicates = [];
     for (var i = 0; i < conditions.length; i++) {
         var _a = conditions[i], matcherGroup = _a.matcherGroup, partitions = _a.partitions, label = _a.label, conditionType = _a.conditionType;
@@ -35,8 +35,8 @@ export default function parser(log, conditions, storage) {
             // and break the loop
             break;
         }
-        predicates.push(conditionFactory(log, andCombiner(log, expressions), Treatments.parse(partitions), label, conditionType));
+        predicates.push(conditionContext(log, andCombinerContext(log, expressions), Treatments.parse(partitions), label, conditionType));
     }
     // Instanciate evaluator given the set of conditions using if else if logic
-    return ifElseIfCombiner(log, predicates);
+    return ifElseIfCombinerContext(log, predicates);
 }

package/esm/evaluator/treatments/index.js

@@ -36,4 +36,4 @@ var Treatments = /** @class */ (function () {
     };
     return Treatments;
 }());
-export default Treatments;
+export { Treatments };

package/esm/evaluator/value/index.js

@@ -1,4 +1,4 @@
-import sanitizeValue from './sanitize';
+import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 function parseValue(log, key, attributeName, attributes) {
     var value = undefined;
@@ -19,10 +19,10 @@ function parseValue(log, key, attributeName, attributes) {
 /**
  * Defines value to be matched (key / attribute).
  */
-export default function value(log, key, matcherDto, attributes) {
+export function sanitizeValue(log, key, matcherDto, attributes) {
     var attributeName = matcherDto.attribute;
     var valueToMatch = parseValue(log, key, attributeName, attributes);
-    var sanitizedValue = sanitizeValue(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
+    var sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
     if (sanitizedValue !== undefined) {
         return sanitizedValue;
     }

package/esm/evaluator/value/sanitize.js

@@ -57,7 +57,7 @@ function getProcessingFunction(matcherTypeID, dataType) {
 /**
  * Sanitize matcher value
  */
-export default function sanitize(log, matcherTypeID, value, dataType, attributes) {
+export function sanitize(log, matcherTypeID, value, dataType, attributes) {
     var processor = getProcessingFunction(matcherTypeID, dataType);
     var sanitizedValue;
     switch (dataType) {

package/esm/integrations/browser.js

@@ -1,5 +1,5 @@
 import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '../utils/constants/browser';
-import pluggableIntegrationsManagerFactory from './pluggable';
+import { pluggableIntegrationsManagerFactory } from './pluggable';
 import { GoogleAnalyticsToSplit } from './ga/GoogleAnalyticsToSplit';
 import { SplitToGoogleAnalytics } from './ga/SplitToGoogleAnalytics';
 /**
@@ -11,7 +11,7 @@ import { SplitToGoogleAnalytics } from './ga/SplitToGoogleAnalytics';
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(integrations, params) {
+export function integrationsManagerFactory(integrations, params) {
     // maps integration config items into integration factories to reuse the pluggable integration manager
     var integrationFactories = integrations
         .map(function (integrationOptions) {

package/esm/integrations/ga/GaToSplit.js

@@ -1,5 +1,5 @@
 /* eslint-disable no-undef */
-import objectAssign from 'object-assign';
+import { objectAssign } from '../../utils/lang/objectAssign';
 import { isString, isFiniteNumber, uniqAsStrings } from '../../utils/lang';
 import { validateEvent, validateEventValue, validateEventProperties, validateKey, validateTrafficType, } from '../../utils/inputValidation';
 var logPrefix = 'ga-to-split: ';

package/esm/integrations/pluggable.js

@@ -8,7 +8,7 @@ import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../utils/constants';
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(integrations, params) {
+export function pluggableIntegrationsManagerFactory(integrations, params) {
     var listeners = [];
     // No need to check if `settings.integrations` is an array of functions. It was already validated
     integrations.forEach(function (integrationFactory) {

package/esm/listeners/browser.js

@@ -1,7 +1,7 @@
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSyncTask';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSyncTask';
 import { OPTIMIZED, DEBUG } from '../utils/constants';
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 var UNLOAD_DOM_EVENT = 'unload';
@@ -95,4 +95,4 @@ var BrowserSignalListener = /** @class */ (function () {
     };
     return BrowserSignalListener;
 }());
-export default BrowserSignalListener;
+export { BrowserSignalListener };

package/esm/listeners/node.js

@@ -1,4 +1,4 @@
-import thenable from '../utils/promise/thenable';
+import { thenable } from '../utils/promise/thenable';
 import { LOG_PREFIX_CLEANUP, CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 var SIGTERM = 'SIGTERM';
 var EVENT_NAME = 'for SIGTERM signal.';
@@ -62,4 +62,4 @@ var NodeSignalListener = /** @class */ (function () {
     };
     return NodeSignalListener;
 }());
-export default NodeSignalListener;
+export { NodeSignalListener };

package/esm/logger/index.js

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { find } from '../utils/lang';
 import { _Map } from '../utils/lang/maps';
 export var LogLevels = {

package/esm/logger/messages/info.js

@@ -21,7 +21,7 @@ export var codesInfo = codesWarn.concat([
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect in %s seconds.'],
-    [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + '%sConnecting to streaming.'],
+    [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting to streaming.'],
     [c.STREAMING_DISABLED, c.LOG_PREFIX_SYNC_STREAMING + 'Streaming is disabled for given Api key. Switching to polling mode.'],
     [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting from streaming.'],
     [c.SYNC_START_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming not available. Starting polling.'],

package/esm/logger/messages/warn.js

@@ -20,9 +20,9 @@ export var codesWarn = codesError.concat([
     [c.WARN_TRIMMING_PROPERTIES, '%s: Event has more than 300 properties. Some of them will be trimmed when processed.'],
     [c.WARN_CONVERTING, '%s: %s "%s" is not of type string, converting.'],
     [c.WARN_TRIMMING, '%s: %s "%s" has extra whitespace, trimming.'],
-    [c.WARN_NOT_EXISTENT_SPLIT, '%s: split "%s" does not exist in this environment, please double check what splits exist in the web console.'],
+    [c.WARN_NOT_EXISTENT_SPLIT, '%s: split "%s" does not exist in this environment, please double check what splits exist in the Split web console.'],
     [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
-    [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding split in this environment, make sure you\'re tracking your events to a valid traffic type defined in the web console.'],
+    [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding split in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split web console.'],
     // initialization / settings validation
     [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS + ': %s integration item(s) at settings is invalid. %s'],
     [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS + ': split filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],

package/esm/readiness/readinessManager.js

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = objectAssign(new EventEmitter(), {

package/esm/readiness/sdkReadinessManager.js

@@ -1,5 +1,5 @@
-import objectAssign from 'object-assign';
-import promiseWrapper from '../utils/promise/wrapper';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
@@ -14,7 +14,7 @@ var REMOVE_LISTENER_EVENT = 'removeListener';
  * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export default function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager) {
+export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager) {
     if (readyTimeout === void 0) { readyTimeout = 0; }
     if (internalReadyCbCount === void 0) { internalReadyCbCount = 0; }
     if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, readyTimeout); }

package/esm/sdkClient/client.js

@@ -1,5 +1,5 @@
 import { evaluateFeature, evaluateFeatures } from '../evaluator';
-import thenable from '../utils/promise/thenable';
+import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
@@ -10,7 +10,7 @@ import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
  * Creator of base client with getTreatments and track methods.
  */
 // @TODO missing time tracking to collect telemetry
-export default function clientFactory(params) {
+export function clientFactory(params) {
     var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, _a = params.settings, log = _a.log, mode = _a.mode, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker;
     function getTreatment(key, splitName, attributes, withConfig) {
         if (withConfig === void 0) { withConfig = false; }

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 'object-assign';
+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 'object-assign';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export default 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/clientInputValidation.js

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
@@ -6,7 +6,7 @@ import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export default function clientInputValidationDecorator(log, client, readinessManager, isStorageSync) {
+export function clientInputValidationDecorator(log, client, readinessManager, isStorageSync) {
     if (isStorageSync === void 0) { isStorageSync = false; }
     /**
      * Avoid repeating this validations code

package/esm/sdkClient/sdkClient.js

@@ -1,8 +1,8 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../utils/constants';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
-import clientFactory from './client';
-import clientInputValidationDecorator from './clientInputValidation';
+import { clientFactory } from './client';
+import { clientInputValidationDecorator } from './clientInputValidation';
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */

package/esm/sdkClient/sdkClientMethodCS.js

@@ -1,8 +1,8 @@
-import clientCSDecorator from './clientCS';
+import { clientCSDecorator } from './clientCS';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 function buildInstanceId(key) {
@@ -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,