@splitsoftware/splitio-commons 3.0.0-rc.0 → 3.0.0-rc.2

package/src/sync/streaming/constants.ts

@@ -6,7 +6,7 @@ export const SECONDS_BEFORE_EXPIRATION = 600;
  * emitted on SSE and Authenticate non-recoverable errors, STREAMING_DISABLED control notification and authentication with pushEnabled false
  * triggers `handleNonRetryableError` call
  */
-export const PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
+export const PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR';
 /**
  * emitted on SSE and Authenticate recoverable errors
  * triggers `handleRetryableError` call
@@ -19,7 +19,7 @@ export const PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
 export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 
 /**
- * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NONRETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
+ * emitted on STREAMING_PAUSED control notification, OCCUPANCY equal to 0, PUSH_NON_RETRYABLE_ERROR and PUSH_RETRYABLE_ERROR events.
  * triggers `startPolling` and `stopWorkers` calls
  */
 export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';

package/src/sync/streaming/pushManager.ts

@@ -6,17 +6,17 @@ import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
 import { MySegmentsUpdateWorker } from './UpdateWorkers/MySegmentsUpdateWorker';
 import { SegmentsUpdateWorker } from './UpdateWorkers/SegmentsUpdateWorker';
-import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
+import { DefinitionsUpdateWorker } from './UpdateWorkers/DefinitionsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { checkIfServerSide, getMatching } from '../../utils/key';
-import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NON_RETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseCompressedData } from './parseUtils';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
-import { IAuthTokenPushEnabled } from './AuthClient/types';
+import { IJwtCredentialV2 } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -55,8 +55,8 @@ export function pushManagerFactory(
   // init workers
   // 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 SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = SplitsUpdateWorker(log, storage, pollingManager.definitionsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
+  // 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);
 
   // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
@@ -67,10 +67,10 @@ export function pushManagerFactory(
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
 
-  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
+  // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NON_RETRYABLE_ERROR error.
   // It is used to halt the `connectPush` process if it was in progress.
   let disconnected: boolean | undefined;
-  // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+  // flag that indicates a PUSH_NON_RETRYABLE_ERROR, condition with which starting pushManager again is ignored.
   // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
   let disabled: boolean | undefined; // `disabled` implies `disconnected === true`
 
@@ -81,7 +81,7 @@ export function pushManagerFactory(
   let timeoutIdTokenRefresh: ReturnType<typeof setTimeout>;
   let timeoutIdSseOpen: ReturnType<typeof setTimeout>;
 
-  function scheduleTokenRefreshAndSse(authData: IAuthTokenPushEnabled) {
+  function scheduleTokenRefreshAndSse(authData: IJwtCredentialV2) {
     // clear scheduled tasks if exist
     if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
     if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
@@ -117,11 +117,11 @@ export function pushManagerFactory(
       function (authData) {
         if (disconnected) return;
 
-        // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+        // 'pushEnabled: false' is handled as a PUSH_NON_RETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
         // close the sseClient in case the org has been bloqued while the instance was connected to streaming
         if (!authData.pushEnabled) {
           log.info(STREAMING_DISABLED);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
           return;
         }
 
@@ -140,7 +140,7 @@ export function pushManagerFactory(
         // Handle 4XX HTTP errors: 401 (invalid SDK Key) or 400 (using incorrect SDK Key, i.e., client-side SDK Key on server-side)
         if (error.statusCode >= 400 && error.statusCode < 500) {
           telemetryTracker.streamingEvent(AUTH_REJECTION);
-          pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+          pushEmitter.emit(PUSH_NON_RETRYABLE_ERROR);
           return;
         }
 
@@ -168,7 +168,7 @@ export function pushManagerFactory(
 
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
-    splitsUpdateWorker.stop();
+    definitionsUpdateWorker.stop();
     if (userKey) forOwn(clients, ({ worker }) => worker.stop());
     else segmentsUpdateWorker!.stop();
   }
@@ -183,7 +183,7 @@ export function pushManagerFactory(
 
   /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
 
-  pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+  pushEmitter.on(PUSH_NON_RETRYABLE_ERROR, function handleNonRetryableError() {
     disabled = true;
     // Note: `stopWorkers` is been called twice, but it is not harmful
     disconnectPush();
@@ -218,9 +218,9 @@ export function pushManagerFactory(
 
   /** Functions related to synchronization (Queues and Workers in the spec) */
 
-  pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-  pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
-  pushEmitter.on(RB_SEGMENT_UPDATE, splitsUpdateWorker.put);
+  pushEmitter.on(SPLIT_KILL, definitionsUpdateWorker.killDefinition);
+  pushEmitter.on(SPLIT_UPDATE, definitionsUpdateWorker.put);
+  pushEmitter.on(RB_SEGMENT_UPDATE, definitionsUpdateWorker.put);
 
   function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
     switch (parsedData.u) {

package/src/sync/streaming/types.ts

@@ -7,7 +7,7 @@ import { ControlType } from './constants';
 // Internal SDK events, subscribed by SyncManager and PushManager
 export type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP'
 export type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
-export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+export type PUSH_NON_RETRYABLE_ERROR = 'PUSH_NON_RETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
@@ -22,7 +22,7 @@ export type RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE';
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NON_RETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | RB_SEGMENT_UPDATE | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
   T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData :

package/src/sync/submitters/telemetrySubmitter.ts

@@ -119,7 +119,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const { storage: { telemetry }, platform: { now } } = params;
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness } = params;
   const stopTimer = timer(now);
 
   const submitter = firstPushWindowDecorator(
@@ -135,7 +135,6 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
     telemetry.recordTimeUntilReadyFromCache(stopTimer());
   });
 
-  sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
     telemetry.recordTimeUntilReady(stopTimer());
 

package/src/sync/syncManagerOnline.ts

@@ -9,10 +9,11 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { ISdkFactoryContextSync } from '../sdkFactory/types';
-import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
-import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
+import { SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
 import { splitChangesFetcherFactory } from './polling/fetchers/splitChangesFetcher';
-import { IDefinitionChangesFetcher } from './polling/fetchers/types';
+import { IDefinitionChangesFetcher, ISegmentChangesFetcher } from './polling/fetchers/types';
+import { segmentChangesFetcherFactory } from './polling/fetchers/segmentChangesFetcher';
 
 /**
  * Online SyncManager factory.
@@ -24,9 +25,10 @@ import { IDefinitionChangesFetcher } from './polling/fetchers/types';
  * @param definitionChangesFetcherFactory - optional to replace the default split changes fetcher
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher) => IPollingManager,
+  pollingManagerFactory?: (params: ISdkFactoryContextSync, definitionChangesFetcher: IDefinitionChangesFetcher, segmentChangesFetcher: ISegmentChangesFetcher) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
-  definitionChangesFetcherFactory = splitChangesFetcherFactory
+  definitionFetcherFactory = splitChangesFetcherFactory,
+  segmentFetcherFactory = (params: ISdkFactoryContextSync) => segmentChangesFetcherFactory(params.splitApi.fetchSegmentChanges)
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -37,7 +39,7 @@ export function syncManagerOnlineFactory(
     const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } }, telemetryTracker, storage, readiness } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionChangesFetcherFactory(params));
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params, definitionFetcherFactory(params), segmentFetcherFactory(params));
 
     /** Push Manager */
     const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
@@ -45,7 +47,7 @@ export function syncManagerOnlineFactory(
       undefined;
 
     /** Submitter Manager */
-    // It is not inyected as push and polling managers, because at the moment it is required
+    // It is not injected as push and polling managers, because at the moment it is required
     const submitterManager = submitterManagerFactory(params);
 
     /** Sync Manager logic */
@@ -102,7 +104,7 @@ export function syncManagerOnlineFactory(
           if (startFirstTime) {
             // Emits SDK_READY_FROM_CACHE
             if (!cacheMetadata.initialCacheLoad) {
-              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+              readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, cacheMetadata);
             }
 
           }

package/src/utils/Backoff.ts

@@ -40,6 +40,27 @@ export class Backoff {
     return delayInMillis;
   }
 
+  /**
+   * Schedule a delayed call to `cb`
+   * @returns a promise that resolves/rejects with the result of the `cb` function, which must return a promise.
+   */
+  scheduleCallAsync<T>(): Promise<T> {
+    const delayInMillis = Math.min(this.baseMillis * Math.pow(2, this.attempts), this.maxMillis);
+
+    if (this.timeoutID) clearTimeout(this.timeoutID);
+    this.attempts++;
+
+    return new Promise<T>((resolve, reject) => {
+      this.timeoutID = setTimeout(() => {
+        this.timeoutID = undefined;
+        this.cb().then(resolve, reject);
+      }, delayInMillis);
+    });
+  }
+
+  /**
+   * Reset the backoff attempts
+   */
   reset() {
     this.attempts = 0;
     if (this.timeoutID) {

package/src/utils/inputValidation/trafficTypeExistence.ts

@@ -1,6 +1,6 @@
 import { thenable } from '../promise/thenable';
 import { LOCALHOST_MODE } from '../constants';
-import { ISplitsCacheBase } from '../../storages/types';
+import { IDefinitionsCacheBase } from '../../storages/types';
 import { IReadinessManager } from '../../readiness/types';
 import SplitIO from '../../../types/splitio';
 import { MaybeThenable } from '../../dtos/types';
@@ -14,7 +14,7 @@ function logTTExistenceWarning(log: ILogger, maybeTT: string, method: string) {
 /**
  * Separated from the previous method since on some cases it'll be async.
  */
-export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: ISplitsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
+export function validateTrafficTypeExistence(log: ILogger, readinessManager: IReadinessManager, splitsCache: IDefinitionsCacheBase, mode: SplitIO.SDKMode, maybeTT: string, method: string): MaybeThenable<boolean> {
 
   // If not ready or in localhost mode, we won't run the validation
   if (!readinessManager.isReady() || mode === LOCALHOST_MODE) return true;

package/src/utils/jwt/types.ts

@@ -1,6 +1,6 @@
 export interface IDecodedJWTToken {
   ['x-ably-capability']: string
-  exp: number
+  exp: number // epoch seconds
   iat: number
 
   /** Unused fields: */

package/src/utils/lang/sets.ts

@@ -12,6 +12,8 @@ export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
   return new Set(setToArray(set).concat(setToArray(set2)));
 }
 
-export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
-  return list.filter(item => list2.indexOf(item) === -1);
+export function returnDifference<T>(list1?: T[] | null, list2?: T[] | null): T[] {
+  list1 = list1 || [];
+  list2 = list2 || [];
+  return list1.filter(item => list2!.indexOf(item) === -1);
 }

package/src/utils/settingsValidation/index.ts

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

package/src/utils/settingsValidation/url.ts

@@ -1,9 +1,10 @@
 import { ISettings } from '../../types';
 
-const telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
+const telemetryEndpointMatcher = /^\/v1\/(metrics|keys)\/(config|usage|ss|cs)/;
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-const authEndpointMatcher = /^\/v2\/auth/;
+const authEndpointMatcher = /^\/(v2|v3)\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;
+const configsEndpointMatcher = /^\/v1\/(configs|segmentChanges)/;
 
 /**
  * Get URL based on a given target (path).
@@ -26,5 +27,8 @@ export function url(settings: ISettings, target: string) {
   if (streamingEndpointMatcher.test(target)) {
     return `${settings.urls.streaming}${target}`;
   }
+  if (configsEndpointMatcher.test(target)) {
+    return `${settings.urls.configs}${target}`;
+  }
   return `${settings.urls.sdk}${target}`;
 }

package/types/splitio.d.ts

@@ -495,7 +495,7 @@ declare namespace SplitIO {
   }
 
   /**
-   * Metadata for the update event emitted when the SDK cache is updated with new data for flags or segments.
+   * Metadata for the update event emitted when the SDK cache is updated with new data for flags, configs, or segments.
    */
   type SdkUpdateMetadata = {
     /**
@@ -503,7 +503,7 @@ declare namespace SplitIO {
      */
     type: SdkUpdateMetadataType;
     /**
-     * The names of the flags or segments that were updated.
+     * The names of the flags or configs that were updated. Empty array if the update is of type 'SEGMENTS_UPDATE'.
      */
     names: string[];
   }
@@ -644,6 +644,7 @@ declare namespace SplitIO {
       auth: string;
       streaming: string;
       telemetry: string;
+      configs: string;
     };
     readonly integrations?: IntegrationFactory[];
     readonly logger?: Logger;
@@ -2316,11 +2317,23 @@ declare namespace SplitIO {
      */
     authorizationKey: string;
     /**
-     * Configs definitions refresh rate for polling, in seconds.
+     * Polling rate for configs and segments refresh, in seconds. Minimum value: 5.
      *
      * @defaultValue `60`
      */
-    configsRefreshRate?: number;
+    pollingRate?: number;
+    /**
+     * Push rate for events and impressions, in seconds. Minimum value: 60.
+     *
+     * @defaultValue `60`
+     */
+    pushRate?: number;
+    /**
+     * Maximum queue size for events and impressions. When the queue reaches this size, a flush is triggered. Minimum value: 1000.
+     *
+     * @defaultValue `10000`
+     */
+    queueSize?: number;
     /**
      * Logging level.
      *
@@ -2338,11 +2351,17 @@ declare namespace SplitIO {
      */
     urls?: {
       /**
-       * String property to override the base URL where the SDK will get rollout plan related data, like feature flags and segments definitions.
+       * String property to override the base URL where the SDK will get JWT authentication credentials.
+       *
+       * @defaultValue `'https://auth.split.io/api'`
+       */
+      auth?: string;
+      /**
+       * String property to override the base URL where the SDK will get rollout plan related data, like configs and segments definitions.
        *
-       * @defaultValue `'https://appconfig.split.io/api'`
+       * @defaultValue `'https://configs.split.io/api'`
        */
-      sdk?: string;
+      configs?: string;
       /**
        * String property to override the base URL where the SDK will post event-related information like impressions.
        *
@@ -2449,7 +2468,7 @@ declare namespace SplitIO {
   /**
    * Configs SDK client interface.
    */
-  interface ConfigsClient extends IStatusInterface {
+  interface ConfigsClient extends Omit<IStatusInterface, 'ready'> {
     /**
      * Destroys the client.
      *

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSplitsCacheAsync = void 0;
-var objectAssign_1 = require("../utils/lang/objectAssign");
-/**
- * This class provides a skeletal implementation of the ISplitsCacheAsync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheAsync = /** @class */ (function () {
-    function AbstractSplitsCacheAsync() {
-    }
-    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        return Promise.all([
-            this.setChangeNumber(changeNumber),
-            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
-            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF); }))
-        ]).then(function (_a) {
-            var added = _a[1], removed = _a[2];
-            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
-        });
-    };
-    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
-    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
-        return Promise.resolve(true);
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     * The promise will never be rejected.
-     */
-    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var _this = this;
-        return this.getSplit(name).then(function (split) {
-            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-                var newSplit = (0, objectAssign_1.objectAssign)({}, split);
-                newSplit.killed = true;
-                newSplit.defaultTreatment = defaultTreatment;
-                newSplit.changeNumber = changeNumber;
-                return _this.addSplit(newSplit);
-            }
-            return false;
-        }).catch(function () { return false; });
-    };
-    return AbstractSplitsCacheAsync;
-}());
-exports.AbstractSplitsCacheAsync = AbstractSplitsCacheAsync;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.usesSegmentsSync = exports.usesSegments = exports.AbstractSplitsCacheSync = void 0;
-var objectAssign_1 = require("../utils/lang/objectAssign");
-var constants_1 = require("../utils/constants");
-/**
- * This class provides a skeletal implementation of the ISplitsCacheSync interface
- * to minimize the effort required to implement this interface.
- */
-var AbstractSplitsCacheSync = /** @class */ (function () {
-    function AbstractSplitsCacheSync() {
-    }
-    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
-        var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF); }).some(function (result) { return result; }) || updated;
-        this.setChangeNumber(changeNumber);
-        return updated;
-    };
-    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
-        var _this = this;
-        var splits = {};
-        names.forEach(function (name) {
-            splits[name] = _this.getSplit(name);
-        });
-        return splits;
-    };
-    AbstractSplitsCacheSync.prototype.getAll = function () {
-        var _this = this;
-        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
-    };
-    /**
-     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
-     * Used for SPLIT_KILL push notifications.
-     *
-     * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
-     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
-     */
-    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
-        var split = this.getSplit(name);
-        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
-            var newSplit = (0, objectAssign_1.objectAssign)({}, split);
-            newSplit.killed = true;
-            newSplit.defaultTreatment = defaultTreatment;
-            newSplit.changeNumber = changeNumber;
-            return this.addSplit(newSplit);
-        }
-        return false;
-    };
-    return AbstractSplitsCacheSync;
-}());
-exports.AbstractSplitsCacheSync = AbstractSplitsCacheSync;
-/**
- * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
- */
-function usesSegments(ruleEntity) {
-    var conditions = ruleEntity.conditions || [];
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
-                return true;
-        }
-    }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
-    return false;
-}
-exports.usesSegments = usesSegments;
-function usesSegmentsSync(storage) {
-    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-}
-exports.usesSegmentsSync = usesSegmentsSync;