@splitsoftware/splitio-commons 1.1.0 → 1.2.1-rc.1

package/src/sync/streaming/pushManager.ts

@@ -1,7 +1,5 @@
-import { IPushEventEmitter, IPushManagerCS } from './types';
+import { IPushEventEmitter, IPushManager } from './types';
 import { ISSEClient } from './SSEClient/types';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
 import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { Backoff } from '../../utils/Backoff';
@@ -12,17 +10,15 @@ import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
 import { getMatching } from '../../utils/key';
 import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { IPlatform } from '../../sdkFactory/types';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';
 import { KeyList, UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
+import { ISyncManagerFactoryParams } from '../types';
 
 /**
  * PushManager factory:
@@ -30,17 +26,15 @@ import { IAuthTokenPushEnabled } from './AuthClient/types';
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(
+  params: ISyncManagerFactoryParams,
   pollingManager: IPollingManager,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  fetchAuth: IFetchAuth,
-  platform: IPlatform,
-  settings: ISettings,
-): IPushManagerCS | undefined {
+): IPushManager | undefined {
+
+  const { settings, storage, splitApi, readiness, platform } = params;
 
   // `userKey` is the matching key of main client in client-side SDK.
   // It can be used to check if running on client-side or server-side SDK.
-  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined; //
+  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
   const log = settings.log;
 
   let sseClient: ISSEClient;
@@ -51,7 +45,7 @@ export function pushManagerFactory(
     log.warn(STREAMING_FALLBACK, [e]);
     return;
   }
-  const authenticate = authenticateFactory(fetchAuth);
+  const authenticate = authenticateFactory(splitApi.fetchAuth);
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
@@ -59,7 +53,8 @@ export function pushManagerFactory(
   sseClient.setEventHandler(sseHandler);
 
   // init workers
-  const segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+  // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+  const segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
   const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
 
@@ -68,11 +63,6 @@ export function pushManagerFactory(
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
   const clients: Record<string, { hash64: Hash64, worker: MySegmentsUpdateWorker }> = {};
-  if (userKey) {
-    const hash = hashUserKey(userKey);
-    userKeyHashes[hash] = userKey;
-    clients[userKey] = { hash64: hash64(userKey), worker: segmentsUpdateWorker as MySegmentsUpdateWorker };
-  }
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -176,7 +166,7 @@ export function pushManagerFactory(
   function stopWorkers() {
     splitsUpdateWorker.backoff.reset();
     if (userKey) forOwn(clients, ({ worker }) => worker.backoff.reset());
-    else segmentsUpdateWorker.backoff.reset();
+    else (segmentsUpdateWorker as SegmentsUpdateWorker).backoff.reset();
   }
 
   pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
@@ -306,37 +296,40 @@ export function pushManagerFactory(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter),
     {
-      // Expose functionality for starting and stoping push mode:
-      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
-
+      // Stop/pause push mode
+      stop() {
+        disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
+        if (userKey) this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).
+      },
+      // Start/resume push mode
       start() {
         // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.
         if (disabled || disconnected === false) return;
         disconnected = false;
-        // Run in next event-loop cycle for optimization on client-side: if multiple clients are created in the same cycle than the factory, only one authentication is performed.
-        setTimeout(connectPush);
+
+        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+        else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
       // [Only for client-side]
       add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask) {
-        clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
-
         const hash = hashUserKey(userKey);
 
         if (!userKeyHashes[hash]) {
           userKeyHashes[hash] = userKey;
+          clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
-        }
 
-        // Reconnects in case of a new client.
-        // Run in next event-loop cycle to save authentication calls
-        // in case the user is creating several clients in the current cycle.
-        setTimeout(function checkForReconnect() {
-          if (connectForNewClient) {
-            connectForNewClient = false;
-            connectPush();
-          }
-        }, 0);
+          // Reconnects in case of a new client.
+          // Run in next event-loop cycle to save authentication calls
+          // in case multiple clients are created in the current cycle.
+          setTimeout(function checkForReconnect() {
+            if (connectForNewClient) {
+              connectForNewClient = false;
+              connectPush();
+            }
+          }, 0);
+        }
       },
       // [Only for client-side]
       remove(userKey: string) {

package/src/sync/streaming/types.ts

@@ -1,11 +1,7 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IFetchAuth } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { IEventEmitter, ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISegmentsSyncTask } from '../polling/types';
+import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -45,26 +41,10 @@ export interface IPushEventEmitter extends IEventEmitter {
 }
 
 /**
- * PushManager for server-side
+ * PushManager
  */
-export interface IPushManager extends ITask, IPushEventEmitter { }
-
-/**
- * PushManager for client-side with support for multiple clients
- */
-export interface IPushManagerCS extends IPushManager {
+export interface IPushManager extends ITask, IPushEventEmitter {
+  // Methods used in client-side, to support multiple clients
   add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void,
   remove(userKey: string): void
 }
-
-/**
- * Signature of push manager factory/constructor
- */
-export type IPushManagerFactoryParams = [
-  pollingManager: IPollingManager,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  fetchAuth: IFetchAuth,
-  platform: IPlatform,
-  settings: ISettings
-]

package/src/sync/submitters/submitterManager.ts

@@ -2,15 +2,11 @@ import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSyncTaskFactory } from './eventsSyncTask';
 import { impressionsSyncTaskFactory } from './impressionsSyncTask';
 import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
-import { ISplitApi } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
+import { ISyncManagerFactoryParams } from '../types';
 
-export function submitterManagerFactory(
-  settings: ISettings,
-  storage: IStorageSync,
-  splitApi: ISplitApi,
-) {
+export function submitterManagerFactory(params: ISyncManagerFactoryParams) {
+
+  const { settings, storage, splitApi } = params;
   const log = settings.log;
   const submitters = [
     impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),

package/src/sync/syncManagerOnline.ts

@@ -2,8 +2,8 @@ import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { IReadinessManager } from '../readiness/types';
 import { IStorageSync } from '../storages/types';
-import { IPushManagerFactoryParams, IPushManager, IPushManagerCS } from './streaming/types';
-import { IPollingManager, IPollingManagerCS, IPollingManagerFactoryParams } from './polling/types';
+import { IPushManager } from './streaming/types';
+import { IPollingManager, IPollingManagerCS } from './polling/types';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 
@@ -16,44 +16,38 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (...args: IPollingManagerFactoryParams) => IPollingManager,
-  pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined
+  pollingManagerFactory?: (params: ISyncManagerFactoryParams) => IPollingManager,
+  pushManagerFactory?: (params: ISyncManagerFactoryParams, pollingManager: IPollingManager) => IPushManager | undefined,
 ): (params: ISyncManagerFactoryParams) => ISyncManagerCS {
 
   /**
    * SyncManager factory for modular SDK
    */
-  return function ({
-    settings,
-    platform,
-    splitApi,
-    storage,
-    readiness
-  }: ISyncManagerFactoryParams): ISyncManagerCS {
+  return function (params: ISyncManagerFactoryParams): ISyncManagerCS {
 
-    const log = settings.log;
+    const { log, streamingEnabled } = params.settings;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(splitApi, storage, readiness, settings);
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
-    const pushManager = settings.streamingEnabled && pollingManager && pushManagerFactory ?
-      pushManagerFactory(pollingManager, storage, readiness, splitApi.fetchAuth, platform, settings) :
+    const pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+      pushManagerFactory(params, pollingManager) :
       undefined;
 
     /** Submitter Manager */
     // It is not inyected as push and polling managers, because at the moment it is required
-    const submitter = submitterManagerFactory(settings, storage, splitApi);
+    const submitter = submitterManagerFactory(params);
 
 
     /** Sync Manager logic */
 
     function startPolling() {
-      if (!pollingManager!.isRunning()) {
+      if (pollingManager!.isRunning()) {
+        log.info(SYNC_CONTINUE_POLLING);
+      } else {
         log.info(SYNC_START_POLLING);
         pollingManager!.start();
-      } else {
-        log.info(SYNC_CONTINUE_POLLING);
       }
     }
 
@@ -96,7 +90,7 @@ export function syncManagerOnlineFactory(
         }
 
         // start periodic data recording (events, impressions, telemetry).
-        submitter && submitter.start();
+        if (submitter) submitter.start();
         running = true;
       },
 
@@ -141,7 +135,7 @@ export function syncManagerOnlineFactory(
                 // of segments since `syncAll` was already executed when starting the main client
                 mySegmentsSyncTask.execute();
               }
-              (pushManager as IPushManagerCS).add(matchingKey, mySegmentsSyncTask);
+              pushManager.add(matchingKey, mySegmentsSyncTask);
             } else {
               if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }
@@ -151,7 +145,7 @@ export function syncManagerOnlineFactory(
             const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);
             if (mySegmentsSyncTask) {
               // stop syncing
-              if (pushManager) (pushManager as IPushManagerCS).remove(matchingKey);
+              if (pushManager) pushManager.remove(matchingKey);
               if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
 
               (pollingManager as IPollingManagerCS).remove(matchingKey);

package/src/types.ts

@@ -381,6 +381,10 @@ interface IBasicClient extends IStatusInterface {
    * @returns {Promise<void>}
    */
   destroy(): Promise<void>
+
+  // Whether the client implements the client-side API, i.e, with bound key, (true), or the server-side API (false).
+  // Exposed for internal purposes only. Not considered part of the public API, and might be renamed eventually.
+  isBrowserClient: boolean
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -1108,6 +1112,45 @@ export namespace SplitIO {
      * @returns {boolean} Whether the event was added to the queue succesfully or not.
      */
     track(...args: [trafficType: string, eventType: string, value?: number, properties?: Properties] | [eventType: string, value?: number, properties?: Properties]): boolean,
+    /**
+     * Add an attribute to client's in memory attributes storage
+     * @function setAttribute
+     * @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): boolean,
+    /**
+     * Returns the attribute with the given key
+     * @function getAttribute
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object,
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     * @function setAttributes
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean,
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     * @function getAttributes
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>,
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     * @function removeAttribute
+     * @param {string} attributeName
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean,
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean
   }
   /**
    * Representation of a manager instance with synchronous storage of the SDK.

package/src/utils/inputValidation/attribute.ts

@@ -0,0 +1,21 @@
+import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+
+export function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean {
+  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 = isFiniteNumber(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.ts

@@ -1,6 +1,7 @@
 import { isObject } from '../lang';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
+import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
@@ -11,3 +12,16 @@ export function validateAttributes(log: ILogger, maybeAttrs: any, method: string
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
   return false;
 }
+
+export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<string, Object>, method: string): boolean {
+  if (!validateAttributes(log, maybeAttributes, method)) return false;
+
+  let result = true;
+  Object.keys(maybeAttributes).forEach(attributeKey => {
+    if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+      result = false;
+  });
+
+  return result;
+
+}

package/src/utils/inputValidation/eventProperties.ts

@@ -1,4 +1,5 @@
-import { isObject, shallowClone, isString, isFiniteNumber, isBoolean } from '../lang';
+import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
+import { objectAssign } from '../lang/objectAssign';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
@@ -22,7 +23,8 @@ export function validateEventProperties(log: ILogger, maybeProperties: any, meth
   }
 
   const keys = Object.keys(maybeProperties);
-  const clone = shallowClone(maybeProperties);
+  // Shallow clone
+  const clone = objectAssign({}, maybeProperties);
   // To avoid calculating the size twice we'll return it from here.
   const output = {
     properties: clone,

package/src/utils/lang/index.ts

@@ -194,20 +194,6 @@ export function merge(target: { [key: string]: any }, source: { [key: string]: a
   return res;
 }
 
-/**
- * Shallow clone an object
- */
-export function shallowClone(obj: any): any {
-  const keys = Object.keys(obj);
-  const output: Record<string, any> = {};
-
-  for (let i = 0; i < keys.length; i++) {
-    output[keys[i]] = obj[keys[i]];
-  }
-
-  return output;
-}
-
 /**
  * Checks if the target string starts with the sub string.
  */

package/src/utils/murmur3/legacy.ts

@@ -0,0 +1,48 @@
+// Deprecated hashing function, used for split bucketing. Replaced by murmur3
+
+//
+// JAVA reference implementation for the hashing function.
+//
+// int h = 0;
+// for (int i = 0; i < key.length(); i++) {
+//     h = 31 * h + key.charAt(i);
+// }
+// return h ^ seed; // XOR the hash and seed
+//
+
+function ToInteger(x: number) {
+  x = Number(x);
+  return x < 0 ? Math.ceil(x) : Math.floor(x);
+}
+
+function modulo(a: number, b: number) {
+  return a - Math.floor(a / b) * b;
+}
+
+function ToUint32(x: number) {
+  return modulo(ToInteger(x), Math.pow(2, 32));
+}
+
+function ToInt32(x: number) {
+  let uint32 = ToUint32(x);
+
+  if (uint32 >= Math.pow(2, 31)) {
+    return uint32 - Math.pow(2, 32);
+  } else {
+    return uint32;
+  }
+}
+
+export function hash(str: string, seed: number): number {
+  let h = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
+  }
+
+  return ToInt32(h ^ seed);
+}
+
+export function bucket(str: string, seed: number): number {
+  return Math.abs(hash(str, seed) % 100) + 1;
+}

package/src/utils/promise/timeout.ts

@@ -3,7 +3,7 @@ export function timeout<T>(ms: number, promise: Promise<T>): Promise<T> {
 
   return new Promise((resolve, reject) => {
     const tid = setTimeout(() => {
-      reject(new Error(`Operation timed out because it exceeded the configured time limit of ${ms}ms.`));
+      reject(new Error(`Operation timed out because it exceeded the configured time limit of ${ms} ms.`));
     }, ms);
 
     promise.then((res) => {

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -0,0 +1,51 @@
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+export declare function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient): TClient & {
+    getTreatment: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => string | SplitIO.AsyncTreatment;
+    getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
+    getTreatments: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => import("../dtos/types").MaybeThenable<boolean>;
+    /**
+     * 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): boolean;
+    /**
+     * Returns the attribute with the given key
+     *
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * 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>): boolean;
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     *
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>;
+    /**
+     * 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): boolean;
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean;
+};

package/types/sdkClient/clientCS.d.ts

@@ -1,3 +1,4 @@
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
@@ -6,4 +7,4 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export declare function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;
+export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;

package/types/storages/inMemory/AttributesCacheInMemory.d.ts

@@ -0,0 +1,43 @@
+export declare class AttributesCacheInMemory {
+    private 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: string, attributeValue: Object): boolean;
+    /**
+     * Retrieves the value of a given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @returns {Object?} stored attribute value
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * Create or update all the given attributes
+     *
+     * @param {[string, Object]} attributes attributes to create or update
+     * @returns {boolean} attributes were stored
+     */
+    setAttributes(attributes: Record<string, Object>): boolean;
+    /**
+     * Retrieve the full attributes map
+     *
+     * @returns {Map<string, Object>} stored attributes
+     */
+    getAll(): Record<string, Object>;
+    /**
+     * Removes a given attribute from the map
+     *
+     * @param {string} attributeName attribute to remove
+     * @returns {boolean} attribute removed
+     */
+    removeAttribute(attributeName: string): boolean;
+    /**
+     * Clears all attributes stored in the SDK
+     *
+     */
+    clear(): boolean;
+}