@splitsoftware/splitio-commons 2.4.2-rc.3 → 11.5.0-rc.0

package/esm/storages/AbstractSplitsCacheSync.js

@@ -1,70 +0,0 @@
-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.
- */
-var AbstractSplitsCacheSync = /** @class */ (function () {
-    function AbstractSplitsCacheSync() {
-    }
-    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        this.setChangeNumber(changeNumber);
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
-    };
-    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
-        var _this = this;
-        var splits = {};
-        names.forEach(function (name) {
-            splits[name] = _this.getSplit(name);
-        });
-        return splits;
-    };
-    AbstractSplitsCacheSync.prototype.getAll = function () {
-        var _this = this;
-        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
-    };
-    /**
-     * 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.
-     */
-    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var split = this.getSplit(name);
-        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-            var newSplit = objectAssign({}, split);
-            newSplit.killed = true;
-            newSplit.defaultTreatment = defaultTreatment;
-            newSplit.changeNumber = changeNumber;
-            return this.addSplit(newSplit);
-        }
-        return false;
-    };
-    return AbstractSplitsCacheSync;
-}());
-export { AbstractSplitsCacheSync };
-/**
- * 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) {
-    var conditions = ruleEntity.conditions || [];
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
-                return true;
-        }
-    }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
-    return false;
-}
-export function usesSegmentsSync(storage) {
-    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}

package/esm/storages/KeyBuilder.js

@@ -1,63 +0,0 @@
-import { hash } from '../utils/murmur3/murmur3';
-var everythingAtTheEnd = /[^.]+$/;
-var DEFAULT_PREFIX = 'SPLITIO';
-export function validatePrefix(prefix) {
-    return prefix ? prefix + '.SPLITIO' : 'SPLITIO';
-}
-var KeyBuilder = /** @class */ (function () {
-    function KeyBuilder(prefix) {
-        if (prefix === void 0) { prefix = DEFAULT_PREFIX; }
-        this.prefix = prefix;
-    }
-    KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
-        return this.prefix + ".trafficType." + trafficType;
-    };
-    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
-        return this.prefix + ".flagSet." + flagSet;
-    };
-    KeyBuilder.prototype.buildSplitKey = function (splitName) {
-        return this.prefix + ".split." + splitName;
-    };
-    KeyBuilder.prototype.buildSplitsTillKey = function () {
-        return this.prefix + ".splits.till";
-    };
-    KeyBuilder.prototype.buildSplitKeyPrefix = function () {
-        return this.prefix + ".split.";
-    };
-    KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {
-        return this.prefix + ".rbsegment." + rbsegmentName;
-    };
-    KeyBuilder.prototype.buildRBSegmentsTillKey = function () {
-        return this.prefix + ".rbsegments.till";
-    };
-    KeyBuilder.prototype.buildRBSegmentKeyPrefix = function () {
-        return this.prefix + ".rbsegment.";
-    };
-    KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.prefix + ".segment." + segmentName;
-    };
-    KeyBuilder.prototype.buildSegmentTillKey = function (segmentName) {
-        return this.prefix + ".segment." + segmentName + ".till";
-    };
-    KeyBuilder.prototype.extractKey = function (builtKey) {
-        var s = builtKey.match(everythingAtTheEnd);
-        if (s && s.length) {
-            return s[0];
-        }
-        else {
-            throw new Error('Invalid latency key provided');
-        }
-    };
-    KeyBuilder.prototype.buildHashKey = function () {
-        return this.prefix + ".hash";
-    };
-    return KeyBuilder;
-}());
-export { KeyBuilder };
-/**
- * Generates a murmur32 hash based on the authorization key, the feature flags filter query, and version of SplitChanges API.
- * The hash is in hexadecimal format (8 characters max, 32 bits).
- */
-export function getStorageHash(settings) {
-    return hash(settings.core.authorizationKey + "::" + settings.sync.__splitFiltersValidation.queryString + "::" + settings.sync.flagSpecVersion).toString(16);
-}

package/esm/storages/KeyBuilderCS.js

@@ -1,61 +0,0 @@
-import { __extends } from "tslib";
-import { startsWith } from '../utils/lang';
-import { KeyBuilder } from './KeyBuilder';
-var KeyBuilderCS = /** @class */ (function (_super) {
-    __extends(KeyBuilderCS, _super);
-    function KeyBuilderCS(prefix, matchingKey) {
-        var _this = _super.call(this, prefix) || this;
-        _this.matchingKey = matchingKey;
-        _this.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.(splits?|trafficType|flagSet)\\.");
-        return _this;
-    }
-    /**
-     * @override
-     */
-    KeyBuilderCS.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.prefix + "." + this.matchingKey + ".segment." + segmentName;
-    };
-    KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {
-        var prefix = this.prefix + "." + this.matchingKey + ".segment.";
-        if (startsWith(builtSegmentKeyName, prefix))
-            return builtSegmentKeyName.slice(prefix.length);
-    };
-    KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
-        return this.prefix + ".splits.lastUpdated";
-    };
-    KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
-        return this.regexSplitsCacheKey.test(key);
-    };
-    KeyBuilderCS.prototype.buildTillKey = function () {
-        return this.prefix + "." + this.matchingKey + ".segments.till";
-    };
-    KeyBuilderCS.prototype.isSplitKey = function (key) {
-        return startsWith(key, this.prefix + ".split.");
-    };
-    KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
-        return startsWith(key, this.prefix + ".rbsegment.");
-    };
-    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
-        return this.prefix + ".splits.usingSegments";
-    };
-    KeyBuilderCS.prototype.buildLastClear = function () {
-        return this.prefix + ".lastClear";
-    };
-    return KeyBuilderCS;
-}(KeyBuilder));
-export { KeyBuilderCS };
-export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
-    return {
-        buildSegmentNameKey: function (segmentName) {
-            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
-        },
-        extractSegmentName: function (builtSegmentKeyName) {
-            var p = prefix + "." + matchingKey + ".largeSegment.";
-            if (startsWith(builtSegmentKeyName, p))
-                return builtSegmentKeyName.slice(p.length);
-        },
-        buildTillKey: function () {
-            return prefix + "." + matchingKey + ".largeSegments.till";
-        }
-    };
-}

package/esm/storages/KeyBuilderSS.js

@@ -1,57 +0,0 @@
-import { __extends } from "tslib";
-import { KeyBuilder } from './KeyBuilder';
-export var METHOD_NAMES = {
-    t: 'treatment',
-    ts: 'treatments',
-    tc: 'treatmentWithConfig',
-    tcs: 'treatmentsWithConfig',
-    tf: 'treatmentsByFlagSet',
-    tfs: 'treatmentsByFlagSets',
-    tcf: 'treatmentsWithConfigByFlagSet',
-    tcfs: 'treatmentsWithConfigByFlagSets',
-    tr: 'track'
-};
-var KeyBuilderSS = /** @class */ (function (_super) {
-    __extends(KeyBuilderSS, _super);
-    function KeyBuilderSS(prefix, metadata) {
-        var _this = _super.call(this, prefix) || this;
-        _this.latencyPrefix = _this.prefix + ".telemetry.latencies";
-        _this.exceptionPrefix = _this.prefix + ".telemetry.exceptions";
-        _this.initPrefix = _this.prefix + ".telemetry.init";
-        _this.versionablePrefix = metadata.s + "/" + metadata.n + "/" + metadata.i;
-        return _this;
-    }
-    KeyBuilderSS.prototype.buildRegisteredSegmentsKey = function () {
-        return this.prefix + ".segments.registered";
-    };
-    KeyBuilderSS.prototype.buildImpressionsKey = function () {
-        return this.prefix + ".impressions";
-    };
-    KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
-        return this.prefix + ".impressions.count";
-    };
-    KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
-        return this.prefix + ".uniquekeys";
-    };
-    KeyBuilderSS.prototype.buildEventsKey = function () {
-        return this.prefix + ".events";
-    };
-    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
-        return this.buildSplitKeyPrefix() + "*";
-    };
-    KeyBuilderSS.prototype.searchPatternForRBSegmentKeys = function () {
-        return this.buildRBSegmentKeyPrefix() + "*";
-    };
-    /* Telemetry keys */
-    KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
-        return this.latencyPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method] + "/" + bucket;
-    };
-    KeyBuilderSS.prototype.buildExceptionKey = function (method) {
-        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method];
-    };
-    KeyBuilderSS.prototype.buildInitKey = function () {
-        return this.initPrefix + "::" + this.versionablePrefix;
-    };
-    return KeyBuilderSS;
-}(KeyBuilder));
-export { KeyBuilderSS };

package/esm/storages/dataLoader.js

@@ -1,46 +0,0 @@
-// This value might be eventually set via a config parameter
-var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
-/**
- * Factory of client-side storage loader
- *
- * @param preloadedData - validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
- */
-export function dataLoaderFactory(preloadedData) {
-    /**
-     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-     *
-     * @param storage - object containing `splits` and `segments` cache (client-side variant)
-     * @param userId - user key string of the provided MySegmentsCache
-     */
-    // @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-    // @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-    return function loadData(storage, userId) {
-        // Do not load data if current preloadedData is empty
-        if (Object.keys(preloadedData).length === 0)
-            return;
-        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
-        var storedSince = storage.splits.getChangeNumber();
-        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        // Do not load data if current localStorage data is more recent,
-        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-        if (storedSince > since || lastUpdated < expirationTimestamp)
-            return;
-        // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
-        storage.splits.clear();
-        // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.update(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }), [], since);
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-        if (!mySegmentsData) {
-            // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
-            mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
-            });
-        }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
-    };
-}

package/esm/storages/findLatencyIndex.js

@@ -1,14 +0,0 @@
-import { isNaNNumber } from '../utils/lang';
-var MIN = 0;
-var MAX = 22;
-var BASE = 1.5;
-/**
- * Calculates buckets from latency in milliseconds
- *
- * @param latencyInMs - latency in milliseconds
- * @returns a bucket index from 0 to 22 inclusive
- */
-export function findLatencyIndex(latencyInMs) {
-    var index = Math.min(MAX, Math.max(MIN, Math.ceil(Math.log(latencyInMs) / Math.log(BASE))));
-    return isNaNNumber(index) ? 0 : index; // index is NaN if latency is not a positive number
-}

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,78 +0,0 @@
-import { __extends } from "tslib";
-import { isNaNNumber } from '../../utils/lang';
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-import { LOG_PREFIX, DEFINED } from './constants';
-var MySegmentsCacheInLocal = /** @class */ (function (_super) {
-    __extends(MySegmentsCacheInLocal, _super);
-    function MySegmentsCacheInLocal(log, keys, storage) {
-        var _this = _super.call(this) || this;
-        _this.log = log;
-        _this.keys = keys;
-        _this.storage = storage;
-        return _this;
-        // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
-    }
-    MySegmentsCacheInLocal.prototype.addSegment = function (name) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        try {
-            if (this.storage.getItem(segmentKey) === DEFINED)
-                return false;
-            this.storage.setItem(segmentKey, DEFINED);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        try {
-            if (this.storage.getItem(segmentKey) !== DEFINED)
-                return false;
-            this.storage.removeItem(segmentKey);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
-        return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
-    };
-    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
-        var registeredSegments = [];
-        for (var i = 0, len = this.storage.length; i < len; i++) {
-            var segmentName = this.keys.extractSegmentName(this.storage.key(i));
-            if (segmentName)
-                registeredSegments.push(segmentName);
-        }
-        return registeredSegments;
-    };
-    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
-        return 1;
-    };
-    MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            if (changeNumber)
-                this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            else
-                this.storage.removeItem(this.keys.buildTillKey());
-        }
-        catch (e) {
-            this.log.error(e);
-        }
-    };
-    MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = this.storage.getItem(this.keys.buildTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return isNaNNumber(value) ? n : value;
-        }
-        return n;
-    };
-    return MySegmentsCacheInLocal;
-}(AbstractMySegmentsCacheSync));
-export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -1,114 +0,0 @@
-import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
-import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
-import { LOG_PREFIX } from './constants';
-var RBSegmentsCacheInLocal = /** @class */ (function () {
-    function RBSegmentsCacheInLocal(settings, keys, storage) {
-        this.keys = keys;
-        this.log = settings.log;
-        this.storage = storage;
-    }
-    RBSegmentsCacheInLocal.prototype.clear = function () {
-        var _this = this;
-        this.getNames().forEach(function (name) { return _this.remove(name); });
-        this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
-    };
-    RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        this.setChangeNumber(changeNumber);
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
-    };
-    RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
-    };
-    RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
-        var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        var count = toNumber(this.storage.getItem(segmentsCountKey)) + diff;
-        if (count > 0)
-            this.storage.setItem(segmentsCountKey, count + '');
-        else
-            this.storage.removeItem(segmentsCountKey);
-    };
-    RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
-        try {
-            var name_1 = rbSegment.name;
-            var rbSegmentKey = this.keys.buildRBSegmentKey(name_1);
-            var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
-            var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
-            this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
-            var usesSegmentsDiff = 0;
-            if (previous && usesSegments(previous))
-                usesSegmentsDiff--;
-            if (usesSegments(rbSegment))
-                usesSegmentsDiff++;
-            if (usesSegmentsDiff !== 0)
-                this.updateSegmentCount(usesSegmentsDiff);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    RBSegmentsCacheInLocal.prototype.remove = function (name) {
-        try {
-            var rbSegment = this.get(name);
-            if (!rbSegment)
-                return false;
-            this.storage.removeItem(this.keys.buildRBSegmentKey(name));
-            if (usesSegments(rbSegment))
-                this.updateSegmentCount(-1);
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    RBSegmentsCacheInLocal.prototype.getNames = function () {
-        var len = this.storage.length;
-        var accum = [];
-        var cur = 0;
-        while (cur < len) {
-            var key = this.storage.key(cur);
-            if (key != null && this.keys.isRBSegmentKey(key))
-                accum.push(this.keys.extractKey(key));
-            cur++;
-        }
-        return accum;
-    };
-    RBSegmentsCacheInLocal.prototype.get = function (name) {
-        var item = this.storage.getItem(this.keys.buildRBSegmentKey(name));
-        return item && JSON.parse(item);
-    };
-    RBSegmentsCacheInLocal.prototype.contains = function (names) {
-        var namesArray = setToArray(names);
-        var namesInStorage = this.getNames();
-        return namesArray.every(function (name) { return namesInStorage.indexOf(name) !== -1; });
-    };
-    RBSegmentsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return isNaNNumber(value) ? n : value;
-        }
-        return n;
-    };
-    RBSegmentsCacheInLocal.prototype.usesSegments = function () {
-        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        return isFiniteNumber(splitsWithSegmentsCount) ?
-            splitsWithSegmentsCount > 0 :
-            true;
-    };
-    return RBSegmentsCacheInLocal;
-}());
-export { RBSegmentsCacheInLocal };