@splitsoftware/splitio-commons 1.0.1-rc.6 → 1.2.1-rc.0

package/types/sdkClient/clientAttributesDecoration.d.ts

@@ -0,0 +1,51 @@
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
+ */
+export declare function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient): TClient & {
+    getTreatment: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => string | SplitIO.AsyncTreatment;
+    getTreatmentWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentWithConfig | SplitIO.AsyncTreatmentWithConfig;
+    getTreatments: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.Treatments | SplitIO.AsyncTreatments;
+    getTreatmentsWithConfig: (maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes | undefined) => SplitIO.TreatmentsWithConfig | SplitIO.AsyncTreatmentsWithConfig;
+    track: (maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number | undefined, maybeProperties?: SplitIO.Properties | undefined) => import("../dtos/types").MaybeThenable<boolean>;
+    /**
+     * Add an attribute to client's in memory attributes storage
+     *
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean;
+    /**
+     * Returns the attribute with the given key
+     *
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     *
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean;
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     *
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>;
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     *
+     * @param {string} attributeName
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean;
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean;
+};

package/types/sdkClient/clientCS.d.ts

@@ -1,3 +1,4 @@
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
 /**
  * Decorator that binds a key and (optionally) a traffic type to client methods
@@ -6,4 +7,4 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export declare function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;
+export declare function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient;

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

@@ -0,0 +1,43 @@
+export declare class AttributesCacheInMemory {
+    private attributesCache;
+    /**
+     * Create or update the value for the given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @param {Object} attributeValue attribute value
+     * @returns {boolean} the attribute was stored
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean;
+    /**
+     * Retrieves the value of a given attribute
+     *
+     * @param {string} attributeName attribute name
+     * @returns {Object?} stored attribute value
+     */
+    getAttribute(attributeName: string): Object;
+    /**
+     * Create or update all the given attributes
+     *
+     * @param {[string, Object]} attributes attributes to create or update
+     * @returns {boolean} attributes were stored
+     */
+    setAttributes(attributes: Record<string, Object>): boolean;
+    /**
+     * Retrieve the full attributes map
+     *
+     * @returns {Map<string, Object>} stored attributes
+     */
+    getAll(): Record<string, Object>;
+    /**
+     * Removes a given attribute from the map
+     *
+     * @param {string} attributeName attribute to remove
+     * @returns {boolean} attribute removed
+     */
+    removeAttribute(attributeName: string): boolean;
+    /**
+     * Clears all attributes stored in the SDK
+     *
+     */
+    clear(): boolean;
+}

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

@@ -0,0 +1,51 @@
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType } from '../../sync/submitters/types';
+import { TelemetryCacheSync } from '../types';
+export declare class TelemetryCacheInMemory implements TelemetryCacheSync {
+    private timeUntilReady?;
+    getTimeUntilReady(): number | undefined;
+    recordTimeUntilReady(ms: number): void;
+    private timeUntilReadyFromCache?;
+    getTimeUntilReadyFromCache(): number | undefined;
+    recordTimeUntilReadyFromCache(ms: number): void;
+    private notReadyUsage;
+    getNonReadyUsage(): number;
+    recordNonReadyUsage(): void;
+    private impressionStats;
+    getImpressionStats(type: ImpressionDataType): number;
+    recordImpressionStats(type: ImpressionDataType, count: number): void;
+    private eventStats;
+    getEventStats(type: EventDataType): number;
+    recordEventStats(type: EventDataType, count: number): void;
+    private lastSync;
+    getLastSynchronization(): Record<OperationType, number | undefined>;
+    recordSuccessfulSync(resource: OperationType, timeMs: number): void;
+    private httpErrors;
+    popHttpErrors(): Record<OperationType, {
+        [statusCode: string]: number;
+    }>;
+    recordSyncError(resource: OperationType, status: number): void;
+    private httpLatencies;
+    popHttpLatencies(): Record<OperationType, number[]>;
+    recordSyncLatency(resource: OperationType, latencyMs: number): void;
+    private authRejections;
+    popAuthRejections(): number;
+    recordAuthRejections(): void;
+    private tokenRefreshes;
+    popTokenRefreshes(): number;
+    recordTokenRefreshes(): void;
+    private streamingEvents;
+    popStreamingEvents(): StreamingEvent[];
+    recordStreamingEvents(streamingEvent: StreamingEvent): void;
+    private tags;
+    popTags(): string[];
+    addTag(tag: string): void;
+    private sessionLength?;
+    getSessionLength(): number | undefined;
+    recordSessionLength(ms: number): void;
+    private exceptions;
+    popExceptions(): Record<Method, number>;
+    recordException(method: Method): void;
+    private latencies;
+    popLatencies(): Record<Method, number[]>;
+    recordLatency(method: Method, latencyMs: number): void;
+}

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

@@ -0,0 +1,2 @@
+export declare class TelemetryCachePluggable {
+}

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

@@ -0,0 +1,17 @@
+import { ISyncTask, ITimeTracker } from '../types';
+import { IPostMetricsUsage } from '../../services/types';
+import { IStorageSync, TelemetryCacheSync } from '../../storages/types';
+import { TelemetryStatsPayload } from './types';
+import { ILogger } from '../../logger/types';
+/**
+ * Converts `impressions` data from cache into request payload.
+ */
+export declare function telemetryCacheAdapter(telemetryCache: TelemetryCacheSync, storage: IStorageSync): {
+    isEmpty(): boolean;
+    clear(): void;
+    state(): TelemetryStatsPayload;
+};
+/**
+ * Sync task that periodically posts impressions data
+ */
+export declare function telemetrySyncTaskFactory(log: ILogger, postMetricsUsage: IPostMetricsUsage, telemetryCache: TelemetryCacheSync, telemetryRefreshRate: number, latencyTracker: ITimeTracker, storage: IStorageSync): ISyncTask;

package/types/types.d.ts

@@ -375,6 +375,7 @@ interface IBasicClient extends IStatusInterface {
      * @returns {Promise<void>}
      */
     destroy(): Promise<void>;
+    isBrowserClient: boolean;
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -1108,6 +1109,45 @@ export declare namespace SplitIO {
          * @returns {boolean} Whether the event was added to the queue succesfully or not.
          */
         track(...args: [trafficType: string, eventType: string, value?: number, properties?: Properties] | [eventType: string, value?: number, properties?: Properties]): boolean;
+        /**
+         * Add an attribute to client's in memory attributes storage
+         * @function setAttribute
+         * @param {string} attributeName Attrinute name
+         * @param {string, number, boolean, list} attributeValue Attribute value
+         * @returns {boolean} true if the attribute was stored and false otherways
+         */
+        setAttribute(attributeName: string, attributeValue: Object): boolean;
+        /**
+         * Returns the attribute with the given key
+         * @function getAttribute
+         * @param {string} attributeName Attribute name
+         * @returns {Object} Attribute with the given key
+         */
+        getAttribute(attributeName: string): Object;
+        /**
+         * Add to client's in memory attributes storage the attributes in 'attributes'
+         * @function setAttributes
+         * @param {Object} attributes Object with attributes to store
+         * @returns true if attributes were stored an false otherways
+         */
+        setAttributes(attributes: Record<string, Object>): boolean;
+        /**
+         * Return all the attributes stored in client's in memory attributes storage
+         * @function getAttributes
+         * @returns {Object} returns all the stored attributes
+         */
+        getAttributes(): Record<string, Object>;
+        /**
+         * Removes from client's in memory attributes storage the attribute with the given key
+         * @function removeAttribute
+         * @param {string} attributeName
+         * @returns {boolean} true if attribute was removed and false otherways
+         */
+        removeAttribute(attributeName: string): boolean;
+        /**
+         * Remove all the stored attributes in the client's in memory attribute storage
+         */
+        clearAttributes(): boolean;
     }
     /**
      * Representation of a manager instance with synchronous storage of the SDK.

package/types/utils/EventEmitter.d.ts

@@ -0,0 +1,4 @@
+import { IEventEmitter } from '../types';
+export declare const EventEmitter: {
+    new (): IEventEmitter;
+};

package/types/utils/inputValidation/attribute.d.ts

@@ -0,0 +1,2 @@
+import { ILogger } from '../../logger/types';
+export declare function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean;

package/types/utils/inputValidation/attributes.d.ts

@@ -1,3 +1,4 @@
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 export declare function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false;
+export declare function validateAttributesDeep(log: ILogger, maybeAttributes: Record<string, Object>, method: string): boolean;

package/types/utils/murmur3/legacy.d.ts

@@ -0,0 +1,2 @@
+export declare function hash(str: string, seed: number): number;
+export declare function bucket(str: string, seed: number): number;