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

package/cjs/storages/pluggable/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluggableStorage = void 0;
 var tslib_1 = require("tslib");
 var KeyBuilderSS_1 = require("../KeyBuilderSS");
-var SplitsCachePluggable_1 = require("./SplitsCachePluggable");
+var DefinitionsCachePluggable_1 = require("./DefinitionsCachePluggable");
 var SegmentsCachePluggable_1 = require("./SegmentsCachePluggable");
 var ImpressionsCachePluggable_1 = require("./ImpressionsCachePluggable");
 var EventsCachePluggable_1 = require("./EventsCachePluggable");
@@ -106,7 +106,7 @@ function PluggableStorage(options) {
             return e; // Propagate error for shared clients
         });
         return {
-            splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCachePluggable_1.DefinitionsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCachePluggable_1.RBSegmentsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),

package/cjs/storages/setRolloutPlan.js

@@ -24,16 +24,16 @@ exports.validateRolloutPlan = validateRolloutPlan;
  * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
  */
 function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
     var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
     log.debug("storage: set feature flags and segments".concat(matchingKey ? " for key ".concat(matchingKey) : ''));
-    if (splits && ff) {
-        splits.clear();
-        splits.update(ff.d, [], ff.t);
+    if (definitions && ff) {
+        definitions.clear();
+        definitions.update(ff.d || [], [], ff.t);
     }
     if (rbSegments && rbs) {
         rbSegments.clear();
-        rbSegments.update(rbs.d, [], rbs.t);
+        rbSegments.update(rbs.d || [], [], rbs.t);
     }
     var segmentChanges = rolloutPlan.segmentChanges;
     if (matchingKey) { // add memberships data (client-side)

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -10,7 +10,7 @@ var constants_3 = require("../../../logger/constants");
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
 function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
-    var log = settings.log, splitsCache = storage.splits;
+    var log = settings.log, definitions = storage.definitions;
     var startingUp = true;
     return function objectUpdater() {
         var splits = [];
@@ -39,16 +39,16 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 });
             });
             return Promise.all([
-                splitsCache.clear(),
-                splitsCache.update(splits, [], Date.now())
+                definitions.clear(),
+                definitions.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED, { type: constants_2.FLAGS_UPDATE, names: [] });
+                readiness.definitions.emit(constants_2.SDK_DEFINITIONS_ARRIVED, { type: constants_2.FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
                     Promise.resolve(storage.validateCache ? storage.validateCache() : { initialCacheLoad: true /* Fallback: assume initial load when validateCache doesn't exist */ }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: constants_2.SEGMENTS_UPDATE, names: [] });

package/cjs/sync/polling/fetchers/splitChangesFetcher.js

@@ -61,7 +61,7 @@ function splitChangesFetcherFactory(params) {
                 lastProxyCheckTimestamp = undefined;
                 return splitChangesFetcher(-1, undefined, undefined, -1)
                     .then(function (splitChangesResponse) {
-                    return Promise.all([storage.splits.clear(), storage.rbSegments.clear()])
+                    return Promise.all([storage.definitions.clear(), storage.rbSegments.clear()])
                         .then(function () { return splitChangesResponse; });
                 });
             }

package/cjs/sync/polling/pollingManagerCS.js

@@ -7,7 +7,7 @@ var definitionsSyncTask_1 = require("./syncTasks/definitionsSyncTask");
 var key_1 = require("../../utils/key");
 var constants_1 = require("../../readiness/constants");
 var constants_2 = require("../../logger/constants");
-var AbstractSplitsCacheSync_1 = require("../../storages/AbstractSplitsCacheSync");
+var AbstractDefinitionsCacheSync_1 = require("../../storages/AbstractDefinitionsCacheSync");
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -32,10 +32,10 @@ function pollingManagerCSFactory(params, definitionChangesFetcher) {
         });
     }
     // smart pausing
-    readiness.splits.on(constants_1.SDK_SPLITS_ARRIVED, function () {
+    readiness.definitions.on(constants_1.SDK_DEFINITIONS_ARRIVED, function () {
         if (!definitionsSyncTask.isRunning())
             return; // noop if not doing polling
-        var usingSegments = (0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage);
+        var usingSegments = (0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage);
         if (usingSegments !== mySegmentsSyncTask.isRunning()) {
             log.info(constants_2.POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
             if (usingSegments) {
@@ -50,13 +50,13 @@ function pollingManagerCSFactory(params, definitionChangesFetcher) {
         var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady(metadata) {
-            if (!readiness.isReady() && !(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
+            if (!readiness.isReady() && !(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
                 readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
         }
-        if (!(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
+        if (!(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
             setTimeout(smartReady, 0);
         else
-            readiness.splits.once(constants_1.SDK_SPLITS_ARRIVED, smartReady);
+            readiness.definitions.once(constants_1.SDK_DEFINITIONS_ARRIVED, smartReady);
         mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
         return mySegmentsSyncTask;
     }
@@ -67,7 +67,7 @@ function pollingManagerCSFactory(params, definitionChangesFetcher) {
         start: function () {
             log.info(constants_2.POLLING_START);
             definitionsSyncTask.start();
-            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
+            if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
                 startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)

package/cjs/sync/polling/pollingManagerSS.js

@@ -7,11 +7,11 @@ var constants_1 = require("../../logger/constants");
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-function pollingManagerSSFactory(params, definitionChangesFetcher) {
-    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
+    var storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings);
-    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(splitApi.fetchSegmentChanges, storage, readiness, settings);
+    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
     return {
         definitionsSyncTask: definitionsSyncTask,
         segmentsSyncTask: segmentsSyncTask,

package/cjs/sync/polling/syncTasks/definitionsSyncTask.js

@@ -7,6 +7,6 @@ var definitionChangesUpdater_1 = require("../updaters/definitionChangesUpdater")
  * Creates a sync task that periodically executes a `definitionChangesUpdater` task
  */
 function definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, isClientSide) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, definitionChangesUpdater_1.definitionChangesUpdaterFactory)(settings.log, definitionChangesFetcher, storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'definitionChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, definitionChangesUpdater_1.definitionChangesUpdaterFactory)(settings.log, definitionChangesFetcher, storage, settings.sync.__splitFiltersValidation, readiness.definitions, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'definitionChangesUpdater');
 }
 exports.definitionsSyncTaskFactory = definitionsSyncTaskFactory;

package/cjs/sync/polling/syncTasks/segmentsSyncTask.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentsSyncTaskFactory = void 0;
 var syncTask_1 = require("../../syncTask");
-var segmentChangesFetcher_1 = require("../fetchers/segmentChangesFetcher");
 var segmentChangesUpdater_1 = require("../updaters/segmentChangesUpdater");
 /**
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
-function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+function segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, segmentChangesFetcher, storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }
 exports.segmentsSyncTaskFactory = segmentsSyncTaskFactory;

package/cjs/sync/polling/updaters/definitionChangesUpdater.js

@@ -106,10 +106,10 @@ function convertInstantUpdateToDefinitionChanges(instantUpdate) {
  * @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` or `/configs` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, definitionsEventEmitter, 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 definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments;
     var startingUp = true;
     /** timeout decorator for `definitionChangesFetcher` promise  */
     function _promiseDecorator(promise) {
@@ -151,7 +151,7 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
                     var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
                     updatedDefinitions = names;
                     log.debug(constants_2.SYNC_UPDATE, [definitionChangesFetcher.type, added.length, removed.length]);
-                    ffUpdate = splits.update(added, removed, definitionChanges.d.till);
+                    ffUpdate = definitions.update(added, removed, definitionChanges.d.till);
                 }
                 var rbsUpdate = false;
                 if (definitionChanges.rbs) {
@@ -167,9 +167,9 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
                     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))))
+                    if (definitionsEventEmitter) {
+                        // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
+                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((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
@@ -178,7 +178,7 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
                                     type: updatedDefinitions.length > 0 ? definitionChangesFetcher.type === 'configs' ? constants_1.CONFIGS_UPDATE : constants_1.FLAGS_UPDATE : constants_1.SEGMENTS_UPDATE,
                                     names: updatedDefinitions.length > 0 ? updatedDefinitions : []
                                 };
-                                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, metadata);
+                                definitionsEventEmitter.emit(constants_1.SDK_DEFINITIONS_ARRIVED, metadata);
                             }
                             return true;
                         });
@@ -200,7 +200,7 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
             });
         }
         // `getChangeNumber` never rejects or throws error
-        return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
+        return Promise.all([definitions.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
     };
 }
 exports.definitionChangesUpdaterFactory = definitionChangesUpdaterFactory;

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -5,7 +5,7 @@ var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var constants_3 = require("../../streaming/constants");
-var AbstractSplitsCacheSync_1 = require("../../../storages/AbstractSplitsCacheSync");
+var AbstractDefinitionsCacheSync_1 = require("../../../storages/AbstractDefinitionsCacheSync");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -37,7 +37,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
         if (storage.save)
             storage.save();
         // Notify update if required
-        if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED, { type: constants_1.SEGMENTS_UPDATE, names: [] });
         }

package/cjs/sync/streaming/SSEHandler/NotificationKeeper.js

@@ -73,7 +73,7 @@ function notificationKeeperFactory(pushEmitter, telemetryTracker) {
                         c.cTime = timestamp;
                         if (controlType === constants_2.ControlType.STREAMING_DISABLED) {
                             telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.DISABLED);
-                            pushEmitter.emit(constants_2.PUSH_NONRETRYABLE_ERROR);
+                            pushEmitter.emit(constants_2.PUSH_NON_RETRYABLE_ERROR);
                         }
                         else if (hasPublishers) {
                             if (controlType === constants_2.ControlType.STREAMING_PAUSED && hasResumed) {

package/cjs/sync/streaming/SSEHandler/index.js

@@ -51,7 +51,7 @@ function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
                 pushEmitter.emit(constants_1.PUSH_RETRYABLE_ERROR);
             }
             else {
-                pushEmitter.emit(constants_1.PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(constants_1.PUSH_NON_RETRYABLE_ERROR);
             }
         },
         /* NotificationProcessor */

package/cjs/sync/streaming/UpdateWorkers/{SplitsUpdateWorker.js → DefinitionsUpdateWorker.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SplitsUpdateWorker = void 0;
+exports.DefinitionsUpdateWorker = void 0;
 var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../readiness/constants");
 var Backoff_1 = require("../../../utils/Backoff");
@@ -9,19 +9,19 @@ var constants_4 = require("../constants");
 var parseUtils_1 = require("../parseUtils");
 var constants_5 = require("./constants");
 /**
- * SplitsUpdateWorker factory
+ * DefinitionsUpdateWorker factory
  */
-function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
-    var ff = SplitsUpdateWorker(storage.splits);
-    var rbs = SplitsUpdateWorker(storage.rbSegments);
-    function SplitsUpdateWorker(cache) {
+function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker, segmentsSyncTask) {
+    var ff = DefinitionsUpdateWorker(storage.definitions);
+    var rbs = DefinitionsUpdateWorker(storage.rbSegments);
+    function DefinitionsUpdateWorker(cache) {
         var maxChangeNumber = -1;
         var handleNewEvent = false;
         var isHandlingEvent;
         var cdnBypass;
         var instantUpdate;
-        var backoff = new Backoff_1.Backoff(__handleSplitUpdateCall, constants_5.FETCH_BACKOFF_BASE, constants_5.FETCH_BACKOFF_MAX_WAIT);
-        function __handleSplitUpdateCall() {
+        var backoff = new Backoff_1.Backoff(__handleDefinitionUpdateCall, constants_5.FETCH_BACKOFF_BASE, constants_5.FETCH_BACKOFF_MAX_WAIT);
+        function __handleDefinitionUpdateCall() {
             isHandlingEvent = true;
             if (maxChangeNumber > cache.getChangeNumber()) {
                 handleNewEvent = false;
@@ -30,7 +30,7 @@ function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitte
                     if (!isHandlingEvent)
                         return; // halt if `stop` has been called
                     if (handleNewEvent) {
-                        __handleSplitUpdateCall();
+                        __handleDefinitionUpdateCall();
                     }
                     else {
                         if (instantUpdate)
@@ -55,7 +55,7 @@ function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitte
                         else {
                             backoff.reset();
                             cdnBypass = true;
-                            __handleSplitUpdateCall();
+                            __handleDefinitionUpdateCall();
                         }
                     }
                 });
@@ -83,7 +83,7 @@ function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitte
                     instantUpdate = { payload: payload, changeNumber: changeNumber, type: type };
                 }
                 if (backoff.timeoutID || !isHandlingEvent)
-                    __handleSplitUpdateCall();
+                    __handleDefinitionUpdateCall();
                 backoff.reset();
             },
             stop: function () {
@@ -118,11 +118,11 @@ function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitte
          * @param splitName - name of split to kill
          * @param defaultTreatment - default treatment value
          */
-        killSplit: function (_a) {
+        killDefinition: function (_a) {
             var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-            if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
+            if (storage.definitions.killLocally(splitName, defaultTreatment, changeNumber)) {
                 // trigger an SDK_UPDATE if Split was killed locally
-                splitsEventEmitter.emit(constants_2.SDK_SPLITS_ARRIVED, true);
+                definitionsEventEmitter.emit(constants_2.SDK_DEFINITIONS_ARRIVED, true);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
             ff.put({ changeNumber: changeNumber });
@@ -133,4 +133,4 @@ function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitte
         }
     };
 }
-exports.SplitsUpdateWorker = SplitsUpdateWorker;
+exports.DefinitionsUpdateWorker = DefinitionsUpdateWorker;

package/cjs/sync/streaming/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.RB_SEGMENT_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MEMBERSHIPS_LS_UPDATE = exports.MEMBERSHIPS_MS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
+exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.RB_SEGMENT_UPDATE = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MEMBERSHIPS_LS_UPDATE = exports.MEMBERSHIPS_MS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NON_RETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
 // time for refresh token
 exports.SECONDS_BEFORE_EXPIRATION = 600;
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -8,7 +8,7 @@ exports.SECONDS_BEFORE_EXPIRATION = 600;
  * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
  * triggers `handleNonRetryableError` call
  */
-exports.PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+exports.PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR';
 /**
  * emitted on SSE and Authenticate recoverable errors
  * triggers `handleRetryableError` call
@@ -20,7 +20,7 @@ exports.PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
  */
 exports.PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 /**
- * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NON_RETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
  * triggers `startPolling` and `stopWorkers` calls
  */
 exports.PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';

package/cjs/sync/streaming/pushManager.js

@@ -6,7 +6,7 @@ var Backoff_1 = require("../../utils/Backoff");
 var SSEHandler_1 = require("./SSEHandler");
 var MySegmentsUpdateWorker_1 = require("./UpdateWorkers/MySegmentsUpdateWorker");
 var SegmentsUpdateWorker_1 = require("./UpdateWorkers/SegmentsUpdateWorker");
-var SplitsUpdateWorker_1 = require("./UpdateWorkers/SplitsUpdateWorker");
+var DefinitionsUpdateWorker_1 = require("./UpdateWorkers/DefinitionsUpdateWorker");
 var AuthClient_1 = require("./AuthClient");
 var lang_1 = require("../../utils/lang");
 var SSEClient_1 = require("./SSEClient");
@@ -45,8 +45,8 @@ function pushManagerFactory(params, pollingManager) {
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : (0, SegmentsUpdateWorker_1.SegmentsUpdateWorker)(log, pollingManager.segmentsSyncTask, storage.segments);
-    // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = (0, SplitsUpdateWorker_1.SplitsUpdateWorker)(log, storage, pollingManager.definitionsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
+    // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
+    var definitionsUpdateWorker = (0, DefinitionsUpdateWorker_1.DefinitionsUpdateWorker)(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -54,10 +54,10 @@ function pushManagerFactory(params, pollingManager) {
     var clients = {};
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
-    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
+    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NON_RETRYABLE_ERROR error.
     // It is used to halt the `connectPush` process if it was in progress.
     var disconnected;
-    // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+    // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
     // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
     var disabled; // `disabled` implies `disconnected === true`
     /** PushManager functions related to initialization */
@@ -96,11 +96,11 @@ function pushManagerFactory(params, pollingManager) {
         authenticate(userKeys).then(function (authData) {
             if (disconnected)
                 return;
-            // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+            // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
             // close the sseClient in case the org has been bloqued while the instance was connected to streaming
             if (!authData.pushEnabled) {
                 log.info(constants_2.STREAMING_DISABLED);
-                pushEmitter.emit(constants_1.PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(constants_1.PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
@@ -115,7 +115,7 @@ function pushManagerFactory(params, pollingManager) {
             // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
             if (error.statusCode >= 400 && error.statusCode < 500) {
                 telemetryTracker.streamingEvent(constants_3.AUTH_REJECTION);
-                pushEmitter.emit(constants_1.PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(constants_1.PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // Handle other HTTP and network errors as recoverable errors
@@ -139,7 +139,7 @@ function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.stop();
+        definitionsUpdateWorker.stop();
         if (userKey)
             (0, lang_1.forOwn)(clients, function (_a) {
                 var worker = _a.worker;
@@ -155,7 +155,7 @@ function pushManagerFactory(params, pollingManager) {
         connectPushRetryBackoff.reset();
     });
     /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
-    pushEmitter.on(constants_1.PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    pushEmitter.on(constants_1.PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
         disabled = true;
         // Note: `stopWorkers` is been called twice, but it is not harmful
         disconnectPush();
@@ -181,9 +181,9 @@ function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
-    pushEmitter.on(constants_1.SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(constants_1.SPLIT_UPDATE, splitsUpdateWorker.put);
-    pushEmitter.on(constants_1.RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(constants_1.SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+    pushEmitter.on(constants_1.SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(constants_1.RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case types_1.UpdateStrategy.BoundedFetchRequest: {

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -107,13 +107,12 @@ function telemetrySubmitterFactory(params) {
     var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness;
     var stopTimer = (0, timer_1.timer)(now);
     var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
-    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(constants_2.SDK_READY, function () {
         telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started

package/cjs/sync/syncManagerOnline.js

@@ -7,8 +7,9 @@ var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
 var constants_4 = require("../readiness/constants");
-var AbstractSplitsCacheSync_1 = require("../storages/AbstractSplitsCacheSync");
+var AbstractDefinitionsCacheSync_1 = require("../storages/AbstractDefinitionsCacheSync");
 var splitChangesFetcher_1 = require("./polling/fetchers/splitChangesFetcher");
+var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -18,21 +19,22 @@ var splitChangesFetcher_1 = require("./polling/fetchers/splitChangesFetcher");
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
  * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionChangesFetcherFactory) {
-    if (definitionChangesFetcherFactory === void 0) { definitionChangesFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
+function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.splitApi.fetchSegmentChanges); }; }
     /**
      * SyncManager factory for modular SDK
      */
     return function (params) {
         var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, telemetryTracker = params.telemetryTracker, storage = params.storage, readiness = params.readiness;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionChangesFetcherFactory(params));
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
-        // It is not inyected as push and polling managers, because at the moment it is required
+        // It is not injected as push and polling managers, because at the moment it is required
         var submitterManager = (0, submitterManager_1.submitterManagerFactory)(params);
         /** Sync Manager logic */
         function startPolling() {
@@ -80,7 +82,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, def
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(constants_4.SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                     }
                     // start syncing splits and segments
@@ -139,7 +141,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, def
                         if (pushManager) {
                             if (pollingManager.isRunning()) {
                                 // if doing polling, we must start the periodic fetch of data
-                                if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
+                                if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -149,7 +151,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, def
                             }
                         }
                         else {
-                            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
+                            if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
                                 mySegmentsSyncTask.start();
                         }
                     }

package/cjs/utils/Backoff.js

@@ -27,6 +27,26 @@ var Backoff = /** @class */ (function () {
         this.attempts++;
         return delayInMillis;
     };
+    /**
+     * Schedule a delayed call to `cb`
+     * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
+     */
+    Backoff.prototype.scheduleCallAsync = function () {
+        var _this = this;
+        var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+        if (this.timeoutID)
+            clearTimeout(this.timeoutID);
+        this.attempts++;
+        return new Promise(function (resolve, reject) {
+            _this.timeoutID = setTimeout(function () {
+                _this.timeoutID = undefined;
+                _this.cb().then(resolve, reject);
+            }, delayInMillis);
+        });
+    };
+    /**
+     * Reset the backoff attempts
+     */
     Backoff.prototype.reset = function () {
         this.attempts = 0;
         if (this.timeoutID) {

package/cjs/utils/lang/sets.js

@@ -15,9 +15,9 @@ function returnSetsUnion(set, set2) {
     return new Set(setToArray(set).concat(setToArray(set2)));
 }
 exports.returnSetsUnion = returnSetsUnion;
-function returnDifference(list, list2) {
-    if (list === void 0) { list = []; }
-    if (list2 === void 0) { list2 = []; }
-    return list.filter(function (item) { return list2.indexOf(item) === -1; });
+function returnDifference(list1, list2) {
+    list1 = list1 || [];
+    list2 = list2 || [];
+    return list1.filter(function (item) { return list2.indexOf(item) === -1; });
 }
 exports.returnDifference = returnDifference;

package/cjs/utils/settingsValidation/index.js

@@ -55,6 +55,8 @@ exports.base = {
         streaming: 'https://streaming.split.io',
         // Telemetry Server
         telemetry: 'https://telemetry.split.io/api',
+        // Configs Server
+        configs: 'https://configs.split.io/api',
     },
     // Defines which kind of storage we should instantiate.
     storage: undefined,

package/cjs/utils/settingsValidation/url.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.url = void 0;
-var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
+var telemetryEndpointMatcher = /^\/v1\/(metrics|keys)\/(config|usage|ss|cs)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/v2\/auth/;
+var authEndpointMatcher = /^\/(v2|v3)\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
+var configsEndpointMatcher = /^\/v1\/(configs|segmentChanges)/;
 /**
  * Get URL based on a given target (path).
  * ATM, it is only used for testing purposes.
@@ -26,6 +27,9 @@ function url(settings, target) {
     if (streamingEndpointMatcher.test(target)) {
         return "".concat(settings.urls.streaming).concat(target);
     }
+    if (configsEndpointMatcher.test(target)) {
+        return "".concat(settings.urls.configs).concat(target);
+    }
     return "".concat(settings.urls.sdk).concat(target);
 }
 exports.url = url;