@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/esm/utils/settingsValidation/url.js

@@ -1,6 +1,6 @@
 var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
-var authEndpointMatcher = /^\/v2\/auth/;
+var authEndpointMatcher = /^\/(v2|v3)\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
 /**
  * Get URL based on a given target (path).
@@ -12,16 +12,16 @@ var streamingEndpointMatcher = /^\/(sse|event-stream)/;
  */
 export function url(settings, target) {
     if (telemetryEndpointMatcher.test(target)) {
-        return "" + settings.urls.telemetry + target;
+        return "".concat(settings.urls.telemetry).concat(target);
     }
     if (eventsEndpointMatcher.test(target)) {
-        return "" + settings.urls.events + target;
+        return "".concat(settings.urls.events).concat(target);
     }
     if (authEndpointMatcher.test(target)) {
-        return "" + settings.urls.auth + target;
+        return "".concat(settings.urls.auth).concat(target);
     }
     if (streamingEndpointMatcher.test(target)) {
-        return "" + settings.urls.streaming + target;
+        return "".concat(settings.urls.streaming).concat(target);
     }
-    return "" + settings.urls.sdk + target;
+    return "".concat(settings.urls.sdk).concat(target);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.12.0",
+  "version": "3.0.0-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -49,21 +49,30 @@
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
-    "ioredis": "^4.28.0 || ^5.0.0"
+    "bloom-filters": "^3.0.0",
+    "ioredis": "^4.28.0 || ^5.0.0",
+    "node-fetch": "^2.7.0"
   },
   "peerDependenciesMeta": {
+    "bloom-filters": {
+      "optional": true
+    },
     "ioredis": {
       "optional": true
+    },
+    "node-fetch": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@types/ioredis": "^4.28.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
-    "@typescript-eslint/eslint-plugin": "^6.6.0",
-    "@typescript-eslint/parser": "^6.6.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "bloom-filters": "^3.0.4",
     "cross-env": "^7.0.2",
-    "eslint": "^8.48.0",
+    "eslint": "^8.56.0",
     "eslint-plugin-compat": "^6.0.1",
     "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-tsdoc": "^0.3.0",
@@ -76,7 +85,7 @@
     "redis-server": "1.2.2",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.0.5",
-    "typescript": "4.4.4"
+    "typescript": "4.7.4"
   },
   "sideEffects": false
 }

package/src/dtos/types.ts

@@ -2,8 +2,6 @@ import SplitIO from '../../types/splitio';
 
 export type MaybeThenable<T> = T | Promise<T>
 
-/** Split Matchers */
-
 export type IMatcherDataType = null | 'DATETIME' | 'NUMBER'
 
 export interface IUnaryNumericMatcherData {
@@ -23,7 +21,7 @@ export interface IBetweenStringMatcherData {
 }
 
 export interface IWhitelistMatcherData {
-  whitelist: string[]
+  whitelist?: string[] | null
 }
 
 export interface IInSegmentMatcherData {
@@ -39,12 +37,12 @@ export interface IDependencyMatcherData {
   treatments: string[]
 }
 
-interface ISplitMatcherBase {
+interface IDefinitionMatcherBase {
   matcherType: string
-  negate: boolean
-  keySelector: null | {
+  negate?: boolean
+  keySelector?: null | {
     trafficType: string,
-    attribute: string | null
+    attribute?: string | null
   }
   userDefinedSegmentMatcherData?: null | IInSegmentMatcherData
   userDefinedLargeSegmentMatcherData?: null | IInLargeSegmentMatcherData
@@ -57,144 +55,143 @@ interface ISplitMatcherBase {
   betweenStringMatcherData?: null | IBetweenStringMatcherData
 }
 
-interface IAllKeysMatcher extends ISplitMatcherBase {
+interface IAllKeysMatcher extends IDefinitionMatcherBase {
   matcherType: 'ALL_KEYS'
 }
 
-interface IInSegmentMatcher extends ISplitMatcherBase {
+interface IInSegmentMatcher extends IDefinitionMatcherBase {
   matcherType: 'IN_SEGMENT',
   userDefinedSegmentMatcherData: IInSegmentMatcherData
 }
 
-interface IInRBSegmentMatcher extends ISplitMatcherBase {
+interface IInRBSegmentMatcher extends IDefinitionMatcherBase {
   matcherType: 'IN_RULE_BASED_SEGMENT',
   userDefinedSegmentMatcherData: IInSegmentMatcherData
 }
 
-interface IInLargeSegmentMatcher extends ISplitMatcherBase {
+interface IInLargeSegmentMatcher extends IDefinitionMatcherBase {
   matcherType: 'IN_LARGE_SEGMENT',
   userDefinedLargeSegmentMatcherData: IInLargeSegmentMatcherData
 }
 
-interface IWhitelistMatcher extends ISplitMatcherBase {
+interface IWhitelistMatcher extends IDefinitionMatcherBase {
   matcherType: 'WHITELIST',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IEqualToMatcher extends ISplitMatcherBase {
+interface IEqualToMatcher extends IDefinitionMatcherBase {
   matcherType: 'EQUAL_TO',
   unaryNumericMatcherData: IUnaryNumericMatcherData
 }
 
-interface IGreaterThanOrEqualToMatcher extends ISplitMatcherBase {
+interface IGreaterThanOrEqualToMatcher extends IDefinitionMatcherBase {
   matcherType: 'GREATER_THAN_OR_EQUAL_TO',
   unaryNumericMatcherData: IUnaryNumericMatcherData
 }
 
-interface ILessThanOrEqualToMatcher extends ISplitMatcherBase {
+interface ILessThanOrEqualToMatcher extends IDefinitionMatcherBase {
   matcherType: 'LESS_THAN_OR_EQUAL_TO',
   unaryNumericMatcherData: IUnaryNumericMatcherData
 }
 
-interface IBetweenMatcher extends ISplitMatcherBase {
+interface IBetweenMatcher extends IDefinitionMatcherBase {
   matcherType: 'BETWEEN'
   betweenMatcherData: IBetweenMatcherData
 }
 
-interface IEqualToSetMatcher extends ISplitMatcherBase {
+interface IEqualToSetMatcher extends IDefinitionMatcherBase {
   matcherType: 'EQUAL_TO_SET',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IContainsAnyOfSetMatcher extends ISplitMatcherBase {
+interface IContainsAnyOfSetMatcher extends IDefinitionMatcherBase {
   matcherType: 'CONTAINS_ANY_OF_SET',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IContainsAllOfSetMatcher extends ISplitMatcherBase {
+interface IContainsAllOfSetMatcher extends IDefinitionMatcherBase {
   matcherType: 'CONTAINS_ALL_OF_SET',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IPartOfSetMatcher extends ISplitMatcherBase {
+interface IPartOfSetMatcher extends IDefinitionMatcherBase {
   matcherType: 'PART_OF_SET',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IStartsWithMatcher extends ISplitMatcherBase {
+interface IStartsWithMatcher extends IDefinitionMatcherBase {
   matcherType: 'STARTS_WITH',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IEndsWithMatcher extends ISplitMatcherBase {
+interface IEndsWithMatcher extends IDefinitionMatcherBase {
   matcherType: 'ENDS_WITH',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IContainsStringMatcher extends ISplitMatcherBase {
+interface IContainsStringMatcher extends IDefinitionMatcherBase {
   matcherType: 'CONTAINS_STRING',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-interface IInSplitTreatmentMatcher extends ISplitMatcherBase {
+interface IInSplitTreatmentMatcher extends IDefinitionMatcherBase {
   matcherType: 'IN_SPLIT_TREATMENT',
   dependencyMatcherData: IDependencyMatcherData,
 }
 
-interface IEqualToBooleanMatcher extends ISplitMatcherBase {
+interface IEqualToBooleanMatcher extends IDefinitionMatcherBase {
   matcherType: 'EQUAL_TO_BOOLEAN',
   booleanMatcherData: boolean
 }
 
-interface IMatchesStringMatcher extends ISplitMatcherBase {
+interface IMatchesStringMatcher extends IDefinitionMatcherBase {
   matcherType: 'MATCHES_STRING',
   stringMatcherData: string
 }
 
-interface IEqualToSemverMatcher extends ISplitMatcherBase {
+interface IEqualToSemverMatcher extends IDefinitionMatcherBase {
   matcherType: 'EQUAL_TO_SEMVER',
   stringMatcherData: string
 }
 
-interface IGreaterThanOrEqualToSemverMatcher extends ISplitMatcherBase {
+interface IGreaterThanOrEqualToSemverMatcher extends IDefinitionMatcherBase {
   matcherType: 'GREATER_THAN_OR_EQUAL_TO_SEMVER',
   stringMatcherData: string
 }
 
 
-interface ILessThanOrEqualToSemverMatcher extends ISplitMatcherBase {
+interface ILessThanOrEqualToSemverMatcher extends IDefinitionMatcherBase {
   matcherType: 'LESS_THAN_OR_EQUAL_TO_SEMVER',
   stringMatcherData: string
 }
 
-interface IBetweenSemverMatcher extends ISplitMatcherBase {
+interface IBetweenSemverMatcher extends IDefinitionMatcherBase {
   matcherType: 'BETWEEN_SEMVER'
   betweenStringMatcherData: IBetweenStringMatcherData
 }
 
-interface IInListSemverMatcher extends ISplitMatcherBase {
+interface IInListSemverMatcher extends IDefinitionMatcherBase {
   matcherType: 'IN_LIST_SEMVER',
   whitelistMatcherData: IWhitelistMatcherData
 }
 
-export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
+export type IDefinitionMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
   ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
   IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
   IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher |
   IInLargeSegmentMatcher | IInRBSegmentMatcher
 
-/** Split object */
-export interface ISplitPartition {
+export interface IDefinitionPartition {
   treatment: string
   size: number
 }
 
-export interface ISplitCondition {
+export interface IDefinitionCondition {
   matcherGroup: {
     combiner: 'AND',
-    matchers: ISplitMatcher[]
+    matchers: IDefinitionMatcher[]
   }
-  partitions?: ISplitPartition[]
+  partitions?: IDefinitionPartition[]
   label?: string
   conditionType?: 'ROLLOUT' | 'WHITELIST'
 }
@@ -204,53 +201,51 @@ export interface IExcludedSegment {
   name: string,
 }
 
-export interface IRBSegment {
-  name: string,
-  changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
-  conditions?: ISplitCondition[],
+export interface TargetingEntity {
+  name: string;
+  changeNumber: number;
+  status?: 'ACTIVE' | 'ARCHIVED';
+  conditions: IDefinitionCondition[];
+}
+
+export interface IRBSegment extends TargetingEntity {
   excluded?: {
     keys?: string[] | null,
     segments?: IExcludedSegment[] | null
-  }
+  } | null
 }
 
-export interface ISplit {
-  name: string,
-  changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
-  conditions: ISplitCondition[],
+export interface IDefinition extends TargetingEntity {
+  trafficTypeName: string;
+  sets?: string[] | null;
+  impressionsDisabled?: boolean;
   prerequisites?: null | {
     n: string,
     ts: string[]
-  }[]
-  killed: boolean,
-  defaultTreatment: string,
-  trafficTypeName: string,
-  seed: number,
-  trafficAllocation?: number,
-  trafficAllocationSeed?: number
+  }[];
+  killed: boolean;
+  defaultTreatment: string;
+  seed: number;
+  trafficAllocation?: number;
+  trafficAllocationSeed?: number;
   configurations?: {
-    [treatmentName: string]: string
-  },
-  sets?: string[],
-  impressionsDisabled?: boolean
+    [treatmentName: string]: string | SplitIO.JsonObject
+  } | null;
 }
 
-// Split definition used in offline mode
-export type ISplitPartial = Pick<ISplit, 'conditions' | 'configurations' | 'trafficTypeName'>
-
 /** Interface of the parsed JSON response of `/splitChanges` */
-export interface ISplitChangesResponse {
-  ff?: {
-    t: number,
-    s?: number,
-    d: ISplit[]
+export interface IDefinitionChangesResponse {
+  d?: {
+    till: number,
+    since?: number | null,
+    updated: IDefinition[],
+    removed: string[],
   },
   rbs?: {
-    t: number,
-    s?: number,
-    d: IRBSegment[]
+    till: number,
+    since?: number | null,
+    updated: IRBSegment[],
+    removed: string[],
   }
 }
 

package/src/evaluator/Engine.ts

@@ -4,10 +4,10 @@ import { keyParser } from '../utils/key';
 import { thenable } from '../utils/promise/thenable';
 import { NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED, PREREQUISITES_NOT_MET } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { ISplit, MaybeThenable } from '../dtos/types';
+import { IDefinition, MaybeThenable } from '../dtos/types';
 import SplitIO from '../../types/splitio';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluation, IEvaluationResult, ISplitEvaluator } from './types';
+import { IEvaluation, IEvaluationResult, IDefinitionEvaluator } from './types';
 import { ILogger } from '../logger/types';
 import { ENGINE_DEFAULT } from '../logger/constants';
 import { prerequisitesMatcherContext } from './matchers/prerequisites';
@@ -19,7 +19,7 @@ function evaluationResult(result: IEvaluation | undefined, defaultTreatment: str
   };
 }
 
-export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync | IStorageAsync) {
+export function engineParser(log: ILogger, split: IDefinition, storage: IStorageSync | IStorageAsync) {
   const { killed, seed, trafficAllocation, trafficAllocationSeed, status, conditions, prerequisites } = split;
 
   const defaultTreatment = isString(split.defaultTreatment) ? split.defaultTreatment : CONTROL;
@@ -29,7 +29,7 @@ export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync
 
   return {
 
-    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: IDefinitionEvaluator): MaybeThenable<IEvaluationResult> {
 
       const parsedKey = keyParser(key);
 

package/src/evaluator/combiners/and.ts

@@ -2,11 +2,11 @@ import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { MaybeThenable } from '../../dtos/types';
-import { ISplitEvaluator } from '../types';
+import { IDefinitionEvaluator } from '../types';
 import { ENGINE_COMBINER_AND } from '../../logger/constants';
 import SplitIO from '../../../types/splitio';
 
-export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>>) {
+export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<boolean>>) {
 
   function andResults(results: boolean[]): boolean {
     // Array.prototype.every is supported by target environments
@@ -16,7 +16,7 @@ export function andCombinerContext(log: ILogger, matchers: Array<(key: SplitIO.S
     return hasMatchedAll;
   }
 
-  return function andCombiner(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator): MaybeThenable<boolean> {
+  return function andCombiner(key: SplitIO.SplitKey, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator): MaybeThenable<boolean> {
     const matcherResults = matchers.map(matcher => matcher(key, attributes, splitEvaluator));
 
     // If any matching result is a thenable we should use Promise.all

package/src/evaluator/combiners/ifelseif.ts

@@ -4,7 +4,7 @@ import { thenable } from '../../utils/promise/thenable';
 import { UNSUPPORTED_MATCHER_TYPE } from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
 import SplitIO from '../../../types/splitio';
-import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
+import { IEvaluation, IEvaluator, IDefinitionEvaluator } from '../types';
 import { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants';
 
 export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]): IEvaluator {
@@ -33,7 +33,7 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
     return undefined;
   }
 
-  function ifElseIfCombiner(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  function ifElseIfCombiner(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) {
     // In Async environments we are going to have async predicates. There is none way to know
     // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
     // define how to return the treatment (wrap result into a Promise or not).

package/src/evaluator/condition/engineUtils.ts

@@ -18,10 +18,10 @@ export function getTreatment(log: ILogger, key: string, seed: number | undefined
 /**
  * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
  */
-export function shouldApplyRollout(trafficAllocation: number, key: string, trafficAllocationSeed: number) {
+export function shouldApplyRollout(trafficAllocation: number, bucketingKey: string, trafficAllocationSeed: number) {
   // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
   if (trafficAllocation < 100) {
-    const _bucket = bucket(key, trafficAllocationSeed);
+    const _bucket = bucket(bucketingKey, trafficAllocationSeed);
 
     if (_bucket > trafficAllocation) {
       return false;

package/src/evaluator/condition/index.ts

@@ -2,7 +2,7 @@ import { getTreatment, shouldApplyRollout } from './engineUtils';
 import { thenable } from '../../utils/promise/thenable';
 import { NOT_IN_SPLIT } from '../../utils/labels';
 import { MaybeThenable } from '../../dtos/types';
-import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
+import { IEvaluation, IEvaluator, IDefinitionEvaluator } from '../types';
 import SplitIO from '../../../types/splitio';
 import { ILogger } from '../../logger/types';
 
@@ -22,9 +22,9 @@ function match(log: ILogger, matchingResult: boolean, bucketingKey: string | und
 }
 
 // Condition factory
-export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.SplitKeyObject, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>, treatments?: { getTreatmentFor: (x: number) => string }, label?: string, conditionType?: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
+export function conditionContext(log: ILogger, matcherEvaluator: (key: SplitIO.SplitKeyObject, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) => MaybeThenable<boolean>, treatments?: { getTreatmentFor: (x: number) => string }, label?: string, conditionType?: 'ROLLOUT' | 'WHITELIST'): IEvaluator {
 
-  return function conditionEvaluator(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) {
+  return function conditionEvaluator(key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: IDefinitionEvaluator) {
 
     // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
     if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation!, key.bucketingKey, trafficAllocationSeed!)) {

package/src/evaluator/fallbackConfigsCalculator/fallbackSanitizer/index.ts

@@ -0,0 +1,76 @@
+import SplitIO from '../../../../types/splitio';
+import { ILogger } from '../../../logger/types';
+import { isObject, isString } from '../../../utils/lang';
+
+const CONFIG_NAME_DISCARD_REASON = 'Invalid config name (max 100 chars, no spaces)';
+const VARIANT_DISCARD_REASON = 'Invalid variant (max 100 chars and must match pattern)';
+const VALUE_DISCARD_REASON = 'Invalid value (must be an object)';
+
+const VARIANT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+
+export function isValidConfigName(name: string): boolean {
+  return name.length <= 100 && !name.includes(' ');
+}
+
+export function isValidConfig(config?: SplitIO.Config): boolean {
+  if (!isObject(config)) return false;
+  if (!isString(config!.variant) || config!.variant.length > 100 || !VARIANT_PATTERN.test(config!.variant)) return false;
+  if (!isObject(config!.value)) return false;
+  return true;
+}
+
+function sanitizeGlobal(logger: ILogger, config?: SplitIO.Config): SplitIO.Config | undefined {
+  if (config === undefined) return undefined;
+  if (!isValidConfig(config)) {
+    if (!isObject(config) || !isString(config!.variant) || config!.variant.length > 100 || !VARIANT_PATTERN.test(config!.variant)) {
+      logger.error(`Fallback configs - Discarded fallback: ${VARIANT_DISCARD_REASON}`);
+    } else {
+      logger.error(`Fallback configs - Discarded fallback: ${VALUE_DISCARD_REASON}`);
+    }
+    return undefined;
+  }
+  return config;
+}
+
+function sanitizeByName(
+  logger: ILogger,
+  byNameFallbacks?: Record<string, SplitIO.Config>
+): Record<string, SplitIO.Config> {
+  const sanitizedByName: Record<string, SplitIO.Config> = {};
+
+  if (!isObject(byNameFallbacks)) return sanitizedByName;
+
+  Object.keys(byNameFallbacks!).forEach((configName) => {
+    const config = byNameFallbacks![configName];
+
+    if (!isValidConfigName(configName)) {
+      logger.error(`Fallback configs - Discarded config '${configName}': ${CONFIG_NAME_DISCARD_REASON}`);
+      return;
+    }
+
+    if (!isValidConfig(config)) {
+      if (!isObject(config) || !isString(config.variant) || config.variant.length > 100 || !VARIANT_PATTERN.test(config.variant)) {
+        logger.error(`Fallback configs - Discarded config '${configName}': ${VARIANT_DISCARD_REASON}`);
+      } else {
+        logger.error(`Fallback configs - Discarded config '${configName}': ${VALUE_DISCARD_REASON}`);
+      }
+      return;
+    }
+
+    sanitizedByName[configName] = config;
+  });
+
+  return sanitizedByName;
+}
+
+export function sanitizeFallbacks(logger: ILogger, fallbacks: SplitIO.FallbackConfigs): SplitIO.FallbackConfigs | undefined {
+  if (!isObject(fallbacks)) {
+    logger.error('Fallback configs - Discarded configuration: it must be an object with optional `global` and `byName` properties');
+    return;
+  }
+
+  return {
+    global: sanitizeGlobal(logger, fallbacks.global),
+    byName: sanitizeByName(logger, fallbacks.byName)
+  };
+}

package/src/evaluator/fallbackConfigsCalculator/index.ts

@@ -0,0 +1,24 @@
+import { IFallbackCalculator } from '../fallbackTreatmentsCalculator/index';
+import { CONTROL } from '../../utils/constants';
+import SplitIO from '../../../types/splitio';
+
+export const FALLBACK_PREFIX = 'fallback - ';
+
+export function FallbackConfigsCalculator(fallbacks: SplitIO.FallbackConfigs = {}): IFallbackCalculator {
+
+  return (configName: string, label = '') => {
+    const fallback = fallbacks.byName?.[configName] || fallbacks.global;
+
+    return fallback ?
+      {
+        treatment: fallback.variant,
+        config: fallback.value,
+        label: `${FALLBACK_PREFIX}${label}`,
+      } :
+      {
+        treatment: CONTROL,
+        config: null,
+        label,
+      };
+  };
+}

package/src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -2,10 +2,8 @@ import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '
 import { ILogger } from '../../../logger/types';
 import { isObject, isString } from '../../../utils/lang';
 
-enum FallbackDiscardReason {
-  FlagName = 'Invalid flag name (max 100 chars, no spaces)',
-  Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
-}
+const FLAG_NAME_DISCARD_REASON = 'Invalid flag name (max 100 chars, no spaces)';
+const TREATMENT_DISCARD_REASON = 'Invalid treatment (max 100 chars and must match pattern)';
 
 const TREATMENT_PATTERN = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
 
@@ -25,7 +23,7 @@ export function isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
 function sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
   if (treatment === undefined) return undefined;
   if (!isValidTreatment(treatment)) {
-    logger.error(`Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`);
+    logger.error(`Fallback treatments - Discarded fallback: ${TREATMENT_DISCARD_REASON}`);
     return undefined;
   }
   return treatment;
@@ -43,12 +41,12 @@ function sanitizeByFlag(
     const t = byFlagFallbacks![flag];
 
     if (!isValidFlagName(flag)) {
-      logger.error(`Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`);
+      logger.error(`Fallback treatments - Discarded flag '${flag}': ${FLAG_NAME_DISCARD_REASON}`);
       return;
     }
 
     if (!isValidTreatment(t)) {
-      logger.error(`Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`);
+      logger.error(`Fallback treatments - Discarded treatment for flag '${flag}': ${TREATMENT_DISCARD_REASON}`);
       return;
     }