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

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

@@ -1,37 +1,40 @@
 import { STREAMING_PARSING_SPLIT_UPDATE } from '../../../logger/constants';
-import { SDK_DEFINITIONS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_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';
 /**
- * DefinitionsUpdateWorker factory
+ * SplitsUpdateWorker factory
  */
-export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker) {
-    var ff = DefinitionsUpdateWorker(storage.definitions);
-    var rbs = DefinitionsUpdateWorker(storage.rbSegments);
-    function DefinitionsUpdateWorker(cache) {
+export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
+    var ff = SplitsUpdateWorker(storage.splits);
+    var rbs = SplitsUpdateWorker(storage.rbSegments);
+    function SplitsUpdateWorker(cache) {
         var maxChangeNumber = -1;
         var handleNewEvent = false;
         var isHandlingEvent;
         var cdnBypass;
         var instantUpdate;
-        var backoff = new Backoff(__handleDefinitionUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
-        function __handleDefinitionUpdateCall() {
+        var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
+        function __handleSplitUpdateCall() {
             isHandlingEvent = true;
             if (maxChangeNumber > cache.getChangeNumber()) {
                 handleNewEvent = false;
                 // fetch splits revalidating data if cached
-                definitionsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(function () {
+                splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, instantUpdate).then(function () {
                     if (!isHandlingEvent)
                         return; // halt if `stop` has been called
                     if (handleNewEvent) {
-                        __handleDefinitionUpdateCall();
+                        __handleSplitUpdateCall();
                     }
                     else {
                         if (instantUpdate)
                             telemetryTracker.trackUpdatesFromSSE(SPLITS);
+                        // fetch new registered segments for server-side API. Not retrying on error
+                        if (segmentsSyncTask)
+                            segmentsSyncTask.execute(true);
                         var attempts = backoff.attempts + 1;
                         if (ff.isSync() && rbs.isSync()) {
                             log.debug("Refresh completed".concat(cdnBypass ? ' bypassing the CDN' : '', " in ").concat(attempts, " attempts."));
@@ -49,7 +52,7 @@ export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, defin
                         else {
                             backoff.reset();
                             cdnBypass = true;
-                            __handleDefinitionUpdateCall();
+                            __handleSplitUpdateCall();
                         }
                     }
                 });
@@ -77,7 +80,7 @@ export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, defin
                     instantUpdate = { payload: payload, changeNumber: changeNumber, type: type };
                 }
                 if (backoff.timeoutID || !isHandlingEvent)
-                    __handleDefinitionUpdateCall();
+                    __handleSplitUpdateCall();
                 backoff.reset();
             },
             stop: function () {
@@ -112,11 +115,11 @@ export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, defin
          * @param splitName - name of split to kill
          * @param defaultTreatment - default treatment value
          */
-        killDefinition: function (_a) {
+        killSplit: function (_a) {
             var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-            if (storage.definitions.killLocally(splitName, defaultTreatment, changeNumber)) {
+            if (storage.splits.killLocally(splitName, defaultTreatment, changeNumber)) {
                 // trigger an SDK_UPDATE if Split was killed locally
-                definitionsEventEmitter.emit(SDK_DEFINITIONS_ARRIVED, true);
+                splitsEventEmitter.emit(SDK_SPLITS_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_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR';
+export var PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_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_NON_RETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
  * triggers `startPolling` and `stopWorkers` calls
  */
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';

package/esm/sync/streaming/parseUtils.js

@@ -30,22 +30,22 @@ function decompress(data, compression) {
     throw new Error("Invalid compression algorithm #".concat(compression));
 }
 /**
- * Decode, decompress and parse the provided 'data' into an object of type T
+ * Decode, decompress and parse the provided 'data' into a KeyList object
  *
  * @param data - base64 encoded string
  * @param compression - 1 GZIP, 2 ZLIB
  * @param avoidPrecisionLoss - true as default, set it as false if dont need to avoid precission loss
- * @returns parsed object
+ * @returns keyList
  * @throws if data string cannot be decoded, decompressed or parsed
  */
-export function parseCompressedData(data, compression, avoidPrecisionLoss) {
+export function parseKeyList(data, compression, avoidPrecisionLoss) {
     if (avoidPrecisionLoss === void 0) { avoidPrecisionLoss = true; }
-    var binData = decompress(data, compression);
-    var str = Uint8ArrayToString(binData);
-    // replace numbers to strings, to avoid losing precision (e.g., 64-bit IDs in KeyList)
+    var binKeyList = decompress(data, compression);
+    var strKeyList = Uint8ArrayToString(binKeyList);
+    // replace numbers to strings, to avoid losing precision
     if (avoidPrecisionLoss)
-        str = str.replace(/\d+/g, '"$&"');
-    return JSON.parse(str);
+        strKeyList = strKeyList.replace(/\d+/g, '"$&"');
+    return JSON.parse(strKeyList);
 }
 /**
  * Decode, decompress and parse the provided 'data' into a Bitmap object
@@ -77,7 +77,7 @@ export function isInBitmap(bitmap, hash64hex) {
  */
 export function parseFFUpdatePayload(compression, data) {
     return compression > 0 ?
-        parseCompressedData(data, compression, false) :
+        parseKeyList(data, compression, false) :
         JSON.parse(decodeFromBase64(data));
 }
 var DEFAULT_MAX_INTERVAL = 60000;

package/esm/sync/streaming/pushManager.js

@@ -3,15 +3,15 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
+import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 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_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 { 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 { 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';
+import { getDelay, isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
@@ -20,7 +20,7 @@ import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
     var userKey = checkIfServerSide(settings) ? undefined : getMatching(settings.core.key);
@@ -34,7 +34,7 @@ export function pushManagerFactory(params, pollingManager) {
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(serviceApi.fetchAuth);
+    var authenticate = authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
@@ -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 DefinitionsUpdateWorker to fetch new segments
-    var definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
+    // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
+    var splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.splitsSyncTask, readiness.splits, 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_NON_RETRYABLE_ERROR error.
+    // 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.
     // It is used to halt the `connectPush` process if it was in progress.
     var disconnected;
-    // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+    // flag that indicates a PUSH_NONRETRYABLE_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_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+            // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_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_NON_RETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NONRETRYABLE_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_NON_RETRYABLE_ERROR);
+                pushEmitter.emit(PUSH_NONRETRYABLE_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() {
-        definitionsUpdateWorker.stop();
+        splitsUpdateWorker.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_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
+    pushEmitter.on(PUSH_NONRETRYABLE_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, definitionsUpdateWorker.killDefinition);
-    pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
-    pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
+    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
@@ -203,7 +203,7 @@ export function pushManagerFactory(params, pollingManager) {
             case UpdateStrategy.KeyList: {
                 var keyList = void 0, added_1, removed_1;
                 try {
-                    keyList = parseCompressedData(parsedData.d, parsedData.c);
+                    keyList = parseKeyList(parsedData.d, parsedData.c);
                     added_1 = new Set(keyList.a);
                     removed_1 = new Set(keyList.r);
                 }

package/esm/sync/submitters/eventsSubmitter.js

@@ -4,7 +4,7 @@ import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
  * Submitter that periodically posts tracked events
  */
 export function eventsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.serviceApi.postEventsBulk, events = params.storage.events;
+    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.splitApi.postEventsBulk, events = params.storage.events;
     // don't retry events.
     var submitter = submitterFactory(log, postEventsBulk, events, eventsPushRate);
     // Set a timer for the first push window of events.

package/esm/sync/submitters/impressionCountsSubmitter.js

@@ -25,7 +25,7 @@ var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
  * Submitter that periodically posts impression counts
  */
 export function impressionCountsSubmitterFactory(params) {
-    var log = params.settings.log, postTestImpressionsCount = params.serviceApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
+    var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
     // retry impressions counts only once.
     return submitterFactory(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, fromImpressionCountsCollector, 1);
 }

package/esm/sync/submitters/impressionsSubmitter.js

@@ -11,7 +11,7 @@ export function fromImpressionsCollector(sendLabels, data) {
         dto.push({
             f: name,
             i: value.map(function (entry) {
-                return {
+                var keyImpression = {
                     k: entry.keyName,
                     t: entry.treatment,
                     m: entry.time,
@@ -19,10 +19,9 @@ export function fromImpressionsCollector(sendLabels, data) {
                     r: sendLabels ? entry.label : undefined,
                     b: entry.bucketingKey,
                     pt: entry.pt,
-                    properties: entry.properties,
-                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
-                    et: entry.entityType, // Definition type
+                    properties: entry.properties // Properties
                 };
+                return keyImpression;
             })
         });
     });
@@ -32,7 +31,7 @@ export function fromImpressionsCollector(sendLabels, data) {
  * Submitter that periodically posts impressions data
  */
 export function impressionsSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.serviceApi.postTestImpressionsBulk, impressions = params.storage.impressions;
+    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions;
     // retry impressions only once.
     var syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
     // register impressions submitter to be executed when impressions cache is full

package/esm/sync/submitters/telemetrySubmitter.js

@@ -102,17 +102,18 @@ 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, serviceApi = params.serviceApi, readiness = params.readiness;
+    var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var stopTimer = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, serviceApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
+    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
         if (submitter.isRunning()) {
-            var postMetricsConfigTask = submitterFactory(log, serviceApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
+            var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
             postMetricsConfigTask.execute();
         }
     });

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -5,7 +5,7 @@ var UNIQUE_KEYS_RATE = 900000; // 15 minutes
  * Submitter that periodically posts impression counts
  */
 export function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.serviceApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
     var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE);

package/esm/sync/syncManagerOnline.js

@@ -3,10 +3,8 @@ 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_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
-import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
-import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
+import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -14,24 +12,21 @@ import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesF
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @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, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges); }; }
+export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * 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, definitionFetcherFactory(params), segmentFetcherFactory(params));
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
         var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
-        // It is not injected as push and polling managers, because at the moment it is required
+        // It is not inyected as push and polling managers, because at the moment it is required
         var submitterManager = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
@@ -79,7 +74,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
                         if (!cacheMetadata.initialCacheLoad) {
-                            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
                         }
                     }
                     // start syncing splits and segments

package/esm/utils/Backoff.js

@@ -24,26 +24,6 @@ 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/inputValidation/index.js

@@ -4,10 +4,10 @@ export { validateEvent } from './event';
 export { validateEventValue } from './eventValue';
 export { validateEventProperties } from './eventProperties';
 export { validateKey } from './key';
-export { validateDefinition } from './definition';
-export { validateDefinitions } from './definitions';
+export { validateSplit } from './split';
+export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfReadyFromCache, validateIfOperational } from './isOperational';
-export { validateDefinitionExistence } from './definitionExistence';
+export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validateEvaluationOptions } from './eventProperties';

package/esm/utils/inputValidation/isOperational.js

@@ -5,13 +5,13 @@ export function validateIfNotDestroyed(log, readinessManager, method) {
     log.error(ERROR_CLIENT_DESTROYED, [method]);
     return false;
 }
-export function validateIfReadyFromCache(log, readinessManager, method) {
+export function validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames) {
     if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(CLIENT_NOT_READY_FROM_CACHE, [method]);
+    log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag ".concat(featureFlagNameOrNames.toString()) : '']);
     return false;
 }
 // Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
-export function validateIfOperational(log, readinessManager, method) {
-    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method);
+export function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
+    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
 }

package/esm/utils/inputValidation/{definition.js → split.js}

@@ -2,21 +2,21 @@ import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../log
 import { isString } from '../lang';
 // include BOM and nbsp
 var TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
-export function validateDefinition(log, maybeDefinition, method, item) {
+export function validateSplit(log, maybeSplit, method, item) {
     if (item === void 0) { item = 'feature flag name'; }
-    if (maybeDefinition == undefined) { // eslint-disable-line eqeqeq
+    if (maybeSplit == undefined) { // eslint-disable-line eqeqeq
         log.error(ERROR_NULL, [method, item]);
     }
-    else if (!isString(maybeDefinition)) {
+    else if (!isString(maybeSplit)) {
         log.error(ERROR_INVALID, [method, item]);
     }
     else {
-        if (TRIMMABLE_SPACES_REGEX.test(maybeDefinition)) {
-            log.warn(WARN_TRIMMING, [method, item, maybeDefinition]);
-            maybeDefinition = maybeDefinition.trim();
+        if (TRIMMABLE_SPACES_REGEX.test(maybeSplit)) {
+            log.warn(WARN_TRIMMING, [method, item, maybeSplit]);
+            maybeSplit = maybeSplit.trim();
         }
-        if (maybeDefinition.length > 0) {
-            return maybeDefinition;
+        if (maybeSplit.length > 0) {
+            return maybeSplit;
         }
         else {
             log.error(ERROR_EMPTY, [method, item]);

package/esm/utils/inputValidation/splitExistence.js

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,21 @@
+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;
+}

package/esm/utils/labels/index.js

@@ -1,11 +1,11 @@
 import { FALLBACK_PREFIX } from '../../evaluator/fallbackTreatmentsCalculator';
 export var SPLIT_KILLED = 'killed';
 export var NO_CONDITION_MATCH = 'default rule';
-export var DEFINITION_NOT_FOUND = 'definition not found';
+export var SPLIT_NOT_FOUND = 'definition not found';
 export var SDK_NOT_READY = 'not ready';
 export var EXCEPTION = 'exception';
 export var SPLIT_ARCHIVED = 'archived';
 export var NOT_IN_SPLIT = 'not in split';
 export var UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 export var PREREQUISITES_NOT_MET = 'prerequisites not met';
-export var FALLBACK_DEFINITION_NOT_FOUND = FALLBACK_PREFIX + DEFINITION_NOT_FOUND;
+export var FALLBACK_SPLIT_NOT_FOUND = FALLBACK_PREFIX + SPLIT_NOT_FOUND;

package/esm/utils/settingsValidation/index.js

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

package/esm/utils/settingsValidation/splitFilters.js

@@ -1,4 +1,4 @@
-import { validateDefinitions } from '../inputValidation/definitions';
+import { validateSplits } from '../inputValidation/splits';
 import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_LOWERCASE_FLAGSET, WARN_INVALID_FLAGSET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
@@ -42,7 +42,7 @@ function validateFilterType(maybeFilterType) {
  */
 function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
-    var result = validateDefinitions(log, values, LOG_PREFIX_SETTINGS, "".concat(type, " filter"), "".concat(type, " filter value"));
+    var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, "".concat(type, " filter"), "".concat(type, " filter value"));
     if (result) {
         if (type === 'bySet') {
             result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
@@ -168,7 +168,7 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     return res;
 }
 export function validateFlagSets(log, method, flagSets, flagSetsInConfig) {
-    var sets = validateDefinitions(log, flagSets, method, 'flag sets', 'flag set');
+    var sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
     var toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
     if (flagSetsInConfig.length > 0) {
         toReturn = toReturn.filter(function (flagSet) {

package/esm/utils/settingsValidation/url.js

@@ -1,8 +1,7 @@
-var telemetryEndpointMatcher = /^\/v1\/(metrics|keys)\/(config|usage|ss|cs)/;
+var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/(v2|v3)\/auth/;
+var authEndpointMatcher = /^\/v2\/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.
@@ -24,8 +23,5 @@ 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);
 }