@splitsoftware/splitio-commons 1.6.2-rc.12 → 1.6.2-rc.13

package/types/storages/types.d.ts

@@ -1,7 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
-import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+import { MaybeThenable, ISplit } from '../dtos/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, ISettings } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -264,48 +263,43 @@ export interface IImpressionsCacheBase {
 export interface IEventsCacheBase {
     track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
 }
-/** Impressions and events cache for standalone mode (sync) */
-export interface IRecorderCacheProducerSync<T> {
+export interface IImpressionCountsCacheBase {
+    track(featureName: string, timeFrame: number, amount: number): void;
+}
+export interface IUniqueKeysCacheBase {
+    track(key: string, value: string): void;
+}
+/** Impressions and events cache for standalone and partial consumer modes (sync methods) */
+export interface IRecorderCacheSync<T> {
     isEmpty(): boolean;
     clear(): void;
     pop(toMerge?: T): T;
 }
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<ImpressionDTO[]> {
     track(data: ImpressionDTO[]): void;
     setOnFullQueueCb(cb: () => void): void;
 }
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheSync<SplitIO.EventData[]> {
     track(data: SplitIO.EventData, size?: number): boolean;
     setOnFullQueueCb(cb: () => void): void;
 }
-/** Impressions and events cache for consumer and producer mode (async) */
-export interface IRecorderCacheProducerAsync<T> {
+export interface IImpressionCountsCacheSync extends IImpressionCountsCacheBase, IRecorderCacheSync<Record<string, number>> {
+}
+export interface IUniqueKeysCacheSync extends IUniqueKeysCacheBase, IRecorderCacheSync<UniqueKeysPayloadSs | UniqueKeysPayloadCs> {
+    setOnFullQueueCb(cb: () => void): void;
+}
+/** Impressions and events cache for consumer and producer modes (async methods) */
+export interface IRecorderCacheAsync<T> {
     count(): Promise<number>;
     drop(count?: number): Promise<void>;
     popNWithMetadata(count: number): Promise<T>;
 }
-export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
+export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
     track(data: ImpressionDTO[]): Promise<void>;
 }
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
+export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
     track(data: SplitIO.EventData, size?: number): Promise<boolean>;
 }
-/**
- * Impression counts cache for impressions dedup in standalone and producer mode.
- * Only in memory. Named `ImpressionsCounter` in spec.
- */
-export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-    track(featureName: string, timeFrame: number, amount: number): void;
-    isEmpty(): boolean;
-    pop(toMerge?: Record<string, number>): Record<string, number>;
-}
-export interface IUniqueKeysCacheBase {
-    track(key: string, value: string): void;
-    isEmpty(): boolean;
-    pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs;
-    setOnFullQueueCb(cb: () => void): void;
-    clear(): void;
-}
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -356,7 +350,7 @@ export interface ITelemetryEvaluationProducerSync {
 }
 export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
 }
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync {
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync, IRecorderCacheSync<TelemetryUsageStatsPayload> {
 }
 /**
  * Telemetry storage interface for consumer mode.
@@ -377,7 +371,7 @@ export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync,
 /**
  * Storages
  */
-export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheSync, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
+export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCache extends ISegmentsCacheBase, TImpressionsCache extends IImpressionsCacheBase, TImpressionsCountCache extends IImpressionCountsCacheBase, TEventsCache extends IEventsCacheBase, TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync, TUniqueKeysCache extends IUniqueKeysCacheBase> {
     splits: TSplitsCache;
     segments: TSegmentsCache;
     impressions: TImpressionsCache;
@@ -388,23 +382,19 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheBase> {
+export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
 }
-export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
+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 {
-    log: ILogger;
-    impressionsQueueSize?: number;
-    eventsQueueSize?: number;
-    optimize?: boolean;
-    mode: SDKMode;
-    impressionsMode?: string;
-    matchingKey?: string;
-    splitFiltersValidation?: ISplitFiltersValidation;
+    settings: ISettings;
+    /**
+     * Error-first callback invoked when the storage is ready to be used. An error means that the storage failed to connect and shouldn't be used.
+     * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
+     */
     onReadyCb: (error?: any) => void;
-    metadata: IMetadata;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/sync/submitters/submitter.d.ts

@@ -1,11 +1,11 @@
 import { ISyncTask } from '../types';
-import { IRecorderCacheProducerSync } from '../../storages/types';
+import { IRecorderCacheSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { IResponse } from '../../services/types';
 /**
  * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
  */
-export declare function submitterFactory<T>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheProducerSync<T>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: T) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
+export declare function submitterFactory<T>(log: ILogger, postClient: (body: string) => Promise<IResponse>, sourceCache: IRecorderCacheSync<T>, postRate: number, dataName: string, fromCacheToPayload?: (cacheData: T) => any, maxRetries?: number, debugLogs?: boolean): ISyncTask<[], void>;
 /**
  * Decorates a provided submitter with a first execution window
  */

package/types/sync/submitters/telemetrySubmitter.d.ts

@@ -1,15 +1,7 @@
-import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { ITelemetryCacheSync } from '../../storages/types';
+import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
 import { ISettings, SDKMode } from '../../types';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Converts data from telemetry cache into /metrics/usage request payload.
- */
-export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync): {
-    isEmpty(): boolean;
-    clear(): void;
-    pop(): TelemetryUsageStatsPayload;
-};
 export declare function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats;
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.

package/types/sync/submitters/types.d.ts

@@ -97,19 +97,19 @@ export declare type TOKEN = 'to';
 export declare type SEGMENT = 'se';
 export declare type MY_SEGMENT = 'ms';
 export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
-export declare type LastSync = Record<OperationType, number | undefined>;
-export declare type HttpErrors = Record<OperationType, {
+export declare type LastSync = Partial<Record<OperationType, number | undefined>>;
+export declare type HttpErrors = Partial<Record<OperationType, {
     [statusCode: string]: number;
-}>;
-export declare type HttpLatencies = Record<OperationType, Array<number>>;
+}>>;
+export declare type HttpLatencies = Partial<Record<OperationType, Array<number>>>;
 export declare type TREATMENT = 't';
 export declare type TREATMENTS = 'ts';
 export declare type TREATMENT_WITH_CONFIG = 'tc';
 export declare type TREATMENTS_WITH_CONFIG = 'tcs';
 export declare type TRACK = 'tr';
 export declare type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
-export declare type MethodLatencies = Record<Method, Array<number>>;
-export declare type MethodExceptions = Record<Method, number>;
+export declare type MethodLatencies = Partial<Record<Method, Array<number>>>;
+export declare type MethodExceptions = Partial<Record<Method, number>>;
 export declare type CONNECTION_ESTABLISHED = 0;
 export declare type OCCUPANCY_PRI = 10;
 export declare type OCCUPANCY_SEC = 20;

package/types/trackers/impressionObserver/utils.d.ts

@@ -1,12 +1,4 @@
 import { ISettings } from '../../types';
-/**
- * Checks if impressions previous time should be added or not.
- */
-export declare function shouldAddPt(settings: ISettings): boolean;
-/**
- * Checks if it should dedupe impressions or not.
- */
-export declare function shouldBeOptimized(settings: ISettings): boolean;
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/types/trackers/strategy/strategyNone.d.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { IStrategy, IUniqueKeysTracker } from '../types';
 /**
  * None strategy for impressions tracker.
@@ -7,4 +7,4 @@ import { IStrategy, IUniqueKeysTracker } from '../types';
  * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
  * @returns IStrategyResult
  */
-export declare function strategyNoneFactory(impressionsCounter: IImpressionCountsCacheSync, uniqueKeysTracker: IUniqueKeysTracker): IStrategy;
+export declare function strategyNoneFactory(impressionsCounter: IImpressionCountsCacheBase, uniqueKeysTracker: IUniqueKeysTracker): IStrategy;

package/types/trackers/strategy/strategyOptimized.d.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { IImpressionObserver } from '../impressionObserver/types';
 import { IStrategy } from '../types';
 /**
@@ -8,4 +8,4 @@ import { IStrategy } from '../types';
  * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
  * @returns IStrategyResult
  */
-export declare function strategyOptimizedFactory(impressionsObserver: IImpressionObserver, impressionsCounter: IImpressionCountsCacheSync): IStrategy;
+export declare function strategyOptimizedFactory(impressionsObserver: IImpressionObserver, impressionsCounter: IImpressionCountsCacheBase): IStrategy;

package/types/trackers/uniqueKeysTracker.d.ts

@@ -4,7 +4,7 @@ import { IFilterAdapter, IUniqueKeysTracker } from './types';
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
- *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
+ * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
  * @param uniqueKeysCache cache to save unique keys