[SDK Configs] Baseline

.eslintrc

@@ -1,4 +1,5 @@
 {
+  "root": true,
   "extends": [
     "eslint:recommended"
   ],

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 {
@@ -39,7 +37,7 @@ export interface IDependencyMatcherData {
   treatments: string[]
 }
 
-interface ISplitMatcherBase {
+interface IDefinitionMatcherBase {
   matcherType: string
   negate?: boolean
   keySelector?: null | {
@@ -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,48 +201,44 @@ export interface IExcludedSegment {
   name: string,
 }
 
-export interface IRBSegment {
-  name: string,
-  changeNumber: number,
-  status?: 'ACTIVE' | 'ARCHIVED',
-  conditions?: ISplitCondition[] | null,
+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[];
+  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
+  };
 }
 
-// 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 {
+export interface IDefinitionChangesResponse {
   ff?: {
     t: number,
     s?: number,
-    d: ISplit[]
+    d: IDefinition[]
   },
   rbs?: {
     t: number,

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);