@splitsoftware/splitio-commons 1.6.2-rc.4 → 1.6.2-rc.7

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

@@ -0,0 +1,37 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
+export declare class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+    private onFullQueue?;
+    private readonly maxStorage;
+    private uniqueTrackerSize;
+    private uniqueKeysTracker;
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    constructor(uniqueKeysQueueSize?: number);
+    setOnFullQueueCb(cb: () => void): void;
+    /**
+     * Store unique keys in sequential order
+     * key: string = key.
+     * value: HashSet<string> = set of split names.
+     */
+    track(key: string, featureName: string): void;
+    /**
+     * Clear the data stored on the cache.
+     */
+    clear(): void;
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    pop(): UniqueKeysPayloadCs;
+    /**
+     * Check if the cache is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    private fromUniqueKeysCollector;
+}

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

@@ -0,0 +1,9 @@
+import { ICountsCacheAsync } from '../types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+export declare class CountsCacheInRedis implements ICountsCacheAsync {
+    private readonly redis;
+    private readonly keys;
+    constructor(keys: KeyBuilderSS, redis: Redis);
+    track(metricName: string): Promise<boolean>;
+}

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

@@ -0,0 +1,32 @@
+import { IEventsCacheAsync } from '../types';
+import { IMetadata } from '../../dtos/types';
+import { Redis } from 'ioredis';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
+import { StoredEventWithMetadata } from '../../sync/submitters/types';
+export declare class EventsCacheInRedis implements IEventsCacheAsync {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly metadata;
+    constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
+    /**
+     * Add a new event object into the queue.
+     * Unlike `impressions::track`, result promise is never rejected.
+     */
+    track(eventData: SplitIO.EventData): Promise<boolean>;
+    /**
+     * Generates the JSON as we'll store it on Redis.
+     */
+    private _toJSON;
+    count(): Promise<number>;
+    drop(count?: number): Promise<any>;
+    /**
+     * Pop the given number of events from the storage.
+     * The returned promise rejects if the wrapper operation fails.
+     *
+     * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
+     * It is the submitter responsability to handle that.
+     */
+    popNWithMetadata(count: number): Promise<StoredEventWithMetadata[]>;
+}

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

@@ -0,0 +1,14 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+export declare class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate?: number);
+    postImpressionCountsInRedis(): false | Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    start(): void;
+    stop(): void;
+}

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

@@ -0,0 +1,18 @@
+import { IImpressionsCacheAsync } from '../types';
+import { IMetadata } from '../../dtos/types';
+import { ImpressionDTO } from '../../types';
+import { Redis } from 'ioredis';
+import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
+import { ILogger } from '../../logger/types';
+export declare class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly metadata;
+    constructor(log: ILogger, key: string, redis: Redis, metadata: IMetadata);
+    track(impressions: ImpressionDTO[]): Promise<void>;
+    private _toJSON;
+    count(): Promise<number>;
+    drop(count?: number): Promise<any>;
+    popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]>;
+}

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

@@ -0,0 +1,9 @@
+import { ILatenciesCacheAsync } from '../types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+export declare class LatenciesCacheInRedis implements ILatenciesCacheAsync {
+    private readonly redis;
+    private readonly keys;
+    constructor(keys: KeyBuilderSS, redis: Redis);
+    track(metricName: string, latency: number): Promise<boolean>;
+}

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

@@ -0,0 +1,24 @@
+import ioredis from 'ioredis';
+import { ILogger } from '../../logger/types';
+/**
+ * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
+ */
+export declare class RedisAdapter extends ioredis {
+    private readonly log;
+    private _options;
+    private _notReadyCommandsQueue?;
+    private _runningCommands;
+    constructor(log: ILogger, storageSettings: Record<string, any>);
+    _listenToEvents(): void;
+    _setTimeoutWrappers(): void;
+    _setDisconnectWrapper(): void;
+    /**
+     * Receives the options and returns an array of parameters for the ioredis constructor.
+     * Keeping both redis setup options for backwards compatibility.
+     */
+    static _defineLibrarySettings(options: Record<string, any>): any[];
+    /**
+     * Parses the options into what we care about.
+     */
+    static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>): object;
+}

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

@@ -0,0 +1,18 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { ISegmentsCacheAsync } from '../types';
+export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
+    private readonly log;
+    private readonly redis;
+    private readonly keys;
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    addToSegment(name: string, segmentKeys: string[]): Promise<boolean>;
+    removeFromSegment(name: string, segmentKeys: string[]): 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[]>;
+    clear(): Promise<boolean>;
+}

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

@@ -0,0 +1,92 @@
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
+import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+/**
+ * ISplitsCacheAsync implementation that stores split definitions in Redis.
+ * Supported by Node.
+ */
+export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
+    private readonly log;
+    private readonly redis;
+    private readonly keys;
+    private redisError?;
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    private _decrementCounts;
+    private _incrementCounts;
+    /**
+     * Add a given split.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., redis operation fails)
+     */
+    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, 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.
+     * or rejected if it fails (e.g., redis operation fails).
+     */
+    removeSplit(name: string): Promise<number>;
+    /**
+     * Remove a list of splits.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., redis operation fails).
+     */
+    removeSplits(names: string[]): Promise<any>;
+    /**
+     * Get split definition or null if it's not defined.
+     * Returned promise is rejected if redis operation fails.
+     */
+    getSplit(name: string): Promise<ISplit | null>;
+    /**
+     * Set till number.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails.
+     */
+    setChangeNumber(changeNumber: number): Promise<boolean>;
+    /**
+     * 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 redis operation fails.
+     * The promise will never be rejected.
+     */
+    getChangeNumber(): Promise<number>;
+    /**
+     * Get list of all split definitions.
+     * The returned promise is resolved with the list of split definitions,
+     * or rejected if redis operation fails.
+     *
+     * @TODO we need to benchmark which is the maximun number of commands we could
+     *       pipeline without kill redis performance.
+     */
+    getAll(): Promise<ISplit[]>;
+    /**
+     * Get list of split names.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if redis operation fails.
+     */
+    getSplitNames(): Promise<string[]>;
+    /**
+     * Check traffic type existence.
+     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+     * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
+     * It will never be rejected.
+     */
+    trafficTypeExists(trafficType: string): Promise<boolean>;
+    /**
+     * Delete everything in the current database.
+     *
+     * @NOTE documentation says it never fails.
+     */
+    clear(): Promise<boolean>;
+    /**
+     * Fetches multiple splits definitions.
+     * Returned promise is rejected if redis operation fails.
+     */
+    getSplits(names: string[]): Promise<Record<string, ISplit | null>>;
+}

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

@@ -0,0 +1,20 @@
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { ITelemetryCacheAsync } from '../types';
+import { Redis } from 'ioredis';
+export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly redis;
+    /**
+     * Create a Telemetry cache that uses Redis as storage.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param redis  Redis client.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
+    recordLatency(method: Method, latencyMs: number): Promise<number | void>;
+    recordException(method: Method): Promise<number | void>;
+    recordConfig(): Promise<number | void>;
+}

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

@@ -0,0 +1,4 @@
+export declare const LOG_PREFIX = "storage:redis: ";
+export declare const DEFAULT_CACHE_SIZE = 30000;
+export declare const REFRESH_RATE = 300000;
+export declare const TTL_REFRESH = 3600;

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

@@ -0,0 +1,10 @@
+import { IStorageAsyncFactory } from '../types';
+export interface InRedisStorageOptions {
+    prefix?: string;
+    options?: Record<string, any>;
+}
+/**
+ * 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): IStorageAsyncFactory;

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

@@ -0,0 +1,15 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+import { UniqueKeysCacheInMemory } from '../inMemory/uniqueKeysCacheInMemory';
+import { ILogger } from '../../logger/types';
+export declare class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+    private readonly log;
+    private readonly key;
+    private readonly redis;
+    private readonly refreshRate;
+    private intervalId;
+    constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize?: number, refreshRate?: number);
+    postUniqueKeysInRedis(): Promise<boolean | import("ioredis").BooleanResponse | undefined>;
+    start(): void;
+    stop(): void;
+}

package/types/storages/metadataBuilder.d.ts

@@ -0,0 +1,3 @@
+import { IMetadata } from '../dtos/types';
+import { ISettings } from '../types';
+export declare function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata;

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

@@ -0,0 +1,38 @@
+import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
+import { IMetadata } from '../../dtos/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;
+    private readonly wrapper;
+    private readonly key;
+    private readonly metadata;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
+    /**
+     * Push given event to the storage.
+     * @param eventData  Event item to push.
+     * @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: SplitIO.EventData): Promise<boolean>;
+    private _toJSON;
+    /**
+     * Returns a promise that resolves with the count of stored events, or 0 if there was some error.
+     * The promise will never be rejected.
+     */
+    count(): Promise<number>;
+    /**
+     * Removes the given number of events from the store. If a number is not provided, it deletes all items.
+     * The returned promise rejects if the wrapper operation fails.
+     */
+    drop(count?: number): Promise<any>;
+    /**
+     * Pop the given number of events from the storage.
+     * The returned promise rejects if the wrapper operation fails.
+     *
+     * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
+     * It is the submitter responsability to handle that.
+     */
+    popNWithMetadata(count: number): Promise<StoredEventWithMetadata[]>;
+}

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

@@ -0,0 +1,35 @@
+import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
+import { IMetadata } from '../../dtos/types';
+import { ImpressionDTO } from '../../types';
+import { ILogger } from '../../logger/types';
+import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
+export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync {
+    private readonly log;
+    private readonly key;
+    private readonly wrapper;
+    private readonly metadata;
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
+    /**
+     * Push given impressions to the storage.
+     * @param impressions  List of impresions to push.
+     * @returns  A promise that is resolved if the push operation succeeded
+     * or rejected if the wrapper operation fails.
+     */
+    track(impressions: ImpressionDTO[]): Promise<void>;
+    private _toJSON;
+    /**
+     * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
+     * The promise will never be rejected.
+     */
+    count(): Promise<number>;
+    /**
+     * Removes the given number of impressions from the store. If a number is not provided, it deletes all items.
+     * The returned promise rejects if the wrapper operation fails.
+     */
+    drop(count?: number): Promise<void>;
+    /**
+     * Pop the given number of impressions from the store.
+     * The returned promise rejects if the wrapper operation fails.
+     */
+    popNWithMetadata(count: number): Promise<StoredImpressionWithMetadata[]>;
+}

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

@@ -0,0 +1,54 @@
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
+import { ILogger } from '../../logger/types';
+/**
+ * ISegmentsCacheAsync implementation for pluggable storages.
+ */
+export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
+    private readonly log;
+    private readonly keys;
+    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.
+     */
+    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
+    /**
+     * 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.
+     * The promise will never be rejected.
+     */
+    getChangeNumber(name: string): Promise<number>;
+    /**
+     * Add the given segment names to the set of registered segments.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    registerSegments(segments: string[]): Promise<boolean | void>;
+    /**
+     * Returns a promise that resolves with the set of registered segments in a list,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    getRegisteredSegments(): Promise<string[]>;
+    /** @TODO implement if required by DataLoader or Producer mode  */
+    clear(): Promise<boolean>;
+}

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

@@ -0,0 +1,90 @@
+import { KeyBuilder } from '../KeyBuilder';
+import { IPluggableStorageWrapper } from '../types';
+import { ILogger } from '../../logger/types';
+import { ISplit } from '../../dtos/types';
+import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
+/**
+ * ISplitsCacheAsync implementation for pluggable storages.
+ */
+export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly wrapper;
+    /**
+     * Create a SplitsCache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param wrapper  Adapted wrapper storage.
+     */
+    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper);
+    private _decrementCounts;
+    private _incrementCounts;
+    /**
+     * Add a given split.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., wrapper operation fails)
+     */
+    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, 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.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    removeSplit(name: string): Promise<boolean | void>;
+    /**
+     * Remove a list of splits.
+     * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    removeSplits(names: string[]): Promise<void>;
+    /**
+     * Get split.
+     * 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<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, 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<ISplit[]>;
+    /**
+     * Get list of split names.
+     * The returned promise is resolved with the list of split names,
+     * or rejected if wrapper operation fails.
+     */
+    getSplitNames(): Promise<string[]>;
+    /**
+     * Check traffic type existence.
+     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+     * In case of wrapper operation failures, the promise resolves with a true value, assuming that the TT might exist.
+     * It will never be rejected.
+     */
+    trafficTypeExists(trafficType: string): Promise<boolean>;
+    /**
+     * Set till number.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails (e.g., wrapper operation fails).
+     */
+    setChangeNumber(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.
+     * The promise will never be rejected.
+     */
+    getChangeNumber(): Promise<number>;
+    clear(): Promise<boolean>;
+}

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

@@ -0,0 +1,18 @@
+import { ILogger } from '../../logger/types';
+import { Method } from '../../sync/submitters/types';
+import { KeyBuilderSS } from '../KeyBuilderSS';
+import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
+export declare class TelemetryCachePluggable implements ITelemetryCacheAsync {
+    private readonly log;
+    private readonly keys;
+    private readonly wrapper;
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param wrapper  Adapted wrapper storage.
+     */
+    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
+    recordLatency(method: Method, latencyMs: number): Promise<number | void>;
+    recordException(method: Method): Promise<number | void>;
+}

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

@@ -0,0 +1 @@
+export declare const LOG_PREFIX = "storage:pluggable: ";

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

@@ -0,0 +1,13 @@
+import { IPluggableStorageWrapper } from '../types';
+import { ISet } from '../../utils/lang/sets';
+/**
+ * Creates a IPluggableStorageWrapper implementation that stores items in memory.
+ * The `_cache` property is the object were items are stored.
+ * Intended for testing purposes.
+ *
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
+ */
+export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
+    _cache: Record<string, string | string[] | ISet<string>>;
+    _setConnDelay(connDelay: number): void;
+};

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

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

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

@@ -0,0 +1,12 @@
+import { ILogger } from '../../logger/types';
+import { IPluggableStorageWrapper } from '../types';
+export declare const METHODS_TO_PROMISE_WRAP: string[];
+/**
+ * Adapter of the Pluggable Storage Wrapper.
+ * Used to handle exceptions as rejected promises, in order to simplify the error handling on storages.
+ *
+ * @param log logger instance
+ * @param wrapper storage wrapper to adapt
+ * @returns an adapted version of the given storage wrapper
+ */
+export declare function wrapperAdapter(log: ILogger, wrapper: IPluggableStorageWrapper): IPluggableStorageWrapper;