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

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -1,194 +0,0 @@
-import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
-import { startsWith } from '../../../utils/lang';
-import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
-import { setToArray } from '../../../utils/lang/sets';
-import { SPLIT_UPDATE } from '../../streaming/constants';
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments) {
-    var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-    return registeredSegments.then(function (segmentNames) {
-        return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
-    });
-}
-/**
- * Collect segments from a raw FF or RBS definition.
- * Exported for testing purposes.
- */
-export function parseSegments(ruleEntity, matcherType) {
-    if (matcherType === void 0) { matcherType = IN_SEGMENT; }
-    var _a = ruleEntity, conditions = _a.conditions, excluded = _a.excluded;
-    var segments = new Set();
-    if (excluded && excluded.segments) {
-        excluded.segments.forEach(function (_a) {
-            var type = _a.type, name = _a.name;
-            if ((type === STANDARD_SEGMENT && matcherType === IN_SEGMENT) || (type === RULE_BASED_SEGMENT && matcherType === IN_RULE_BASED_SEGMENT)) {
-                segments.add(name);
-            }
-        });
-    }
-    if (conditions) {
-        for (var i = 0; i < conditions.length; i++) {
-            var matchers = conditions[i].matcherGroup.matchers;
-            matchers.forEach(function (matcher) {
-                if (matcher.matcherType === matcherType)
-                    segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-            });
-        }
-    }
-    return segments;
-}
-/**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
- *
- * @param featureFlag - feature flag to be evaluated
- * @param filters - splitFiltersValidation bySet | byName
- */
-function matchFilters(featureFlag, filters) {
-    var _a = filters.groupedFilters, setsFilter = _a.bySet, namesFilter = _a.byName, prefixFilter = _a.byPrefix;
-    if (setsFilter.length > 0)
-        return featureFlag.sets && featureFlag.sets.some(function (featureFlagSet) { return setsFilter.indexOf(featureFlagSet) > -1; });
-    var namesFilterConfigured = namesFilter.length > 0;
-    var prefixFilterConfigured = prefixFilter.length > 0;
-    if (!namesFilterConfigured && !prefixFilterConfigured)
-        return true;
-    var matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-    var matchPrefix = prefixFilterConfigured && prefixFilter.some(function (prefix) { return startsWith(featureFlag.name, prefix); });
-    return matchNames || matchPrefix;
-}
-/**
- * Given the list of splits from /splitChanges endpoint, it returns the mutations,
- * i.e., an object with added splits, removed splits and used segments.
- * Exported for testing purposes.
- */
-export function computeMutation(rules, segments, filters) {
-    return rules.reduce(function (accum, ruleEntity) {
-        if (ruleEntity.status !== 'ARCHIVED' && (!filters || matchFilters(ruleEntity, filters))) {
-            accum.added.push(ruleEntity);
-            parseSegments(ruleEntity).forEach(function (segmentName) {
-                segments.add(segmentName);
-            });
-        }
-        else {
-            accum.removed.push(ruleEntity);
-        }
-        accum.names.push(ruleEntity.name);
-        return accum;
-    }, { added: [], removed: [], names: [] });
-}
-/**
- * factory of SplitChanges updater, a task that:
- *  - fetches split changes using `splitChangesFetcher`
- *  - updates `splitsCache`
- *  - uses `splitsEventEmitter` to emit events related to split data updates
- *
- * @param log -  Logger instance
- * @param splitChangesFetcher -  Fetcher of `/splitChanges`
- * @param splits -  Splits storage, with sync or async methods
- * @param segments -  Segments storage, with sync or async methods
- * @param splitsEventEmitter -  Optional readiness manager. Not required for synchronizer or producer mode.
- * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
- * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
- */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
-    if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
-    if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments;
-    var startingUp = true;
-    /** timeout decorator for `splitChangesFetcher` promise  */
-    function _promiseDecorator(promise) {
-        if (startingUp && requestTimeoutBeforeReady)
-            promise = timeout(requestTimeoutBeforeReady, promise);
-        return promise;
-    }
-    /**
-     * 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.
-     *
-     * @param noCache - true to revalidate data to fetch
-     * @param till - query param to bypass CDN requests
-     */
-    return function splitChangesUpdater(noCache, till, instantUpdate) {
-        /**
-         * @param since - current changeNumber at splitsCache
-         * @param retry - current number of retry attempts
-         */
-        function _splitChangesUpdater(sinces, retry) {
-            if (retry === void 0) { retry = 0; }
-            var since = sinces[0], rbSince = sinces[1];
-            log.debug(SYNC_SPLITS_FETCH, sinces);
-            return Promise.resolve(instantUpdate ?
-                instantUpdate.type === SPLIT_UPDATE ?
-                    // IFFU edge case: a change to a flag that adds an IN_RULE_BASED_SEGMENT matcher that is not present yet
-                    Promise.resolve(rbSegments.contains(parseSegments(instantUpdate.payload, IN_RULE_BASED_SEGMENT))).then(function (contains) {
-                        return contains ?
-                            { ff: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
-                            splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator);
-                    }) :
-                    { rbs: { d: [instantUpdate.payload], t: instantUpdate.changeNumber } } :
-                splitChangesFetcher(since, noCache, till, rbSince, _promiseDecorator))
-                .then(function (splitChanges) {
-                var usedSegments = new Set();
-                var updatedFlags = [];
-                var ffUpdate = false;
-                if (splitChanges.ff) {
-                    var _a = computeMutation(splitChanges.ff.d || [], usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
-                    updatedFlags = names;
-                    log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
-                    ffUpdate = splits.update(added, removed, splitChanges.ff.t);
-                }
-                var rbsUpdate = false;
-                if (splitChanges.rbs) {
-                    var _b = computeMutation(splitChanges.rbs.d || [], usedSegments), added = _b.added, removed = _b.removed;
-                    log.debug(SYNC_RBS_UPDATE, [added.length, removed.length]);
-                    rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
-                }
-                return Promise.all([ffUpdate, rbsUpdate,
-                    // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
-                    segments.registerSegments(setToArray(usedSegments))
-                ]).then(function (_a) {
-                    var ffChanged = _a[0], rbsChanged = _a[1];
-                    if (storage.save)
-                        storage.save();
-                    startingUp = false;
-                    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 || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
-                            .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
-                            .then(function (emitSplitsArrivedEvent) {
-                            // emit SDK events
-                            if (emitSplitsArrivedEvent) {
-                                var metadata = {
-                                    type: updatedFlags.length > 0 ? FLAGS_UPDATE : SEGMENTS_UPDATE,
-                                    names: updatedFlags.length > 0 ? updatedFlags : []
-                                };
-                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
-                            }
-                            return true;
-                        });
-                    }
-                    return true;
-                });
-            })
-                .catch(function (error) {
-                if (startingUp && retriesOnFailureBeforeReady > retry) {
-                    retry += 1;
-                    log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
-                    return _splitChangesUpdater(sinces, retry);
-                }
-                else {
-                    startingUp = false;
-                    log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
-                }
-                return false;
-            });
-        }
-        // `getChangeNumber` never rejects or throws error
-        return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_splitChangesUpdater);
-    };
-}

package/esm/utils/inputValidation/splitExistence.js

@@ -1,15 +0,0 @@
-import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
-import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
-/**
- * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
- */
-export function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
-    if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
-        if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
-            log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
-            return false;
-        }
-    }
-    return true;
-}

package/esm/utils/inputValidation/splits.js

@@ -1,21 +0,0 @@
-import { ERROR_EMPTY_ARRAY } from '../../logger/constants';
-import { uniq } from '../lang';
-import { validateSplit } from './split';
-export function validateSplits(log, maybeSplits, method, listName, item) {
-    if (listName === void 0) { listName = 'feature flag names'; }
-    if (item === void 0) { item = 'feature flag name'; }
-    if (Array.isArray(maybeSplits) && maybeSplits.length > 0) {
-        var validatedArray_1 = [];
-        // Remove invalid values
-        maybeSplits.forEach(function (maybeSplit) {
-            var splitName = validateSplit(log, maybeSplit, method, item);
-            if (splitName)
-                validatedArray_1.push(splitName);
-        });
-        // Strip off duplicated values if we have valid split names then return
-        if (validatedArray_1.length)
-            return uniq(validatedArray_1);
-    }
-    log.error(ERROR_EMPTY_ARRAY, [method, listName]);
-    return false;
-}