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

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

@@ -2,7 +2,6 @@ import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * 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

@@ -229,35 +229,29 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
 }
 /** 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) */
@@ -393,7 +387,6 @@ 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;
     /**
@@ -401,6 +394,10 @@ 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;
+    /**
+     * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
+     */
+    onReadyFromCacheCb: () => 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/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, whenInit: (cb: () => void) => void, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -10,4 +10,4 @@ import { ISettings } from '../types';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, whenInit: (cb: () => void) => void, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

@@ -54,6 +54,7 @@ export interface IImpressionSenderAdapter {
 }
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+    start(): void;
     stop(): void;
     track(key: string, featureName: string): void;
 }

package/types/types.d.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from './dtos/types';
+import { IMembershipsResponse, ISplit, ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -91,6 +91,7 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
+    readonly preloadedData?: SplitIO.PreloadedData;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -769,31 +770,30 @@ 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;
         /**
-         * Map of feature flags to their stringified definitions.
+         * List of feature flag definitions.
+         * @TODO rename to flags
          */
-        splitsData: {
-            [splitName: string]: string;
-        };
+        splitsData: ISplit[];
         /**
-         * Optional map of user keys to their list of segments.
-         * @TODO remove when releasing first version
+         * Optional map of user keys to their memberships.
+         * @TODO rename to memberships
          */
-        mySegmentsData?: {
-            [key: string]: string[];
+        membershipsData?: {
+            [key: string]: IMembershipsResponse;
         };
         /**
-         * Optional map of segments to their stringified definitions.
-         * This property is ignored if `mySegmentsData` was provided.
+         * Optional map of segments to their list of keys.
+         * This property is ignored if `membershipsData` was provided.
+         * @TODO rename to segments
          */
         segmentsData?: {
-            [segmentName: string]: string;
+            [segmentName: string]: string[];
         };
     }
     /**

package/types/utils/lang/sets.d.ts

@@ -1,2 +1,3 @@
+export declare function setToArray<T>(set: Set<T>): T[];
 export declare function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T>;
 export declare function returnDifference<T>(list?: T[], list2?: T[]): T[];