@splitsoftware/splitio-commons 1.6.2-rc.3 → 1.6.2-rc.6

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

@@ -1,6 +1,7 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation that stores split definitions in Redis.
@@ -19,13 +20,13 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    addSplit(name: string, split: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * Add a list of splits.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    addSplits(entries: [string, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
@@ -42,7 +43,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Set till number.
      * The returned promise is resolved when the operation success,
@@ -63,7 +64,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * @TODO we need to benchmark which is the maximun number of commands we could
      *       pipeline without kill redis performance.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,
@@ -87,5 +88,5 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * Fetches multiple splits definitions.
      * Returned promise is rejected if redis operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
 }

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

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';

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

@@ -1,4 +1,4 @@
-import { StorageAsyncFactory } from '../../types';
+import { IStorageAsyncFactory } from '../types';
 export interface InRedisStorageOptions {
     prefix?: string;
     options?: Record<string, any>;
@@ -7,4 +7,4 @@ export interface InRedisStorageOptions {
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
-export declare function InRedisStorage(options?: InRedisStorageOptions): StorageAsyncFactory;
+export declare function InRedisStorage(options?: InRedisStorageOptions): IStorageAsyncFactory;

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

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { EventData } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
 export declare class EventsCachePluggable implements IEventsCacheAsync {
     private readonly log;
@@ -15,7 +15,7 @@ export declare class EventsCachePluggable implements IEventsCacheAsync {
      * @returns  A promise that is resolved with a boolean value indicating if the push operation succeeded or failed.
      * Unlike `impressions::track`, The promise will never be rejected.
      */
-    track(eventData: EventData): Promise<boolean>;
+    track(eventData: SplitIO.EventData): Promise<boolean>;
     private _toJSON;
     /**
      * Returns a promise that resolves with the count of stored events, or 0 if there was some error.

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

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync {
     private readonly log;

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

@@ -1,6 +1,6 @@
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 /**
  * ISegmentsCacheAsync implementation for pluggable storages.
  */

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

@@ -1,6 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -23,13 +24,13 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    addSplit(name: string, split: string): Promise<boolean>;
+    addSplit(name: string, split: ISplit): Promise<boolean>;
     /**
      * Add a list of splits.
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    addSplits(entries: [string, string][]): Promise<boolean[]>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -47,19 +48,19 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * The returned promise is resolved with the split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplit(name: string): Promise<string | null>;
+    getSplit(name: string): Promise<ISplit | null>;
     /**
      * Get list of splits.
      * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
      * or rejected if wrapper operation fails.
      */
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     /**
      * Get list of all split definitions.
      * The returned promise is resolved with the list of split definitions,
      * or rejected if wrapper operation fails.
      */
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     /**
      * Get list of split names.
      * The returned promise is resolved with the list of split names,

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

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';

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

@@ -1,5 +1,4 @@
-import { IPluggableStorageWrapper } from '../types';
-import { StorageAsyncFactory } from '../../types';
+import { IPluggableStorageWrapper, IStorageAsyncFactory } from '../types';
 export interface PluggableStorageOptions {
     prefix?: string;
     wrapper: IPluggableStorageWrapper;
@@ -7,4 +6,4 @@ export interface PluggableStorageOptions {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export declare function PluggableStorage(options: PluggableStorageOptions): StorageAsyncFactory;
+export declare function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory;

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

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IPluggableStorageWrapper } from '../types';
 export declare const METHODS_TO_PROMISE_WRAP: string[];
 /**

package/types/storages/types.d.ts

@@ -1,6 +1,7 @@
-import { MaybeThenable, IMetadata } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
+import { ILogger } from '../logger/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
-import { ImpressionDTO, SDKMode, ILogger, EventData, ISplitFiltersValidation } from '../types';
+import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 /**
  * Interface of a pluggable storage wrapper.
  */
@@ -177,13 +178,13 @@ export interface IPluggableStorageWrapper {
 }
 /** Splits cache */
 export interface ISplitsCacheBase {
-    addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>;
     removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
-    getSplit(name: string): MaybeThenable<string | null>;
-    getSplits(names: string[]): MaybeThenable<Record<string, string | null>>;
+    getSplit(name: string): MaybeThenable<ISplit | null>;
+    getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
     getChangeNumber(): MaybeThenable<number>;
-    getAll(): MaybeThenable<string[]>;
+    getAll(): MaybeThenable<ISplit[]>;
     getSplitNames(): MaybeThenable<string[]>;
     trafficTypeExists(trafficType: string): MaybeThenable<boolean>;
     usesSegments(): MaybeThenable<boolean>;
@@ -192,13 +193,13 @@ export interface ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): boolean[];
+    addSplits(entries: [string, ISplit][]): boolean[];
     removeSplits(names: string[]): boolean[];
-    getSplit(name: string): string | null;
-    getSplits(names: string[]): Record<string, string | null>;
+    getSplit(name: string): ISplit | null;
+    getSplits(names: string[]): Record<string, ISplit | null>;
     setChangeNumber(changeNumber: number): boolean;
     getChangeNumber(): number;
-    getAll(): string[];
+    getAll(): ISplit[];
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
@@ -207,13 +208,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-    addSplits(entries: [string, string][]): Promise<boolean[] | void>;
+    addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
     removeSplits(names: string[]): Promise<boolean[] | void>;
-    getSplit(name: string): Promise<string | null>;
-    getSplits(names: string[]): Promise<Record<string, string | null>>;
+    getSplit(name: string): Promise<ISplit | null>;
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
     setChangeNumber(changeNumber: number): Promise<boolean | void>;
     getChangeNumber(): Promise<number>;
-    getAll(): Promise<string[]>;
+    getAll(): Promise<ISplit[]>;
     getSplitNames(): Promise<string[]>;
     trafficTypeExists(trafficType: string): Promise<boolean>;
     usesSegments(): Promise<boolean>;
@@ -259,7 +260,7 @@ export interface IImpressionsCacheBase {
     track(data: ImpressionDTO[]): MaybeThenable<void>;
 }
 export interface IEventsCacheBase {
-    track(data: EventData, size?: number): MaybeThenable<boolean>;
+    track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
 }
 /** Impressions and events cache for standalone mode (sync) */
 export interface IRecorderCacheProducerSync<T> {
@@ -271,8 +272,8 @@ export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderC
     track(data: ImpressionDTO[]): void;
     setOnFullQueueCb(cb: () => void): void;
 }
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<EventData[]> {
-    track(data: EventData, size?: number): boolean;
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+    track(data: SplitIO.EventData, size?: number): boolean;
     setOnFullQueueCb(cb: () => void): void;
 }
 /** Impressions and events cache for consumer and producer mode (async) */
@@ -285,7 +286,7 @@ export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorder
     track(data: ImpressionDTO[]): Promise<void>;
 }
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
-    track(data: EventData, size?: number): Promise<boolean>;
+    track(data: SplitIO.EventData, size?: number): Promise<boolean>;
 }
 /**
  * Impression counts cache for impressions dedup in standalone and producer mode.
@@ -392,39 +393,12 @@ export interface IStorageFactoryParams {
     onReadyCb: (error?: any) => void;
     metadata: IMetadata;
 }
-/**
- * Defines the format of Split data to preload on the factory storage (cache).
- */
-export interface PreloadedData {
-    /**
-     * Timestamp of the last moment the data was synchronized with Split servers.
-     * 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 splits to their serialized definitions.
-     */
-    splitsData: {
-        [splitName: string]: string;
-    };
-    /**
-     * Optional map of user keys to their list of segments.
-     * @TODO remove when releasing first version
-     */
-    mySegmentsData?: {
-        [key: string]: string[];
-    };
-    /**
-     * Optional map of segments to their serialized definitions.
-     * This property is ignored if `mySegmentsData` was provided.
-     */
-    segmentsData?: {
-        [segmentName: string]: string;
-    };
-}
+export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
+export declare type IStorageSyncFactory = {
+    readonly type: StorageType;
+    (params: IStorageFactoryParams): IStorageSync;
+};
+export declare type IStorageAsyncFactory = {
+    type: StorageType;
+    (params: IStorageFactoryParams): IStorageAsync;
+};

package/types/sync/offline/LocalhostFromObject.d.ts

@@ -1,2 +1,2 @@
-import { LocalhostFactory } from '../../types';
-export declare function LocalhostFromObject(): LocalhostFactory;
+import { SplitIO } from '../../types';
+export declare function LocalhostFromObject(): SplitIO.LocalhostFactory;

package/types/sync/polling/updaters/mySegmentsUpdater.d.ts

@@ -1,7 +1,7 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
 import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 declare type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>;
 /**
  * factory of MySegments updater, a task that:

package/types/sync/polling/updaters/segmentChangesUpdater.d.ts

@@ -1,7 +1,7 @@
 import { ISegmentChangesFetcher } from '../fetchers/types';
 import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 declare type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>;
 /**
  * Factory of SegmentChanges updater, a task that:

package/types/sync/polling/updaters/splitChangesUpdater.d.ts

@@ -3,7 +3,7 @@ import { ISegmentsCacheBase, ISplitsCacheBase } from '../../../storages/types';
 import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 declare type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>;
 /**
  * Collect segments from a raw split definition.
@@ -11,7 +11,7 @@ declare type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promis
  */
 export declare function parseSegments({ conditions }: ISplit): ISet<string>;
 interface ISplitMutations {
-    added: [string, string][];
+    added: [string, ISplit][];
     removed: string[];
     segments: string[];
 }

package/types/sync/streaming/SSEHandler/index.d.ts

@@ -1,6 +1,6 @@
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 /**
  * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { ISegmentsSyncTask } from '../../polling/types';
 import { IUpdateWorker } from './types';

package/types/sync/streaming/UpdateWorkers/SplitsUpdateWorker.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../../types';
+import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';

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

@@ -1,6 +1,6 @@
 import { ISyncTask } from '../types';
 import { IRecorderCacheProducerSync } from '../../storages/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IResponse } from '../../services/types';
 /**
  * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter

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

@@ -1,5 +1,5 @@
 import { IMetadata } from '../../dtos/types';
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { ISyncTask } from '../types';
 export declare type ImpressionsPayload = {
     /** Split name */
@@ -57,7 +57,7 @@ export declare type StoredEventWithMetadata = {
     /** Metadata */
     m: IMetadata;
     /** Stored event */
-    e: EventData;
+    e: SplitIO.EventData;
 };
 /**
  * Telemetry usage stats

package/types/sync/syncTask.d.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../types';
+import { ILogger } from '../logger/types';
 import { ISyncTask } from './types';
 /**
  * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.

package/types/trackers/types.d.ts

@@ -1,18 +1,18 @@
-import { ImpressionDTO, EventData, ImpressionData, Attributes } from '../types';
+import { SplitIO, ImpressionDTO } from '../types';
 import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
 import { NetworkError } from '../services/types';
 /** Events tracker */
 export interface IEventsHandler {
-    handleEvent(eventData: EventData): any;
+    handleEvent(eventData: SplitIO.EventData): any;
 }
 export declare type IEventTracker = IEventsCacheBase;
 /** Impressions tracker */
 export interface IImpressionsHandler {
-    handleImpression(impressionData: ImpressionData): any;
+    handleImpression(impressionData: SplitIO.ImpressionData): any;
 }
 export interface IImpressionsTracker {
-    track(impressions: ImpressionDTO[], attributes?: Attributes): void;
+    track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes): void;
 }
 /** Telemetry tracker */
 export declare type AUTH_REJECTION = 80;
@@ -33,4 +33,8 @@ export interface ITelemetryTracker {
      * Records streaming event
      */
     streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void;
+    /**
+     * Records tag
+     */
+    addTag(tag: string): void;
 }