@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/utils/settingsValidation/consent.ts

@@ -1,16 +0,0 @@
-import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import SplitIO from '../../../types/splitio';
-import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
-import { stringToUpperCase } from '../lang';
-
-const userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
-
-export function validateConsent({ userConsent, log }: { userConsent?: any, log: ILogger }): SplitIO.ConsentStatus {
-  userConsent = stringToUpperCase(userConsent);
-
-  if (userConsentValues.indexOf(userConsent) > -1) return userConsent;
-
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);
-  return CONSENT_GRANTED;
-}

package/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +0,0 @@
-import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-import SplitIO from '../../../types/splitio';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
-import { stringToUpperCase } from '../lang';
-
-export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
-  impressionsMode = stringToUpperCase(impressionsMode);
-
-  if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1) return impressionsMode;
-
-  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
-  return OPTIMIZED;
-}

package/src/utils/settingsValidation/index.ts

@@ -1,207 +0,0 @@
-import { merge, get } from '../lang';
-import { validateMode } from './mode';
-import { validateSplitFilters } from './splitFilters';
-import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG, FLAG_SPEC_VERSION } from '../constants';
-import { validImpressionsMode } from './impressionsMode';
-import { ISettingsValidationParams } from './types';
-import { ISettings } from '../../types';
-import { validateKey } from '../inputValidation/key';
-import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
-
-// Exported for telemetry
-export const base = {
-  // Define which kind of object you want to retrieve from SplitFactory
-  mode: STANDALONE_MODE,
-
-  core: {
-    // API token (tight to an environment)
-    authorizationKey: undefined,
-    // key used in your system (only required for browser version)
-    key: undefined,
-    // toggle impressions tracking of labels
-    labelsEnabled: true,
-    // toggle sendind (true) or not sending (false) IP and Host Name with impressions, events, and telemetries requests (only used on nodejs version)
-    IPAddressesEnabled: undefined
-  },
-
-  scheduler: {
-    // fetch feature updates each 60 sec
-    featuresRefreshRate: 60,
-    // fetch segments updates each 60 sec
-    segmentsRefreshRate: 60,
-    // publish telemetry stats each 3600 secs (1 hour)
-    telemetryRefreshRate: 3600,
-    // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
-    impressionsRefreshRate: 300,
-    // fetch offline changes each 15 sec
-    offlineRefreshRate: 15,
-    // publish events every 60 seconds after the first flush
-    eventsPushRate: 60,
-    // how many events will be queued before flushing
-    eventsQueueSize: 500,
-    // how many impressions will be queued before flushing
-    impressionsQueueSize: 30000,
-    // backoff base seconds to wait before re attempting to connect to push notifications
-    pushRetryBackoffBase: 1,
-  },
-
-  urls: {
-    // CDN having all the information for your environment
-    sdk: 'https://sdk.split.io/api',
-    // SDK event and impression endpoints
-    events: 'https://events.split.io/api',
-    // SDK Auth Server
-    auth: 'https://auth.split.io/api',
-    // Streaming Server
-    streaming: 'https://streaming.split.io',
-    // Telemetry Server
-    telemetry: 'https://telemetry.split.io/api',
-  },
-
-  // Defines which kind of storage we should instantiate.
-  storage: undefined,
-
-  // Defines if the logs are enabled, SDK wide.
-  debug: undefined,
-
-  // Defines the impression listener.
-  impressionListener: undefined,
-
-  // Instance version.
-  version: undefined,
-
-  // List of integrations.
-  integrations: undefined,
-
-  // toggle using (true) or not using (false) Server-Side Events for synchronizing storage
-  streamingEnabled: true,
-
-  sync: {
-    splitFilters: undefined,
-    // impressions collection mode
-    impressionsMode: OPTIMIZED,
-    enabled: true,
-    flagSpecVersion: FLAG_SPEC_VERSION
-  },
-
-  // Logger
-  log: undefined
-};
-
-function fromSecondsToMillis(n: number) {
-  return Math.round(n * 1000);
-}
-
-/**
- * Validates the given config and use it to build a settings object.
- * NOTE: it doesn't validate the SDK Key. Call `validateApiKey` or `validateAndTrackApiKey` for that after settings validation.
- *
- * @param config - user defined configuration
- * @param validationParams - defaults and fields validators used to validate and creates a settings object from a given config
- */
-export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
-
-  const { defaults, runtime, storage, integrations, logger, consent, flagSpec } = validationParams;
-
-  // creates a settings object merging base, defaults and config objects.
-  const withDefaults = merge({}, base, defaults, config) as ISettings;
-  // Keeps reference to the `features` property
-  withDefaults.features = get(config, 'features');
-
-  // ensure a valid logger.
-  // First thing to validate, since other validators might use the logger.
-  const log = logger(withDefaults); // @ts-ignore, modify readonly prop
-  withDefaults.log = log;
-
-  // ensure a valid impressionsMode
-  const sync = withDefaults.sync;
-  sync.impressionsMode = validImpressionsMode(log, sync.impressionsMode);
-
-  function validateMinValue(paramName: string, actualValue: number, minValue: number) {
-    if (actualValue >= minValue) return actualValue;
-    // actualValue is not a number or is lower than minValue
-    log.error(ERROR_MIN_CONFIG_PARAM, [paramName, minValue]);
-    return minValue;
-  }
-
-  // Scheduler periods
-  const { scheduler, startup } = withDefaults;
-  scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
-  scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-  scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
-  scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-  scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
-
-  // Default impressionsRefreshRate for DEBUG mode is 60 secs
-  if (get(config, 'scheduler.impressionsRefreshRate') === undefined && sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
-  scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
-
-  // Log deprecation for old telemetry param
-  if (scheduler.metricsRefreshRate) log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');
-
-  // Startup periods
-  startup.requestTimeoutBeforeReady = fromSecondsToMillis(startup.requestTimeoutBeforeReady);
-  startup.readyTimeout = fromSecondsToMillis(startup.readyTimeout);
-  startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);
-
-  // ensure a valid SDK mode
-  // @ts-ignore, modify readonly prop
-  withDefaults.mode = validateMode(withDefaults.core.authorizationKey, withDefaults.mode);
-
-  // ensure a valid Storage based on mode defined.
-  // @ts-ignore, modify readonly prop
-  if (storage) withDefaults.storage = storage(withDefaults);
-
-  // Validate key and TT (for client-side)
-  const maybeKey = withDefaults.core.key;
-  if (validationParams.acceptKey) {
-    // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-    if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
-      withDefaults.core.key = 'localhost_key';
-    } else {
-      // Keeping same behavior than JS SDK: if settings key or TT are invalid,
-      // `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, LOG_PREFIX_CLIENT_INSTANTIATION);
-    }
-  } else {
-    // On server-side, key is undefined and used to distinguish from client-side
-    if (maybeKey !== undefined) log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
-    withDefaults.core.key = undefined;
-  }
-
-  // Current ip/hostname information
-  // @ts-ignore, modify readonly prop
-  withDefaults.runtime = runtime(withDefaults);
-
-  // ensure a valid list of integrations.
-  // `integrations` returns an array of valid integration items.
-  // @ts-ignore, modify readonly prop
-  if (integrations) withDefaults.integrations = integrations(withDefaults);
-
-  // validate push options
-  if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
-    withDefaults.streamingEnabled = true;
-    // Backoff bases.
-    // We are not checking if bases are positive numbers. Thus, we might be re-authenticating immediately (`setTimeout` with NaN or negative number)
-    scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
-  }
-
-  // validate sync enabled
-  if (sync.enabled !== false) {
-    sync.enabled = true;
-  }
-
-  // validate the `splitFilters` settings and parse splits query
-  const splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
-  sync.splitFilters = splitFiltersValidation.validFilters;
-  sync.__splitFiltersValidation = splitFiltersValidation;
-
-  // ensure a valid flag spec version
-  sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
-  // ensure a valid user consent value
-  // @ts-ignore, modify readonly prop
-  withDefaults.userConsent = consent ? consent(withDefaults) : undefined;
-
-  return withDefaults;
-}

package/src/utils/settingsValidation/integrations/common.ts

@@ -1,27 +0,0 @@
-import { WARN_INTEGRATION_INVALID } from '../../../logger/constants';
-import { ILogger } from '../../../logger/types';
-
-/**
- * This function validates `settings.integrations` object
- *
- * @param settings - config object provided by the user to initialize the sdk
- * @param integrationValidator - filter used to remove invalid integration items
- * @param extraWarning - optional string used to better describe why an item might be invalid
- *
- * @returns array of valid integration items. The array might be empty if `settings` object does not have valid integrations.
- */
-export function validateIntegrations(settings: { log: ILogger, integrations?: any }, integrationValidator: (integrationItem: any) => boolean, extraWarning?: string) {
-  const { integrations, log } = settings;
-
-  // If integrations is not an array or an empty array, we return an empty array (no integrations).
-  if (!Array.isArray(integrations) || integrations.length === 0) return [];
-
-  // We remove invalid integration items
-  const validIntegrations = integrations.filter(integrationValidator);
-
-  // Log a warning if at least one item is invalid
-  const invalids = integrations.length - validIntegrations.length;
-  if (invalids) log.warn(WARN_INTEGRATION_INVALID, [invalids, extraWarning || '']);
-
-  return validIntegrations;
-}

package/src/utils/settingsValidation/integrations/configurable.ts

@@ -1,20 +0,0 @@
-import { validateIntegrations } from './common';
-import { isString } from '../../lang';
-import { ILogger } from '../../../logger/types';
-
-/**
- * This function validates `settings.integrations` object that consists of a list of configuration items, used by the isomorphic JS SDK.
- *
- * @param settings - config object provided by the user to initialize the sdk
- * @param validIntegrationTypes - list of integration types to filter from `settings.integrations`
- *
- * @returns array of valid integration items. The array might be empty if `settings` object does not have valid integrations.
- */
-export function validateConfigurableIntegrations(settings: { log: ILogger, integrations?: any }, validIntegrationTypes: string[] = []) {
-
-  return validateIntegrations(
-    settings,
-    integration => integration && isString(integration.type) && validIntegrationTypes.indexOf(integration.type) > -1,
-    'Integration items must have a valid "type" value'
-  );
-}

package/src/utils/settingsValidation/integrations/pluggable.ts

@@ -1,19 +0,0 @@
-import { ISettings } from '../../../types';
-import { validateIntegrations } from './common';
-import { ILogger } from '../../../logger/types';
-
-/**
- * This function validates `settings.integrations` object that consists of a list of pluggable integration factories.
- *
- * @param settings - config object provided by the user to initialize the sdk
- *
- * @returns array of valid integration factories. The array might be empty if `settings` object does not have valid integrations.
- */
-export function validatePluggableIntegrations(settings: { log: ILogger, integrations?: any }): ISettings['integrations'] {
-
-  return validateIntegrations(
-    settings,
-    integration => typeof integration === 'function',
-    'Integration items must be functions that initialize the integrations'
-  );
-}

package/src/utils/settingsValidation/logger/builtinLogger.ts

@@ -1,54 +0,0 @@
-import { isLogLevelString, Logger, LogLevels } from '../../../logger';
-import { ILogger } from '../../../logger/types';
-import { isLocalStorageAvailable } from '../../env/isLocalStorageAvailable';
-import { isNode } from '../../env/isNode';
-import { codesDebug } from '../../../logger/messages/debug';
-import { getLogLevel } from './commons';
-import SplitIO from '../../../../types/splitio';
-
-const allCodes = new Map(codesDebug);
-
-// @TODO set default debug setting instead of initialLogLevel when integrating in JS and Node packages
-const LS_KEY = 'splitio_debug';
-const ENV_VAR_KEY = 'SPLITIO_DEBUG';
-
-/**
- * Logger initial debug level, that is disabled ('NONE') by default.
- * Acceptable values are: 'DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'.
- * Other acceptable values are 'on', 'enable' and 'enabled', which are equivalent to 'DEBUG'.
- * Any other string value is equivalent to disable.
- */
-const initialState = String(
-  // eslint-disable-next-line no-undef
-  isNode ? process.env[ENV_VAR_KEY] : isLocalStorageAvailable() ? localStorage.getItem(LS_KEY) : ''
-);
-
-
-// By default it starts disabled.
-let initialLogLevel = LogLevels.NONE;
-
-// Kept to avoid a breaking change ('on', 'enable' and 'enabled' are equivalent)
-if (/^(enabled?|on)/i.test(initialState)) {
-  initialLogLevel = LogLevels.DEBUG;
-} else if (isLogLevelString(initialState)) {
-  initialLogLevel = initialState;
-}
-
-/**
- * Validates the `debug` property at config and use it to set the log level.
- *
- * @param settings - user config object, with an optional `debug` property of type boolean or string log level.
- * @returns a logger instance with the log level at `settings.debug`. If `settings.debug` is invalid or not provided, `initialLogLevel` is used.
- */
-export function validateLogger(settings: { debug: unknown }): ILogger {
-  const { debug } = settings;
-
-  const logLevel: SplitIO.LogLevel | undefined = debug !== undefined ? getLogLevel(debug) : initialLogLevel;
-
-  const log = new Logger({ logLevel: logLevel || initialLogLevel }, allCodes);
-
-  // @ts-ignore // if logLevel is undefined at this point, it means that settings `debug` value is invalid
-  if (!logLevel) log._log(LogLevels.ERROR, 'Invalid Log Level - No changes to the logs will be applied.');
-
-  return log;
-}

package/src/utils/settingsValidation/logger/commons.ts

@@ -1,24 +0,0 @@
-
-import { LogLevels, isLogLevelString } from '../../../logger';
-import SplitIO from '../../../../types/splitio';
-
-/**
- * Returns the LogLevel for the given debugValue or undefined if it is invalid,
- * i.e., if the debugValue is not a boolean or LogLevel string.
- *
- * @param debugValue - debug value at config
- * @returns LogLevel of the given debugValue or undefined if the provided value is invalid
- */
-export function getLogLevel(debugValue: unknown): SplitIO.LogLevel | undefined {
-  if (typeof debugValue === 'boolean') {
-    if (debugValue) {
-      return LogLevels.DEBUG;
-    } else {
-      return LogLevels.NONE;
-    }
-  } else if (typeof debugValue === 'string' && isLogLevelString(debugValue)) {
-    return debugValue;
-  } else {
-    return undefined;
-  }
-}

package/src/utils/settingsValidation/logger/pluggableLogger.ts

@@ -1,35 +0,0 @@
-import { Logger, LogLevels } from '../../../logger';
-import { ILogger } from '../../../logger/types';
-import SplitIO from '../../../../types/splitio';
-import { getLogLevel } from './commons';
-
-function isLogger(log: any): log is ILogger {
-  return log !== null && typeof log === 'object' && typeof log.debug === 'function' && typeof log.info === 'function' && typeof log.warn === 'function' && typeof log.error === 'function' && typeof log.setLogLevel === 'function';
-}
-
-// By default it starts disabled.
-let initialLogLevel = LogLevels.NONE;
-
-/**
- * Validates the `debug` property at config and use it to set the logger.
- *
- * @param settings - user config object, with an optional `debug` property of type boolean, string log level or a Logger object.
- * @returns a logger instance, that might be: the provided logger at `settings.debug`, or one with the given `debug` log level,
- * or one with NONE log level if `debug` is not defined or invalid.
- */
-export function validateLogger(settings: { debug: unknown }): ILogger {
-  const { debug } = settings;
-  let logLevel: SplitIO.LogLevel | undefined = initialLogLevel;
-
-  if (debug !== undefined) {
-    if (isLogger(debug)) return debug;
-    logLevel = getLogLevel(settings.debug);
-  }
-
-  const log = new Logger({ logLevel: logLevel || initialLogLevel });
-
-  // @ts-ignore // `debug` value is invalid if logLevel is undefined at this point
-  if (!logLevel) log._log(LogLevels.ERROR, 'Invalid `debug` value at config. Logs will be disabled.');
-
-  return log;
-}

package/src/utils/settingsValidation/mode.ts

@@ -1,17 +0,0 @@
-import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
-
-export function validateMode(key: string, mode: string) {
-  // Leaving the comparison as is, in case we change the mode name but not the setting.
-  if (key === 'localhost') return LOCALHOST_MODE;
-
-  if ([STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(mode) === -1) throw Error('Invalid mode provided');
-
-  return mode;
-}
-
-/**
- * Storage is async if mode is consumer or partial consumer
- */
-export function isConsumerMode(mode: string) {
-  return CONSUMER_MODE === mode || CONSUMER_PARTIAL_MODE === mode;
-}

package/src/utils/settingsValidation/runtime.ts

@@ -1,9 +0,0 @@
-import { ISettings } from '../../types';
-
-// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.
-export function validateRuntime(): ISettings['runtime'] {
-  return {
-    ip: false,
-    hostname: false
-  };
-}

package/src/utils/settingsValidation/splitFilters.ts

@@ -1,197 +0,0 @@
-import { validateSplits } from '../inputValidation/splits';
-import { ISplitFiltersValidation } from '../../dtos/types';
-import SplitIO from '../../../types/splitio';
-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_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>`
-const FILTERS_METADATA = [
-  {
-    type: 'bySet' as SplitIO.SplitFilterType,
-    maxLength: 50,
-    queryParam: 'sets='
-  },
-  {
-    type: 'byName' as SplitIO.SplitFilterType,
-    maxLength: 400,
-    queryParam: 'names='
-  },
-  {
-    type: 'byPrefix' as SplitIO.SplitFilterType,
-    maxLength: 50,
-    queryParam: 'prefixes='
-  }
-];
-
-const VALID_FLAGSET_REGEX = /^[a-z0-9][_a-z0-9]{0,49}$/;
-const CAPITAL_LETTERS_REGEX = /[A-Z]/;
-
-/**
- * Validates that the given value is a valid filter type
- */
-function validateFilterType(maybeFilterType: any): maybeFilterType is SplitIO.SplitFilterType {
-  return FILTERS_METADATA.some(filterMetadata => filterMetadata.type === maybeFilterType);
-}
-
-/**
- * Validate, deduplicate and sort a given list of filter values.
- *
- * @param type - filter type string used for log messages
- * @param values - list of values to validate, deduplicate and sort
- * @param maxLength - max length allowed for the list of values
- * @returns list of valid, unique and alphabetically sorted non-empty strings. The list is empty if `values` param is not a non-empty array or all its values are invalid.
- *
- * @throws Error if the sanitized list exceeds the length indicated by `maxLength`
- */
-function validateSplitFilter(log: ILogger, type: SplitIO.SplitFilterType, values: string[], maxLength: number) {
-  // validate and remove invalid and duplicated values
-  let result = validateSplits(log, values, LOG_PREFIX_SETTINGS, `${type} filter`, `${type} filter value`);
-
-  if (result) {
-
-    if (type === 'bySet') {
-      result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
-    }
-
-    // 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.`);
-
-    // sort values
-    result.sort();
-  }
-  return result || []; // returns empty array if `result` is `false`
-}
-
-/**
- * Returns a string representing the URL encoded query component of /splitChanges URL.
- *
- * @param groupedFilters - object of filters. Each filter must be a list of valid, unique and ordered string values.
- * @returns null or string with the `split filter query` component of the URL.
- */
-function queryStringBuilder(groupedFilters: Record<SplitIO.SplitFilterType, string[]>) {
-  const queryParams: string[] = [];
-  FILTERS_METADATA.forEach(({ type, queryParam }) => {
-    const filter = groupedFilters[type];
-    if (filter.length > 0) queryParams.push(queryParam + filter.map(value => encodeURIComponent(value)).join(','));
-  });
-  return queryParams.length > 0 ? '&' + queryParams.join('&') : null;
-}
-
-/**
- * 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
- *   - Be in lowercase
- *   - Be alphanumeric
- *   - have a max length of 50 characters
- *
- * @returns sanitized list of set names
- */
-function sanitizeFlagSets(log: ILogger, flagSets: string[], method: string) {
-  let sanitizedSets = flagSets
-    .map(flagSet => {
-      if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
-        log.warn(WARN_LOWERCASE_FLAGSET, [method, flagSet]);
-        flagSet = flagSet.toLowerCase();
-      }
-      return flagSet;
-    })
-    .filter(flagSet => {
-      if (!VALID_FLAGSET_REGEX.test(flagSet)) {
-        log.warn(WARN_INVALID_FLAGSET, [method, flagSet, VALID_FLAGSET_REGEX, flagSet]);
-        return false;
-      }
-      if (typeof flagSet !== 'string') return false;
-      return true;
-    });
-  return uniq(sanitizedSets);
-}
-
-function configuredFilter(validFilters: SplitIO.SplitFilter[], filterType: SplitIO.SplitFilterType) {
-  return find(validFilters, (filter: SplitIO.SplitFilter) => filter.type === filterType && filter.values.length > 0);
-}
-
-/**
- * Validates `splitFilters` configuration object and parses it into a query string for filtering splits on `/splitChanges` fetch.
- *
- * @param log - logger
- * @param maybeSplitFilters - split filters configuration param provided by the user
- * @param 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.
- *  - `groupedFilters`: list of values grouped by filter type.
- *
- * @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, mode: string): ISplitFiltersValidation {
-  // Validation result schema
-  const res = {
-    validFilters: [],
-    queryString: null,
-    groupedFilters: { bySet: [], byName: [], byPrefix: [] },
-  } as ISplitFiltersValidation;
-
-  // 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 (isConsumerMode(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);
-    return res;
-  }
-
-  // Validate filters and group their values by filter type inside `groupedFilters` object
-  res.validFilters = maybeSplitFilters.filter((filter, index) => {
-    if (filter && validateFilterType(filter.type) && Array.isArray(filter.values)) {
-      res.groupedFilters[filter.type as SplitIO.SplitFilterType] = res.groupedFilters[filter.type as SplitIO.SplitFilterType].concat(filter.values);
-      return true;
-    } else {
-      log.warn(WARN_SPLITS_FILTER_INVALID, [index]);
-    }
-    return false;
-  });
-
-  // By filter type, remove invalid and duplicated values and order them
-  FILTERS_METADATA.forEach(({ type, maxLength }) => {
-    if (res.groupedFilters[type].length > 0) res.groupedFilters[type] = validateSplitFilter(log, type, res.groupedFilters[type], maxLength);
-  });
-
-  const 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 validateFlagSets(log: ILogger, method: string, flagSets: string[], flagSetsInConfig: string[]): string[] | false {
-  const sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
-  let toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
-  if (flagSetsInConfig.length > 0) {
-    toReturn = toReturn.filter(flagSet => {
-      if (flagSetsInConfig.indexOf(flagSet) > -1) {
-        return true;
-      }
-      log.warn(WARN_FLAGSET_NOT_CONFIGURED, [method, flagSet]);
-      return false;
-    });
-  }
-
-  return toReturn.length ? toReturn : false;
-}