@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.10

package/esm/services/authProvider.js

@@ -1,63 +0,0 @@
-import { authenticateFactory } from '../sync/streaming/AuthClient';
-import { Backoff } from '../utils/Backoff';
-import { LOG_PREFIX_SYNC_AUTH } from '../logger/constants';
-import { TOKEN } from '../utils/constants';
-var SKEW_SECONDS = 30;
-function isExpired(credential) {
-    return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
-}
-/**
- * Factory of AuthProvider, which provides JWT credentials for authenticated HTTP requests.
- * Credentials are fetched lazily on demand, cached in memory, and retried with backoff on failure.
- */
-export function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
-    var urls = settings.urls, log = settings.log;
-    function fetchAuth() {
-        var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config,aiconfig");
-        return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN), false, true);
-    }
-    var authenticate = authenticateFactory(fetchAuth);
-    var backoff = new Backoff(fetchCredential);
-    var cachedCredential;
-    var inFlightPromise;
-    var stopped = false;
-    function fetchCredential() {
-        return authenticate().then(function (credential) {
-            log.info(LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
-            cachedCredential = credential;
-            inFlightPromise = undefined;
-            backoff.reset();
-            return credential;
-        }).catch(function (error) {
-            // Avoid rejected promises and unnecessary retries after stop()
-            if (stopped)
-                return cachedCredential;
-            if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
-                log.error(LOG_PREFIX_SYNC_AUTH + 'non-retryable error fetching credential (status ' + error.statusCode + '): ' + error.message);
-                inFlightPromise = undefined;
-                throw error;
-            }
-            log.warn(LOG_PREFIX_SYNC_AUTH + 'credential fetch failed (attempt ' + (backoff.attempts + 1) + '). Error: ' + error.message);
-            return backoff.scheduleCallAsync();
-        });
-    }
-    return {
-        credential: function () {
-            if (cachedCredential && !isExpired(cachedCredential)) {
-                return Promise.resolve(cachedCredential);
-            }
-            if (cachedCredential)
-                log.debug(LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
-            return inFlightPromise || (inFlightPromise = fetchCredential());
-        },
-        invalidate: function () {
-            cachedCredential = undefined;
-        },
-        stop: function () {
-            stopped = true;
-            cachedCredential = undefined;
-            inFlightPromise = undefined;
-            backoff.reset();
-        }
-    };
-}

package/esm/services/secureSplitHttpClient.js

@@ -1,35 +0,0 @@
-import { __assign } from "tslib";
-import { splitHttpClientFactory } from './splitHttpClient';
-import { authProviderFactory } from './authProvider';
-/**
- * Factory of Secure HTTP client, which authenticates requests using a JWT token.
- * On 401 responses, invalidates the cached credential and retries once with a fresh token.
- *
- * @param settings - SDK settings
- * @param platform - object containing environment-specific dependencies
- * @param fetchAuth - function to fetch auth credentials from the /v2/auth endpoint
- */
-export function secureSplitHttpClientFactory(settings, platform, telemetryTracker) {
-    var splitHttpClient = splitHttpClientFactory(settings, platform);
-    var authProvider = authProviderFactory(settings, splitHttpClient, telemetryTracker);
-    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
-        return splitHttpClient(url, __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
-    }
-    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
-        return authProvider.credential().then(function (credential) {
-            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
-                .catch(function (error) {
-                if (error.statusCode === 401) {
-                    // retry once for 401, in case the token has just expired
-                    authProvider.invalidate();
-                    return authProvider.credential().then(function (newCredential) {
-                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
-                    });
-                }
-                throw error;
-            });
-        });
-    };
-    httpClient.stop = function () { return authProvider.stop(); };
-    return httpClient;
-}

package/esm/services/serviceApi.js

@@ -1,141 +0,0 @@
-import { splitHttpClientFactory } from './splitHttpClient';
-import { objectAssign } from '../utils/lang/objectAssign';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
-import { ERROR_TOO_MANY_SETS } from '../logger/constants';
-var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
-function userKeyToQueryParam(userKey) {
-    return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
-}
-/**
- * Factory of ServiceApi objects, which group the collection of HTTP endpoints used by the SDKs
- *
- * @param settings - validated settings object
- * @param platform - object containing environment-specific dependencies
- * @param telemetryTracker - telemetry tracker
- * @param secureSplitHttpClientFactory - factory of SecureSplitHttpClient objects
- */
-export function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttpClientFactory) {
-    var urls = settings.urls;
-    var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
-    var SplitSDKImpressionsMode = settings.sync.impressionsMode;
-    var splitHttpClient = splitHttpClientFactory(settings, platform);
-    var secureSplitHttpClient = secureSplitHttpClientFactory(settings, platform, telemetryTracker);
-    return {
-        // @TODO throw errors if health check requests fail, to log them in the Synchronizer
-        getSdkAPIHealthCheck: function () {
-            var url = "".concat(urls.sdk, "/api/version");
-            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
-        },
-        getEventsAPIHealthCheck: function () {
-            var url = "".concat(urls.events, "/api/version");
-            return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
-        },
-        fetchAuth: function (userMatchingKeys) {
-            var url = "".concat(urls.auth, "/api/v2/auth?s=").concat(settings.sync.flagSpecVersion);
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
-        },
-        fetchSplitChanges: function (since, noCache, till, rbSince) {
-            var url = "".concat(urls.sdk, "/api/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
-                .catch(function (err) {
-                if (err.statusCode === 414)
-                    settings.log.error(ERROR_TOO_MANY_SETS);
-                throw err;
-            });
-        },
-        fetchSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = "".concat(urls.sdk, "/api/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
-        },
-        // @TODO support filterQueryString and handle ERROR_TOO_MANY_SETS error
-        fetchConfigs: function (since, noCache, till, rbSince) {
-            var url = "".concat(urls.configs, "/api/v1/configs?since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
-            return secureSplitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
-        },
-        fetchConfigsSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = "".concat(urls.configs, "/api/v1/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
-            return secureSplitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
-        },
-        fetchMemberships: function (userMatchingKey, noCache, till) {
-            /**
-             * URI encoding of user keys in order to:
-             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
-             *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
-             */
-            var url = "".concat(urls.sdk, "/api/memberships/").concat(encodeURIComponent(userMatchingKey)).concat(till ? '?till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
-        },
-        /**
-         * Post events.
-         *
-         * @param body -  Events bulk payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postEventsBulk: function (body, headers) {
-            var url = "".concat(urls.events, "/api/events/bulk");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
-        },
-        /**
-         * Post impressions.
-         *
-         * @param body -  Impressions bulk payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postTestImpressionsBulk: function (body, headers) {
-            var url = "".concat(urls.events, "/api/testImpressions/bulk");
-            return splitHttpClient(url, {
-                // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
-                method: 'POST',
-                body: body,
-                headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            }, telemetryTracker.trackHttp(IMPRESSIONS));
-        },
-        /**
-         * Post impressions counts.
-         *
-         * @param body -  Impressions counts payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postTestImpressionsCount: function (body, headers) {
-            var url = "".concat(urls.events, "/api/testImpressions/count");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
-        },
-        /**
-         * Post unique keys for client side.
-         *
-         * @param body -  unique keys payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postUniqueKeysBulkCs: function (body, headers) {
-            var url = "".concat(urls.telemetry, "/api/v1/keys/cs");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
-        },
-        /**
-         * Post unique keys for server side.
-         *
-         * @param body -  unique keys payload
-         * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postUniqueKeysBulkSs: function (body, headers) {
-            var url = "".concat(urls.telemetry, "/api/v1/keys/ss");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
-        },
-        postMetricsConfig: function (body, headers) {
-            var url = "".concat(urls.telemetry, "/api/v1/metrics/config");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-        },
-        postMetricsUsage: function (body, headers) {
-            var url = "".concat(urls.telemetry, "/api/v1/metrics/usage");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-        },
-        stop: function () {
-            secureSplitHttpClient.stop();
-        }
-    };
-}

package/esm/storages/AbstractDefinitionsCacheAsync.js

@@ -1,48 +0,0 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-/**
- * This class provides a skeletal implementation of the IDefinitionsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractDefinitionsCacheAsync = /** @class */ (function () {
-    function AbstractDefinitionsCacheAsync() {
-    }
-    AbstractDefinitionsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (addedFF) { return _this.add(addedFF); })),
-            Promise.all(toRemove.map(function (removedFF) { return _this.remove(removedFF); }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    // @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.
-    AbstractDefinitionsCacheAsync.prototype.usesSegments = function () {
-        return Promise.resolve(true);
-    };
-    /**
-     * Kill `name` definition and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns a promise that is resolved once the definition kill operation is performed. The fulfillment value is a boolean: `true` if the operation succeeded updating the definition or `false` if no definition is updated,
-     * for instance, if the `changeNumber` is old, or if the definition 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.
-     */
-    AbstractDefinitionsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var _this = this;
-        return this.get(name).then(function (definition) {
-            if (definition && (!definition.changeNumber || definition.changeNumber < changeNumber)) {
-                var newDefinition = objectAssign({}, definition);
-                newDefinition.killed = true;
-                newDefinition.defaultTreatment = defaultTreatment;
-                newDefinition.changeNumber = changeNumber;
-                return _this.add(newDefinition);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractDefinitionsCacheAsync;
-}());
-export { AbstractDefinitionsCacheAsync };

package/esm/storages/AbstractDefinitionsCacheSync.js

@@ -1,71 +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 IDefinitionsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractDefinitionsCacheSync = /** @class */ (function () {
-    function AbstractDefinitionsCacheSync() {
-    }
-    AbstractDefinitionsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.add(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.remove(removedFF); }).some(function (result) { return result; }) || updated;
-        this.setChangeNumber(changeNumber);
-        return updated;
-    };
-    AbstractDefinitionsCacheSync.prototype.getMany = function (names) {
-        var _this = this;
-        var definitions = {};
-        names.forEach(function (name) {
-            definitions[name] = _this.get(name);
-        });
-        return definitions;
-    };
-    AbstractDefinitionsCacheSync.prototype.getAll = function () {
-        var _this = this;
-        return this.getNames().map(function (key) { return _this.get(key); });
-    };
-    /**
-     * Kill `name` definition and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns `true` if the operation successed updating the definition, or `false` if no definition is updated,
-     * for instance, if the `changeNumber` is old, or if the definition is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     */
-    AbstractDefinitionsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var definition = this.get(name);
-        if (definition && (!definition.changeNumber || definition.changeNumber < changeNumber)) {
-            var newDefinition = objectAssign({}, definition);
-            newDefinition.killed = true;
-            newDefinition.defaultTreatment = defaultTreatment;
-            newDefinition.changeNumber = changeNumber;
-            return this.add(newDefinition);
-        }
-        return false;
-    };
-    return AbstractDefinitionsCacheSync;
-}());
-export { AbstractDefinitionsCacheSync };
-/**
- * Given a parsed definition, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `definitionsCache::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.definitions.usesSegments() || storage.rbSegments.usesSegments();
-}

package/esm/storages/inLocalStorage/DefinitionsCacheInLocal.js

@@ -1,191 +0,0 @@
-import { __extends } from "tslib";
-import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
-import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
-import { LOG_PREFIX } from './constants';
-import { setToArray } from '../../utils/lang/sets';
-var DefinitionsCacheInLocal = /** @class */ (function (_super) {
-    __extends(DefinitionsCacheInLocal, _super);
-    function DefinitionsCacheInLocal(settings, keys, storage) {
-        var _this = _super.call(this) || this;
-        _this.keys = keys;
-        _this.log = settings.log;
-        _this.setsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-        _this.storage = storage;
-        return _this;
-    }
-    DefinitionsCacheInLocal.prototype._decrementCount = function (key) {
-        var count = toNumber(this.storage.getItem(key)) - 1;
-        if (count > 0)
-            this.storage.setItem(key, count + '');
-        else
-            this.storage.removeItem(key);
-    };
-    DefinitionsCacheInLocal.prototype._decrementCounts = function (definition) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
-            this._decrementCount(ttKey);
-            if (usesSegments(definition)) {
-                var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
-                this._decrementCount(segmentsCountKey);
-            }
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
-    };
-    DefinitionsCacheInLocal.prototype._incrementCounts = function (definition) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
-            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
-            if (usesSegments(definition)) {
-                var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
-                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
-            }
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
-    };
-    /**
-     * Removes all definitions related data from localStorage (splits, counters, changeNumber and lastUpdated).
-     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
-     */
-    DefinitionsCacheInLocal.prototype.clear = function () {
-        var _this = this;
-        // collect item keys
-        var len = this.storage.length;
-        var accum = [];
-        for (var cur = 0; cur < len; cur++) {
-            var key = this.storage.key(cur);
-            if (key != null && this.keys.isDefinitionsCacheKey(key))
-                accum.push(key);
-        }
-        // remove items
-        accum.forEach(function (key) {
-            _this.storage.removeItem(key);
-        });
-        this.hasSync = false;
-    };
-    DefinitionsCacheInLocal.prototype.add = function (definition) {
-        var name = definition.name;
-        var definitionKey = this.keys.buildDefinitionKey(name);
-        var definitionFromStorage = this.storage.getItem(definitionKey);
-        var previousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : null;
-        if (previousDefinition) {
-            this._decrementCounts(previousDefinition);
-            this.removeFromSets(previousDefinition.name, previousDefinition.sets);
-        }
-        this.storage.setItem(definitionKey, JSON.stringify(definition));
-        this._incrementCounts(definition);
-        this.addToSets(definition);
-        return true;
-    };
-    DefinitionsCacheInLocal.prototype.remove = function (name) {
-        var definition = this.get(name);
-        if (!definition)
-            return false;
-        this.storage.removeItem(this.keys.buildDefinitionKey(name));
-        this._decrementCounts(definition);
-        this.removeFromSets(definition.name, definition.sets);
-        return true;
-    };
-    DefinitionsCacheInLocal.prototype.get = function (name) {
-        var item = this.storage.getItem(this.keys.buildDefinitionKey(name));
-        return item && JSON.parse(item);
-    };
-    DefinitionsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
-        try {
-            this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
-            // update "last updated" timestamp with current time
-            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-            this.hasSync = true;
-            return true;
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-            return false;
-        }
-    };
-    DefinitionsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = this.storage.getItem(this.keys.buildDefinitionsTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return isNaNNumber(value) ? n : value;
-        }
-        return n;
-    };
-    DefinitionsCacheInLocal.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.isDefinitionKey(key))
-                accum.push(this.keys.extractKey(key));
-            cur++;
-        }
-        return accum;
-    };
-    DefinitionsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
-        var ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
-        return isFiniteNumber(ttCount) && ttCount > 0;
-    };
-    DefinitionsCacheInLocal.prototype.usesSegments = function () {
-        // If cache hasn't been synchronized with the cloud, assume we need them.
-        if (!this.hasSync)
-            return true;
-        var storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
-        var definitionsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        return isFiniteNumber(definitionsWithSegmentsCount) ?
-            definitionsWithSegmentsCount > 0 :
-            true;
-    };
-    DefinitionsCacheInLocal.prototype.getNamesBySets = function (sets) {
-        var _this = this;
-        return sets.map(function (set) {
-            var setKey = _this.keys.buildSetKey(set);
-            var setFromStorage = _this.storage.getItem(setKey);
-            return new Set(setFromStorage ? JSON.parse(setFromStorage) : []);
-        });
-    };
-    DefinitionsCacheInLocal.prototype.addToSets = function (definition) {
-        var _this = this;
-        if (!definition.sets)
-            return;
-        definition.sets.forEach(function (set) {
-            if (_this.setsFilter.length > 0 && !_this.setsFilter.some(function (filterSet) { return filterSet === set; }))
-                return;
-            var setKey = _this.keys.buildSetKey(set);
-            var setFromStorage = _this.storage.getItem(setKey);
-            var setCache = new Set(setFromStorage ? JSON.parse(setFromStorage) : []);
-            if (setCache.has(definition.name))
-                return;
-            setCache.add(definition.name);
-            _this.storage.setItem(setKey, JSON.stringify(setToArray(setCache)));
-        });
-    };
-    DefinitionsCacheInLocal.prototype.removeFromSets = function (definitionName, sets) {
-        var _this = this;
-        if (!sets)
-            return;
-        sets.forEach(function (set) {
-            _this.removeNames(set, definitionName);
-        });
-    };
-    DefinitionsCacheInLocal.prototype.removeNames = function (setName, definitionName) {
-        var setKey = this.keys.buildSetKey(setName);
-        var setFromStorage = this.storage.getItem(setKey);
-        if (!setFromStorage)
-            return;
-        var setCache = new Set(JSON.parse(setFromStorage));
-        setCache.delete(definitionName);
-        if (setCache.size === 0) {
-            this.storage.removeItem(setKey);
-            return;
-        }
-        this.storage.setItem(setKey, JSON.stringify(setToArray(setCache)));
-    };
-    return DefinitionsCacheInLocal;
-}(AbstractDefinitionsCacheSync));
-export { DefinitionsCacheInLocal };

package/esm/storages/inMemory/DefinitionsCacheInMemory.js

@@ -1,118 +0,0 @@
-import { __extends } from "tslib";
-import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
-import { isFiniteNumber } from '../../utils/lang';
-/**
- * Default IDefinitionsCacheSync implementation that stores split definitions in memory.
- */
-var DefinitionsCacheInMemory = /** @class */ (function (_super) {
-    __extends(DefinitionsCacheInMemory, _super);
-    function DefinitionsCacheInMemory(splitFiltersValidation) {
-        var _this = _super.call(this) || this;
-        _this.definitionsCache = {};
-        _this.ttCache = {};
-        _this.changeNumber = -1;
-        _this.segmentsCount = 0;
-        _this.setsCache = {};
-        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
-        return _this;
-    }
-    DefinitionsCacheInMemory.prototype.clear = function () {
-        this.definitionsCache = {};
-        this.ttCache = {};
-        this.changeNumber = -1;
-        this.segmentsCount = 0;
-        this.setsCache = {};
-    };
-    DefinitionsCacheInMemory.prototype.add = function (definition) {
-        var name = definition.name;
-        var previousDefinition = this.get(name);
-        if (previousDefinition) { // We had this Split already
-            var previousTtName = previousDefinition.trafficTypeName;
-            this.ttCache[previousTtName]--;
-            if (!this.ttCache[previousTtName])
-                delete this.ttCache[previousTtName];
-            this.removeFromFlagSets(previousDefinition.name, previousDefinition.sets);
-            // Subtract from segments count for the previous version of this Split
-            if (usesSegments(previousDefinition))
-                this.segmentsCount--;
-        }
-        // Store the Split.
-        this.definitionsCache[name] = definition;
-        // Update TT cache
-        var ttName = definition.trafficTypeName;
-        this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-        this.addToFlagSets(definition);
-        // Add to segments count for the new version of the Split
-        if (usesSegments(definition))
-            this.segmentsCount++;
-        return true;
-    };
-    DefinitionsCacheInMemory.prototype.remove = function (name) {
-        var definition = this.get(name);
-        if (!definition)
-            return false;
-        // Delete the Split
-        delete this.definitionsCache[name];
-        var ttName = definition.trafficTypeName;
-        this.ttCache[ttName]--; // Update tt cache
-        if (!this.ttCache[ttName])
-            delete this.ttCache[ttName];
-        this.removeFromFlagSets(definition.name, definition.sets);
-        // Update the segments count.
-        if (usesSegments(definition))
-            this.segmentsCount--;
-        return true;
-    };
-    DefinitionsCacheInMemory.prototype.get = function (name) {
-        return this.definitionsCache[name] || null;
-    };
-    DefinitionsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
-        this.changeNumber = changeNumber;
-        return true;
-    };
-    DefinitionsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.changeNumber;
-    };
-    DefinitionsCacheInMemory.prototype.getNames = function () {
-        return Object.keys(this.definitionsCache);
-    };
-    DefinitionsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
-        return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
-    };
-    DefinitionsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
-    };
-    DefinitionsCacheInMemory.prototype.getNamesBySets = function (sets) {
-        var _this = this;
-        return sets.map(function (set) { return _this.setsCache[set] || new Set(); });
-    };
-    DefinitionsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.setsFilter.length > 0 && !_this.setsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            if (!_this.setsCache[featureFlagSet])
-                _this.setsCache[featureFlagSet] = new Set([]);
-            _this.setsCache[featureFlagSet].add(featureFlag.name);
-        });
-    };
-    DefinitionsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, sets) {
-        var _this = this;
-        if (!sets)
-            return;
-        sets.forEach(function (set) {
-            _this.removeNames(set, featureFlagName);
-        });
-    };
-    DefinitionsCacheInMemory.prototype.removeNames = function (setName, featureFlagName) {
-        if (!this.setsCache[setName])
-            return;
-        this.setsCache[setName].delete(featureFlagName);
-        if (this.setsCache[setName].size === 0)
-            delete this.setsCache[setName];
-    };
-    return DefinitionsCacheInMemory;
-}(AbstractDefinitionsCacheSync));
-export { DefinitionsCacheInMemory };