@splitsoftware/splitio-commons 1.9.2-rc.1 → 1.9.2

package/esm/utils/lang/sets.js

@@ -95,10 +95,3 @@ export function __getSetConstructor() {
     return SetPoly;
 }
 export var _Set = __getSetConstructor();
-export function returnSetsUnion(set, set2) {
-    var result = new _Set(setToArray(set));
-    set2.forEach(function (value) {
-        result.add(value);
-    });
-    return result;
-}

package/esm/utils/settingsValidation/index.js

@@ -137,7 +137,7 @@ export function settingsValidation(config, validationParams) {
         }
         else {
             // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
-            // `false` value is used as binded key/TT of the default client, which leads to some issues.
+            // `false` value is used as bound key/TT of the default client, which leads to some issues.
             // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
             withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
         }

package/esm/utils/settingsValidation/splitFilters.js

@@ -1,16 +1,9 @@
 import { STANDALONE_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-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';
+import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS } from '../../logger/constants';
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
 var FILTERS_METADATA = [
-    {
-        type: 'bySet',
-        maxLength: 50,
-        queryParam: 'sets='
-    },
     {
         type: 'byName',
         maxLength: 400,
@@ -22,8 +15,6 @@ var FILTERS_METADATA = [
         queryParam: 'prefixes='
     }
 ];
-var VALID_FLAGSET_REGEX = /^[a-z0-9][_a-z0-9]{0,49}$/;
-var CAPITAL_LETTERS_REGEX = /[A-Z]/;
 /**
  * Validates that the given value is a valid filter type
  */
@@ -44,9 +35,6 @@ function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
     var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
     if (result) {
-        if (type === 'bySet') {
-            result = sanitizeFlagSets(log, result);
-        }
         // check max length
         if (result.length > maxLength)
             throw new Error(maxLength + " unique values can be specified at most for '" + type + "' filter. You passed " + result.length + ". Please consider reducing the amount or using other filter.");
@@ -77,42 +65,6 @@ function queryStringBuilder(groupedFilters) {
     });
     return queryParams.length > 0 ? '&' + queryParams.join('&') : null;
 }
-/**
- * Sanitizes set names list taking in 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
- *   - Be in lowercase
- *   - Be alphanumeric
- *   - have a max length of 50 characters
- *
- * @param {ILogger} log
- * @param {string[]} flagSets
- * @returns sanitized list of set names
- */
-function sanitizeFlagSets(log, flagSets) {
-    var sanitizedSets = flagSets
-        .map(function (flagSet) {
-        if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
-            log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
-            flagSet = flagSet.toLowerCase();
-        }
-        return flagSet;
-    })
-        .filter(function (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;
-        return true;
-    });
-    return uniq(sanitizedSets);
-}
-function configuredFilter(validFilters, filterType) {
-    return find(validFilters, function (filter) { return filter.type === filterType && filter.values.length > 0; });
-}
 /**
  * Validates `splitFilters` configuration object and parses it into a query string for filtering splits on `/splitChanges` fetch.
  *
@@ -131,7 +83,7 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     var res = {
         validFilters: [],
         queryString: null,
-        groupedFilters: { bySet: [], byName: [], byPrefix: [] },
+        groupedFilters: { byName: [], byPrefix: [] }
     };
     // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
     if (!maybeSplitFilters)
@@ -163,29 +115,8 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
         if (res.groupedFilters[type].length > 0)
             res.groupedFilters[type] = validateSplitFilter(log, type, res.groupedFilters[type], maxLength);
     });
-    var setFilter = configuredFilter(res.validFilters, 'bySet');
-    // Clean all filters if set filter is present
-    if (setFilter) {
-        if (configuredFilter(res.validFilters, 'byName') || configuredFilter(res.validFilters, 'byPrefix'))
-            log.error(ERROR_SETS_FILTER_EXCLUSIVE);
-        objectAssign(res.groupedFilters, { byName: [], byPrefix: [] });
-    }
     // build query string
     res.queryString = queryStringBuilder(res.groupedFilters);
     log.debug(SETTINGS_SPLITS_FILTER, [res.queryString]);
     return res;
 }
-export function flagSetsAreValid(log, method, flagSets, flagSetsInConfig) {
-    var sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
-    var toReturn = sets ? sanitizeFlagSets(log, sets) : [];
-    if (flagSetsInConfig.length > 0) {
-        toReturn = toReturn.filter(function (flagSet) {
-            if (flagSetsInConfig.indexOf(flagSet) > -1) {
-                return true;
-            }
-            log.warn(WARN_FLAGSET_NOT_CONFIGURED, [method, flagSet]);
-            return false;
-        });
-    }
-    return toReturn;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.9.2-rc.1",
+  "version": "1.9.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/dtos/types.ts

@@ -163,8 +163,7 @@ export interface ISplit {
   trafficAllocationSeed?: number
   configurations?: {
     [treatmentName: string]: string
-  },
-  sets?: string[]
+  }
 }
 
 // Split definition used in offline mode
@@ -209,5 +208,5 @@ export interface IMetadata {
 export type ISplitFiltersValidation = {
   queryString: string | null,
   groupedFilters: Record<SplitIO.SplitFilterType, string[]>,
-  validFilters: SplitIO.SplitFilter[],
+  validFilters: SplitIO.SplitFilter[]
 };

package/src/evaluator/index.ts

@@ -7,7 +7,6 @@ import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
-import { ISet, setToArray } from '../utils/lang/sets';
 
 const treatmentException = {
   treatment: CONTROL,
@@ -88,29 +87,6 @@ export function evaluateFeatures(
     getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
-export function evaluateFeaturesByFlagSets(
-  log: ILogger,
-  key: SplitIO.SplitKey,
-  flagSets: string[],
-  attributes: SplitIO.Attributes | undefined,
-  storage: IStorageSync | IStorageAsync,
-): MaybeThenable<Record<string,IEvaluationResult>> {
-  let storedFlagNames: MaybeThenable<ISet<string>>;
-
-  // get features by flag sets
-  try {
-    storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
-  } catch (e) {
-    // return empty evaluations
-    return {};
-  }
-
-  // evaluate related features
-  return thenable(storedFlagNames) ?
-    storedFlagNames.then((splitNames) => evaluateFeatures(log, key, setToArray(splitNames), attributes, storage)) :
-    evaluateFeatures(log, key, setToArray(storedFlagNames), attributes, storage);
-}
-
 function getEvaluation(
   log: ILogger,
   splitJSON: ISplit | null,

package/src/logger/constants.ts

@@ -97,9 +97,6 @@ export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_SDK_KEY = 222;
 export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export const STREAMING_PARSING_SPLIT_UPDATE = 224;
-export const WARN_SPLITS_FILTER_INVALID_SET = 225;
-export const WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
-export const WARN_FLAGSET_NOT_CONFIGURED = 227;
 
 export const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export const ERROR_LOGLEVEL_INVALID = 301;
@@ -128,8 +125,6 @@ export const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export const ERROR_STORAGE_INVALID = 324;
 export const ERROR_NOT_BOOLEAN = 325;
 export const ERROR_MIN_CONFIG_PARAM = 326;
-export const ERROR_TOO_MANY_SETS = 327;
-export const ERROR_SETS_FILTER_EXCLUSIVE = 328;
 
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';

package/src/logger/messages/error.ts

@@ -34,6 +34,4 @@ export const codesError: [number, string][] = [
   [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
   [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': the provided storage is invalid.%s Falling back into default MEMORY storage'],
   [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
-  [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the amount of flag sets provided are big causing uri length error.'],
-  [c.ERROR_SETS_FILTER_EXCLUSIVE, c.LOG_PREFIX_SETTINGS+': the Set filter is exclusive and cannot be used simultaneously with names or prefix filters. Ignoring names and prefixes.'],
 ];

package/src/logger/messages/info.ts

@@ -1,7 +1,7 @@
 import * as c from '../constants';
 import { codesWarn } from './warn';
 
-const READY_MSG = 'Split SDK is ready';
+const READY_MSG = 'Split SDK client is ready';
 
 export const codesInfo: [number, string][] = codesWarn.concat([
   // client status

package/src/logger/messages/warn.ts

@@ -24,16 +24,13 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],
   [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
   [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split user interface.'],
-  [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: : you passed %s wich is not part of the configured FlagSetsFilter, ignoring Flag Set.'],
   // initialization / settings validation
   [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS+': %s integration item(s) at settings is invalid. %s'],
   [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS+': feature flag filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],
-  [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS+': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("bySet", "byName" or "byPrefix") and a list of "values".'],
+  [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS+': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'],
   [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS+': feature flag filter configuration must be a non-empty array of filter objects.'],
   [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
 
   [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
   [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
-  [c.WARN_SPLITS_FILTER_INVALID_SET, c.LOG_PREFIX_SETTINGS+': you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
-  [c.WARN_SPLITS_FILTER_LOWERCASE_SET, c.LOG_PREFIX_SETTINGS+': flag set %s should be all lowercase - converting string to lowercase.'],
 ]);

package/src/sdkClient/client.ts

@@ -1,16 +1,15 @@
-import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
+import { evaluateFeature, evaluateFeatures } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
-import { Method } from '../sync/submitters/types';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
@@ -82,41 +81,6 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     return getTreatments(key, featureFlagNames, attributes, true);
   }
 
-  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS) {
-    const stopTelemetryTracker = telemetryTracker.trackEval(method);
-
-    const wrapUp = (evaluationResults: Record<string,IEvaluationResult>) => {
-      const queue: ImpressionDTO[] = [];
-      const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
-      const evaluations = evaluationResults;
-      Object.keys(evaluations).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, `getTreatmentsByFlagSets${withConfig ? 'WithConfig' : ''}`, queue);
-      });
-      impressionsTracker.track(queue, attributes);
-
-      stopTelemetryTracker(queue[0] && queue[0].label);
-      return treatments;
-    };
-
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage) :
-      isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
-
-    return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
-  }
-
-  function getTreatmentsWithConfigByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined) {
-    return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS);
-  }
-
-  function getTreatmentsByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET);
-  }
-
-  function getTreatmentsWithConfigByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET);
-  }
-
   // Internal function
   function processEvaluation(
     evaluation: IEvaluationResult,
@@ -191,10 +155,6 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     getTreatmentWithConfig,
     getTreatments,
     getTreatmentsWithConfig,
-    getTreatmentsByFlagSets,
-    getTreatmentsWithConfigByFlagSets,
-    getTreatmentsByFlagSet,
-    getTreatmentsWithConfigByFlagSet,
     track,
     isClientSide: false
   } as SplitIO.IClient | SplitIO.IAsyncClient;

package/src/sdkClient/clientAttributesDecoration.ts

@@ -16,10 +16,6 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
   const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
   const clientGetTreatments = client.getTreatments;
   const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-  const clientGetTreatmentsByFlagSets = client.getTreatmentsByFlagSets;
-  const clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
-  const clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
-  const clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
   const clientTrack = client.track;
 
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
@@ -38,22 +34,6 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
     return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
-  }
-
-  function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
-  }
-
-  function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
-  }
-
-  function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
-  }
-
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
     return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
   }
@@ -71,10 +51,6 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
     getTreatmentWithConfig: getTreatmentWithConfig,
     getTreatments: getTreatments,
     getTreatmentsWithConfig: getTreatmentsWithConfig,
-    getTreatmentsByFlagSets: getTreatmentsByFlagSets,
-    getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
-    getTreatmentsByFlagSet: getTreatmentsByFlagSet,
-    getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
     track: track,
 
     /**

package/src/sdkClient/clientCS.ts

@@ -21,14 +21,13 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
     getTreatments: clientCS.getTreatments.bind(clientCS, key),
     getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
-    getTreatmentsByFlagSets: clientCS.getTreatmentsByFlagSets.bind(clientCS, key),
-    getTreatmentsWithConfigByFlagSets: clientCS.getTreatmentsWithConfigByFlagSets.bind(clientCS, key),
-    getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
-    getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
 
     // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
     track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
 
-    isClientSide: true
+    // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
+    isClientSide: true,
+    key,
+    trafficType
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/clientInputValidation.ts

@@ -17,7 +17,6 @@ import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
 import { ISettings, SplitIO } from '../types';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
-import { flagSetsAreValid } from '../utils/settingsValidation/splitFilters';
 
 /**
  * Decorator that validates the input before actually executing the client methods.
@@ -31,28 +30,21 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   /**
    * Avoid repeating this validations code
    */
-  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNameOrNames: string | string[] | undefined, maybeAttributes: SplitIO.Attributes | undefined, methodName: string, maybeFlagSetNameOrNames?: string[]) {
+  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNameOrNames: string | string[], maybeAttributes: SplitIO.Attributes | undefined, methodName: string) {
     const multi = startsWith(methodName, 'getTreatments');
     const key = validateKey(log, maybeKey, methodName);
-    let splitOrSplits: string | string[] | false = false;
-    let flagSetOrFlagSets: string[] = [];
-    if (maybeFeatureFlagNameOrNames) {
-      splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
-    }
+    const splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
-    if (maybeFlagSetNameOrNames) {
-      flagSetOrFlagSets = flagSetsAreValid(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
-    }
+
     validateIfOperational(log, readinessManager, methodName);
 
-    const valid = isNotDestroyed && key && (splitOrSplits || flagSetOrFlagSets.length > 0) && attributes !== false;
+    const valid = isNotDestroyed && key && splitOrSplits && attributes !== false;
 
     return {
       valid,
       key,
       splitOrSplits,
-      flagSetOrFlagSets,
       attributes
     };
   }
@@ -107,46 +99,6 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     }
   }
 
-  function getTreatmentsByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSets', maybeFlagSets);
-
-    if (params.valid) {
-      return client.getTreatmentsByFlagSets(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets as string[], params.attributes as SplitIO.Attributes | undefined);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function getTreatmentsWithConfigByFlagSets(maybeKey: SplitIO.SplitKey, maybeFlagSets: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSets', maybeFlagSets);
-
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSets(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets as string[], params.attributes as SplitIO.Attributes | undefined);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function getTreatmentsByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSet', [maybeFlagSet]);
-
-    if (params.valid) {
-      return client.getTreatmentsByFlagSet(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets[0] as string, params.attributes as SplitIO.Attributes | undefined);
-    } else {
-      return wrapResult({});
-    }
-  }
-
-  function getTreatmentsWithConfigByFlagSet(maybeKey: SplitIO.SplitKey, maybeFlagSet: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSet', [maybeFlagSet]);
-
-    if (params.valid) {
-      return client.getTreatmentsWithConfigByFlagSet(params.key as SplitIO.SplitKey, params.flagSetOrFlagSets[0] as string, params.attributes as SplitIO.Attributes | undefined);
-    } else {
-      return wrapResult({});
-    }
-  }
-
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
     const key = validateKey(log, maybeKey, 'track');
     const tt = validateTrafficType(log, maybeTT, 'track');
@@ -167,10 +119,6 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     getTreatmentWithConfig,
     getTreatments,
     getTreatmentsWithConfig,
-    getTreatmentsByFlagSets,
-    getTreatmentsWithConfigByFlagSets,
-    getTreatmentsByFlagSet,
-    getTreatmentsWithConfigByFlagSet,
     track
   } as TClient;
 }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -17,8 +17,8 @@ function buildInstanceId(key: SplitIO.SplitKey) {
 const method = 'Client instantiation';
 
 /**
- * Factory of client method for the client-side API variant where TT is ignored and thus
- * clients don't have a binded TT for the track method.
+ * Factory of client method for the client-side API variant where TT is ignored.
+ * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -19,7 +19,7 @@ const method = 'Client instantiation';
 
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
- * where clients can have a binded TT for the track method, which is provided via the settings
+ * where clients can have a bound TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {

package/src/sdkManager/index.ts

@@ -31,8 +31,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
     killed: splitObject.killed,
     changeNumber: splitObject.changeNumber || 0,
     treatments: collectTreatments(splitObject),
-    configs: splitObject.configurations || {},
-    sets: splitObject.sets || []
+    configs: splitObject.configurations || {}
   };
 }
 

package/src/services/splitApi.ts

@@ -5,7 +5,6 @@ import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
-import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 
@@ -54,11 +53,7 @@ export function splitApiFactory(
 
     fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
       const url = `${urls.sdk}/splitChanges?since=${since}${till ? '&till=' + till : ''}${filterQueryString || ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
-        .catch((err) => {
-          if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);
-          throw err;
-        });
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
     },
 
     fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -44,6 +44,7 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
 
   /**
    * Only used for the `skC`(segment keys count) telemetry stat: 1 for client-side, and total count of keys in server-side.
+   * @TODO for client-side it should be the number of clients, but it requires a refactor of MySegments caches to simplify the code.
    */
   abstract getKeysCount(): number
 

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,7 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -18,7 +17,6 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   abstract getChangeNumber(): Promise<number>
   abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
-  abstract getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
 

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,7 +1,6 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ISet } from '../utils/lang/sets';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -79,8 +78,6 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return false;
   }
 
-  abstract getNamesByFlagSets(flagSets: string[]): ISet<string>
-
 }
 
 /**

package/src/storages/KeyBuilder.ts

@@ -20,10 +20,6 @@ export class KeyBuilder {
     return `${this.prefix}.trafficType.${trafficType}`;
   }
 
-  buildFlagSetKey(flagSet: string) {
-    return `${this.prefix}.flagset.${flagSet}`;
-  }
-
   buildSplitKey(splitName: string) {
     return `${this.prefix}.split.${splitName}`;
   }

package/src/storages/KeyBuilderSS.ts

@@ -7,10 +7,6 @@ export const METHOD_NAMES: Record<Method, string> = {
   ts: 'treatments',
   tc: 'treatmentWithConfig',
   tcs: 'treatmentsWithConfig',
-  tf: 'treatmentsByFlagSet',
-  tfs: 'treatmentsByFlagSets',
-  tcf: 'treatmentsWithConfigByFlagSet',
-  tcfs: 'treatmentsWithConfigByFlagSets',
   tr: 'track'
 };