@splitsoftware/splitio-commons 3.0.1-rc.2 → 3.1.0

package/CHANGES.txt

@@ -1,5 +1,6 @@
-3.1.0 (July XX, 2026)
+3.1.0 (July 23, 2026)
  - Added support for rule-based segments in /api/v1/configs endpoint.
+ - Updated polling flow to fetch new referenced segments immediately.
 
 3.0.0 (June 26, 2026)
  - Extracted SDK lifecycle methods (`init`, `flush`, and `destroy`) into a reusable `sdkLifecycle` module.

package/cjs/evaluator/condition/index.js

@@ -10,7 +10,7 @@ function match(log, matchingResult, bucketingKey, seed, treatments, label) {
         return treatments ? // Feature flag
             {
                 treatment: (0, engineUtils_1.getTreatment)(log, bucketingKey, seed, treatments),
-                label: label
+                label: label !== null && label !== void 0 ? label : ''
             } : // Rule-based segment
             true;
     }

package/cjs/sync/polling/pollingManagerCS.js

@@ -15,7 +15,7 @@ var AbstractDefinitionsCacheSync_1 = require("../../storages/AbstractDefinitions
 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, true);
+    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);

package/cjs/sync/polling/pollingManagerSS.js

@@ -10,8 +10,8 @@ var constants_1 = require("../../logger/constants");
 function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
     var storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings);
     var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(segmentChangesFetcher, storage, readiness, settings);
+    var definitionsSyncTask = (0, definitionsSyncTask_1.definitionsSyncTaskFactory)(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
     return {
         definitionsSyncTask: definitionsSyncTask,
         segmentsSyncTask: segmentsSyncTask,

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

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

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

@@ -8,16 +8,6 @@ var lang_1 = require("../../../utils/lang");
 var constants_3 = require("../../../utils/constants");
 var sets_1 = require("../../../utils/lang/sets");
 var constants_4 = require("../../streaming/constants");
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments) {
-    var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-    return registeredSegments.then(function (segmentNames) {
-        return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
-    });
-}
 /**
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
@@ -106,7 +96,8 @@ function convertInstantUpdateToDefinitionChanges(instantUpdate) {
  * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` or `/configs` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, definitionsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, definitionsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, segmentsSyncTask // undefined for client-side
+) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
     var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments;
@@ -168,8 +159,8 @@ function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage,
                         storage.save();
                     startingUp = false;
                     if (definitionsEventEmitter) {
-                        // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
+                        // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must wait for all registered segments to be fetched
+                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

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

@@ -66,7 +66,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
-                    if (readiness) {
+                    if (readiness && !fetchOnlyNew) {
                         var metadata = {
                             type: constants_1.SEGMENTS_UPDATE,
                             names: []

package/cjs/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.js

@@ -11,7 +11,7 @@ var constants_5 = require("./constants");
 /**
  * DefinitionsUpdateWorker factory
  */
-function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker, segmentsSyncTask) {
+function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker) {
     var ff = DefinitionsUpdateWorker(storage.definitions);
     var rbs = DefinitionsUpdateWorker(storage.rbSegments);
     function DefinitionsUpdateWorker(cache) {
@@ -35,9 +35,6 @@ function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsE
                     else {
                         if (instantUpdate)
                             telemetryTracker.trackUpdatesFromSSE(constants_3.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."));

package/cjs/sync/streaming/pushManager.js

@@ -46,7 +46,7 @@ function pushManagerFactory(params, pollingManager) {
     // 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 DefinitionsUpdateWorker to fetch new segments
-    var definitionsUpdateWorker = (0, DefinitionsUpdateWorker_1.DefinitionsUpdateWorker)(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var definitionsUpdateWorker = (0, DefinitionsUpdateWorker_1.DefinitionsUpdateWorker)(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
     // [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.

package/esm/evaluator/condition/index.js

@@ -7,7 +7,7 @@ function match(log, matchingResult, bucketingKey, seed, treatments, label) {
         return treatments ? // Feature flag
             {
                 treatment: getTreatment(log, bucketingKey, seed, treatments),
-                label: label
+                label: label !== null && label !== void 0 ? label : ''
             } : // Rule-based segment
             true;
     }

package/esm/sync/polling/pollingManagerCS.js

@@ -12,7 +12,7 @@ import { usesSegmentsSync } from '../../storages/AbstractDefinitionsCacheSync';
 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, true);
+    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = getMatching(settings.core.key);

package/esm/sync/polling/pollingManagerSS.js

@@ -7,8 +7,8 @@ import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logg
 export function pollingManagerSSFactory(params, definitionChangesFetcher, segmentChangesFetcher) {
     var storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
     var segmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
+    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
     return {
         definitionsSyncTask: definitionsSyncTask,
         segmentsSyncTask: segmentsSyncTask,

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

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

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

@@ -5,16 +5,6 @@ import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
 import { SPLIT_UPDATE } from '../../streaming/constants';
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments) {
-    var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-    return registeredSegments.then(function (segmentNames) {
-        return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
-    });
-}
 /**
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
@@ -101,7 +91,8 @@ function convertInstantUpdateToDefinitionChanges(instantUpdate) {
  * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` or `/configs` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, definitionsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, storage, splitFiltersValidation, definitionsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, segmentsSyncTask // undefined for client-side
+) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
     var definitions = storage.definitions, rbSegments = storage.rbSegments, segments = storage.segments;
@@ -163,8 +154,8 @@ export function definitionChangesUpdaterFactory(log, definitionChangesFetcher, s
                         storage.save();
                     startingUp = false;
                     if (definitionsEventEmitter) {
-                        // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
+                        // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must wait for all registered segments to be fetched
+                        return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

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

@@ -63,7 +63,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
-                    if (readiness) {
+                    if (readiness && !fetchOnlyNew) {
                         var metadata = {
                             type: SEGMENTS_UPDATE,
                             names: []

package/esm/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.js

@@ -8,7 +8,7 @@ import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES }
 /**
  * DefinitionsUpdateWorker factory
  */
-export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker, segmentsSyncTask) {
+export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, definitionsEventEmitter, telemetryTracker) {
     var ff = DefinitionsUpdateWorker(storage.definitions);
     var rbs = DefinitionsUpdateWorker(storage.rbSegments);
     function DefinitionsUpdateWorker(cache) {
@@ -32,9 +32,6 @@ export function DefinitionsUpdateWorker(log, storage, definitionsSyncTask, defin
                     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."));

package/esm/sync/streaming/pushManager.js

@@ -43,7 +43,7 @@ export function pushManagerFactory(params, pollingManager) {
     // 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, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
     // [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.

package/package.json

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

package/src/dtos/types.ts

@@ -192,7 +192,7 @@ export interface IDefinitionCondition {
     matchers: IDefinitionMatcher[]
   }
   partitions?: IDefinitionPartition[]
-  label?: string
+  label?: string | null
   conditionType?: 'ROLLOUT' | 'WHITELIST'
 }
 

package/src/evaluator/condition/index.ts

@@ -7,12 +7,12 @@ import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
 
 // Build Evaluation object if and only if matchingResult is true
-function match(log: ILogger, matchingResult: boolean, bucketingKey: string | undefined, seed?: number, treatments?: { getTreatmentFor: (x: number) => string }, label?: string): IEvaluation | boolean | undefined {
+function match(log: ILogger, matchingResult: boolean, bucketingKey: string | undefined, seed?: number, treatments?: { getTreatmentFor: (x: number) => string }, label?: string | null): IEvaluation | boolean | undefined {
   if (matchingResult) {
     return treatments ? // Feature flag
       {
         treatment: getTreatment(log, bucketingKey as string, seed, treatments),
-        label: label!
+        label: label ?? ''
       } : // Rule-based segment
       true;
   }
@@ -22,7 +22,7 @@ function match(log: ILogger, matchingResult: boolean, bucketingKey: string | und
 }
 
 // Condition factory
-export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.SplitKeyObject, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<boolean>, treatments?: { getTreatmentFor: (x: number) => string }, label?: string, conditionType?: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
+export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.SplitKeyObject, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<boolean>, treatments?: { getTreatmentFor: (x: number) => string }, label?: string | null, conditionType?: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
 
   return function conditionEvaluator(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) {
 

package/src/sync/polling/pollingManagerCS.ts

@@ -24,7 +24,7 @@ export function pollingManagerCSFactory(
   const { serviceApi, storage, readiness, settings } = params;
   const log = settings.log;
 
-  const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, true);
+  const definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
 
   // Map of matching keys to their corresponding MySegmentsSyncTask.
   const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};

package/src/sync/polling/pollingManagerSS.ts

@@ -17,8 +17,8 @@ export function pollingManagerSSFactory(
   const { storage, readiness, settings } = params;
   const log = settings.log;
 
-  const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
   const segmentsSyncTask: ISegmentsSyncTask = segmentsSyncTaskFactory(segmentChangesFetcher, storage, readiness, settings);
+  const definitionsSyncTask: IDefinitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, segmentsSyncTask);
 
   return {
     definitionsSyncTask,

package/src/sync/polling/syncTasks/definitionsSyncTask.ts

@@ -1,7 +1,7 @@
 import { IStorageSync } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { syncTaskFactory } from '../../syncTask';
-import { IDefinitionsSyncTask } from '../types';
+import { IDefinitionsSyncTask, ISegmentsSyncTask } from '../types';
 import { ISettings } from '../../../types';
 import { definitionChangesUpdaterFactory } from '../updaters/definitionChangesUpdater';
 import { IDefinitionChangesFetcher } from '../fetchers/types';
@@ -14,7 +14,7 @@ export function definitionsSyncTaskFactory(
   storage: IStorageSync,
   readiness: IReadinessManager,
   settings: ISettings,
-  isClientSide?: boolean
+  segmentsSyncTask?: ISegmentsSyncTask // undefined for client-side
 ): IDefinitionsSyncTask {
   return syncTaskFactory(
     settings.log,
@@ -26,7 +26,7 @@ export function definitionsSyncTaskFactory(
       readiness.definitions,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
-      isClientSide
+      segmentsSyncTask
     ),
     settings.scheduler.featuresRefreshRate,
     'definitionChangesUpdater',

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

@@ -1,4 +1,4 @@
-import { ISegmentsCacheBase, IStorageBase } from '../../../storages/types';
+import { IStorageBase } from '../../../storages/types';
 import { IDefinitionChangesFetcher } from '../fetchers/types';
 import { IRBSegment, IDefinition, IDefinitionChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
 import { IDefinitionsEventEmitter } from '../../../readiness/types';
@@ -12,21 +12,11 @@ import { setToArray } from '../../../utils/lang/sets';
 import { SPLIT_UPDATE } from '../../streaming/constants';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
 import { ISplit } from '../fetchers/splitChangesFetcher';
+import { ISegmentsSyncTask } from '../types';
 
 export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
 type DefinitionChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
 
-// Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
-// Returns a promise that could be rejected.
-// @TODO review together with Segments and MySegments storage APIs
-function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
-  let registeredSegments = Promise.resolve(segments.getRegisteredSegments());
-  return registeredSegments.then(segmentNames => {
-    return Promise.all(segmentNames.map(segmentName => segments.getChangeNumber(segmentName)))
-      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== undefined));
-  });
-}
-
 /**
  * Collect segments from a raw FF or RBS definition.
  * Exported for testing purposes.
@@ -133,7 +123,7 @@ export function definitionChangesUpdaterFactory(
   definitionsEventEmitter?: IDefinitionsEventEmitter,
   requestTimeoutBeforeReady = 0,
   retriesOnFailureBeforeReady = 0,
-  isClientSide?: boolean
+  segmentsSyncTask?: ISegmentsSyncTask // undefined for client-side
 ): DefinitionChangesUpdater {
   const { definitions, rbSegments, segments } = storage;
 
@@ -202,8 +192,8 @@ export function definitionChangesUpdaterFactory(
             startingUp = false;
 
             if (definitionsEventEmitter) {
-              // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
+              // To emit SDK_DEFINITIONS_ARRIVED for server-side SDK, we must wait for all registered segments to be fetched
+              return Promise.resolve(!definitionsEventEmitter.definitionsArrived || ((ffChanged || rbsChanged) && (!segmentsSyncTask || segmentsSyncTask.execute(true))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events

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

@@ -76,7 +76,7 @@ export function segmentChangesUpdaterFactory(
     log.debug(`${LOG_PREFIX_SYNC}Started segments update`);
 
     // If not a segment name provided, read list of available segments names to be updated.
-    let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
+    const segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
       const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0));
@@ -85,7 +85,7 @@ export function segmentChangesUpdaterFactory(
         // if at least one segment fetch succeeded, mark segments ready
         if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
           readyOnAlreadyExistentState = false;
-          if (readiness) {
+          if (readiness && !fetchOnlyNew) {
             const metadata: SdkUpdateMetadata = {
               type: SEGMENTS_UPDATE,
               names: []

package/src/sync/streaming/UpdateWorkers/DefinitionsUpdateWorker.ts

@@ -7,7 +7,7 @@ import { IRBSegmentsCacheSync, IDefinitionsCacheSync, IStorageSync } from '../..
 import { ITelemetryTracker } from '../../../trackers/types';
 import { Backoff } from '../../../utils/Backoff';
 import { SPLITS } from '../../../utils/constants';
-import { ISegmentsSyncTask, IDefinitionsSyncTask } from '../../polling/types';
+import { IDefinitionsSyncTask } from '../../polling/types';
 import { InstantUpdate } from '../../polling/updaters/definitionChangesUpdater';
 import { RB_SEGMENT_UPDATE } from '../constants';
 import { parseFFUpdatePayload } from '../parseUtils';
@@ -18,7 +18,7 @@ import { IUpdateWorker } from './types';
 /**
  * DefinitionsUpdateWorker factory
  */
-export function DefinitionsUpdateWorker(log: ILogger, storage: IStorageSync, definitionsSyncTask: IDefinitionsSyncTask, definitionsEventEmitter: IDefinitionsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData]> & { killDefinition(event: ISplitKillData): void } {
+export function DefinitionsUpdateWorker(log: ILogger, storage: IStorageSync, definitionsSyncTask: IDefinitionsSyncTask, definitionsEventEmitter: IDefinitionsEventEmitter, telemetryTracker: ITelemetryTracker): IUpdateWorker<[updateData: ISplitUpdateData]> & { killDefinition(event: ISplitKillData): void } {
 
   const ff = DefinitionsUpdateWorker(storage.definitions);
   const rbs = DefinitionsUpdateWorker(storage.rbSegments);
@@ -42,8 +42,6 @@ export function DefinitionsUpdateWorker(log: ILogger, storage: IStorageSync, def
             __handleDefinitionUpdateCall();
           } else {
             if (instantUpdate) telemetryTracker.trackUpdatesFromSSE(SPLITS);
-            // fetch new registered segments for server-side API. Not retrying on error
-            if (segmentsSyncTask) segmentsSyncTask.execute(true);
 
             const attempts = backoff.attempts + 1;
 

package/src/sync/streaming/pushManager.ts

@@ -56,7 +56,7 @@ export function pushManagerFactory(
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
   const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by DefinitionsUpdateWorker to fetch new segments
-  const definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  const definitionsUpdateWorker = DefinitionsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.definitions, telemetryTracker);
 
   // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};