@splitsoftware/splitio-commons 1.9.1-rc.0 → 1.9.2-rc.0

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -5,5 +5,5 @@ import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -2,6 +2,7 @@ import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { startsWith } from '../../../utils/lang';
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -28,15 +29,34 @@ export function parseSegments(_a) {
     }
     return segments;
 }
+/**
+ * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
+ * If there are set filter defined, names filter is ignored
+ *
+ * @param featureFlag feature flag to be evaluated
+ * @param filters splitFiltersValidation bySet | byName
+ */
+function matchFilters(featureFlag, filters) {
+    var _a = filters.groupedFilters, setsFilter = _a.bySet, namesFilter = _a.byName, prefixFilter = _a.byPrefix;
+    if (setsFilter.length > 0)
+        return featureFlag.sets && featureFlag.sets.some(function (featureFlagSet) { return setsFilter.indexOf(featureFlagSet) > -1; });
+    var namesFilterConfigured = namesFilter.length > 0;
+    var prefixFilterConfigured = prefixFilter.length > 0;
+    if (!namesFilterConfigured && !prefixFilterConfigured)
+        return true;
+    var matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
+    var matchPrefix = prefixFilterConfigured && prefixFilter.some(function (prefix) { return startsWith(featureFlag.name, prefix); });
+    return matchNames || matchPrefix;
+}
 /**
  * Given the list of splits from /splitChanges endpoint, it returns the mutations,
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeSplitsMutation(entries) {
+export function computeSplitsMutation(entries, filters) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
-        if (split.status === 'ACTIVE') {
+        if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
             accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
@@ -64,7 +84,7 @@ export function computeSplitsMutation(entries) {
  * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
     var startingUp = true;
@@ -94,7 +114,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
                 startingUp = false;
-                var mutation = computeSplitsMutation(splitChanges.splits);
+                var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
                 log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
                 log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
                 log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);

package/esm/sync/streaming/parseUtils.js

@@ -7,6 +7,7 @@ function Uint8ArrayToString(myUint8Arr) {
 }
 function StringToUint8Array(myString) {
     var charCodes = myString.split('').map(function (e) { return e.charCodeAt(0); });
+    // eslint-disable-next-line compat/compat
     return new Uint8Array(charCodes);
 }
 /**

package/esm/sync/submitters/telemetrySubmitter.js

@@ -29,6 +29,17 @@ function getRedundantActiveFactories() {
         return acum + usedKeysMap[sdkKey] - 1;
     }, 0);
 }
+function getTelemetryFlagSetsStats(splitFiltersValidation) {
+    // Group every configured flag set in an unique array called originalSets
+    var flagSetsTotal = 0;
+    splitFiltersValidation.validFilters.forEach(function (filter) {
+        if (filter.type === 'bySet')
+            flagSetsTotal += filter.values.length;
+    });
+    var flagSetsValid = splitFiltersValidation.groupedFilters.bySet.length;
+    var flagSetsIgnored = flagSetsTotal - flagSetsValid;
+    return { flagSetsTotal: flagSetsTotal, flagSetsIgnored: flagSetsIgnored };
+}
 export function getTelemetryConfigStats(mode, storageType) {
     return {
         oM: OPERATION_MODE_MAP[mode],
@@ -47,6 +58,7 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         pop: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
             var isClientSide = settings.core.key !== undefined;
+            var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
@@ -74,7 +86,9 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
                 nR: telemetry.getNonReadyUsage(),
                 t: telemetry.popTags(),
                 i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0,
+                fsT: flagSetsTotal,
+                fsI: flagSetsIgnored
             });
         }
     };

package/esm/utils/constants/index.js

@@ -51,6 +51,10 @@ export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';
 export var TREATMENTS_WITH_CONFIG = 'tcs';
+export var TREATMENTS_BY_FLAGSET = 'tf';
+export var TREATMENTS_BY_FLAGSETS = 'tfs';
+export var TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf';
+export var TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs';
 export var TRACK = 'tr';
 export var CONNECTION_ESTABLISHED = 0;
 export var OCCUPANCY_PRI = 10;

package/esm/utils/lang/sets.js

@@ -95,3 +95,10 @@ 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/splitFilters.js

@@ -1,9 +1,16 @@
 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 } 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, ERROR_EMPTY_ARRAY, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
+import { objectAssign } from '../lang/objectAssign';
+import { find, uniq } from '../lang';
 // 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,
@@ -15,6 +22,8 @@ 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
  */
@@ -35,6 +44,9 @@ 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.");
@@ -65,6 +77,42 @@ 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.
  *
@@ -83,7 +131,7 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     var res = {
         validFilters: [],
         queryString: null,
-        groupedFilters: { byName: [], byPrefix: [] }
+        groupedFilters: { bySet: [], byName: [], byPrefix: [] },
     };
     // do nothing if `splitFilters` param is not a non-empty array or mode is not STANDALONE
     if (!maybeSplitFilters)
@@ -115,8 +163,34 @@ 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 toReturn = [];
+    if (flagSets.length === 0) {
+        log.error(ERROR_EMPTY_ARRAY, [method, 'flagSets']);
+        return toReturn;
+    }
+    var sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
+    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, [flagSet]);
+            return false;
+        });
+    }
+    return toReturn;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.9.1-rc.0",
+  "version": "1.9.2-rc.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -22,7 +22,7 @@
     "build": "npm run build:cjs && npm run build:esm",
     "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
-    "test": "jest --runInBand",
+    "test": "jest",
     "test:coverage": "jest --coverage",
     "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
@@ -60,12 +60,12 @@
     "@types/ioredis": "^4.28.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
-    "@typescript-eslint/eslint-plugin": "^4.2.0",
-    "@typescript-eslint/parser": "^4.2.0",
+    "@typescript-eslint/eslint-plugin": "^6.6.0",
+    "@typescript-eslint/parser": "^6.6.0",
     "cross-env": "^7.0.2",
     "csv-streamify": "^4.0.0",
-    "eslint": "^7.32.0",
-    "eslint-plugin-compat": "3.7.0",
+    "eslint": "^8.48.0",
+    "eslint-plugin-compat": "^4.2.0",
     "eslint-plugin-import": "^2.25.3",
     "fetch-mock": "^9.11.0",
     "ioredis": "^4.28.0",

package/src/dtos/types.ts

@@ -163,7 +163,8 @@ export interface ISplit {
   trafficAllocationSeed?: number
   configurations?: {
     [treatmentName: string]: string
-  }
+  },
+  sets?: string[]
 }
 
 // Split definition used in offline mode
@@ -208,5 +209,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,6 +7,7 @@ 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,
@@ -87,6 +88,29 @@ 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/integrations/ga/GaToSplit.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-undef */
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { isString, isFiniteNumber, uniqAsStrings } from '../../utils/lang';
 import {
@@ -295,5 +294,6 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
+  // eslint-disable-next-line no-undef
   providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }

package/src/listeners/browser.ts

@@ -15,8 +15,7 @@ import { isConsentGranted } from '../consent';
 
 const VISIBILITYCHANGE_EVENT = 'visibilitychange';
 const PAGEHIDE_EVENT = 'pagehide';
-const UNLOAD_EVENT = 'unload';
-const EVENT_NAME = 'for unload page event.';
+const EVENT_NAME = 'for visibilitychange and pagehide events.';
 
 /**
  * We'll listen for events over the window object.
@@ -33,7 +32,6 @@ export class BrowserSignalListener implements ISignalListener {
   ) {
     this.flushData = this.flushData.bind(this);
     this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
-    this.stopSync = this.stopSync.bind(this);
     this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
   }
 
@@ -48,11 +46,9 @@ export class BrowserSignalListener implements ISignalListener {
       document.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
     }
     if (typeof window !== 'undefined' && window.addEventListener) {
-      // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.
-      // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.
+      // Some browsers, like Safari, does not fire the `visibilitychange` event when the page is being unloaded. Therefore, we also flush data in the `pagehide` event.
+      // If both events are triggered, the latter will find the storage empty, so no duplicate data will be submitted.
       window.addEventListener(PAGEHIDE_EVENT, this.flushData);
-      // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
-      window.addEventListener(UNLOAD_EVENT, this.stopSync);
     }
   }
 
@@ -67,15 +63,9 @@ export class BrowserSignalListener implements ISignalListener {
     }
     if (typeof window !== 'undefined' && window.removeEventListener) {
       window.removeEventListener(PAGEHIDE_EVENT, this.flushData);
-      window.removeEventListener(UNLOAD_EVENT, this.stopSync);
     }
   }
 
-  stopSync() {
-    // Close streaming connection
-    if (this.syncManager && this.syncManager.pushManager) this.syncManager.pushManager.stop();
-  }
-
   /**
    * flushData method.
    * Called when pagehide event is triggered. It flushed remaining impressions and events to the backend,

package/src/logger/constants.ts

@@ -97,6 +97,9 @@ 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;
@@ -125,6 +128,8 @@ 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,4 +34,6 @@ 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/warn.ts

@@ -27,10 +27,12 @@ export const codesWarn: [number, string][] = codesError.concat([
   // 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 ("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 ("bySet", "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/myLogger.ts

@@ -0,0 +1,36 @@
+// get the Console class
+// const { Console } = require('console');
+// get fs module for creating write streams
+const fs = require('fs');
+var pjson = require('../package.json');
+
+//@ts-ignore
+const pad = (value) => ('00'+value).slice(-2);
+const getDate = () => {
+  const date = new Date();
+  return `${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())}_${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+};
+
+//@ts-ignore
+
+const logToFile = (file, msg) => {
+//@ts-ignore
+  fs.appendFileSync(file, `${msg}\n`, (err) => {
+    if (err) {
+      return console.log(err);
+    }
+  });
+};
+
+// make a new logger
+const version = pjson.version.replace('.','').replace('.','');
+const filePath = `logs/${version}_${getDate()}`;
+export const myLogger = {
+  //@ts-ignore
+  log: (msg) => logToFile(filePath, msg),
+  //@ts-ignore
+  logCsv: (msg) => logToFile(`${filePath}.csv`, msg),
+  //@ts-ignore
+  logToFile: (file, msg) => logToFile(`logs/${file}`, msg),
+};
+

package/src/sdkClient/client.ts

@@ -1,15 +1,16 @@
-import { evaluateFeature, evaluateFeatures } from '../evaluator';
+import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } 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 } from '../utils/constants';
+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 { 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 };
 
@@ -81,6 +82,41 @@ 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,
@@ -155,6 +191,10 @@ 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,6 +16,10 @@ 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) {
@@ -34,6 +38,22 @@ 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);
   }
@@ -51,6 +71,10 @@ 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,13 +21,14 @@ 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),
 
-    // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
-    isClientSide: true,
-    key,
-    trafficType
+    isClientSide: true
   }) as SplitIO.ICsClient;
 }