@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.11

package/CHANGES.txt

@@ -1,6 +1,10 @@
-3.2.0 (August 10, 2026)
+3.2.0 (XXX XX, 2026)
  - Added support for AI configs.
+ - Added support for ioredis v6 (Related to issue https://github.com/splitio/javascript-client/issues/951). Note that ioredis v6 requires Node.js 20 or above; stay on ioredis v4 or v5 for older Node.js versions.
+ - Removed the `@types/ioredis` dependency, which is no longer required since the public type definitions don't depend on ioredis types. The `@types/node` dependency, previously installed transitively by `@types/ioredis`, is now declared explicitly, since the public type definitions use Node.js types for the `agent` and `tls` options.
  - Removed Configs SDK-related types and modules and moved them to the Configs SDK repository.
+ - Bugfix - Fixed a memory leak in the `Backoff` utility, where promises returned by pending scheduled calls were never settled when the backoff was reset.
+ - Bugfix - Fixed the authentication service to not send unauthenticated requests when the SDK is destroyed while an authentication retry is pending.
 
 3.1.0 (July 23, 2026)
  - Added support for rule-based segments in /api/v1/configs endpoint.
@@ -20,6 +24,13 @@
  - Removed the misleading warning log 'No listeners for SDK_READY event detected', since users can use the `whenReady` method to wait for the SDK to be ready.
  - BREAKING CHANGES: Renamed some types and modules, and updated the signatures of others for clarity and reusability.
 
+2.13.0 (September 24, 2026)
+ - Added support for ioredis v6 (Related to issue https://github.com/splitio/javascript-client/issues/951). Note that ioredis v6 requires Node.js 20 or above; stay on ioredis v4 or v5 for older Node.js versions.
+ - Removed the `@types/ioredis` dependency, which is no longer required since the public type definitions don't depend on ioredis types. The `@types/node` dependency, previously installed transitively by `@types/ioredis`, is now declared explicitly, since the public type definitions use Node.js types for the `agent` and `tls` options.
+
+2.12.2 (September 23, 2026)
+ - Updated some transitive dependencies for vulnerability fixes.
+
 2.12.1 (June 25, 2026)
  - Updated internal modules to handle `null` values from `/splitChanges` response.
  - Updated some dependencies for vulnerability fixes.

package/cjs/evaluator/index.js

@@ -25,6 +25,12 @@ function treatmentsException(definitionNames) {
     });
     return evaluations;
 }
+function setEvaluationDataFromDefinition(evaluation, definition) {
+    return (0, objectAssign_1.objectAssign)(evaluation, {
+        definition: definition,
+        config: definition.configurations && definition.configurations[evaluation.treatment] || null
+    });
+}
 function evaluateFeature(log, key, definitionName, attributes, storage) {
     var definition;
     try {
@@ -98,8 +104,8 @@ function getEvaluation(log, key, definition, attributes, storage) {
         var split = (0, Engine_1.engineParser)(log, definition, storage);
         var evaluation = split.getTreatment(key, attributes, evaluateFeature);
         return (0, thenable_1.thenable)(evaluation) ?
-            evaluation.then(function (result) { return (0, objectAssign_1.objectAssign)(result, { definition: definition }); }) :
-            (0, objectAssign_1.objectAssign)(evaluation, { definition: definition });
+            evaluation.then(function (result) { return setEvaluationDataFromDefinition(result, definition); }) :
+            setEvaluationDataFromDefinition(evaluation, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;
 }
@@ -131,11 +137,10 @@ function evaluateDefaultTreatment(definitionName, storage) {
 exports.evaluateDefaultTreatment = evaluateDefaultTreatment;
 function getDefaultTreatment(definition) {
     if (definition) {
-        return {
+        return setEvaluationDataFromDefinition({
             treatment: definition.defaultTreatment,
-            label: labels_1.NO_CONDITION_MATCH,
-            definition: definition,
-        };
+            label: labels_1.NO_CONDITION_MATCH, // "default rule"
+        }, definition);
     }
     return EVALUATION_DEFINITION_NOT_FOUND;
 }

package/cjs/presets/serverSide.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serverSideModules = void 0;
-var serviceApi_1 = require("../services/serviceApi");
+var splitApi_1 = require("../services/splitApi");
 var syncManagerOnline_1 = require("../sync/syncManagerOnline");
 var pushManager_1 = require("../sync/streaming/pushManager");
 var pollingManagerSS_1 = require("../sync/polling/pollingManagerSS");
@@ -9,10 +9,10 @@ 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,
+    serviceApiFactory: splitApi_1.splitApiFactory,
     syncManagerFactory: syncManagerOnlineSSFactory,
     sdkManagerFactory: sdkManager_1.sdkManagerFactory,
     sdkClientMethodFactory: sdkClientMethod_1.sdkClientMethodFactory,

package/cjs/sdkClient/client.js

@@ -112,13 +112,11 @@ function clientFactory(params) {
     }
     // Internal function
     function processEvaluation(evaluation, featureFlagName, key, withConfig, invokingMethodName, queue, options) {
-        var _a;
         if (options === void 0) { options = {}; }
         var matchingKey = (0, key_1.getMatching)(key);
         var bucketingKey = (0, key_1.getBucketing)(key);
         var definition = evaluation.definition;
-        var treatment = evaluation.treatment, label = evaluation.label;
-        var config = ((_a = definition === null || definition === void 0 ? void 0 : definition.configurations) === null || _a === void 0 ? void 0 : _a[treatment]) || null;
+        var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === constants_1.CONTROL) {
             var fallbackTreatment = fallbackCalculator(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
@@ -135,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/sdkClient/sdkLifecycle.js

@@ -61,6 +61,8 @@ function sdkLifecycleFactory(params, isSharedClient) {
             }
             // Stop background jobs
             syncManager && syncManager.stop();
+            // Stop the service API (the auth provider backoff retries specifically) before flushing,
+            // so that a pending/never-resolved auth retry doesn't block the flush forever
             serviceApi && serviceApi.stop();
             return __flush().then(function () {
                 // Cleanup storage

package/cjs/services/authProvider.js

@@ -9,32 +9,35 @@ var SKEW_SECONDS = 30;
 function isExpired(credential) {
     return Date.now() / 1000 + SKEW_SECONDS >= credential.decodedToken.exp;
 }
+function noCachedCredentialError() {
+    return new Error(constants_1.LOG_PREFIX_SYNC_AUTH + 'stopped without a cached credential');
+}
 /**
  * Factory of AuthProvider, which provides JWT credentials for authenticated HTTP requests.
  * Credentials are fetched lazily on demand, cached in memory, and retried with backoff on failure.
  */
 function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
     var urls = settings.urls, log = settings.log;
-    function fetchAuth() {
+    var fetchAuth = (0, AuthClient_1.fetchAuthFactory)(function () {
         var url = "".concat(urls.auth, "/api/v3/auth?capabilities=config,aiconfig");
         return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_2.TOKEN), false, true);
-    }
-    var authenticate = (0, AuthClient_1.authenticateFactory)(fetchAuth);
+    });
     var backoff = new Backoff_1.Backoff(fetchCredential);
     var cachedCredential;
     var inFlightPromise;
     var stopped = false;
     function fetchCredential() {
-        return authenticate().then(function (credential) {
+        return fetchAuth().then(function (credential) {
             log.info(constants_1.LOG_PREFIX_SYNC_AUTH + 'credential fetched successfully');
             cachedCredential = credential;
             inFlightPromise = undefined;
             backoff.reset();
             return credential;
         }).catch(function (error) {
-            // Avoid rejected promises and unnecessary retries after stop()
+            // Avoid unnecessary retries after stop(): fall back to any cached credential, or reject
+            // (never resolve with `undefined`, which callers would otherwise send as an unauthenticated request).
             if (stopped)
-                return cachedCredential;
+                return cachedCredential || Promise.reject(noCachedCredentialError());
             if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
                 log.error(constants_1.LOG_PREFIX_SYNC_AUTH + 'non-retryable error fetching credential (status ' + error.statusCode + '): ' + error.message);
                 inFlightPromise = undefined;
@@ -49,18 +52,28 @@ function authProviderFactory(settings, splitHttpClient, telemetryTracker) {
             if (cachedCredential && !isExpired(cachedCredential)) {
                 return Promise.resolve(cachedCredential);
             }
+            // Reuse any fetch already in flight (e.g. one started just before stop()), instead of firing a redundant one.
+            if (inFlightPromise)
+                return inFlightPromise;
+            // No cached credential to fall back to and stopped: reject so callers don't send an unauthenticated request.
+            if (stopped && !cachedCredential) {
+                return Promise.reject(noCachedCredentialError());
+            }
             if (cachedCredential)
                 log.debug(constants_1.LOG_PREFIX_SYNC_AUTH + 'cached credential expired');
-            return inFlightPromise || (inFlightPromise = fetchCredential());
+            // If stopped, this is a last, bounded refetch: fetchCredential()'s catch short-circuits (no backoff retry)
+            // once stopped, so it's a single attempt that falls back to the stale cached credential on failure.
+            return inFlightPromise = fetchCredential();
         },
         invalidate: function () {
             cachedCredential = undefined;
         },
         stop: function () {
             stopped = true;
-            cachedCredential = undefined;
-            inFlightPromise = undefined;
-            backoff.reset();
+            // Keep any in-flight fetch and already-cached credential usable (e.g. by a final flush on destroy).
+            // If a retry is only pending (not actively in flight), settle it immediately instead of waiting out the
+            // backoff delay: with the cached credential if there is one, or rejected otherwise.
+            backoff.reset(cachedCredential ? { value: cachedCredential } : { error: noCachedCredentialError() });
         }
     };
 }

package/cjs/services/secureSplitHttpClient.js

@@ -2,31 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.secureSplitHttpClientFactory = void 0;
 var tslib_1 = require("tslib");
-var splitHttpClient_1 = require("./splitHttpClient");
-var authProvider_1 = require("./authProvider");
 /**
  * Factory of Secure HTTP client, which authenticates requests using a JWT token.
  * On 401 responses, invalidates the cached credential and retries once with a fresh token.
  *
- * @param settings - SDK settings
- * @param platform - object containing environment-specific dependencies
- * @param fetchAuth - function to fetch auth credentials from the /v2/auth endpoint
+ * @param splitHttpClient - `splitHttpClientFactory` to use for making requests
+ * @param authProvider - `authProviderFactory` to use for authentication
  */
-function secureSplitHttpClientFactory(settings, platform, telemetryTracker) {
-    var splitHttpClient = (0, splitHttpClient_1.splitHttpClientFactory)(settings, platform);
-    var authProvider = (0, authProvider_1.authProviderFactory)(settings, splitHttpClient, telemetryTracker);
-    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
-        return splitHttpClient(url, tslib_1.__assign(tslib_1.__assign({}, options), { headers: tslib_1.__assign(tslib_1.__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
+function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, token) {
+        return splitHttpClient(url, token ? tslib_1.__assign(tslib_1.__assign({}, options), { headers: tslib_1.__assign(tslib_1.__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }) : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
     }
-    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt) {
+        if (newVersionHeader === void 0) { newVersionHeader = true; }
+        if (useJwt === void 0) { useJwt = true; }
         return authProvider.credential().then(function (credential) {
-            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
                 .catch(function (error) {
                 if (error.statusCode === 401) {
                     // retry once for 401, in case the token has just expired
                     authProvider.invalidate();
                     return authProvider.credential().then(function (newCredential) {
-                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
                     });
                 }
                 throw error;

package/cjs/services/serviceApi.js

@@ -5,25 +5,36 @@ var splitHttpClient_1 = require("./splitHttpClient");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
+var authProvider_1 = require("./authProvider");
+var secureSplitHttpClient_1 = require("./secureSplitHttpClient");
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
-function userKeyToQueryParam(userKey) {
-    return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
-}
 /**
  * Factory of ServiceApi objects, which group the collection of HTTP endpoints used by the SDKs
  *
  * @param settings - validated settings object
  * @param platform - object containing environment-specific dependencies
  * @param telemetryTracker - telemetry tracker
- * @param secureSplitHttpClientFactory - factory of SecureSplitHttpClient objects
  */
-function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttpClientFactory) {
+function serviceApiFactory(settings, platform, telemetryTracker) {
     var urls = settings.urls;
     var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = (0, splitHttpClient_1.splitHttpClientFactory)(settings, platform);
-    var secureSplitHttpClient = secureSplitHttpClientFactory(settings, platform, telemetryTracker);
+    // Shared authProvider so that the SSE authentication (via `fetchAuth`,
+    // used by `pushManager`) and every authenticated HTTP request to the Configs
+    // API reuse the same cached credential instead of each fetching their own.
+    var authProvider = (0, authProvider_1.authProviderFactory)(settings, splitHttpClient, telemetryTracker);
+    var secureSplitHttpClient = (0, secureSplitHttpClient_1.secureSplitHttpClientFactory)(splitHttpClient, authProvider);
+    var initialAuth = true;
     return {
+        fetchAuth: function () {
+            // Guard condition to avoid invalidating the cached credential on the first pushManager authentication
+            if (initialAuth)
+                initialAuth = false;
+            else
+                authProvider.invalidate();
+            return authProvider.credential();
+        },
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = "".concat(urls.sdk, "/api/version");
@@ -33,15 +44,6 @@ function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttp
             var url = "".concat(urls.events, "/api/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
-        fetchAuth: function (userMatchingKeys) {
-            var url = "".concat(urls.auth, "/api/v2/auth?s=").concat(settings.sync.flagSpecVersion);
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.TOKEN));
-        },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
             var url = "".concat(urls.sdk, "/api/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SPLITS))
@@ -82,7 +84,7 @@ function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttp
          */
         postEventsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/events/bulk");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.EVENTS));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.EVENTS), false, false, false);
         },
         /**
          * Post impressions.
@@ -92,12 +94,12 @@ function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttp
          */
         postTestImpressionsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/bulk");
-            return splitHttpClient(url, {
+            return secureSplitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
                 body: body,
                 headers: (0, objectAssign_1.objectAssign)({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS));
+            }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS), false, false, false);
         },
         /**
          * Post impressions counts.
@@ -107,7 +109,7 @@ function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttp
          */
         postTestImpressionsCount: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/count");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS_COUNT));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS_COUNT), false, false, false);
         },
         /**
          * Post unique keys for client side.
@@ -117,7 +119,7 @@ function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttp
          */
         postUniqueKeysBulkCs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/cs");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), false, false, false);
         },
         /**
          * Post unique keys for server side.
@@ -127,7 +129,7 @@ function serviceApiFactory(settings, platform, telemetryTracker, secureSplitHttp
          */
         postUniqueKeysBulkSs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/ss");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), false, false, false);
         },
         postMetricsConfig: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/metrics/config");

package/cjs/services/splitApi.js

@@ -5,6 +5,7 @@ var splitHttpClient_1 = require("./splitHttpClient");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
+var AuthClient_1 = require("../sync/streaming/AuthClient");
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
@@ -23,6 +24,15 @@ function splitApiFactory(settings, platform, telemetryTracker) {
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
     var splitHttpClient = (0, splitHttpClient_1.splitHttpClientFactory)(settings, platform);
     return {
+        fetchAuth: (0, AuthClient_1.fetchAuthFactory)(function (userMatchingKeys) {
+            var url = "".concat(urls.auth, "/v2/auth?s=").concat(settings.sync.flagSpecVersion);
+            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
+                if (queryParams)
+                    url += '&' + queryParams;
+            }
+            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.TOKEN));
+        }),
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
             var url = "".concat(urls.sdk, "/version");
@@ -32,15 +42,6 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             var url = "".concat(urls.events, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
-        fetchAuth: function (userMatchingKeys) {
-            var url = "".concat(urls.auth, "/v2/auth?s=").concat(settings.sync.flagSpecVersion);
-            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
-                var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams)
-                    url += '&' + queryParams;
-            }
-            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(constants_1.TOKEN));
-        },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
             var url = "".concat(urls.sdk, "/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SPLITS))

package/cjs/storages/inRedis/RedisAdapter.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisAdapter = void 0;
 var tslib_1 = require("tslib");
 // Dynamically require ioredis to prevent strict TypeScript binding
-// and handle module export differences between v4 and v5.
+// and handle module export differences between v4 and later major versions.
 var RedisConstructor;
 try {
     var ioredisLib = require('ioredis');
@@ -11,7 +11,7 @@ try {
 }
 catch (e) {
     // If we reach here, the peer dependency is missing
-    throw new Error('ioredis is missing. Please install ioredis v4 or v5.');
+    throw new Error('ioredis is missing. Please install ioredis v4, v5 or v6.');
 }
 var lang_1 = require("../../utils/lang");
 var thenable_1 = require("../../utils/promise/thenable");
@@ -31,13 +31,16 @@ var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
     lazyConnect: false,
-    // CRITICAL: v5 defaults this to 0 (disabled), which breaks dynamic clusters.
-    // v4 defaulted to 5000. We explicitly set it here to ensure v5 works like v4.
+    // CRITICAL: v5 and v6 default this to 0 (disabled), which breaks dynamic clusters.
+    // v4 defaulted to 5000. We explicitly set it here to ensure v5 and v6 work like v4.
     slotsRefreshInterval: 5000,
+    // v6 defaults to RESP3 (`protocol: 3`). The SDK doesn't use any RESP3 feature,
+    // so we stick to RESP2 to keep the v4 and v5 behavior. Ignored by v4 and v5.
+    protocol: 2,
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- * Refactored to use Composition instead of Inheritance to support both v4 and v5.
+ * Refactored to use Composition instead of Inheritance to support v4, v5 and v6.
  */
 var RedisAdapter = /** @class */ (function () {
     function RedisAdapter(log, storageSettings) {

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;