@splitsoftware/splitio-commons 1.12.1-rc.3 → 1.12.1-rc.5

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,11 +1,11 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
 import { ISplitFiltersValidation } from '../../dtos/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
-import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_SPLITS_FILTER_LOWERCASE_SET, WARN_SPLITS_FILTER_INVALID_SET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
+import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_LOWERCASE_FLAGSET, WARN_INVALID_FLAGSET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
+import { isConsumerMode } from './mode';
 
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
@@ -54,7 +54,7 @@ function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values
   if (result) {
 
     if (type === 'bySet') {
-      result = sanitizeFlagSets(log, result);
+      result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
     }
 
     // check max length
@@ -88,7 +88,7 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
 }
 
 /**
- * Sanitizes set names list taking in account:
+ * Sanitizes set names list taking into account:
  *  - It should be lowercase
  *  - Must adhere the following regular expression /^[a-z0-9][_a-z0-9]{0,49}$/ that means
  *   - must start with a letter or number
@@ -98,20 +98,21 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
  *
  * @param {ILogger} log
  * @param {string[]} flagSets
+ * @param {string} method
  * @returns sanitized list of set names
  */
-function sanitizeFlagSets(log: ILogger, flagSets: string[]) {
+function sanitizeFlagSets(log: ILogger, flagSets: string[], method: string) {
   let sanitizedSets = flagSets
     .map(flagSet => {
       if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
-        log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
+        log.warn(WARN_LOWERCASE_FLAGSET, [method, flagSet]);
         flagSet = flagSet.toLowerCase();
       }
       return flagSet;
     })
     .filter(flagSet => {
       if (!VALID_FLAGSET_REGEX.test(flagSet)) {
-        log.warn(WARN_SPLITS_FILTER_INVALID_SET, [flagSet, VALID_FLAGSET_REGEX, flagSet]);
+        log.warn(WARN_INVALID_FLAGSET, [method, flagSet, VALID_FLAGSET_REGEX, flagSet]);
         return false;
       }
       if (typeof flagSet !== 'string') return false;
@@ -148,7 +149,7 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
   if (!maybeSplitFilters) return res;
   // Warn depending on the mode
-  if (mode === CONSUMER_MODE || mode === CONSUMER_PARTIAL_MODE) {
+  if (isConsumerMode(mode)) {
     log.warn(WARN_SPLITS_FILTER_IGNORED);
     return res;
   }
@@ -188,9 +189,9 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode:
   return res;
 }
 
-export function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] {
+export function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] {
   const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
-  let toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+  let toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
   if (flagSetsInConfig.length > 0) {
     toReturn = toReturn.filter(flagSet => {
       if (flagSetsInConfig.indexOf(flagSet) > -1) {

package/types/logger/constants.d.ts

@@ -95,8 +95,8 @@ export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
 export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
-export declare const WARN_SPLITS_FILTER_INVALID_SET = 225;
-export declare const WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export declare const WARN_INVALID_FLAGSET = 225;
+export declare const WARN_LOWERCASE_FLAGSET = 226;
 export declare const WARN_FLAGSET_NOT_CONFIGURED = 227;
 export declare const WARN_FLAGSET_WITHOUT_FLAGS = 228;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;

package/types/storages/AbstractSplitsCache.d.ts

@@ -0,0 +1,46 @@
+import { ISplit, MaybeThenable } from '../dtos/types';
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+export declare abstract class AbstractSplitsCache {
+    /**
+     * Check if the splits information is already stored in cache. This data can be preloaded.
+     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+     */
+    checkCache(): boolean;
+    protected abstract addSplit(name: string, split: ISplit): MaybeThenable<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).
+     */
+    protected addSplits(entries: [string, ISplit][]): Promise<boolean[]>;
+    protected abstract removeSplit(name: string): MaybeThenable<boolean>;
+    /**
+     * 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).
+     */
+    protected removeSplits(names: string[]): Promise<boolean[]>;
+    protected abstract setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>;
+    /**
+     * Updates the cache with the provided changeNumber, feature flags to add and feature flags to remove.
+     *
+     * @returns {Promise<boolean>} a promise that resolved once the operation is performed successfully. The fulfillment value is `true` if at least one feature flag was added, modified or removed; or `false` if there was no change.
+     * The promise will reject if some storage operation rejects.
+     */
+    update(changeNumber: number, toAdd: [string, ISplit][], toRemove?: string[]): Promise<boolean>;
+    abstract getSplit(name: string): MaybeThenable<ISplit | null>;
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @param {string} name
+     * @param {string} defaultTreatment
+     * @param {number} changeNumber
+     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
+     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     * The promise will never be rejected.
+     */
+    killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
+}

package/types/storages/KeyBuilder.d.ts

@@ -1,6 +1,7 @@
+import { ISettings } from '../types';
 export declare function validatePrefix(prefix: unknown): string;
 export declare class KeyBuilder {
-    protected readonly prefix: string;
+    readonly prefix: string;
     constructor(prefix?: string);
     buildTrafficTypeKey(trafficType: string): string;
     buildFlagSetKey(flagSet: string): string;
@@ -12,4 +13,10 @@ export declare class KeyBuilder {
     buildSegmentNameKey(segmentName: string): string;
     buildSegmentTillKey(segmentName: string): string;
     extractKey(builtKey: string): string;
+    buildHashKey(): string;
 }
+/**
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
+ * The hash is in hexadecimal format (8 characters max, 32 bits).
+ */
+export declare function getStorageHash(settings: ISettings): string;

package/types/storages/KeyBuilderCS.d.ts

@@ -12,5 +12,4 @@ export declare class KeyBuilderCS extends KeyBuilder {
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
-    buildSplitsFilterQueryKey(): string;
 }

package/types/storages/KeyBuilderSS.d.ts

@@ -3,10 +3,10 @@ import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
 export declare const METHOD_NAMES: Record<Method, string>;
 export declare class KeyBuilderSS extends KeyBuilder {
-    latencyPrefix: string;
-    exceptionPrefix: string;
-    initPrefix: string;
-    private versionablePrefix;
+    readonly latencyPrefix: string;
+    readonly exceptionPrefix: string;
+    readonly initPrefix: string;
+    private readonly versionablePrefix;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
     buildImpressionsKey(): string;

package/types/storages/inLocalStorage/SplitsCacheInLocal.d.ts

@@ -1,15 +1,15 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ILogger } from '../../logger/types';
 import { ISet } from '../../utils/lang/sets';
+import { ISettings } from '../../types';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
 export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
-    private readonly log;
     private readonly keys;
-    private readonly splitFiltersValidation;
+    private readonly log;
+    private readonly storageHash;
     private readonly flagSetsFilter;
     private hasSync?;
     private updateNewFilter?;
@@ -18,7 +18,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      * @param {number | undefined} expirationTimestamp
      * @param {ISplitFiltersValidation} splitFiltersValidation
      */
-    constructor(log: ILogger, keys: KeyBuilderCS, expirationTimestamp?: number, splitFiltersValidation?: ISplitFiltersValidation);
+    constructor(settings: ISettings, keys: KeyBuilderCS, expirationTimestamp?: number);
     private _decrementCount;
     private _decrementCounts;
     private _incrementCounts;

package/types/utils/constants/index.d.ts

@@ -24,6 +24,18 @@ export declare const STORAGE_PLUGGABLE: StorageType;
 export declare const CONSENT_GRANTED = "GRANTED";
 export declare const CONSENT_DECLINED = "DECLINED";
 export declare const CONSENT_UNKNOWN = "UNKNOWN";
+export declare const GET_TREATMENT = "getTreatment";
+export declare const GET_TREATMENTS = "getTreatments";
+export declare const GET_TREATMENT_WITH_CONFIG = "getTreatmentWithConfig";
+export declare const GET_TREATMENTS_WITH_CONFIG = "getTreatmentsWithConfig";
+export declare const GET_TREATMENTS_BY_FLAG_SET = "getTreatmentsByFlagSet";
+export declare const GET_TREATMENTS_BY_FLAG_SETS = "getTreatmentsByFlagSets";
+export declare const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = "getTreatmentsWithConfigByFlagSet";
+export declare const GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = "getTreatmentsWithConfigByFlagSets";
+export declare const TRACK_FN_LABEL = "track";
+export declare const SPLIT_FN_LABEL = "split";
+export declare const SPLITS_FN_LABEL = "splits";
+export declare const NAMES_FN_LABEL = "names";
 export declare const QUEUED = 0;
 export declare const DROPPED = 1;
 export declare const DEDUPED = 2;

package/types/utils/lang/sets.d.ts

@@ -58,5 +58,5 @@ interface ISetConstructor {
 export declare function __getSetConstructor(): ISetConstructor;
 export declare const _Set: ISetConstructor;
 export declare function returnSetsUnion<T>(set: ISet<T>, set2: ISet<T>): ISet<T>;
-export declare function returnListDifference<T>(list?: T[], list2?: T[]): T[];
+export declare function returnDifference<T>(list?: T[], list2?: T[]): T[];
 export {};

package/types/utils/settingsValidation/mode.d.ts

@@ -1 +1,5 @@
-export declare function mode(key: string, mode: string): string;
+export declare function validateMode(key: string, mode: string): string;
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export declare function isConsumerMode(mode: string): boolean;

package/types/utils/settingsValidation/splitFilters.d.ts

@@ -14,4 +14,4 @@ import { ILogger } from '../../logger/types';
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
 export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation;
-export declare function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];
+export declare function validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];

package/cjs/trackers/impressionObserver/utils.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStorageSync = void 0;
-var constants_1 = require("../../utils/constants");
-/**
- * Storage is async if mode is consumer or partial consumer
- */
-function isStorageSync(settings) {
-    return [constants_1.CONSUMER_MODE, constants_1.CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
-}
-exports.isStorageSync = isStorageSync;

package/cjs/utils/redis/RedisMock.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisMock = void 0;
-//@ts-nocheck
-function identityFunction(data) {
-    return data;
-}
-function asyncFunction(data) {
-    return Promise.resolve(data);
-}
-var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby'];
-var PIPELINE_METHODS = ['rpush', 'hincrby'];
-var RedisMock = /** @class */ (function () {
-    function RedisMock() {
-        var _this = this;
-        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
-        IDENTITY_METHODS.forEach(function (method) {
-            _this[method] = jest.fn(identityFunction);
-        });
-        ASYNC_METHODS.forEach(function (method) {
-            _this[method] = jest.fn(asyncFunction);
-        });
-        PIPELINE_METHODS.forEach(function (method) {
-            _this.pipelineMethods[method] = _this[method];
-        });
-        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
-    }
-    return RedisMock;
-}());
-exports.RedisMock = RedisMock;

package/esm/trackers/impressionObserver/utils.js

@@ -1,7 +0,0 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';
-/**
- * Storage is async if mode is consumer or partial consumer
- */
-export function isStorageSync(settings) {
-    return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
-}

package/esm/utils/redis/RedisMock.js

@@ -1,28 +0,0 @@
-//@ts-nocheck
-function identityFunction(data) {
-    return data;
-}
-function asyncFunction(data) {
-    return Promise.resolve(data);
-}
-var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby'];
-var PIPELINE_METHODS = ['rpush', 'hincrby'];
-var RedisMock = /** @class */ (function () {
-    function RedisMock() {
-        var _this = this;
-        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
-        IDENTITY_METHODS.forEach(function (method) {
-            _this[method] = jest.fn(identityFunction);
-        });
-        ASYNC_METHODS.forEach(function (method) {
-            _this[method] = jest.fn(asyncFunction);
-        });
-        PIPELINE_METHODS.forEach(function (method) {
-            _this.pipelineMethods[method] = _this[method];
-        });
-        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
-    }
-    return RedisMock;
-}());
-export { RedisMock };

package/src/trackers/impressionObserver/utils.ts

@@ -1,9 +0,0 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';
-import { ISettings } from '../../types';
-
-/**
- * Storage is async if mode is consumer or partial consumer
- */
-export function isStorageSync(settings: Pick<ISettings, 'mode'>) {
-  return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
-}

package/src/utils/redis/RedisMock.ts

@@ -1,31 +0,0 @@
-//@ts-nocheck
-function identityFunction(data: any): any {
-  return data;
-}
-
-function asyncFunction(data: any): Promise<any> {
-  return Promise.resolve(data);
-}
-
-const IDENTITY_METHODS: string[] = [];
-const ASYNC_METHODS = ['rpush', 'hincrby'];
-const PIPELINE_METHODS = ['rpush', 'hincrby'];
-
-export class RedisMock {
-
-  private pipelineMethods: any = { exec: jest.fn(asyncFunction) };
-
-  constructor() {
-    IDENTITY_METHODS.forEach(method => {
-      this[method] = jest.fn(identityFunction);
-    });
-    ASYNC_METHODS.forEach(method => {
-      this[method] = jest.fn(asyncFunction);
-    });
-    PIPELINE_METHODS.forEach(method => {
-      this.pipelineMethods[method] = this[method];
-    });
-
-    this.pipeline = jest.fn(() => { return this.pipelineMethods; });
-  }
-}