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

package/esm/sync/polling/pollingManagerCS.js

@@ -2,9 +2,9 @@ import { forOwn } from '../../utils/lang';
 import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { getMatching } from '../../utils/key';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
-import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -29,7 +29,7 @@ export function pollingManagerCSFactory(params, definitionChangesFetcher) {
         });
     }
     // smart pausing
-    readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
+    readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, function () {
         if (!definitionsSyncTask.isRunning())
             return; // noop if not doing polling
         var usingSegments = usesSegmentsSync(storage);
@@ -53,7 +53,7 @@ export function pollingManagerCSFactory(params, definitionChangesFetcher) {
         if (!usesSegmentsSync(storage))
             setTimeout(smartReady, 0);
         else
-            readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
+            readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
         mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
         return mySegmentsSyncTask;
     }

package/esm/sync/polling/pollingManagerSS.js

@@ -4,11 +4,11 @@ import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logg
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export function pollingManagerSSFactory(params, definitionChangesFetcher) {
-    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+export function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
+    var storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
-    var segmentsSyncTask = segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);
+    var segmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
     return {
         definitionsSyncTask: definitionsSyncTask,
         segmentsSyncTask: segmentsSyncTask,

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

@@ -4,5 +4,5 @@ import { definitionChangesUpdaterFactory } from '../updaters/definitionChangesUp
  * Creates a sync task that periodically executes a `definitionChangesUpdater` task
  */
 export function definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, definitionChangesUpdaterFactory(settings.log, definitionChangesFetcher, storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'definitionChangesUpdater');
+    return syncTaskFactory(settings.log, definitionChangesUpdaterFactory(settings.log, definitionChangesFetcher, storage, settings.sync.__splitFiltersValidation, readiness.definitions, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'definitionChangesUpdater');
 }

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

@@ -1,9 +1,8 @@
 import { syncTaskFactory } from '../../syncTask';
-import { segmentChangesFetcherFactory } from '../fetchers/segmentChangesFetcher';
 import { segmentChangesUpdaterFactory } from '../updaters/segmentChangesUpdater';
 /**
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
-export function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+export function segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings) {
+    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcher, storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }

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

@@ -1,5 +1,5 @@
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE, CONFIGS_UPDATE } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE, CONFIGS_UPDATE } from '../../../readiness/constants';
 import { SYNC_FETCH, SYNC_UPDATE, SYNC_FETCH_FAILS, SYNC_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';
@@ -101,10 +101,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.
  */
-export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+export 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) {
@@ -146,7 +146,7 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                     var _a = computeMutation(definitionChanges.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
                     updatedDefinitions = names;
                     log.debug(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) {
@@ -162,9 +162,9 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                     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
@@ -173,7 +173,7 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                                     type: updatedDefinitions.length > 0 ? definitionChangesFetcher.type === 'configs' ? CONFIGS_UPDATE : FLAGS_UPDATE : SEGMENTS_UPDATE,
                                     names: updatedDefinitions.length > 0 ? updatedDefinitions : []
                                 };
-                                splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
+                                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, metadata);
                             }
                             return true;
                         });
@@ -195,6 +195,6 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
             });
         }
         // `getChangeNumber` never rejects or throws error
-        return Promise.all([splits.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
+        return Promise.all([definitions.getChangeNumber(), rbSegments.getChangeNumber()]).then(_definitionChangesUpdater);
     };
 }

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

@@ -2,7 +2,7 @@ import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_FETCH_RETRY } from '../../../logger/constants';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
-import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
+import { usesSegmentsSync } from '../../../storages/AbstractDefinitionsCacheSync';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`

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

@@ -1,5 +1,5 @@
 import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
-import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
+import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
 var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
 var STREAMING_EVENT_TYPES = [OCCUPANCY_PRI, OCCUPANCY_SEC];
 /**
@@ -70,7 +70,7 @@ export function notificationKeeperFactory(pushEmitter, telemetryTracker) {
                         c.cTime = timestamp;
                         if (controlType === ControlType.STREAMING_DISABLED) {
                             telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);
-                            pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                            pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                         }
                         else if (hasPublishers) {
                             if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NON_RETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, RB_SEGMENT_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 /**
@@ -48,7 +48,7 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
                 pushEmitter.emit(PUSH_RETRYABLE_ERROR);
             }
             else {
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
             }
         },
         /* NotificationProcessor */

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

@@ -1,24 +1,24 @@
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_DEFINITIONS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
 import { RB_SEGMENT_UPDATE } from '../constants';
 import { parseFFUpdatePayload } from '../parseUtils';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 /**
- * SplitsUpdateWorker factory
+ * DefinitionsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
-    var ff = SplitsUpdateWorker(storage.splits);
-    var rbs = SplitsUpdateWorker(storage.rbSegments);
-    function SplitsUpdateWorker(cache) {
+export 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(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-        function __handleSplitUpdateCall() {
+        var backoff = new Backoff(__handleDefinitionUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+        function __handleDefinitionUpdateCall() {
             isHandlingEvent = true;
             if (maxChangeNumber > cache.getChangeNumber()) {
                 handleNewEvent = false;
@@ -27,7 +27,7 @@ export function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEven
                     if (!isHandlingEvent)
                         return; // halt if `stop` has been called
                     if (handleNewEvent) {
-                        __handleSplitUpdateCall();
+                        __handleDefinitionUpdateCall();
                     }
                     else {
                         if (instantUpdate)
@@ -52,7 +52,7 @@ export function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEven
                         else {
                             backoff.reset();
                             cdnBypass = true;
-                            __handleSplitUpdateCall();
+                            __handleDefinitionUpdateCall();
                         }
                     }
                 });
@@ -80,7 +80,7 @@ export function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEven
                     instantUpdate = { payload: payload, changeNumber: changeNumber, type: type };
                 }
                 if (backoff.timeoutID || !isHandlingEvent)
-                    __handleSplitUpdateCall();
+                    __handleDefinitionUpdateCall();
                 backoff.reset();
             },
             stop: function () {
@@ -115,11 +115,11 @@ export function SplitsUpdateWorker(log, storage, definitionsSyncTask, splitsEven
          * @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(SDK_SPLITS_ARRIVED, true);
+                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, true);
             }
             // queues the SplitChanges fetch (only if changeNumber is newer)
             ff.put({ changeNumber: changeNumber });

package/esm/sync/streaming/constants.js

@@ -5,7 +5,7 @@ export var SECONDS_BEFORE_EXPIRATION = 600;
  * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
  * triggers `handleNonRetryableError` call
  */
-export var PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+export var PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR';
 /**
  * emitted on SSE and Authenticate recoverable errors
  * triggers `handleRetryableError` call
@@ -17,7 +17,7 @@ export var PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
  */
 export var 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
  */
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';

package/esm/sync/streaming/pushManager.js

@@ -3,12 +3,12 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
+import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
@@ -42,8 +42,8 @@ export function pushManagerFactory(params, pollingManager) {
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
-    // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = 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 = 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.
@@ -51,10 +51,10 @@ export 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 */
@@ -93,11 +93,11 @@ export 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(STREAMING_DISABLED);
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(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
@@ -112,7 +112,7 @@ export 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(AUTH_REJECTION);
-                pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
                 return;
             }
             // Handle other HTTP and network errors as recoverable errors
@@ -136,7 +136,7 @@ export function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.stop();
+        definitionsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
                 var worker = _a.worker;
@@ -152,7 +152,7 @@ export 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(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    pushEmitter.on(PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
         disabled = true;
         // Note: `stopWorkers` is been called twice, but it is not harmful
         disconnectPush();
@@ -178,9 +178,9 @@ export function pushManagerFactory(params, pollingManager) {
         connectPush();
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
-    pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-    pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+    pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {

package/esm/sync/submitters/telemetrySubmitter.js

@@ -102,13 +102,12 @@ export 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 = timer(now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
-    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
         telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started

package/esm/sync/syncManagerOnline.js

@@ -3,9 +3,10 @@ import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
 import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
+import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -15,21 +16,22 @@ import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetch
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
  * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionChangesFetcherFactory) {
-    if (definitionChangesFetcherFactory === void 0) { definitionChangesFetcherFactory = splitChangesFetcherFactory; }
+export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return 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 = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
@@ -77,7 +79,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
                         }
                     }
                     // start syncing splits and segments

package/esm/utils/Backoff.js

@@ -24,6 +24,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/esm/utils/lang/sets.js

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

package/esm/utils/settingsValidation/index.js

@@ -52,6 +52,8 @@ export var 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/esm/utils/settingsValidation/url.js

@@ -1,7 +1,8 @@
-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.
@@ -23,5 +24,8 @@ export 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);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.0.0-rc.0",
+  "version": "3.0.0-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -217,7 +217,7 @@ export interface IRBSegment extends TargetingEntity {
 
 export interface IDefinition extends TargetingEntity {
   trafficTypeName: string;
-  sets?: string[];
+  sets?: string[] | null;
   impressionsDisabled?: boolean;
   prerequisites?: null | {
     n: string,
@@ -230,7 +230,7 @@ export interface IDefinition extends TargetingEntity {
   trafficAllocationSeed?: number;
   configurations?: {
     [treatmentName: string]: string | SplitIO.JsonObject
-  };
+  } | null;
 }
 
 /** Interface of the parsed JSON response of `/splitChanges` */

package/src/evaluator/index.ts

@@ -41,9 +41,9 @@ export function evaluateFeature(
   let definition;
 
   try {
-    definition = storage.splits.getSplit(definitionName);
+    definition = storage.definitions.get(definitionName);
   } catch (e) {
-    // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
+    // Exception on sync storage. Not possible ATM with InMemory and InLocal storages.
     return EVALUATION_EXCEPTION;
   }
 
@@ -56,7 +56,7 @@ export function evaluateFeature(
       storage,
       options,
     )).catch(
-      // Exception on async `getSplit` storage. For example, when the storage is redis or
+      // Exception on async storage. For example, when the storage is redis or
       // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
       () => EVALUATION_EXCEPTION
     );
@@ -83,16 +83,16 @@ export function evaluateFeatures(
   let definitions;
 
   try {
-    definitions = storage.splits.getSplits(definitionNames);
+    definitions = storage.definitions.getMany(definitionNames);
   } catch (e) {
-    // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
+    // Exception on sync storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(definitionNames);
   }
 
   return thenable(definitions) ?
     definitions.then(definitions => getEvaluations(log, key, definitionNames, definitions, attributes, storage, options))
       .catch(() => {
-        // Exception on async `getSplits` storage. For example, when the storage is redis or
+        // Exception on async storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(definitionNames);
       }) :
@@ -128,7 +128,7 @@ export function evaluateFeaturesByFlagSets(
 
   // get features by flag sets
   try {
-    storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
+    storedFlagNames = storage.definitions.getNamesBySets(flagSets);
   } catch (e) {
     // return empty evaluations
     return {};
@@ -156,7 +156,7 @@ function getEvaluation(
     const split = engineParser(log, definition, storage);
     const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async and the evaluated flag uses segments or dependencies, evaluation is thenable
+    // If the storage is async and the evaluated definition uses segments or dependencies, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = definition.changeNumber;
@@ -183,7 +183,7 @@ function getEvaluations(
   log: ILogger,
   key: SplitIO.SplitKey,
   definitionNames: string[],
-  splits: Record<string, IDefinition | null>,
+  definitions: Record<string, IDefinition | null>,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   options?: SplitIO.EvaluationOptions,
@@ -194,7 +194,7 @@ function getEvaluations(
     const evaluation = getEvaluation(
       log,
       key,
-      splits[definitionName],
+      definitions[definitionName],
       attributes,
       storage,
       options
@@ -218,7 +218,7 @@ export function evaluateDefaultTreatment(
   let definition;
 
   try {
-    definition = storage.splits.getSplit(definitionName);
+    definition = storage.definitions.get(definitionName);
   } catch (e) {
     return EVALUATION_EXCEPTION;
   }

package/src/logger/constants.ts

@@ -56,7 +56,6 @@ export const SUBMITTERS_PUSH_PAGE_HIDDEN = 125;
 
 export const ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;
-export const CLIENT_NO_LISTENER = 202;
 export const CLIENT_NOT_READY_FROM_CACHE = 203;
 export const SYNC_FETCH_RETRY = 204;
 export const SYNC_FETCH_FAILS = 205;
@@ -123,6 +122,7 @@ export const LOG_PREFIX_ENGINE_COMBINER = LOG_PREFIX_ENGINE + ':combiner: ';
 export const LOG_PREFIX_ENGINE_MATCHER = LOG_PREFIX_ENGINE + ':matcher: ';
 export const LOG_PREFIX_ENGINE_VALUE = LOG_PREFIX_ENGINE + ':value: ';
 export const LOG_PREFIX_SYNC = 'sync: ';
+export const LOG_PREFIX_SYNC_AUTH = 'sync:auth: ';
 export const LOG_PREFIX_SYNC_MANAGER = 'sync:sync-manager: ';
 export const LOG_PREFIX_SYNC_OFFLINE = 'sync:offline: ';
 export const LOG_PREFIX_SYNC_STREAMING = 'sync:streaming: ';