@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.1

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,118 +0,0 @@
-import { __extends } from "tslib";
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-import { isFiniteNumber } from '../../utils/lang';
-/**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- */
-var SplitsCacheInMemory = /** @class */ (function (_super) {
-    __extends(SplitsCacheInMemory, _super);
-    function SplitsCacheInMemory(splitFiltersValidation) {
-        var _this = _super.call(this) || this;
-        _this.splitsCache = {};
-        _this.ttCache = {};
-        _this.changeNumber = -1;
-        _this.segmentsCount = 0;
-        _this.flagSetsCache = {};
-        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-        return _this;
-    }
-    SplitsCacheInMemory.prototype.clear = function () {
-        this.splitsCache = {};
-        this.ttCache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-        this.flagSetsCache = {};
-    };
-    SplitsCacheInMemory.prototype.addSplit = function (split) {
-        var name = split.name;
-        var previousSplit = this.getSplit(name);
-        if (previousSplit) { // We had this Split already
-            var previousTtName = previousSplit.trafficTypeName;
-            this.ttCache[previousTtName]--;
-            if (!this.ttCache[previousTtName])
-                delete this.ttCache[previousTtName];
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Subtract from segments count for the previous version of this Split
-            if (usesSegments(previousSplit))
-                this.segmentsCount--;
-        }
-        // Store the Split.
-        this.splitsCache[name] = split;
-        // Update TT cache
-        var 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++;
-        return true;
-    };
-    SplitsCacheInMemory.prototype.removeSplit = function (name) {
-        var split = this.getSplit(name);
-        if (!split)
-            return false;
-        // Delete the Split
-        delete this.splitsCache[name];
-        var ttName = split.trafficTypeName;
-        this.ttCache[ttName]--; // Update tt cache
-        if (!this.ttCache[ttName])
-            delete this.ttCache[ttName];
-        this.removeFromFlagSets(split.name, split.sets);
-        // Update the segments count.
-        if (usesSegments(split))
-            this.segmentsCount--;
-        return true;
-    };
-    SplitsCacheInMemory.prototype.getSplit = function (name) {
-        return this.splitsCache[name] || null;
-    };
-    SplitsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.changeNumber = changeNumber;
-        return true;
-    };
-    SplitsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.changeNumber;
-    };
-    SplitsCacheInMemory.prototype.getSplitNames = function () {
-        return Object.keys(this.splitsCache);
-    };
-    SplitsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
-        return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
-    };
-    SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
-    };
-    SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new Set(); });
-    };
-    SplitsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            if (!_this.flagSetsCache[featureFlagSet])
-                _this.flagSetsCache[featureFlagSet] = new Set([]);
-            _this.flagSetsCache[featureFlagSet].add(featureFlag.name);
-        });
-    };
-    SplitsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInMemory.prototype.removeNames = function (flagSetName, featureFlagName) {
-        if (!this.flagSetsCache[flagSetName])
-            return;
-        this.flagSetsCache[flagSetName].delete(featureFlagName);
-        if (this.flagSetsCache[flagSetName].size === 0)
-            delete this.flagSetsCache[flagSetName];
-    };
-    return SplitsCacheInMemory;
-}(AbstractSplitsCacheSync));
-export { SplitsCacheInMemory };

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -1,209 +0,0 @@
-import { __extends, __spreadArray } from "tslib";
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { returnDifference } from '../../utils/lang/sets';
-/**
- * ISplitsCacheAsync implementation for pluggable storages.
- */
-var SplitsCachePluggable = /** @class */ (function (_super) {
-    __extends(SplitsCachePluggable, _super);
-    /**
-     * Create a SplitsCache that uses a storage wrapper.
-     * @param log -  Logger instance.
-     * @param keys -  Key builder.
-     * @param wrapper -  Adapted wrapper storage.
-     */
-    function SplitsCachePluggable(log, keys, wrapper, splitFiltersValidation) {
-        var _this = _super.call(this) || this;
-        _this.log = log;
-        _this.keys = keys;
-        _this.wrapper = wrapper;
-        _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-        return _this;
-    }
-    SplitsCachePluggable.prototype._decrementCounts = function (split) {
-        var _this = this;
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.wrapper.decr(ttKey).then(function (count) {
-            if (count === 0)
-                return _this.wrapper.del(ttKey);
-        });
-    };
-    SplitsCachePluggable.prototype._incrementCounts = function (split) {
-        var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        return this.wrapper.incr(ttKey);
-    };
-    SplitsCachePluggable.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
-        var _this = this;
-        var removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
-        if (this.flagSetsFilter.length > 0) {
-            addToFlagSets = addToFlagSets.filter(function (flagSet) {
-                return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });
-            });
-        }
-        var items = [featureFlagName];
-        return Promise.all(__spreadArray(__spreadArray([], removeFromFlagSets.map(function (flagSetName) { return _this.wrapper.removeItems(_this.keys.buildFlagSetKey(flagSetName), items); }), true), addToFlagSets.map(function (flagSetName) { return _this.wrapper.addItems(_this.keys.buildFlagSetKey(flagSetName), items); }), true));
-    };
-    /**
-     * Add a given split.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., wrapper operation fails)
-     */
-    SplitsCachePluggable.prototype.addSplit = function (split) {
-        var _this = this;
-        var name = split.name;
-        var splitKey = this.keys.buildSplitKey(name);
-        return this.wrapper.get(splitKey).then(function (splitFromStorage) {
-            // handling parsing error
-            var parsedPreviousSplit, stringifiedNewSplit;
-            try {
-                parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                stringifiedNewSplit = JSON.stringify(split);
-            }
-            catch (e) {
-                throw new Error('Error parsing feature flag definition: ' + e);
-            }
-            return _this.wrapper.set(splitKey, stringifiedNewSplit).then(function () {
-                // avoid unnecessary increment/decrement operations
-                if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName)
-                    return;
-                // update traffic type counts
-                return _this._incrementCounts(split).then(function () {
-                    if (parsedPreviousSplit)
-                        return _this._decrementCounts(parsedPreviousSplit);
-                });
-            }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
-        }).then(function () { return true; });
-    };
-    /**
-     * Remove a given split.
-     * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SplitsCachePluggable.prototype.removeSplit = function (name) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split) {
-                return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
-            }
-        }).then(function () {
-            return _this.wrapper.del(_this.keys.buildSplitKey(name));
-        });
-    };
-    /**
-     * Get split.
-     * The returned promise is resolved with the split definition or null if it's not defined,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getSplit = function (name) {
-        return this.wrapper.get(this.keys.buildSplitKey(name))
-            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
-    };
-    /**
-     * Get list of splits.
-     * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getSplits = function (names) {
-        var _this = this;
-        var keys = names.map(function (name) { return _this.keys.buildSplitKey(name); });
-        return this.wrapper.getMany(keys).then(function (splitDefinitions) {
-            var splits = {};
-            names.forEach(function (name, idx) {
-                var split = splitDefinitions[idx];
-                splits[name] = split && JSON.parse(split);
-            });
-            return Promise.resolve(splits);
-        });
-    };
-    /**
-     * Get list of all split definitions.
-     * The returned promise is resolved with the list of split definitions,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getAll = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
-            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
-            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
-            return JSON.parse(splitDefinition);
-        }); });
-    };
-    /**
-     * Get list of split names.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     */
-    SplitsCachePluggable.prototype.getSplitNames = function () {
-        var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
-    };
-    /**
-     * Get list of feature flag names related to a given list of flag set names.
-     * The returned promise is resolved with the list of feature flag names per flag set.
-     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
-     */
-    SplitsCachePluggable.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        return Promise.all(flagSets.map(function (flagSet) {
-            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
-        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
-    };
-    /**
-     * Check traffic type existence.
-     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
-     * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
-     * It will never be rejected.
-     */
-    SplitsCachePluggable.prototype.trafficTypeExists = function (trafficType) {
-        var _this = this;
-        // If there is a number there should be > 0, otherwise the TT is considered as not existent.
-        return this.wrapper.get(this.keys.buildTrafficTypeKey(trafficType))
-            .then(function (ttCount) {
-            if (ttCount === null)
-                return false; // if entry doesn't exist, means that TT doesn't exist
-            ttCount = parseInt(ttCount, 10);
-            if (!isFiniteNumber(ttCount) || ttCount < 0) {
-                _this.log.info(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to data corruption of some sorts."));
-                return false;
-            }
-            return ttCount > 0;
-        }).catch(function (e) {
-            _this.log.error(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to an error: ").concat(e, "."));
-            // If there is an error, bypass the validation so the event can get tracked.
-            return true;
-        });
-    };
-    /**
-     * Set till number.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SplitsCachePluggable.prototype.setChangeNumber = function (changeNumber) {
-        return this.wrapper.set(this.keys.buildSplitsTillKey(), changeNumber + '');
-    };
-    /**
-     * Get till number or -1 if it's not defined.
-     * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.
-     * The promise will never be rejected.
-     */
-    SplitsCachePluggable.prototype.getChangeNumber = function () {
-        var _this = this;
-        return this.wrapper.get(this.keys.buildSplitsTillKey()).then(function (value) {
-            var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
-        }).catch(function (e) {
-            _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
-            return -1;
-        });
-    };
-    // @TODO implement if required by DataLoader or producer mode
-    SplitsCachePluggable.prototype.clear = function () {
-        return Promise.resolve(true);
-    };
-    return SplitsCachePluggable;
-}(AbstractSplitsCacheAsync));
-export { SplitsCachePluggable };

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,63 +0,0 @@
-import { ISplitsCacheAsync } from './types';
-import { IDefinition } from '../dtos/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
-
-  protected abstract addSplit(split: IDefinition): Promise<boolean>
-  protected abstract removeSplit(name: string): Promise<boolean>
-  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
-
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): Promise<boolean> {
-    return Promise.all([
-      this.setChangeNumber(changeNumber),
-      Promise.all(toAdd.map(addedFF => this.addSplit(addedFF))),
-      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF)))
-    ]).then(([, added, removed]) => {
-      return added.some(result => result) || removed.some(result => result);
-    });
-  }
-
-  abstract getSplit(name: string): Promise<IDefinition | null>
-  abstract getSplits(names: string[]): Promise<Record<string, IDefinition | null>>
-  abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<IDefinition[]>
-  abstract getSplitNames(): Promise<string[]>
-  abstract getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]>
-  abstract trafficTypeExists(trafficType: string): Promise<boolean>
-  abstract clear(): Promise<boolean | void>
-
-  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-  // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-  usesSegments(): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-   * Used for SPLIT_KILL push notifications.
-   *
-   * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-   * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-   * The promise will never be rejected.
-   */
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
-    return this.getSplit(name).then(split => {
-
-      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-        const newSplit = objectAssign({}, split);
-        newSplit.killed = true;
-        newSplit.defaultTreatment = defaultTreatment;
-        newSplit.changeNumber = changeNumber;
-
-        return this.addSplit(newSplit);
-      }
-      return false;
-    }).catch(() => false);
-  }
-
-}

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,95 +0,0 @@
-import { ISplitsCacheSync, IStorageSync } from './types';
-import { IRBSegment, IDefinition } from '../dtos/types';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
-
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
-
-  protected abstract addSplit(split: IDefinition): boolean
-  protected abstract removeSplit(name: string): boolean
-  protected abstract setChangeNumber(changeNumber: number): boolean | void
-
-  update(toAdd: IDefinition[], toRemove: string[], changeNumber: number): boolean {
-    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.removeSplit(removedFF)).some(result => result) || updated;
-    this.setChangeNumber(changeNumber);
-    return updated;
-  }
-
-  abstract getSplit(name: string): IDefinition | null
-
-  getSplits(names: string[]): Record<string, IDefinition | null> {
-    const splits: Record<string, IDefinition | null> = {};
-    names.forEach(name => {
-      splits[name] = this.getSplit(name);
-    });
-    return splits;
-  }
-
-  abstract getChangeNumber(): number
-
-  getAll(): IDefinition[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as IDefinition);
-  }
-
-  abstract getSplitNames(): string[]
-
-  abstract trafficTypeExists(trafficType: string): boolean
-
-  abstract usesSegments(): boolean
-
-  abstract clear(): void
-
-  /**
-   * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-   * Used for SPLIT_KILL push notifications.
-   *
-   * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-   * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-   */
-  killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {
-    const split = this.getSplit(name);
-
-    if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-      const newSplit = objectAssign({}, split);
-      newSplit.killed = true;
-      newSplit.defaultTreatment = defaultTreatment;
-      newSplit.changeNumber = changeNumber;
-
-      return this.addSplit(newSplit);
-    }
-    return false;
-  }
-
-  abstract getNamesByFlagSets(flagSets: string[]): Set<string>[]
-
-}
-
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-export function usesSegments(ruleEntity: IDefinition | IRBSegment) {
-  const conditions = ruleEntity.conditions || [];
-  for (let i = 0; i < conditions.length; i++) {
-    const matchers = conditions[i].matcherGroup.matchers;
-
-    for (let j = 0; j < matchers.length; j++) {
-      const matcher = matchers[j].matcherType;
-      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
-    }
-  }
-
-  const excluded = (ruleEntity as IRBSegment).excluded;
-  if (excluded && excluded.segments && excluded.segments.length > 0) return true;
-
-  return false;
-}
-
-export function usesSegmentsSync(storage: Pick<IStorageSync, 'splits' | 'rbSegments'>) {
-  return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}