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

package/cjs/sync/streaming/pushManager.js

@@ -6,8 +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 AuthClient_1 = require("./AuthClient");
+var DefinitionsUpdateWorker_1 = require("./UpdateWorkers/DefinitionsUpdateWorker");
 var lang_1 = require("../../utils/lang");
 var SSEClient_1 = require("./SSEClient");
 var key_1 = require("../../utils/key");
@@ -22,8 +21,9 @@ var constants_3 = require("../../utils/constants");
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
+function pushManagerFactory(params, pollingManager, definitionsUpdateWorkerFactory) {
+    if (definitionsUpdateWorkerFactory === void 0) { definitionsUpdateWorkerFactory = DefinitionsUpdateWorker_1.DefinitionsUpdateWorker; }
+    var settings = params.settings, storage = params.storage, serviceApi = params.serviceApi, 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 = (0, key_1.checkIfServerSide)(settings) ? undefined : (0, key_1.getMatching)(settings.core.key);
@@ -37,7 +37,6 @@ function pushManagerFactory(params, pollingManager) {
         log.warn(constants_2.STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = (0, AuthClient_1.authenticateFactory)(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = (0, SSEHandler_1.SSEHandlerFactory)(log, pushEmitter, telemetryTracker);
@@ -45,19 +44,17 @@ 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.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 = {};
+    // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
+    var definitionsUpdateWorker = definitionsUpdateWorkerFactory(params, pollingManager);
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     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,14 +90,14 @@ function pushManagerFactory(params, pollingManager) {
         log.info(constants_2.STREAMING_CONNECTING);
         disconnected = false;
         var userKeys = userKey ? Object.keys(clients) : undefined;
-        authenticate(userKeys).then(function (authData) {
+        serviceApi.fetchAuth(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 +112,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 +136,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 +152,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 +178,12 @@ 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);
+    // Some notification types are specific to the Feature flags or Configs SDKs. Their handlers are
+    // registered unconditionally, since the SDK only subscribes to the channels of its own entities.
+    pushEmitter.on(constants_1.SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+    pushEmitter.on(constants_1.SPLIT_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(constants_1.CONFIG_UPDATE, definitionsUpdateWorker.put);
+    pushEmitter.on(constants_1.RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
     function handleMySegmentsUpdate(parsedData) {
         switch (parsedData.u) {
             case types_1.UpdateStrategy.BoundedFetchRequest: {
@@ -206,7 +206,7 @@ function pushManagerFactory(params, pollingManager) {
             case types_1.UpdateStrategy.KeyList: {
                 var keyList = void 0, added_1, removed_1;
                 try {
-                    keyList = (0, parseUtils_1.parseKeyList)(parsedData.d, parsedData.c);
+                    keyList = (0, parseUtils_1.parseCompressedData)(parsedData.d, parsedData.c);
                     added_1 = new Set(keyList.a);
                     removed_1 = new Set(keyList.r);
                 }
@@ -285,9 +285,7 @@ function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            var hash = (0, AuthClient_1.hashUserKey)(userKey);
-            if (!userKeyHashes[hash]) {
-                userKeyHashes[hash] = userKey;
+            if (!clients[userKey]) {
                 clients[userKey] = {
                     hash64: (0, murmur3_64_1.hash64)(userKey),
                     worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(log, storage, mySegmentsSyncTask, telemetryTracker)
@@ -308,8 +306,6 @@ function pushManagerFactory(params, pollingManager) {
         },
         // [Only for client-side]
         remove: function (userKey) {
-            var hash = (0, AuthClient_1.hashUserKey)(userKey);
-            delete userKeyHashes[hash];
             delete clients[userKey];
         }
     });

package/cjs/sync/submitters/eventsSubmitter.js

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

package/cjs/sync/submitters/impressionCountsSubmitter.js

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

package/cjs/sync/submitters/impressionsSubmitter.js

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

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -107,18 +107,17 @@ 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, serviceApi = params.serviceApi, 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);
+    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, serviceApi.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
         if (submitter.isRunning()) {
-            var postMetricsConfigTask = (0, submitter_1.submitterFactory)(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
+            var postMetricsConfigTask = (0, submitter_1.submitterFactory)(log, serviceApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);
             postMetricsConfigTask.execute();
         }
     });

package/cjs/sync/submitters/uniqueKeysSubmitter.js

@@ -8,7 +8,7 @@ var UNIQUE_KEYS_RATE = 900000; // 15 minutes
  * Submitter that periodically posts impression counts
  */
 function uniqueKeysSubmitterFactory(params) {
-    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 _a = params.settings, log = _a.log, key = _a.core.key, _b = params.serviceApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
     var syncTask = (0, submitter_1.submitterFactory)(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE);

package/cjs/sync/syncManagerOnline.js

@@ -7,7 +7,7 @@ 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");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -29,7 +29,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, 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() {
@@ -77,7 +77,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                     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
@@ -136,7 +136,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                         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 {
@@ -146,7 +146,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                             }
                         }
                         else {
-                            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
+                            if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
                                 mySegmentsSyncTask.start();
                         }
                     }

package/cjs/utils/Backoff.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Backoff = void 0;
 var Backoff = /** @class */ (function () {
     /**
-     * Schedule function calls with exponential backoff
+     * Schedule function calls with exponential backoff.
+     * @param cb - The function to call. Must return a promise if used with `scheduleCallAsync`.
      */
     function Backoff(cb, baseMillis, maxMillis) {
         this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
@@ -20,19 +21,50 @@ var Backoff = /** @class */ (function () {
         var delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
+        this.attempts++;
         this.timeoutID = setTimeout(function () {
             _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
-        this.attempts++;
         return delayInMillis;
     };
-    Backoff.prototype.reset = function () {
+    /**
+     * 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.pending = { resolve: resolve, reject: reject };
+            _this.timeoutID = setTimeout(function () {
+                _this.timeoutID = undefined;
+                _this.pending = undefined;
+                _this.cb().then(resolve, reject);
+            }, delayInMillis);
+        });
+    };
+    /**
+     * Reset the backoff attempts, canceling any scheduled `cb` call. If a `scheduleCallAsync` call is pending
+     * and the caller wants to settle it immediately instead of waiting for `cb` to be invoked, pass `settle`:
+     * `{ value }` to resolve, or `{ error }` to reject.
+     */
+    Backoff.prototype.reset = function (settle) {
         this.attempts = 0;
         if (this.timeoutID) {
             clearTimeout(this.timeoutID);
             this.timeoutID = undefined;
         }
+        if (settle && this.pending) {
+            if ('value' in settle)
+                this.pending.resolve(settle.value);
+            else
+                this.pending.reject(settle.error);
+            this.pending = undefined;
+        }
     };
     Backoff.DEFAULT_BASE_MILLIS = 1000; // 1 second
     Backoff.DEFAULT_MAX_MILLIS = 1800000; // 30 minutes