@splitsoftware/splitio-commons 2.1.0 → 2.1.1-rc.1

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -26,7 +26,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.segmentsCount = 0;
   }
 
-  addSplit(name: string, split: ISplit): boolean {
+  addSplit(split: ISplit): boolean {
+    const name = split.name;
     const previousSplit = this.getSplit(name);
     if (previousSplit) { // We had this Split already
 
@@ -40,41 +41,35 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       if (usesSegments(previousSplit)) this.segmentsCount--;
     }
 
-    if (split) {
-      // Store the Split.
-      this.splitsCache[name] = split;
-      // Update TT cache
-      const ttName = split.trafficTypeName;
-      this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-      this.addToFlagSets(split);
+    // Store the Split.
+    this.splitsCache[name] = split;
+    // Update TT cache
+    const ttName = split.trafficTypeName;
+    this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+    this.addToFlagSets(split);
 
-      // Add to segments count for the new version of the Split
-      if (usesSegments(split)) this.segmentsCount++;
+    // Add to segments count for the new version of the Split
+    if (usesSegments(split)) this.segmentsCount++;
 
-      return true;
-    } else {
-      return false;
-    }
+    return true;
   }
 
   removeSplit(name: string): boolean {
     const split = this.getSplit(name);
-    if (split) {
-      // Delete the Split
-      delete this.splitsCache[name];
+    if (!split) return false;
 
-      const ttName = split.trafficTypeName;
-      this.ttCache[ttName]--; // Update tt cache
-      if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      this.removeFromFlagSets(split.name, split.sets);
+    // Delete the Split
+    delete this.splitsCache[name];
 
-      // Update the segments count.
-      if (usesSegments(split)) this.segmentsCount--;
+    const ttName = split.trafficTypeName;
+    this.ttCache[ttName]--; // Update tt cache
+    if (!this.ttCache[ttName]) delete this.ttCache[ttName];
+    this.removeFromFlagSets(split.name, split.sets);
 
-      return true;
-    } else {
-      return false;
-    }
+    // Update the segments count.
+    if (usesSegments(split)) this.segmentsCount--;
+
+    return true;
   }
 
   getSplit(name: string): ISplit | null {

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -82,7 +82,8 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(name: string, split: ISplit): Promise<boolean> {
+  addSplit(split: ISplit): Promise<boolean> {
+    const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then(splitFromStorage => {
 
@@ -107,18 +108,9 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     }).then(() => true);
   }
 
-  /**
-   * Add a list of splits.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., redis operation fails)
-   */
-  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
-    return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
-  }
-
   /**
    * Remove a given split.
-   * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
+   * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
    * or rejected if it fails (e.g., redis operation fails).
    */
   removeSplit(name: string) {
@@ -127,19 +119,10 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         return this._decrementCounts(split).then(() => this._updateFlagSets(name, split.sets));
       }
     }).then(() => {
-      return this.redis.del(this.keys.buildSplitKey(name));
+      return this.redis.del(this.keys.buildSplitKey(name)).then(status => status === 1);
     });
   }
 
-  /**
-   * Remove a list of splits.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., redis operation fails).
-   */
-  removeSplits(names: string[]): Promise<any> {
-    return Promise.all(names.map(name => this.removeSplit(name)));
-  }
-
   /**
    * Get split definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -66,7 +66,8 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: ISplit): Promise<boolean> {
+  addSplit(split: ISplit): Promise<boolean> {
+    const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
@@ -91,15 +92,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     }).then(() => true);
   }
 
-  /**
-   * Add a list of splits.
-   * The returned promise is resolved when the operation success
-   * or rejected if it fails (e.g., wrapper operation fails)
-   */
-  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
-    return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
-  }
-
   /**
    * Remove a given split.
    * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -115,15 +107,6 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     });
   }
 
-  /**
-   * Remove a list of splits.
-   * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  removeSplits(names: string[]): Promise<void> { // @ts-ignore
-    return Promise.all(names.map(name => this.removeSplit(name)));
-  }
-
   /**
    * Get split.
    * The returned promise is resolved with the split definition or null if it's not defined,

package/src/storages/types.ts

@@ -177,11 +177,9 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
-  removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): MaybeThenable<boolean>,
   getSplit(name: string): MaybeThenable<ISplit | null>,
   getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
-  setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
   getAll(): MaybeThenable<ISplit[]>,
@@ -198,11 +196,9 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): boolean[],
-  removeSplits(names: string[]): boolean[],
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean,
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
-  setChangeNumber(changeNumber: number): boolean | void,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
@@ -215,11 +211,9 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
-  removeSplits(names: string[]): Promise<boolean[] | void>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean>,
   getSplit(name: string): Promise<ISplit | null>,
   getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
-  setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
   getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
@@ -428,13 +422,13 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
  */
 
 export interface IStorageBase<
-  TSplitsCache extends ISplitsCacheBase,
-  TSegmentsCache extends ISegmentsCacheBase,
-  TImpressionsCache extends IImpressionsCacheBase,
-  TImpressionsCountCache extends IImpressionCountsCacheBase,
-  TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
-  TUniqueKeysCache extends IUniqueKeysCacheBase
+  TSplitsCache extends ISplitsCacheBase = ISplitsCacheBase,
+  TSegmentsCache extends ISegmentsCacheBase = ISegmentsCacheBase,
+  TImpressionsCache extends IImpressionsCacheBase = IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheBase = IImpressionCountsCacheBase,
+  TEventsCache extends IEventsCacheBase = IEventsCacheBase,
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync = ITelemetryCacheSync | ITelemetryCacheAsync,
+  TUniqueKeysCache extends IUniqueKeysCacheBase = IUniqueKeysCacheBase
 > {
   splits: TSplitsCache,
   segments: TSegmentsCache,

package/src/storages/utils.ts

@@ -30,6 +30,7 @@ export function impressionsToJSON(impressions: SplitIO.ImpressionDTO[], metadata
         c: impression.changeNumber,
         m: impression.time,
         pt: impression.pt,
+        properties: impression.properties
       }
     };
 

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, ISplit][] = [];
+    const splits: ISplit[] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -37,24 +37,23 @@ export function fromObjectUpdaterFactory(
     if (!loadError && splitsMock) {
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
-      forOwn(splitsMock, function (val, name) {
-        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
-          name, {
-            name,
-            status: 'ACTIVE',
-            killed: false,
-            trafficAllocation: 100,
-            defaultTreatment: CONTROL,
-            conditions: val.conditions || [],
-            configurations: val.configurations,
-            trafficTypeName: val.trafficTypeName
-          }
-        ]);
+      forOwn(splitsMock, (val, name) => {
+        // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+        splits.push({
+          name,
+          status: 'ACTIVE',
+          killed: false,
+          trafficAllocation: 100,
+          defaultTreatment: CONTROL,
+          conditions: val.conditions || [],
+          configurations: val.configurations,
+          trafficTypeName: val.trafficTypeName
+        });
       });
 
       return Promise.all([
         splitsCache.clear(), // required to sync removed splits from mock
-        splitsCache.addSplits(splits)
+        splitsCache.update(splits, [], Date.now())
       ]).then(() => {
         readiness.splits.emit(SDK_SPLITS_ARRIVED);
 

package/src/sync/polling/syncTasks/splitsSyncTask.ts

@@ -22,8 +22,7 @@ export function splitsSyncTaskFactory(
     splitChangesUpdaterFactory(
       settings.log,
       splitChangesFetcherFactory(fetchSplitChanges),
-      storage.splits,
-      storage.segments,
+      storage,
       settings.sync.__splitFiltersValidation,
       readiness.splits,
       settings.startup.requestTimeoutBeforeReady,

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -1,11 +1,11 @@
-import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
+import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
@@ -42,8 +42,8 @@ export function parseSegments({ conditions }: ISplit): Set<string> {
 }
 
 interface ISplitMutations {
-  added: [string, ISplit][],
-  removed: string[],
+  added: ISplit[],
+  removed: ISplit[],
   segments: string[]
 }
 
@@ -77,13 +77,13 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
   const segments = new Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
-      accum.added.push([split.name, split]);
+      accum.added.push(split);
 
       parseSegments(split).forEach((segmentName: string) => {
         segments.add(segmentName);
       });
     } else {
-      accum.removed.push(split.name);
+      accum.removed.push(split);
     }
 
     return accum;
@@ -111,14 +111,14 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
 export function splitChangesUpdaterFactory(
   log: ILogger,
   splitChangesFetcher: ISplitChangesFetcher,
-  splits: ISplitsCacheBase,
-  segments: ISegmentsCacheBase,
+  storage: Pick<IStorageBase, 'splits' | 'segments'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
 ): ISplitChangesUpdater {
+  const { splits, segments } = storage;
 
   let startingUp = true;
 
@@ -128,16 +128,6 @@ export function splitChangesUpdaterFactory(
     return promise;
   }
 
-  /** Returns true if at least one split was updated */
-  function isThereUpdate(flagsChange: [boolean | void, void | boolean[], void | boolean[], boolean | void] | [any, any, any]) {
-    const [, added, removed] = flagsChange;
-    // There is at least one added or modified feature flag
-    if (added && added.some((update: boolean) => update)) return true;
-    // There is at least one removed feature flag
-    if (removed && removed.some((update: boolean) => update)) return true;
-    return false;
-  }
-
   /**
    * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
    * Returned promise will not be rejected.
@@ -162,22 +152,17 @@ export function splitChangesUpdaterFactory(
 
           const mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
 
-          log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
-          log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
-          log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
+          log.debug(SYNC_SPLITS_UPDATE, [mutation.added.length, mutation.removed.length, mutation.segments.length]);
 
           // Write into storage
           // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
           return Promise.all([
-            // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-            splits.setChangeNumber(splitChanges.till),
-            splits.addSplits(mutation.added),
-            splits.removeSplits(mutation.removed),
+            splits.update(mutation.added, mutation.removed, splitChanges.till),
             segments.registerSegments(mutation.segments)
-          ]).then((flagsChange) => {
+          ]).then(([isThereUpdate]) => {
             if (splitsEventEmitter) {
               // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events

package/src/sync/submitters/impressionsSubmitter.ts

@@ -25,8 +25,9 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           m: entry.time, // Timestamp
           c: entry.changeNumber, // ChangeNumber
           r: sendLabels ? entry.label : undefined, // Rule
-          b: entry.bucketingKey ? entry.bucketingKey : undefined, // Bucketing Key
-          pt: entry.pt ? entry.pt : undefined // Previous time
+          b: entry.bucketingKey, // Bucketing Key
+          pt: entry.pt, // Previous time
+          properties: entry.properties // Properties
         };
 
         return keyImpression;

package/src/sync/submitters/types.ts

@@ -3,26 +3,30 @@ import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
 
+type ImpressionPayload = {
+  /** Matching Key */
+  k: string;
+  /** Bucketing Key */
+  b?: string;
+  /** Treatment */
+  t: string;
+  /** Timestamp */
+  m: number;
+  /** Change number */
+  c: number;
+  /** Rule label */
+  r?: string;
+  /** Previous time */
+  pt?: number;
+  /** Stringified JSON object with properties */
+  properties?: string;
+};
+
 export type ImpressionsPayload = {
   /** Split name */
   f: string,
   /** Key Impressions */
-  i: {
-    /** User Key */
-    k: string;
-    /** Treatment */
-    t: string;
-    /** Timestamp */
-    m: number;
-    /** ChangeNumber */
-    c: number;
-    /** Rule label */
-    r?: string;
-    /** Bucketing Key */
-    b?: string;
-    /** Previous time */
-    pt?: number;
-  }[]
+  i: ImpressionPayload[]
 }[]
 
 export type ImpressionCountsPayload = {
@@ -60,23 +64,9 @@ export type StoredImpressionWithMetadata = {
   /** Metadata */
   m: IMetadata,
   /** Stored impression */
-  i: {
-    /** keyName */
-    k: string,
-    /** bucketingKey */
-    b?: string,
-    /** Split name */
-    f: string,
-    /** treatment */
-    t: string,
-    /** label */
-    r: string,
-    /** changeNumber */
-    c: number,
-    /** time */
-    m: number
-    /** previous time */
-    pt?: number
+  i: ImpressionPayload & {
+    /** Feature flag name */
+    f: string
   }
 }
 

package/src/trackers/strategy/strategyOptimized.ts

@@ -18,6 +18,9 @@ export function strategyOptimizedFactory(
 
   return {
     process(impression: SplitIO.ImpressionDTO) {
+      // DEBUG mode without previous time, for impressions with properties
+      if (impression.properties) return true;
+
       impression.pt = impressionsObserver.testAndSet(impression);
 
       const now = Date.now();

package/src/utils/inputValidation/eventProperties.ts

@@ -66,3 +66,13 @@ export function validateEventProperties(log: ILogger, maybeProperties: any, meth
 
   return output;
 }
+
+export function validateEvaluationOptions(log: ILogger, maybeOptions: any, method: string): SplitIO.EvaluationOptions | undefined {
+  if (isObject(maybeOptions)) {
+    const properties = validateEventProperties(log, maybeOptions.properties, method).properties;
+    return properties && Object.keys(properties).length > 0 ? { properties } : undefined;
+  } else if (maybeOptions) {
+    log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);
+  }
+  return undefined;
+}

package/src/utils/inputValidation/index.ts

@@ -11,3 +11,4 @@ export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';
+export { validateEvaluationOptions } from './eventProperties';