@splitsoftware/splitio-commons 3.1.1-rc.2 → 3.1.1-rc.4

package/CHANGES.txt

@@ -1,4 +1,4 @@
-3.2.0 (August 10, 2026)
+3.2.0 (August 28, 2026)
  - Added support for AI configs.
  - Removed Configs SDK-related types and modules and moved them to the Configs SDK repository.
 

package/cjs/presets/serverSide.js

@@ -9,7 +9,7 @@ var InMemoryStorage_1 = require("../storages/inMemory/InMemoryStorage");
 var sdkManager_1 = require("../sdkManager");
 var sdkClientMethod_1 = require("../sdkClient/sdkClientMethod");
 var impressionObserverSS_1 = require("../trackers/impressionObserver/impressionObserverSS");
-var syncManagerOnlineSSFactory = (0, syncManagerOnline_1.syncManagerOnlineFactory)(pollingManagerSS_1.pollingManagerSSFactory, pushManager_1.pushManagerFactory);
+var syncManagerOnlineSSFactory = (0, syncManagerOnline_1.syncManagerOnlineFactory)((0, pollingManagerSS_1.pollingManagerSSFactory)(), pushManager_1.pushManagerFactory);
 exports.serverSideModules = {
     storageFactory: InMemoryStorage_1.InMemoryStorageFactory,
     serviceApiFactory: serviceApi_1.serviceApiFactory,

package/cjs/sdkClient/client.js

@@ -133,10 +133,10 @@ function clientFactory(params) {
                     time: Date.now(),
                     bucketingKey: bucketingKey,
                     label: label,
-                    changeNumber: definition.changeNumber,
+                    changeNumber: definition === null || definition === void 0 ? void 0 : definition.changeNumber,
                     properties: stringify(options.properties)
                 },
-                disabled: options.impressionsDisabled || definition.impressionsDisabled
+                disabled: options.impressionsDisabled || (definition === null || definition === void 0 ? void 0 : definition.impressionsDisabled)
             });
         }
         if (withConfig) {

package/cjs/sync/polling/pollingManagerCS.js

@@ -8,93 +8,98 @@ var key_1 = require("../../utils/key");
 var constants_1 = require("../../readiness/constants");
 var constants_2 = require("../../logger/constants");
 var AbstractDefinitionsCacheSync_1 = require("../../storages/AbstractDefinitionsCacheSync");
+var splitChangesFetcher_1 = require("./fetchers/splitChangesFetcher");
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-function pollingManagerCSFactory(params, definitionChangesFetcher) {
-    var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings);
-    // Map of matching keys to their corresponding MySegmentsSyncTask.
-    var mySegmentsSyncTasks = {};
-    var matchingKey = (0, key_1.getMatching)(settings.core.key);
-    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
-    function startMySegmentsSyncTasks() {
-        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            mySegmentsSyncTask.start();
-        });
-    }
-    function stopMySegmentsSyncTasks() {
-        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            if (mySegmentsSyncTask.isRunning())
-                mySegmentsSyncTask.stop();
-        });
-    }
-    // smart pausing
-    readiness.definitions.on(constants_1.SDK_DEFINITIONS_ARRIVED, function () {
-        if (!definitionsSyncTask.isRunning())
-            return; // noop if not doing polling
-        var usingSegments = (0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage);
-        if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-            log.info(constants_2.POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-            if (usingSegments) {
-                startMySegmentsSyncTasks();
-            }
-            else {
-                stopMySegmentsSyncTasks();
-            }
-        }
-    });
-    function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
-        // smart ready
-        function smartReady(metadata) {
-            if (!readiness.isReady() && !(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
-                readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
+function pollingManagerCSFactory(definitionFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
+    return function (params) {
+        var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings);
+        // Map of matching keys to their corresponding MySegmentsSyncTask.
+        var mySegmentsSyncTasks = {};
+        var matchingKey = (0, key_1.getMatching)(settings.core.key);
+        var mySegmentsSyncTask = add(matchingKey, readiness, storage);
+        function startMySegmentsSyncTasks() {
+            (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                mySegmentsSyncTask.start();
+            });
         }
-        if (!(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
-            setTimeout(smartReady, 0);
-        else
-            readiness.definitions.once(constants_1.SDK_DEFINITIONS_ARRIVED, smartReady);
-        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-        return mySegmentsSyncTask;
-    }
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: mySegmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(constants_2.POLLING_START);
-            definitionsSyncTask.start();
-            if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
-                startMySegmentsSyncTasks();
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(constants_2.POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            stopMySegmentsSyncTasks();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        // fetch definitions and segments
-        syncAll: function () {
-            var promises = [definitionsSyncTask.execute()];
+        function stopMySegmentsSyncTasks() {
             (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-                promises.push(mySegmentsSyncTask.execute());
+                if (mySegmentsSyncTask.isRunning())
+                    mySegmentsSyncTask.stop();
             });
-            return Promise.all(promises);
-        },
-        // Support for handling mySegments sync of multiple clients
-        add: add,
-        remove: function (matchingKey) {
-            delete mySegmentsSyncTasks[matchingKey];
-        },
-        get: function (matchingKey) {
-            return mySegmentsSyncTasks[matchingKey];
         }
+        // smart pausing
+        readiness.definitions.on(constants_1.SDK_DEFINITIONS_ARRIVED, function () {
+            if (!definitionsSyncTask.isRunning())
+                return; // noop if not doing polling
+            var usingSegments = (0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage);
+            if (usingSegments !== mySegmentsSyncTask.isRunning()) {
+                log.info(constants_2.POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
+                if (usingSegments) {
+                    startMySegmentsSyncTasks();
+                }
+                else {
+                    stopMySegmentsSyncTasks();
+                }
+            }
+        });
+        function add(matchingKey, readiness, storage) {
+            var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
+            // smart ready
+            function smartReady(metadata) {
+                if (!readiness.isReady() && !(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+                    readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
+            }
+            if (!(0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+                setTimeout(smartReady, 0);
+            else
+                readiness.definitions.once(constants_1.SDK_DEFINITIONS_ARRIVED, smartReady);
+            mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+            return mySegmentsSyncTask;
+        }
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: mySegmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(constants_2.POLLING_START);
+                definitionsSyncTask.start();
+                if ((0, AbstractDefinitionsCacheSync_1.usesSegmentsSync)(storage))
+                    startMySegmentsSyncTasks();
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(constants_2.POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                stopMySegmentsSyncTasks();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.isRunning,
+            // fetch definitions and segments
+            syncAll: function () {
+                var promises = [definitionsSyncTask.execute()];
+                (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                    promises.push(mySegmentsSyncTask.execute());
+                });
+                return Promise.all(promises);
+            },
+            // Support for handling mySegments sync of multiple clients
+            add: add,
+            remove: function (matchingKey) {
+                delete mySegmentsSyncTasks[matchingKey];
+            },
+            get: function (matchingKey) {
+                return mySegmentsSyncTasks[matchingKey];
+            }
+        };
     };
 }
 exports.pollingManagerCSFactory = pollingManagerCSFactory;

package/cjs/sync/polling/pollingManagerSS.js

@@ -4,46 +4,54 @@ exports.pollingManagerSSFactory = void 0;
 var definitionsSyncTask_1 = require("./syncTasks/definitionsSyncTask");
 var segmentsSyncTask_1 = require("./syncTasks/segmentsSyncTask");
 var constants_1 = require("../../logger/constants");
+var segmentChangesFetcher_1 = require("./fetchers/segmentChangesFetcher");
+var splitChangesFetcher_1 = require("./fetchers/splitChangesFetcher");
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
-    var storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
-    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: segmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(constants_1.POLLING_START);
-            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
-            log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
-            var startingUp = definitionsSyncTask.start();
-            if (startingUp) {
-                startingUp.then(function () {
-                    if (definitionsSyncTask.isRunning())
-                        segmentsSyncTask.start();
+function pollingManagerSSFactory(definitionFetcherFactory, segmentFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.serviceApi.fetchSegmentChanges); }; }
+    return function (params) {
+        var storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var segmentChangesFetcher = segmentFetcherFactory(params);
+        var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
+        var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: segmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(constants_1.POLLING_START);
+                log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
+                log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
+                var startingUp = definitionsSyncTask.start();
+                if (startingUp) {
+                    startingUp.then(function () {
+                        if (definitionsSyncTask.isRunning())
+                            segmentsSyncTask.start();
+                    });
+                }
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(constants_1.POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                if (segmentsSyncTask.isRunning())
+                    segmentsSyncTask.stop();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.isRunning,
+            syncAll: function () {
+                // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+                return definitionsSyncTask.execute().then(function () {
+                    return segmentsSyncTask.execute();
                 });
             }
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(constants_1.POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            if (segmentsSyncTask.isRunning())
-                segmentsSyncTask.stop();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        syncAll: function () {
-            // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
-            return definitionsSyncTask.execute().then(function () {
-                return segmentsSyncTask.execute();
-            });
-        }
+        };
     };
 }
 exports.pollingManagerSSFactory = pollingManagerSSFactory;

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

@@ -31,7 +31,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
+                        log.debug("".concat(constants_2.LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with since = ").concat(x.since, " and till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });

package/cjs/sync/submitters/impressionsSubmitter.js

@@ -23,7 +23,7 @@ function fromImpressionsCollector(sendLabels, data) {
                     b: entry.bucketingKey,
                     pt: entry.pt,
                     properties: entry.properties,
-                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+                    // @TODO: add entityType to public SplitIO.ImpressionDTO type
                     et: entry.entityType, // Definition type
                 };
             })

package/cjs/sync/syncManagerOnline.js

@@ -8,8 +8,6 @@ var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
 var constants_4 = require("../readiness/constants");
 var AbstractDefinitionsCacheSync_1 = require("../storages/AbstractDefinitionsCacheSync");
-var splitChangesFetcher_1 = require("./polling/fetchers/splitChangesFetcher");
-var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -17,18 +15,15 @@ var segmentChangesFetcher_1 = require("./polling/fetchers/segmentChangesFetcher"
  * @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
  */
-function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, definitionFetcherFactory, segmentFetcherFactory) {
-    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcher_1.splitChangesFetcherFactory; }
-    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(params.serviceApi.fetchSegmentChanges); }; }
+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) :

package/esm/presets/serverSide.js

@@ -6,7 +6,7 @@ import { InMemoryStorageFactory } from '../storages/inMemory/InMemoryStorage';
 import { sdkManagerFactory } from '../sdkManager';
 import { sdkClientMethodFactory } from '../sdkClient/sdkClientMethod';
 import { impressionObserverSSFactory } from '../trackers/impressionObserver/impressionObserverSS';
-var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory(), pushManagerFactory);
 export var serverSideModules = {
     storageFactory: InMemoryStorageFactory,
     serviceApiFactory: serviceApiFactory,

package/esm/sdkClient/client.js

@@ -129,10 +129,10 @@ export function clientFactory(params) {
                     time: Date.now(),
                     bucketingKey: bucketingKey,
                     label: label,
-                    changeNumber: definition.changeNumber,
+                    changeNumber: definition === null || definition === void 0 ? void 0 : definition.changeNumber,
                     properties: stringify(options.properties)
                 },
-                disabled: options.impressionsDisabled || definition.impressionsDisabled
+                disabled: options.impressionsDisabled || (definition === null || definition === void 0 ? void 0 : definition.impressionsDisabled)
             });
         }
         if (withConfig) {

package/esm/sync/polling/pollingManagerCS.js

@@ -5,92 +5,97 @@ import { getMatching } from '../../utils/key';
 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/AbstractDefinitionsCacheSync';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export function pollingManagerCSFactory(params, definitionChangesFetcher) {
-    var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
-    // Map of matching keys to their corresponding MySegmentsSyncTask.
-    var mySegmentsSyncTasks = {};
-    var matchingKey = getMatching(settings.core.key);
-    var mySegmentsSyncTask = add(matchingKey, readiness, storage);
-    function startMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            mySegmentsSyncTask.start();
-        });
-    }
-    function stopMySegmentsSyncTasks() {
-        forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-            if (mySegmentsSyncTask.isRunning())
-                mySegmentsSyncTask.stop();
-        });
-    }
-    // smart pausing
-    readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, function () {
-        if (!definitionsSyncTask.isRunning())
-            return; // noop if not doing polling
-        var usingSegments = usesSegmentsSync(storage);
-        if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-            log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-            if (usingSegments) {
-                startMySegmentsSyncTasks();
-            }
-            else {
-                stopMySegmentsSyncTasks();
-            }
-        }
-    });
-    function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
-        // smart ready
-        function smartReady(metadata) {
-            if (!readiness.isReady() && !usesSegmentsSync(storage))
-                readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+export function pollingManagerCSFactory(definitionFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
+    return function (params) {
+        var serviceApi = params.serviceApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
+        // Map of matching keys to their corresponding MySegmentsSyncTask.
+        var mySegmentsSyncTasks = {};
+        var matchingKey = getMatching(settings.core.key);
+        var mySegmentsSyncTask = add(matchingKey, readiness, storage);
+        function startMySegmentsSyncTasks() {
+            forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                mySegmentsSyncTask.start();
+            });
         }
-        if (!usesSegmentsSync(storage))
-            setTimeout(smartReady, 0);
-        else
-            readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
-        mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-        return mySegmentsSyncTask;
-    }
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: mySegmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(POLLING_START);
-            definitionsSyncTask.start();
-            if (usesSegmentsSync(storage))
-                startMySegmentsSyncTasks();
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            stopMySegmentsSyncTasks();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        // fetch definitions and segments
-        syncAll: function () {
-            var promises = [definitionsSyncTask.execute()];
+        function stopMySegmentsSyncTasks() {
             forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-                promises.push(mySegmentsSyncTask.execute());
+                if (mySegmentsSyncTask.isRunning())
+                    mySegmentsSyncTask.stop();
             });
-            return Promise.all(promises);
-        },
-        // Support for handling mySegments sync of multiple clients
-        add: add,
-        remove: function (matchingKey) {
-            delete mySegmentsSyncTasks[matchingKey];
-        },
-        get: function (matchingKey) {
-            return mySegmentsSyncTasks[matchingKey];
         }
+        // smart pausing
+        readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, function () {
+            if (!definitionsSyncTask.isRunning())
+                return; // noop if not doing polling
+            var usingSegments = usesSegmentsSync(storage);
+            if (usingSegments !== mySegmentsSyncTask.isRunning()) {
+                log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
+                if (usingSegments) {
+                    startMySegmentsSyncTasks();
+                }
+                else {
+                    stopMySegmentsSyncTasks();
+                }
+            }
+        });
+        function add(matchingKey, readiness, storage) {
+            var mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
+            // smart ready
+            function smartReady(metadata) {
+                if (!readiness.isReady() && !usesSegmentsSync(storage))
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+            }
+            if (!usesSegmentsSync(storage))
+                setTimeout(smartReady, 0);
+            else
+                readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
+            mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+            return mySegmentsSyncTask;
+        }
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: mySegmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(POLLING_START);
+                definitionsSyncTask.start();
+                if (usesSegmentsSync(storage))
+                    startMySegmentsSyncTasks();
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                stopMySegmentsSyncTasks();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.isRunning,
+            // fetch definitions and segments
+            syncAll: function () {
+                var promises = [definitionsSyncTask.execute()];
+                forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+                    promises.push(mySegmentsSyncTask.execute());
+                });
+                return Promise.all(promises);
+            },
+            // Support for handling mySegments sync of multiple clients
+            add: add,
+            remove: function (matchingKey) {
+                delete mySegmentsSyncTasks[matchingKey];
+            },
+            get: function (matchingKey) {
+                return mySegmentsSyncTasks[matchingKey];
+            }
+        };
     };
 }

package/esm/sync/polling/pollingManagerSS.js

@@ -1,45 +1,53 @@
 import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
+import { segmentChangesFetcherFactory } from './fetchers/segmentChangesFetcher';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
-    var storage = params.storage, readiness = params.readiness, settings = params.settings;
-    var log = settings.log;
-    var segmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
-    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
-    return {
-        definitionsSyncTask: definitionsSyncTask,
-        segmentsSyncTask: segmentsSyncTask,
-        // Start periodic fetching (polling)
-        start: function () {
-            log.info(POLLING_START);
-            log.debug(LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
-            log.debug(LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
-            var startingUp = definitionsSyncTask.start();
-            if (startingUp) {
-                startingUp.then(function () {
-                    if (definitionsSyncTask.isRunning())
-                        segmentsSyncTask.start();
+export function pollingManagerSSFactory(definitionFetcherFactory, segmentFetcherFactory) {
+    if (definitionFetcherFactory === void 0) { definitionFetcherFactory = splitChangesFetcherFactory; }
+    if (segmentFetcherFactory === void 0) { segmentFetcherFactory = function (params) { return segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges); }; }
+    return function (params) {
+        var storage = params.storage, readiness = params.readiness, settings = params.settings;
+        var log = settings.log;
+        var definitionChangesFetcher = definitionFetcherFactory(params);
+        var segmentChangesFetcher = segmentFetcherFactory(params);
+        var segmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
+        var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+        return {
+            definitionsSyncTask: definitionsSyncTask,
+            segmentsSyncTask: segmentsSyncTask,
+            // Start periodic fetching (polling)
+            start: function () {
+                log.info(POLLING_START);
+                log.debug(LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " will be refreshed each ").concat(settings.scheduler.featuresRefreshRate, " millis"));
+                log.debug(LOG_PREFIX_SYNC_POLLING + "segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
+                var startingUp = definitionsSyncTask.start();
+                if (startingUp) {
+                    startingUp.then(function () {
+                        if (definitionsSyncTask.isRunning())
+                            segmentsSyncTask.start();
+                    });
+                }
+            },
+            // Stop periodic fetching (polling)
+            stop: function () {
+                log.info(POLLING_STOP);
+                if (definitionsSyncTask.isRunning())
+                    definitionsSyncTask.stop();
+                if (segmentsSyncTask.isRunning())
+                    segmentsSyncTask.stop();
+            },
+            // Used by SyncManager to know if running in polling mode.
+            isRunning: definitionsSyncTask.isRunning,
+            syncAll: function () {
+                // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+                return definitionsSyncTask.execute().then(function () {
+                    return segmentsSyncTask.execute();
                 });
             }
-        },
-        // Stop periodic fetching (polling)
-        stop: function () {
-            log.info(POLLING_STOP);
-            if (definitionsSyncTask.isRunning())
-                definitionsSyncTask.stop();
-            if (segmentsSyncTask.isRunning())
-                segmentsSyncTask.stop();
-        },
-        // Used by SyncManager to know if running in polling mode.
-        isRunning: definitionsSyncTask.isRunning,
-        syncAll: function () {
-            // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
-            return definitionsSyncTask.execute().then(function () {
-                return segmentsSyncTask.execute();
-            });
-        }
+        };
     };
 }

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

@@ -28,7 +28,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug("".concat(LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
+                        log.debug("".concat(LOG_PREFIX_SYNC, "Processing ").concat(segmentName, " with since = ").concat(x.since, " and till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });

package/esm/sync/submitters/impressionsSubmitter.js

@@ -20,7 +20,7 @@ export function fromImpressionsCollector(sendLabels, data) {
                     b: entry.bucketingKey,
                     pt: entry.pt,
                     properties: entry.properties,
-                    // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+                    // @TODO: add entityType to public SplitIO.ImpressionDTO type
                     et: entry.entityType, // Definition type
                 };
             })

package/esm/sync/syncManagerOnline.js

@@ -5,8 +5,6 @@ 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';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -14,18 +12,15 @@ 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) :

package/package.json

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

package/src/dtos/types.ts

@@ -236,7 +236,7 @@ export interface IDefinition extends TargetingEntity {
   } | null;
   /** Definition classification. Absent means a feature flag. */
   type?: ConfigType;
-  /** Only meaningful when `type === 'AI'`. */
+  /** Only meaningful when `type === 'ai'`. */
   subtype?: ConfigSubtype;
 }
 

package/src/presets/serverSide.ts

@@ -7,7 +7,7 @@ import { sdkManagerFactory } from '../sdkManager';
 import { sdkClientMethodFactory } from '../sdkClient/sdkClientMethod';
 import { impressionObserverSSFactory } from '../trackers/impressionObserver/impressionObserverSS';
 
-const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
+const syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory(), pushManagerFactory);
 
 export const serverSideModules = {
   storageFactory: InMemoryStorageFactory,

package/src/sdkClient/client.ts

@@ -161,10 +161,10 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
           time: Date.now(),
           bucketingKey,
           label,
-          changeNumber: definition!.changeNumber,
+          changeNumber: definition?.changeNumber,
           properties: stringify(options.properties)
         }, // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
-        disabled: options.impressionsDisabled || definition!.impressionsDisabled
+        disabled: options.impressionsDisabled || definition?.impressionsDisabled
       });
     }
 

package/src/sync/polling/pollingManagerCS.ts

@@ -10,110 +10,112 @@ import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 import { SdkUpdateMetadata } from '../../../types/splitio';
-import { IDefinitionChangesFetcher } from './fetchers/types';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
 export function pollingManagerCSFactory(
-  params: ISdkFactoryContextSync,
-  definitionChangesFetcher: IDefinitionChangesFetcher
-): IPollingManagerCS {
+  definitionFetcherFactory = splitChangesFetcherFactory,
+): (params: ISdkFactoryContextSync) => IPollingManagerCS {
 
-  const { serviceApi, storage, readiness, settings } = params;
-  const log = settings.log;
+  return function (params: ISdkFactoryContextSync): IPollingManagerCS {
+    const { serviceApi, storage, readiness, settings } = params;
+    const log = settings.log;
 
-  const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
+    const definitionChangesFetcher = definitionFetcherFactory(params);
+    const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
 
-  // Map of matching keys to their corresponding MySegmentsSyncTask.
-  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
+    // Map of matching keys to their corresponding MySegmentsSyncTask.
+    const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
 
-  const matchingKey = getMatching(settings.core.key);
-  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
+    const matchingKey = getMatching(settings.core.key);
+    const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
-  function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-      mySegmentsSyncTask.start();
-    });
-  }
+    function startMySegmentsSyncTasks() {
+      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+        mySegmentsSyncTask.start();
+      });
+    }
 
-  function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-      if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
-    });
-  }
-
-  // smart pausing
-  readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, () => {
-    if (!definitionsSyncTask.isRunning()) return; // noop if not doing polling
-    const usingSegments = usesSegmentsSync(storage);
-    if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-      log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-      if (usingSegments) {
-        startMySegmentsSyncTasks();
-      } else {
-        stopMySegmentsSyncTasks();
-      }
+    function stopMySegmentsSyncTasks() {
+      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+        if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
+      });
     }
-  });
 
-  function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
+    // smart pausing
+    readiness.definitions.on(SDK_DEFINITIONS_ARRIVED, () => {
+      if (!definitionsSyncTask.isRunning()) return; // noop if not doing polling
+      const usingSegments = usesSegmentsSync(storage);
+      if (usingSegments !== mySegmentsSyncTask.isRunning()) {
+        log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
+        if (usingSegments) {
+          startMySegmentsSyncTasks();
+        } else {
+          stopMySegmentsSyncTasks();
+        }
+      }
+    });
+
+    function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
+      const mySegmentsSyncTask = mySegmentsSyncTaskFactory(serviceApi.fetchMemberships, storage, readiness, settings, matchingKey);
 
-    // smart ready
-    function smartReady(metadata: SdkUpdateMetadata) {
-      if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+      // smart ready
+      function smartReady(metadata: SdkUpdateMetadata) {
+        if (!readiness.isReady() && !usesSegmentsSync(storage)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+      }
+      if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
+      else readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
+
+      mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+      return mySegmentsSyncTask;
     }
-    if (!usesSegmentsSync(storage)) setTimeout(smartReady, 0);
-    else readiness.definitions.once(SDK_DEFINITIONS_ARRIVED, smartReady);
 
-    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-    return mySegmentsSyncTask;
-  }
+    return {
+      definitionsSyncTask,
+      segmentsSyncTask: mySegmentsSyncTask,
 
-  return {
-    definitionsSyncTask,
-    segmentsSyncTask: mySegmentsSyncTask,
+      // Start periodic fetching (polling)
+      start() {
+        log.info(POLLING_START);
 
-    // Start periodic fetching (polling)
-    start() {
-      log.info(POLLING_START);
+        definitionsSyncTask.start();
+        if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
+      },
 
-      definitionsSyncTask.start();
-      if (usesSegmentsSync(storage)) startMySegmentsSyncTasks();
-    },
+      // Stop periodic fetching (polling)
+      stop() {
+        log.info(POLLING_STOP);
 
-    // Stop periodic fetching (polling)
-    stop() {
-      log.info(POLLING_STOP);
+        if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
+        stopMySegmentsSyncTasks();
+      },
 
-      if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
-      stopMySegmentsSyncTasks();
-    },
+      // Used by SyncManager to know if running in polling mode.
+      isRunning: definitionsSyncTask.isRunning,
 
-    // Used by SyncManager to know if running in polling mode.
-    isRunning: definitionsSyncTask.isRunning,
+      // fetch definitions and segments
+      syncAll() {
+        const promises = [definitionsSyncTask.execute()];
+        forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+          promises.push(mySegmentsSyncTask.execute());
+        });
+        return Promise.all(promises);
+      },
 
-    // fetch definitions and segments
-    syncAll() {
-      const promises = [definitionsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
-        promises.push(mySegmentsSyncTask.execute());
-      });
-      return Promise.all(promises);
-    },
+      // Support for handling mySegments sync of multiple clients
+      add,
 
-    // Support for handling mySegments sync of multiple clients
-    add,
+      remove(matchingKey: string) {
+        delete mySegmentsSyncTasks[matchingKey];
+      },
 
-    remove(matchingKey: string) {
-      delete mySegmentsSyncTasks[matchingKey];
-    },
+      get(matchingKey: string) {
+        return mySegmentsSyncTasks[matchingKey];
+      }
+    };
 
-    get(matchingKey: string) {
-      return mySegmentsSyncTasks[matchingKey];
-    }
   };
-
 }

package/src/sync/polling/pollingManagerSS.ts

@@ -3,57 +3,61 @@ import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { IPollingManager, ISegmentsSyncTask, IDefinitionsSyncTask } from './types';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IDefinitionChangesFetcher, ISegmentChangesFetcher } from './fetchers/types';
+import { segmentChangesFetcherFactory } from './fetchers/segmentChangesFetcher';
+import { splitChangesFetcherFactory } from './fetchers/splitChangesFetcher';
 
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
 export function pollingManagerSSFactory(
-  params: ISdkFactoryContextSync,
-  definitionChangesFetcher: IDefinitionChangesFetcher,
-  segmentChangesFetcher: ISegmentChangesFetcher
-): IPollingManager {
-
-  const { storage, readiness, settings } = params;
-  const log = settings.log;
-
-  const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
-  const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
-
-  return {
-    definitionsSyncTask,
-    segmentsSyncTask,
-
-    // Start periodic fetching (polling)
-    start() {
-      log.info(POLLING_START);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `${definitionChangesFetcher.type} will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
-      log.debug(LOG_PREFIX_SYNC_POLLING + `segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
-
-      const startingUp = definitionsSyncTask.start();
-      if (startingUp) {
-        startingUp.then(() => {
-          if (definitionsSyncTask.isRunning()) segmentsSyncTask.start();
+  definitionFetcherFactory = splitChangesFetcherFactory,
+  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges)
+): (params: ISdkFactoryContextSync) => IPollingManager {
+
+  return function (params: ISdkFactoryContextSync): IPollingManager {
+    const { storage, readiness, settings } = params;
+    const log = settings.log;
+
+    const definitionChangesFetcher = definitionFetcherFactory(params);
+    const segmentChangesFetcher = segmentFetcherFactory(params);
+    const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
+    const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
+
+    return {
+      definitionsSyncTask,
+      segmentsSyncTask,
+
+      // Start periodic fetching (polling)
+      start() {
+        log.info(POLLING_START);
+        log.debug(LOG_PREFIX_SYNC_POLLING + `${definitionChangesFetcher.type} will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
+        log.debug(LOG_PREFIX_SYNC_POLLING + `segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
+
+        const startingUp = definitionsSyncTask.start();
+        if (startingUp) {
+          startingUp.then(() => {
+            if (definitionsSyncTask.isRunning()) segmentsSyncTask.start();
+          });
+        }
+      },
+
+      // Stop periodic fetching (polling)
+      stop() {
+        log.info(POLLING_STOP);
+
+        if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
+        if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop();
+      },
+
+      // Used by SyncManager to know if running in polling mode.
+      isRunning: definitionsSyncTask.isRunning,
+
+      syncAll() {
+        // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+        return definitionsSyncTask.execute().then(() => {
+          return segmentsSyncTask.execute();
         });
       }
-    },
-
-    // Stop periodic fetching (polling)
-    stop() {
-      log.info(POLLING_STOP);
-
-      if (definitionsSyncTask.isRunning()) definitionsSyncTask.stop();
-      if (segmentsSyncTask.isRunning()) segmentsSyncTask.stop();
-    },
-
-    // Used by SyncManager to know if running in polling mode.
-    isRunning: definitionsSyncTask.isRunning,
-
-    syncAll() {
-      // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
-      return definitionsSyncTask.execute().then(() => {
-        return segmentsSyncTask.execute();
-      });
-    }
+    };
   };
 }

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -47,7 +47,7 @@ export function segmentChangesUpdaterFactory(
         false :
         segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
           return Promise.all(changes.map(x => {
-            log.debug(`${LOG_PREFIX_SYNC}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
+            log.debug(`${LOG_PREFIX_SYNC}Processing ${segmentName} with since = ${x.since} and till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
             return segments.update(segmentName, x.added, x.removed, x.till);
           })).then((updates) => {
             return updates.some(update => update);

package/src/sync/submitters/impressionsSubmitter.ts

@@ -1,14 +1,14 @@
 import { groupBy, forOwn } from '../../utils/lang';
 import SplitIO from '../../../types/splitio';
 import { submitterFactory } from './submitter';
-import { ImpressionsPayload } from './types';
+import { EntityType, ImpressionsPayload } from './types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * Converts `impressions` data from cache into request payload.
  */
-export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.ImpressionDTO[]): ImpressionsPayload {
+export function fromImpressionsCollector(sendLabels: boolean, data: (SplitIO.ImpressionDTO & { entityType?: EntityType })[]): ImpressionsPayload {
   let groupedByFeature = groupBy(data, 'feature');
   let dto: ImpressionsPayload = [];
 
@@ -25,7 +25,7 @@ export function fromImpressionsCollector(sendLabels: boolean, data: SplitIO.Impr
           b: entry.bucketingKey, // Bucketing Key
           pt: entry.pt, // Previous time
           properties: entry.properties, // Properties
-          // @ts-expect-error - entityType is not yet public. @TODO: add to SplitIO.ImpressionDTO type
+          // @TODO: add entityType to public SplitIO.ImpressionDTO type
           et: entry.entityType, // Definition type
         };
       })

package/src/sync/submitters/types.ts

@@ -3,7 +3,7 @@ import { IMetadata } from '../../dtos/types';
 import SplitIO from '../../../types/splitio';
 import { ISyncTask } from '../types';
 
-type EntityType = 'config' | 'flag' | 'ai-config';
+export type EntityType = 'config' | 'flag' | 'ai-config';
 
 type ImpressionPayload = {
   /** Matching Key */
@@ -15,7 +15,7 @@ type ImpressionPayload = {
   /** Timestamp */
   m: number;
   /** Change number */
-  c: number;
+  c?: number;
   /** Rule label */
   r?: string;
   /** Previous time */

package/src/sync/syncManagerOnline.ts

@@ -11,9 +11,6 @@ import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
 import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
 import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
-import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
-import { IDefinitionChangesFetcher, ISegmentChangesFetcher } from './polling/fetchers/types';
-import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
 
 /**
  * Online SyncManager factory.
@@ -22,13 +19,10 @@ 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?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher, segmentChangesFetcher: ISegmentChangesFetcher) => IPollingManager,
+  pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
-  definitionFetcherFactory = splitChangesFetcherFactory,
-  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.serviceApi.fetchSegmentChanges)
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -39,7 +33,7 @@ export function syncManagerOnlineFactory(
     const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
     const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?

package/types/splitio.d.ts

@@ -1031,9 +1031,10 @@ declare namespace SplitIO {
      */
     label: string;
     /**
-     * Version of the feature flag
+     * Version of the feature flag.
+     * Undefined if the feature flag was not found, for example, if the label is 'not ready', 'exception' or 'definition not found'.
      */
-    changeNumber: number;
+    changeNumber?: number;
     /**
      * Previous time
      */