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

package/types/storages/types.d.ts

@@ -1,407 +0,0 @@
-import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
-import { MySegmentsData } from '../sync/polling/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, ISettings } from '../types';
-/**
- * Interface of a pluggable storage wrapper.
- */
-export interface IPluggableStorageWrapper {
-    /** Key-Value operations */
-    /**
-     * Get the value of given `key`.
-     *
-     * @function get
-     * @param {string} key Item to retrieve
-     * @returns {Promise<string | null>} A promise that resolves with the element value associated with the specified `key`,
-     * or null if the key does not exist. The promise rejects if the operation fails.
-     */
-    get: (key: string) => Promise<string | null>;
-    /**
-     * Add or update an item with a specified `key` and `value`.
-     *
-     * @function set
-     * @param {string} key Item to update
-     * @param {string} value Value to set
-     * @returns {Promise<void>} A promise that resolves if the operation success, whether the key was added or updated.
-     * The promise rejects if the operation fails.
-     */
-    set: (key: string, value: string) => Promise<boolean | void>;
-    /**
-     * Add or update an item with a specified `key` and `value`.
-     *
-     * @function getAndSet
-     * @param {string} key Item to update
-     * @param {string} value Value to set
-     * @returns {Promise<string | null>} A promise that resolves with the previous value associated to the given `key`, or null if not set.
-     * The promise rejects if the operation fails.
-     */
-    getAndSet: (key: string, value: string) => Promise<string | null>;
-    /**
-     * Removes the specified item by `key`.
-     *
-     * @function del
-     * @param {string} key Item to delete
-     * @returns {Promise<boolean>} A promise that resolves if the operation success, whether the key existed and was removed (resolves with true) or it didn't exist (resolves with false).
-     * The promise rejects if the operation fails, for example, if there is a connection error.
-     */
-    del: (key: string) => Promise<boolean>;
-    /**
-     * Returns all keys matching the given prefix.
-     *
-     * @function getKeysByPrefix
-     * @param {string} prefix String prefix to match
-     * @returns {Promise<string[]>} A promise that resolves with the list of keys that match the given `prefix`.
-     * The promise rejects if the operation fails.
-     */
-    getKeysByPrefix: (prefix: string) => Promise<string[]>;
-    /**
-     * Returns the values of all given `keys`.
-     *
-     * @function getMany
-     * @param {string[]} keys List of keys to retrieve
-     * @returns {Promise<(string | null)[]>} A promise that resolves with the list of items associated with the specified list of `keys`.
-     * For every key that does not hold a string value or does not exist, null is returned. The promise rejects if the operation fails.
-     */
-    getMany: (keys: string[]) => Promise<(string | null)[]>;
-    /** Integer operations */
-    /**
-     * Increments the number stored at `key` by `increment`, or set it to `increment` if the value doesn't exist.
-     *
-     * @function incr
-     * @param {string} key Key to increment
-     * @param {number} increment Value to increment by. Defaults to 1.
-     * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
-     * for example, if there is a connection error or the key contains a string that can not be represented as integer.
-     */
-    incr: (key: string, increment?: number) => Promise<number>;
-    /**
-     * Decrements the number stored at `key` by `decrement`, or set it to minus `decrement` if the value doesn't exist.
-     *
-     * @function decr
-     * @param {string} key Key to decrement
-     * @param {number} decrement Value to decrement by. Defaults to 1.
-     * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
-     * for example, if there is a connection error or the key contains a string that can not be represented as integer.
-     */
-    decr: (key: string, decrement?: number) => Promise<number>;
-    /** Queue operations */
-    /**
-     * Inserts given items at the tail of `key` list. If `key` does not exist, an empty list is created before pushing the items.
-     *
-     * @function pushItems
-     * @param {string} key List key
-     * @param {string[]} items List of items to push
-     * @returns {Promise<void>} A promise that resolves if the operation success.
-     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
-     */
-    pushItems: (key: string, items: string[]) => Promise<void>;
-    /**
-     * Removes and returns the first `count` items from a list. If `key` does not exist, an empty list is items is returned.
-     *
-     * @function popItems
-     * @param {string} key List key
-     * @param {number} count Number of items to pop
-     * @returns {Promise<string[]>} A promise that resolves with the list of removed items from the list, or an empty array when key does not exist.
-     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
-     */
-    popItems: (key: string, count: number) => Promise<string[]>;
-    /**
-     * Returns the count of items in a list, or 0 if `key` does not exist.
-     *
-     * @function getItemsCount
-     * @param {string} key List key
-     * @returns {Promise<number>} A promise that resolves with the number of items at the `key` list, or 0 when `key` does not exist.
-     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a list.
-     */
-    getItemsCount: (key: string) => Promise<number>;
-    /** Set operations */
-    /**
-     * Returns if item is a member of a set.
-     *
-     * @function itemContains
-     * @param {string} key Set key
-     * @param {string} item Item value
-     * @returns {Promise<boolean>} A promise that resolves with true boolean value if `item` is a member of the set stored at `key`,
-     * or false if it is not a member or `key` set does not exist. The promise rejects if the operation fails, for example,
-     * if there is a connection error or the key holds a value that is not a set.
-     */
-    itemContains: (key: string, item: string) => Promise<boolean>;
-    /**
-     * Add the specified `items` to the set stored at `key`. Those items that are already part of the set are ignored.
-     * If key does not exist, an empty set is created before adding the items.
-     *
-     * @function addItems
-     * @param {string} key Set key
-     * @param {string} items Items to add
-     * @returns {Promise<boolean | void>} A promise that resolves if the operation success.
-     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
-     */
-    addItems: (key: string, items: string[]) => Promise<boolean | void>;
-    /**
-     * Remove the specified `items` from the set stored at `key`. Those items that are not part of the set are ignored.
-     *
-     * @function removeItems
-     * @param {string} key Set key
-     * @param {string} items Items to remove
-     * @returns {Promise<boolean | void>} A promise that resolves if the operation success. If key does not exist, the promise also resolves.
-     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
-     */
-    removeItems: (key: string, items: string[]) => Promise<boolean | void>;
-    /**
-     * Returns all the items of the `key` set.
-     *
-     * @function getItems
-     * @param {string} key Set key
-     * @returns {Promise<string[]>} A promise that resolves with the list of items. If key does not exist, the result is an empty list.
-     * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
-     */
-    getItems: (key: string) => Promise<string[]>;
-    /** Control operations */
-    /**
-     * Connects to the underlying storage.
-     * It is meant for storages that requires to be connected to some database or server. Otherwise it can just return a resolved promise.
-     * Note: will be called once on SplitFactory instantiation and once per each shared client instantiation.
-     *
-     * @function connect
-     * @returns {Promise<void>} A promise that resolves when the wrapper successfully connect to the underlying storage.
-     * The promise rejects with the corresponding error if the wrapper fails to connect.
-     */
-    connect: () => Promise<void>;
-    /**
-     * Disconnects from the underlying storage.
-     * It is meant for storages that requires to be closed, in order to release resources. Otherwise it can just return a resolved promise.
-     * Note: will be called once on SplitFactory main client destroy.
-     *
-     * @function disconnect
-     * @returns {Promise<void>} A promise that resolves when the operation ends.
-     * The promise never rejects.
-     */
-    disconnect: () => Promise<void>;
-}
-/** Splits cache */
-export interface ISplitsCacheBase {
-    addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>;
-    removeSplits(names: string[]): MaybeThenable<boolean[] | void>;
-    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<ISplit[]>;
-    getSplitNames(): MaybeThenable<string[]>;
-    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<Set<string>[]>;
-}
-export interface ISplitsCacheSync extends ISplitsCacheBase {
-    addSplits(entries: [string, ISplit][]): boolean[];
-    removeSplits(names: string[]): boolean[];
-    getSplit(name: string): ISplit | null;
-    getSplits(names: string[]): Record<string, ISplit | null>;
-    setChangeNumber(changeNumber: number): boolean | void;
-    getChangeNumber(): number;
-    getAll(): ISplit[];
-    getSplitNames(): string[];
-    trafficTypeExists(trafficType: string): boolean;
-    usesSegments(): boolean;
-    clear(): void;
-    checkCache(): boolean;
-    killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    getNamesByFlagSets(flagSets: string[]): Set<string>[];
-}
-export interface ISplitsCacheAsync extends ISplitsCacheBase {
-    addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
-    removeSplits(names: string[]): Promise<boolean[] | void>;
-    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<ISplit[]>;
-    getSplitNames(): Promise<string[]>;
-    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<Set<string>[]>;
-}
-/** Segments cache */
-export interface ISegmentsCacheBase {
-    isInSegment(name: string, key?: string): MaybeThenable<boolean>;
-    registerSegments(names: string[]): MaybeThenable<boolean | void>;
-    getRegisteredSegments(): MaybeThenable<string[]>;
-    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 {
-    isInSegment(name: string, key?: string): boolean;
-    registerSegments(names: string[]): boolean;
-    getRegisteredSegments(): string[];
-    getKeysCount(): number;
-    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 {
-    isInSegment(name: string, key: string): Promise<boolean>;
-    registerSegments(names: string[]): Promise<boolean | void>;
-    getRegisteredSegments(): Promise<string[]>;
-    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) */
-export interface IImpressionsCacheBase {
-    track(data: ImpressionDTO[]): MaybeThenable<void>;
-}
-export interface IEventsCacheBase {
-    track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>;
-}
-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, IRecorderCacheSync<ImpressionDTO[]> {
-    track(data: ImpressionDTO[]): void;
-    setOnFullQueueCb(cb: () => void): void;
-}
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheSync<SplitIO.EventData[]> {
-    track(data: SplitIO.EventData, size?: number): boolean;
-    setOnFullQueueCb(cb: () => void): void;
-}
-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, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
-    track(data: ImpressionDTO[]): Promise<void>;
-}
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
-    track(data: SplitIO.EventData, size?: number): Promise<boolean>;
-}
-/**
- * Telemetry storage interface for standalone and partial consumer modes.
- * Methods are sync because data is stored in memory.
- */
-export interface ITelemetryInitConsumerSync {
-    getTimeUntilReady(): number | undefined;
-    getTimeUntilReadyFromCache(): number | undefined;
-    getNonReadyUsage(): number;
-}
-export interface ITelemetryRuntimeConsumerSync {
-    getImpressionStats(type: ImpressionDataType): number;
-    getEventStats(type: EventDataType): number;
-    getLastSynchronization(): LastSync;
-    popHttpErrors(): HttpErrors;
-    popHttpLatencies(): HttpLatencies;
-    popAuthRejections(): number;
-    popTokenRefreshes(): number;
-    popStreamingEvents(): Array<StreamingEvent>;
-    popTags(): Array<string> | undefined;
-    getSessionLength(): number | undefined;
-}
-export interface ITelemetryEvaluationConsumerSync {
-    popExceptions(): MethodExceptions;
-    popLatencies(): MethodLatencies;
-}
-export interface ITelemetryStorageConsumerSync extends ITelemetryInitConsumerSync, ITelemetryRuntimeConsumerSync, ITelemetryEvaluationConsumerSync {
-}
-export interface ITelemetryInitProducerSync {
-    recordTimeUntilReady(ms: number): void;
-    recordTimeUntilReadyFromCache(ms: number): void;
-    recordNonReadyUsage(): void;
-}
-export interface ITelemetryRuntimeProducerSync {
-    addTag(tag: string): void;
-    recordImpressionStats(type: ImpressionDataType, count: number): void;
-    recordEventStats(type: EventDataType, count: number): void;
-    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
-    recordHttpError(resource: OperationType, status: number): void;
-    recordHttpLatency(resource: OperationType, latencyMs: number): void;
-    recordAuthRejections(): void;
-    recordTokenRefreshes(): void;
-    recordStreamingEvents(streamingEvent: StreamingEvent): void;
-    recordSessionLength(ms: number): void;
-    recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
-}
-export interface ITelemetryEvaluationProducerSync {
-    recordLatency(method: Method, latencyMs: number): void;
-    recordException(method: Method): void;
-}
-export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync {
-}
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync, IRecorderCacheSync<TelemetryUsageStatsPayload> {
-}
-/**
- * Telemetry storage interface for consumer mode.
- * Methods are async because data is stored in Redis or a pluggable storage.
- */
-export interface ITelemetryEvaluationConsumerAsync {
-    popLatencies(): Promise<MultiMethodLatencies>;
-    popExceptions(): Promise<MultiMethodExceptions>;
-    popConfigs(): Promise<MultiConfigs>;
-}
-export interface ITelemetryEvaluationProducerAsync {
-    recordLatency(method: Method, latencyMs: number): Promise<any>;
-    recordException(method: Method): Promise<any>;
-    recordConfig(): Promise<any>;
-}
-export interface ITelemetryCacheAsync extends ITelemetryEvaluationProducerAsync, ITelemetryEvaluationConsumerAsync {
-}
-/**
- * Storages
- */
-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;
-    impressionCounts?: TImpressionsCountCache;
-    events: TEventsCache;
-    telemetry?: TTelemetryCache;
-    uniqueKeys?: TUniqueKeysCache;
-    destroy(): void | Promise<void>;
-    shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
-}
-export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
-    largeSegments?: ISegmentsCacheSync;
-}
-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;
-    /**
-     * 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;
-}
-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/storages/utils.d.ts

@@ -1,8 +0,0 @@
-import { IMetadata } from '../dtos/types';
-import { Method } from '../sync/submitters/types';
-import { ImpressionDTO, ISettings } from '../types';
-export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;
-export declare function impressionsToJSON(impressions: ImpressionDTO[], metadata: IMetadata): string[];
-export declare function parseMetadata(field: string): [metadata: string] | string;
-export declare function parseExceptionField(field: string): [metadata: string, method: Method] | string;
-export declare function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string;

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

@@ -1 +0,0 @@
-export declare const localhostFromObjectFactory: (params: import("../../sdkFactory/types").ISdkFactoryContextSync) => import("../types").ISyncManagerCS;

package/types/sync/offline/splitsParser/parseCondition.d.ts

@@ -1,7 +0,0 @@
-import { ISplitCondition } from '../../../dtos/types';
-export interface IMockSplitEntry {
-    treatment: string;
-    keys?: string[];
-    config?: string;
-}
-export declare function parseCondition(data: IMockSplitEntry): ISplitCondition;

package/types/sync/offline/splitsParser/splitsParserFromSettings.d.ts

@@ -1,3 +0,0 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { ISettings } from '../../../types';
-export declare function splitsParserFromSettingsFactory(): (settings: Pick<ISettings, 'features'>) => false | Record<string, ISplitPartial>;

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

@@ -1,3 +0,0 @@
-import { ISplitPartial } from '../../../dtos/types';
-import { ISettings } from '../../../types';
-export declare type ISplitsParser = (settings: ISettings) => false | Record<string, ISplitPartial>;

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

@@ -1,10 +0,0 @@
-import { ISyncManagerCS } from '../types';
-import { ISplitsParser } from './splitsParser/types';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Offline SyncManager factory.
- * Can be used for server-side API, and client-side API with or without multiple clients.
- *
- * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
- */
-export declare function syncManagerOfflineFactory(splitsParserFactory: () => ISplitsParser): (params: ISdkFactoryContextSync) => ISyncManagerCS;

package/types/sync/offline/syncTasks/fromObjectSyncTask.d.ts

@@ -1,17 +0,0 @@
-import { IReadinessManager } from '../../../readiness/types';
-import { ISplitsCacheSync } from '../../../storages/types';
-import { ISplitsParser } from '../splitsParser/types';
-import { ISyncTask } from '../../types';
-import { ISettings } from '../../../types';
-/**
- * Offline equivalent of `splitChangesUpdaterFactory`
- */
-export declare function fromObjectUpdaterFactory(splitsParser: ISplitsParser, storage: {
-    splits: ISplitsCacheSync;
-}, readiness: IReadinessManager, settings: ISettings): () => Promise<boolean>;
-/**
- * PollingManager in Offline mode
- */
-export declare function fromObjectSyncTaskFactory(splitsParser: ISplitsParser, storage: {
-    splits: ISplitsCacheSync;
-}, readiness: IReadinessManager, settings: ISettings): ISyncTask<[], boolean>;

package/types/sync/polling/fetchers/mySegmentsFetcher.d.ts

@@ -1,7 +0,0 @@
-import { IFetchMemberships } from '../../../services/types';
-import { IMySegmentsFetcher } from './types';
-/**
- * Factory of MySegments fetcher.
- * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
- */
-export declare function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): IMySegmentsFetcher;

package/types/sync/polling/fetchers/segmentChangesFetcher.d.ts

@@ -1,7 +0,0 @@
-import { IFetchSegmentChanges } from '../../../services/types';
-import { ISegmentChangesFetcher } from './types';
-/**
- * Factory of SegmentChanges fetcher.
- * SegmentChanges fetcher is a wrapper around `segmentChanges` API service that parses the response and handle errors and retries.
- */
-export declare function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentChanges): ISegmentChangesFetcher;

package/types/sync/polling/fetchers/splitChangesFetcher.d.ts

@@ -1,7 +0,0 @@
-import { IFetchSplitChanges } from '../../../services/types';
-import { ISplitChangesFetcher } from './types';
-/**
- * Factory of SplitChanges fetcher.
- * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
- */
-export declare function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges): ISplitChangesFetcher;

package/types/sync/polling/fetchers/types.d.ts

@@ -1,5 +0,0 @@
-import { ISplitChangesResponse, ISegmentChangesResponse, IMembershipsResponse } from '../../../dtos/types';
-import { IResponse } from '../../../services/types';
-export declare type ISplitChangesFetcher = (since: number, noCache?: boolean, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<ISplitChangesResponse>;
-export declare type ISegmentChangesFetcher = (since: number, segmentName: string, noCache?: boolean, till?: number, decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>;
-export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<IMembershipsResponse>;

package/types/sync/polling/pollingManagerCS.d.ts

@@ -1,7 +0,0 @@
-import { IPollingManagerCS } from './types';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Expose start / stop mechanism for polling data from services.
- * For client-side API with multiple clients.
- */
-export declare function pollingManagerCSFactory(params: ISdkFactoryContextSync): IPollingManagerCS;

package/types/sync/polling/pollingManagerSS.d.ts

@@ -1,6 +0,0 @@
-import { IPollingManager } from './types';
-import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-/**
- * Expose start / stop mechanism for pulling data from services.
- */
-export declare function pollingManagerSSFactory(params: ISdkFactoryContextSync): IPollingManager;

package/types/sync/polling/syncTasks/mySegmentsSyncTask.d.ts

@@ -1,9 +0,0 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { IMySegmentsSyncTask } from '../types';
-import { IFetchMemberships } from '../../../services/types';
-import { ISettings } from '../../../types';
-/**
- * Creates a sync task that periodically executes a `mySegmentsUpdater` task
- */
-export declare function mySegmentsSyncTaskFactory(fetchMemberships: IFetchMemberships, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): IMySegmentsSyncTask;

package/types/sync/polling/syncTasks/segmentsSyncTask.d.ts

@@ -1,9 +0,0 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { ISegmentsSyncTask } from '../types';
-import { IFetchSegmentChanges } from '../../../services/types';
-import { ISettings } from '../../../types';
-/**
- * Creates a sync task that periodically executes a `segmentChangesUpdater` task
- */
-export declare function segmentsSyncTaskFactory(fetchSegmentChanges: IFetchSegmentChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings): ISegmentsSyncTask;

package/types/sync/polling/syncTasks/splitsSyncTask.d.ts

@@ -1,9 +0,0 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
-import { ISplitsSyncTask } from '../types';
-import { IFetchSplitChanges } from '../../../services/types';
-import { ISettings } from '../../../types';
-/**
- * Creates a sync task that periodically executes a `splitChangesUpdater` task
- */
-export declare function splitsSyncTaskFactory(fetchSplitChanges: IFetchSplitChanges, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, isClientSide?: boolean): ISplitsSyncTask;

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

@@ -1,33 +0,0 @@
-import { ISplit } from '../../dtos/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IStorageSync } from '../../storages/types';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
-import { ITask, ISyncTask } from '../types';
-export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: {
-    payload: ISplit;
-    changeNumber: number;
-}], boolean> {
-}
-export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> {
-}
-export declare type MySegmentsData = {
-    type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE;
-    cn: number;
-    added: string[];
-    removed: string[];
-};
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> {
-}
-export interface IPollingManager extends ITask {
-    syncAll(): Promise<any>;
-    splitsSyncTask: ISplitsSyncTask;
-    segmentsSyncTask: ISyncTask;
-}
-/**
- * PollingManager for client-side with support for multiple clients
- */
-export interface IPollingManagerCS extends IPollingManager {
-    add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask;
-    remove(matchingKey: string): void;
-    get(matchingKey: string): IMySegmentsSyncTask | undefined;
-}

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

@@ -1,14 +0,0 @@
-import { IMySegmentsFetcher } from '../fetchers/types';
-import { IStorageSync } from '../../../storages/types';
-import { ISegmentsEventEmitter } from '../../../readiness/types';
-import { ILogger } from '../../../logger/types';
-import { MySegmentsData } from '../types';
-declare type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>;
-/**
- * factory of MySegments updater, a task that:
- *  - fetches mySegments using `mySegmentsFetcher`
- *  - updates `mySegmentsCache`
- *  - uses `segmentsEventEmitter` to emit events related to segments data updates
- */
-export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, storage: IStorageSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
-export {};

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

@@ -1,18 +0,0 @@
-import { ISegmentChangesFetcher } from '../fetchers/types';
-import { ISegmentsCacheBase } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/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:
- *  - fetches segment changes using `segmentChangesFetcher`
- *  - updates `segmentsCache`
- *  - uses `segmentsEventEmitter` to emit events related to segments data updates
- *
- * @param log logger instance
- * @param segmentChangesFetcher fetcher of `/segmentChanges`
- * @param segments segments storage, with sync or async methods
- * @param readiness optional readiness manager. Not required for synchronizer or producer mode.
- */
-export declare function segmentChangesUpdaterFactory(log: ILogger, segmentChangesFetcher: ISegmentChangesFetcher, segments: ISegmentsCacheBase, readiness?: IReadinessManager): ISegmentChangesUpdater;
-export {};