@splitsoftware/splitio-commons 1.10.1-rc.4 → 1.12.1-rc.0

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,8 +1,9 @@
+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_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_SPLITS_FILTER_LOWERCASE_SET, WARN_SPLITS_FILTER_INVALID_SET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
 
@@ -102,15 +103,15 @@ function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, stri
 function sanitizeFlagSets(log: ILogger, flagSets: string[]) {
   let sanitizedSets = flagSets
     .map(flagSet => {
-      if (CAPITAL_LETTERS_REGEX.test(flagSet)){
-        log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET,[flagSet]);
+      if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
+        log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET, [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]);
+      if (!VALID_FLAGSET_REGEX.test(flagSet)) {
+        log.warn(WARN_SPLITS_FILTER_INVALID_SET, [flagSet, VALID_FLAGSET_REGEX, flagSet]);
         return false;
       }
       if (typeof flagSet !== 'string') return false;
@@ -128,6 +129,7 @@ function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: Split
  *
  * @param {ILogger} log logger
  * @param {any} maybeSplitFilters split filters configuration param provided by the user
+ * @param {string} mode settings mode
  * @returns it returns an object with the following properties:
  *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.
  *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.
@@ -135,7 +137,7 @@ function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: Split
  *
  * @throws Error if the some of the grouped list of values per filter exceeds the max allowed length
  */
-export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISplitFiltersValidation {
+export function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation {
   // Validation result schema
   const res = {
     validFilters: [],
@@ -145,6 +147,11 @@ export function validateSplitFilters(log: ILogger, maybeSplitFilters: any): ISpl
 
   // 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) {
+    log.warn(WARN_SPLITS_FILTER_IGNORED);
+    return res;
+  }
   // Check collection type
   if (!Array.isArray(maybeSplitFilters) || maybeSplitFilters.length === 0) {
     log.warn(WARN_SPLITS_FILTER_EMPTY);

package/types/evaluator/index.d.ts

@@ -5,4 +5,4 @@ import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 export declare function evaluateFeature(log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<IEvaluationResult>;
 export declare function evaluateFeatures(log: ILogger, key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;
-export declare function evaluateFeaturesByFlagSets(log: ILogger, key: SplitIO.SplitKey, flagSets: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync): MaybeThenable<Record<string, IEvaluationResult>>;
+export declare function evaluateFeaturesByFlagSets(log: ILogger, key: SplitIO.SplitKey, flagSets: string[], attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync, method: string): MaybeThenable<Record<string, IEvaluationResult>>;

package/types/logger/constants.d.ts

@@ -89,6 +89,7 @@ export declare const WARN_NOT_EXISTENT_SPLIT = 215;
 export declare const WARN_LOWERCASE_TRAFFIC_TYPE = 216;
 export declare const WARN_NOT_EXISTENT_TT = 217;
 export declare const WARN_INTEGRATION_INVALID = 218;
+export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
@@ -97,6 +98,7 @@ 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_FLAGSET_NOT_CONFIGURED = 227;
+export declare const WARN_FLAGSET_WITHOUT_FLAGS = 228;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;

package/types/storages/AbstractSplitsCacheAsync.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AbstractSplitsCacheAsync implements ISplitsCacheAs
     abstract getChangeNumber(): Promise<number>;
     abstract getAll(): Promise<ISplit[]>;
     abstract getSplitNames(): Promise<string[]>;
-    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>;
+    abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     abstract trafficTypeExists(trafficType: string): Promise<boolean>;
     abstract clear(): Promise<boolean | void>;
     usesSegments(): Promise<boolean>;

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -35,7 +35,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
      * 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.
      */
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    abstract getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).

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

@@ -48,7 +48,7 @@ export declare class SplitsCacheInLocal extends AbstractSplitsCacheSync {
      */
     private _checkExpiration;
     private _checkFilterQuery;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

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

@@ -22,7 +22,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     getSplitNames(): string[];
     trafficTypeExists(trafficType: string): boolean;
     usesSegments(): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
     private addToFlagSets;
     private removeFromFlagSets;
     private removeNames;

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

@@ -78,7 +78,7 @@ export declare class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
      * or rejected if wrapper operation fails.
      * @todo this is a no-op method to be implemented
     */
-    getNamesByFlagSets(): Promise<ISet<string>>;
+    getNamesByFlagSets(): Promise<ISet<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

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

@@ -1,7 +1,7 @@
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
-import { ISplit } from '../../dtos/types';
+import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
 import { ISet } from '../../utils/lang/sets';
 /**
@@ -11,15 +11,17 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;
+    private readonly flagSetsFilter;
     /**
      * 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);
+    constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper, splitFiltersValidation?: ISplitFiltersValidation);
     private _decrementCounts;
     private _incrementCounts;
+    private _updateFlagSets;
     /**
      * Add a given split.
      * The returned promise is resolved when the operation success
@@ -37,7 +39,7 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
      * 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>;
+    removeSplit(name: string): Promise<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.
@@ -71,10 +73,9 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     /**
      * Get list of split names related to a given flag set names list.
      * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     * @todo this is a no-op method to be implemented
+     * or rejected if any wrapper operation fails.
     */
-    getNamesByFlagSets(): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/types/storages/types.d.ts

@@ -41,10 +41,10 @@ export interface IPluggableStorageWrapper {
      *
      * @function del
      * @param {string} key Item to delete
-     * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
+     * @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 | void>;
+    del: (key: string) => Promise<boolean>;
     /**
      * Returns all keys matching the given prefix.
      *
@@ -193,7 +193,7 @@ export interface ISplitsCacheBase {
     clear(): MaybeThenable<boolean | void>;
     checkCache(): MaybeThenable<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): MaybeThenable<boolean>;
-    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): MaybeThenable<ISet<string>[]>;
 }
 export interface ISplitsCacheSync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): boolean[];
@@ -209,7 +209,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
     clear(): void;
     checkCache(): boolean;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean;
-    getNamesByFlagSets(flagSets: string[]): ISet<string>;
+    getNamesByFlagSets(flagSets: string[]): ISet<string>[];
 }
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
     addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>;
@@ -225,7 +225,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
     clear(): Promise<boolean | void>;
     checkCache(): Promise<boolean>;
     killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>;
-    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>;
+    getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]>;
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {

package/types/types.d.ts

@@ -191,8 +191,6 @@ interface ISharedSettings {
          * List of feature flag filters. These filters are used to fetch a subset of the feature flag definitions in your environment, in order to reduce the delay of the SDK to be ready.
          * This configuration is only meaningful when the SDK is working in "standalone" mode.
          *
-         * At the moment, only one type of feature flag filter is supported: by name.
-         *
          * Example:
          *  `splitFilter: [
          *    { type: 'byName', values: ['my_feature_flag_1', 'my_feature_flag_2'] }, // will fetch feature flags named 'my_feature_flag_1' and 'my_feature_flag_2'

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

@@ -58,4 +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 {};

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

@@ -5,6 +5,7 @@ import { ILogger } from '../../logger/types';
  *
  * @param {ILogger} log logger
  * @param {any} maybeSplitFilters split filters configuration param provided by the user
+ * @param {string} mode settings mode
  * @returns it returns an object with the following properties:
  *  - `validFilters`: the validated `splitFilters` configuration object defined by the user.
  *  - `queryString`: the parsed split filter query. it is null if all filters are invalid or all values in filters are invalid.
@@ -12,5 +13,5 @@ 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): ISplitFiltersValidation;
+export declare function validateSplitFilters(log: ILogger, maybeSplitFilters: any, mode: string): ISplitFiltersValidation;
 export declare function flagSetsAreValid(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[];