@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.4

package/types/storages/inLocalStorage/MySegmentsCacheInLocal.d.ts

@@ -1,15 +1,15 @@
 import { ILogger } from '../../logger/types';
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     private readonly keys;
     private readonly log;
     constructor(log: ILogger, keys: MySegmentsKeyBuilder);
-    addToSegment(name: string): boolean;
-    removeFromSegment(name: string): boolean;
+    protected addSegment(name: string): boolean;
+    protected removeSegment(name: string): boolean;
     isInSegment(name: string): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name?: string, changeNumber?: number): void;
+    protected setChangeNumber(changeNumber?: number): void;
     getChangeNumber(): number;
 }

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -35,6 +35,12 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
+    /**
+     * Check if the splits information is already stored in browser LocalStorage.
+     * In this function we could add more code to check if the data is valid.
+     * @override
+     */
+    checkCache(): boolean;
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *

package/types/storages/inMemory/MySegmentsCacheInMemory.d.ts

@@ -1,15 +1,15 @@
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
  */
-export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
     private segmentCache;
     private cn?;
-    addToSegment(name: string): boolean;
-    removeFromSegment(name: string): boolean;
+    protected addSegment(name: string): boolean;
+    protected removeSegment(name: string): boolean;
     isInSegment(name: string): boolean;
-    setChangeNumber(name?: string, changeNumber?: number): void;
+    protected setChangeNumber(changeNumber?: number): void;
     getChangeNumber(): number;
     getRegisteredSegments(): string[];
     getKeysCount(): number;

package/types/storages/inMemory/SegmentsCacheInMemory.d.ts

@@ -1,19 +1,17 @@
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { ISegmentsCacheSync } from '../types';
 /**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
+ * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
  */
-export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class SegmentsCacheInMemory implements ISegmentsCacheSync {
     private segmentCache;
     private segmentChangeNumber;
-    addToSegment(name: string, segmentKeys: string[]): boolean;
-    removeFromSegment(name: string, segmentKeys: string[]): boolean;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
     isInSegment(name: string, key: string): boolean;
     clear(): void;
     private _registerSegment;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name: string, changeNumber: number): boolean;
     getChangeNumber(name: string): number;
+    resetSegments(): boolean;
 }

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -3,7 +3,6 @@ import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { ISet } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
  */
 export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private flagSetsFilter;

package/types/storages/inRedis/SegmentsCacheInRedis.d.ts

@@ -7,10 +7,13 @@ export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     private readonly redis;
     private readonly keys;
     constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean>;
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean>;
+    /**
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., Redis operation fails).
+     */
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
     isInSegment(name: string, key: string): Promise<boolean>;
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean>;
     getChangeNumber(name: string): Promise<number>;
     registerSegments(segments: string[]): Promise<boolean>;
     getRegisteredSegments(): Promise<string[]>;

package/types/storages/pluggable/SegmentsCachePluggable.d.ts

@@ -10,28 +10,16 @@ export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
     private readonly wrapper;
     constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     /**
-     * Add a list of `segmentKeys` to the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
-     */
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
-    /**
-     * Remove a list of `segmentKeys` from the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., wrapper operation fails).
      */
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
      * Promise can be rejected if wrapper operation fails.
      */
     isInSegment(name: string, key: string): Promise<boolean>;
-    /**
-     * Set till number for the given segment `name`.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/types/storages/types.d.ts

@@ -192,6 +192,7 @@ export interface ISplitsCacheBase {
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
+    checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
     getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>;
 }
@@ -207,6 +208,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
     clear(): void;
+    checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
     getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
@@ -222,40 +224,35 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;
     clear(): Promise<boolean | void>;
+    checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
     getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
-    removeFromSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
     isInSegment(name: string, key?: string): MaybeThenable<boolean>;
     registerSegments(names: string[]): MaybeThenable<boolean | void>;
     getRegisteredSegments(): MaybeThenable<string[]>;
-    setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void>;
     getChangeNumber(name: string): MaybeThenable<number>;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
 }
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys?: string[]): boolean;
-    removeFromSegment(name: string, segmentKeys?: string[]): boolean;
     isInSegment(name: string, key?: string): boolean;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name: string, changeNumber: number): boolean | void;
     getChangeNumber(name?: string): number;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
     resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
     clear(): void;
 }
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
     isInSegment(name: string, key: string): Promise<boolean>;
     registerSegments(names: string[]): Promise<boolean | void>;
     getRegisteredSegments(): Promise<string[]>;
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
     getChangeNumber(name: string): Promise<number>;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
     clear(): Promise<boolean | void>;
 }
 /** Recorder storages (impressions, events and telemetry) */
@@ -382,7 +379,6 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     events: TEventsCache;
     telemetry?: TTelemetryCache;
     uniqueKeys?: TUniqueKeysCache;
-    init?: () => void | Promise<void>;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
@@ -392,6 +388,7 @@ export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCa
 export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
+export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     settings: ISettings;
     /**
@@ -399,7 +396,6 @@ export interface IStorageFactoryParams {
      * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
      */
     onReadyCb: (error?: any) => void;
-    onReadyFromCacheCb: (error?: any) => void;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/sync/types.d.ts

@@ -39,5 +39,5 @@ export interface ISyncManager extends ITask {
     submitterManager?: ISubmitterManager;
 }
 export interface ISyncManagerCS extends ISyncManager {
-    shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;
+    shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): Pick<ISyncManager, 'stop' | 'flush'> | undefined;
 }

package/types/types.d.ts

@@ -1,4 +1,4 @@
-import { ISplit, ISplitFiltersValidation } from './dtos/types';
+import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -92,7 +92,6 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
-    readonly preloadedData?: SplitIO.PreloadedData;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -771,19 +770,21 @@ export declare namespace SplitIO {
          * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
          * @TODO configurable expiration time policy?
          */
+        lastUpdated: number;
         /**
          * Change number of the preloaded data.
          * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
          */
         since: number;
         /**
-         * List of feature flag definitions.
-         * @TODO rename to flags
+         * Map of feature flags to their stringified definitions.
          */
-        splitsData: ISplit[];
+        splitsData: {
+            [splitName: string]: string;
+        };
         /**
          * Optional map of user keys to their list of segments.
-         * @TODO rename to memberships
+         * @TODO remove when releasing first version
          */
         mySegmentsData?: {
             [key: string]: string[];
@@ -791,10 +792,9 @@ export declare namespace SplitIO {
         /**
          * Optional map of segments to their stringified definitions.
          * This property is ignored if `mySegmentsData` was provided.
-         * @TODO rename to segments
          */
         segmentsData?: {
-            [segmentName: string]: string[];
+            [segmentName: string]: string;
         };
     }
     /**

package/types/utils/settingsValidation/storage/storageCS.d.ts

@@ -1,5 +1,10 @@
 import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
+import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
+export declare function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync;
+export declare namespace __InLocalStorageMockFactory {
+    var type: import("../../../storages/types").StorageType;
+}
 /**
  * This function validates `settings.storage` object
  *