@splitsoftware/splitio-commons 1.0.1-rc.5 → 1.2.0

package/src/evaluator/matchers/eq_set.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export default function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function equalToSetMatcher(runtimeAttr: string[]): boolean {
     // Length being the same is the first condition.
     let isEqual = runtimeAttr.length === ruleAttr.length;

package/src/evaluator/matchers/ew.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { endsWith as strEndsWith } from '../../utils/lang';
 
-export default function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function endsWithMatcher(runtimeAttr: string): boolean {
     let endsWith = ruleAttr.some(e => strEndsWith(runtimeAttr, e));
 

package/src/evaluator/matchers/gte.ts

@@ -1,7 +1,7 @@
 import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export default function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
+export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
     let isGreaterEqualThan = runtimeAttr >= ruleAttr;
 

package/src/evaluator/matchers/index.ts

@@ -1,49 +1,49 @@
-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';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
 import { ILogger } from '../../logger/types';
 
 const matchers = [
   undefined, // UNDEFINED: 0,
-  allMatcher, // ALL_KEYS: 1,
-  segmentMatcher, // IN_SEGMENT: 2,
-  whitelistMatcher, // WHITELIST: 3,
-  eqMatcher, // EQUAL_TO: 4,
-  gteMatcher, // GREATER_THAN_OR_EQUAL_TO: 5,
-  lteMatcher, // LESS_THAN_OR_EQUAL_TO: 6,
-  betweenMatcher, // BETWEEN: 7,
-  equalToSetMatcher, // EQUAL_TO_SET: 8,
-  containsAnySetMatcher, // CONTAINS_ANY_OF_SET: 9,
-  containsAllSetMatcher, // CONTAINS_ALL_OF_SET: 10,
-  partOfSetMatcher, // PART_OF_SET: 11,
-  ewMatcher, // ENDS_WITH: 12,
-  swMatcher, // STARTS_WITH: 13,
-  containsStrMatcher, // CONTAINS_STRING: 14,
-  dependencyMatcher, // IN_SPLIT_TREATMENT: 15,
-  booleanMatcher, // EQUAL_TO_BOOLEAN: 16,
-  stringMatcher // MATCHES_STRING: 17
+  allMatcherContext, // ALL_KEYS: 1,
+  segmentMatcherContext, // IN_SEGMENT: 2,
+  whitelistMatcherContext, // WHITELIST: 3,
+  equalToMatcherContext, // EQUAL_TO: 4,
+  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5,
+  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6,
+  betweenMatcherContext, // BETWEEN: 7,
+  equalToSetMatcherContext, // EQUAL_TO_SET: 8,
+  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9,
+  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10,
+  partOfSetMatcherContext, // PART_OF_SET: 11,
+  endsWithMatcherContext, // ENDS_WITH: 12,
+  startsWithMatcherContext, // STARTS_WITH: 13,
+  containsStringMatcherContext, // CONTAINS_STRING: 14,
+  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15,
+  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16,
+  stringMatcherContext // MATCHES_STRING: 17
 ];
 
 /**
  * Matcher factory.
  */
-export default function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined {
+export function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined {
   let {
     type,
     value

package/src/evaluator/matchers/lte.ts

@@ -1,7 +1,7 @@
 import { ENGINE_MATCHER_LESS } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export default function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: function */ {
+export function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: function */ {
   return function lessThanEqualMatcher(runtimeAttr: number): boolean {
     let isLessEqualThan = runtimeAttr <= ruleAttr;
 

package/src/evaluator/matchers/part_of.ts

@@ -2,7 +2,7 @@ import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
-export default function partOfMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function partOfMatcher(runtimeAttr: string[]): boolean {
     // To be part of the length should be minor or equal.
     let isPartOf = runtimeAttr.length <= ruleAttr.length;

package/src/evaluator/matchers/segment.ts

@@ -1,10 +1,10 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
 import { ILogger } from '../../logger/types';
-import thenable from '../../utils/promise/thenable';
+import { thenable } from '../../utils/promise/thenable';
 import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
 
-export default function matcherSegmentContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) {
+export function segmentMatcherContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) {
 
   return function segmentMatcher(key: string): MaybeThenable<boolean> {
     const isInSegment = storage.segments.isInSegment(segmentName, key);

package/src/evaluator/matchers/string.ts

@@ -1,7 +1,7 @@
 import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export default function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
+export function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
   return function stringMatcher(runtimeAttr: string): boolean {
     let re;
 

package/src/evaluator/matchers/sw.ts

@@ -2,7 +2,7 @@ import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { startsWith } from '../../utils/lang';
 
-export default function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
+export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {
   return function startsWithMatcher(runtimeAttr: string): boolean {
     let matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
 

package/src/evaluator/matchers/whitelist.ts

@@ -2,7 +2,7 @@ import { setToArray, ISet } from '../../utils/lang/sets';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 
-export default function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {
+export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {
   return function whitelistMatcher(runtimeAttr: string): boolean {
     let isInWhitelist = ruleAttr.has(runtimeAttr);
 

package/src/evaluator/matchersTransform/index.ts

@@ -1,9 +1,9 @@
 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';
 import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData, IWhitelistMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
@@ -11,7 +11,7 @@ import { IMatcherDto } from '../types';
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
-export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
+export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
 
   let parsedMatchers = matchers.map(matcher => {
     let {

package/src/evaluator/matchersTransform/segment.ts

@@ -3,6 +3,6 @@ import { IInSegmentMatcherData } from '../../dtos/types';
 /**
  * Extract segment name as a plain string.
  */
-export default function transform(segment?: IInSegmentMatcherData) {
+export function segmentTransform(segment?: IInSegmentMatcherData) {
   return segment ? segment.segmentName : undefined;
 }

package/src/evaluator/matchersTransform/set.ts

@@ -3,6 +3,6 @@ import { IWhitelistMatcherData } from '../../dtos/types';
 /**
  * Extract whitelist array. Used by set and string matchers
  */
-export default function transform(whitelistObject: IWhitelistMatcherData) {
+export function setTransform(whitelistObject: IWhitelistMatcherData) {
   return whitelistObject.whitelist;
 }

package/src/evaluator/matchersTransform/unaryNumeric.ts

@@ -3,6 +3,6 @@ import { IUnaryNumericMatcherData } from '../../dtos/types';
 /**
  * Extract value from unary matcher data.
  */
-export default function transform(unaryNumericObject: IUnaryNumericMatcherData) {
+export function numericTransform(unaryNumericObject: IUnaryNumericMatcherData) {
   return unaryNumericObject.value;
 }

package/src/evaluator/matchersTransform/whitelist.ts

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

package/src/evaluator/parser/index.ts

@@ -1,18 +1,18 @@
-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';
+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';
 import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
 import { ISplitCondition } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 
-export default function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
+export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
 
   for (let i = 0; i < conditions.length; i++) {
@@ -53,9 +53,9 @@ export default function parser(log: ILogger, conditions: ISplitCondition[], stor
       break;
     }
 
-    predicates.push(conditionFactory(
+    predicates.push(conditionContext(
       log,
-      andCombiner(log, expressions),
+      andCombinerContext(log, expressions),
       Treatments.parse(partitions),
       label,
       conditionType
@@ -63,5 +63,5 @@ export default function parser(log: ILogger, conditions: ISplitCondition[], stor
   }
 
   // Instanciate evaluator given the set of conditions using if else if logic
-  return ifElseIfCombiner(log, predicates);
+  return ifElseIfCombinerContext(log, predicates);
 }

package/src/evaluator/treatments/index.ts

@@ -1,7 +1,7 @@
 import { ISplitPartition } from '../../dtos/types';
 import { findIndex } from '../../utils/lang';
 
-export default class Treatments {
+export class Treatments {
 
   private _ranges: number[];
   private _treatments: string[];

package/src/evaluator/value/index.ts

@@ -1,7 +1,7 @@
 import { SplitIO } from '../../types';
 import { IMatcherDto } from '../types';
 import { ILogger } from '../../logger/types';
-import sanitizeValue from './sanitize';
+import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
 function parseValue(log: ILogger, key: string, attributeName: string | null, attributes: SplitIO.Attributes) {
@@ -23,10 +23,10 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export default function value(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes) {
+export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
-  const sanitizedValue = sanitizeValue(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
+  const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);
 
   if (sanitizedValue !== undefined) {
     return sanitizedValue;

package/src/evaluator/value/sanitize.ts

@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export default function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 

package/src/integrations/browser.ts

@@ -1,7 +1,7 @@
 import { GOOGLE_ANALYTICS_TO_SPLIT, SPLIT_TO_GOOGLE_ANALYTICS } from '../utils/constants/browser';
 import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './types';
 import { BrowserIntegration } from './ga/types';
-import pluggableIntegrationsManagerFactory from './pluggable';
+import { pluggableIntegrationsManagerFactory } from './pluggable';
 import { GoogleAnalyticsToSplit } from './ga/GoogleAnalyticsToSplit';
 import { SplitToGoogleAnalytics } from './ga/SplitToGoogleAnalytics';
 
@@ -14,7 +14,7 @@ import { SplitToGoogleAnalytics } from './ga/SplitToGoogleAnalytics';
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(
+export function integrationsManagerFactory(
   integrations: BrowserIntegration[],
   params: IIntegrationFactoryParams
 ): IIntegrationManager | undefined {

package/src/integrations/ga/GaToSplit.ts

@@ -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,

package/src/integrations/pluggable.ts

@@ -11,7 +11,7 @@ import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './
  *
  * @returns integration manager or undefined if `integrations` are not present in settings.
  */
-export default function integrationsManagerFactory(
+export function pluggableIntegrationsManagerFactory(
   integrations: Array<(params: IIntegrationFactoryParams) => IIntegration | void>,
   params: IIntegrationFactoryParams
 ): IIntegrationManager | undefined {

package/src/listeners/browser.ts

@@ -8,7 +8,7 @@ import { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
 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';
 import { ISyncManager } from '../sync/types';
 
@@ -19,7 +19,7 @@ const EVENT_NAME = 'for unload page event.';
 /**
  * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
  */
-export default class BrowserSignalListener implements ISignalListener {
+export class BrowserSignalListener implements ISignalListener {
 
   private fromImpressionsCollector: (data: ImpressionDTO[]) => ImpressionsPayload;
 

package/src/listeners/node.ts

@@ -1,6 +1,6 @@
 // @TODO eventually migrate to JS-Node-SDK package.
 import { ISignalListener } from './types';
-import thenable from '../utils/promise/thenable';
+import { thenable } from '../utils/promise/thenable';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings } from '../types';
 import { LOG_PREFIX_CLEANUP, CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
@@ -16,7 +16,7 @@ const EVENT_NAME = 'for SIGTERM signal.';
  * you should call the cleanup logic yourself, since we cannot ensure the data is sent after
  * the process is already exiting.
  */
-export default class NodeSignalListener implements ISignalListener {
+export class NodeSignalListener implements ISignalListener {
 
   private handler: () => MaybeThenable<any>;
   private settings: ISettings;

package/src/logger/index.ts

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { ILoggerOptions, ILogger } from './types';
 import { find } from '../utils/lang';
 import { LogLevel } from '../types';

package/src/logger/messages/info.ts

@@ -24,7 +24,7 @@ export const codesInfo: [number, string][] = 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/src/logger/messages/warn.ts

@@ -21,9 +21,9 @@ export const codesWarn: [number, string][] = 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/src/readiness/readinessManager.ts

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { IEventEmitter } from '../types';
 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';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
@@ -12,7 +12,7 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
   // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
+  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
 
   return splitsEventEmitter;

package/src/readiness/sdkReadinessManager.ts

@@ -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 { ISdkReadinessManager } from './types';
 import { IEventEmitter } from '../types';
@@ -19,7 +19,7 @@ const 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(
+export function sdkReadinessManagerFactory(
   log: ILogger,
   EventEmitter: new () => IEventEmitter,
   readyTimeout = 0,

package/src/sdkClient/client.ts

@@ -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';
@@ -15,7 +15,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: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
+export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings: { log, mode }, impressionsTracker, eventTracker } = params;
 
   function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {

package/src/sdkClient/clientAttributesDecoration.ts

@@ -0,0 +1,122 @@
+import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+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<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
+
+  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;
+  const clientTrack = client.track;
+
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+    return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+  }
+
+  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined{
+    const 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(attributeName: string, attributeValue: Object) {
+      const attribute: Record<string, Object> = {};
+      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(attributeName: string) {
+      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(attributes: Record<string, Object>) {
+      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(): Record<string, Object> {
+      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(attributeName: string) {
+      log.debug(`removed attribute ${attributeName}`);
+      return attributeStorage.removeAttribute(attributeName + '');
+    },
+
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes() {
+      return attributeStorage.clear();
+    }
+    
+  });
+
+}