Merge branch 'sdk-configs-rename-split-to-definition' into configs-sdk-client

Author: EmilianoSanchez

src/evaluator/Engine.ts

@@ -29,7 +29,9 @@ export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync
 
   return {
 
-    getTreatment(key: SplitIO.SplitKey | undefined, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
+    getTreatment(key: SplitIO.SplitKey, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator): MaybeThenable<IEvaluationResult> {
+
+      const parsedKey = keyParser(key);
 
       function evaluate(prerequisitesMet: boolean) {
         if (!prerequisitesMet) {
@@ -40,7 +42,7 @@ export function engineParser(log: ILogger, split: ISplit, storage: IStorageSync
           };
         }
 
-        const evaluation = evaluator(key ? keyParser(key) : undefined, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) as MaybeThenable<IEvaluation>;
+        const evaluation = evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator) as MaybeThenable<IEvaluation>;
 
         return thenable(evaluation) ?
           evaluation.then(result => evaluationResult(result, defaultTreatment)) :

src/evaluator/combiners/ifelseif.ts

@@ -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?: ISplitEvaluator) {
     // 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).

src/evaluator/condition/index.ts

@@ -24,10 +24,10 @@ 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 {
 
-  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?: ISplitEvaluator) {
 
     // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
-    if (!key || (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation!, key.bucketingKey, trafficAllocationSeed!))) {
+    if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation!, key.bucketingKey, trafficAllocationSeed!)) {
       return {
         treatment: undefined, // treatment value is assigned later
         label: NOT_IN_SPLIT

src/evaluator/index.ts

@@ -1,6 +1,6 @@
 import { engineParser } from './Engine';
 import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, DEFINITION_NOT_FOUND } from '../utils/labels';
+import { EXCEPTION, NO_CONDITION_MATCH, DEFINITION_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
@@ -10,24 +10,29 @@ import { ILogger } from '../logger/types';
 import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 
-const treatmentException = {
+const EVALUATION_EXCEPTION = {
   treatment: CONTROL,
   label: EXCEPTION,
   config: null
 };
 
+let EVALUATION_NOT_FOUND = {
+  treatment: CONTROL,
+  label: DEFINITION_NOT_FOUND,
+  config: null
+};
+
 function treatmentsException(splitNames: string[]) {
   const evaluations: Record<string, IEvaluationResult> = {};
   splitNames.forEach(splitName => {
-    evaluations[splitName] = treatmentException;
+    evaluations[splitName] = EVALUATION_EXCEPTION;
   });
   return evaluations;
 }
 
-// @TODO: test cases with no key
 export function evaluateFeature(
   log: ILogger,
-  key: SplitIO.SplitKey | undefined,
+  key: SplitIO.SplitKey,
   splitName: string,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
@@ -39,7 +44,7 @@ export function evaluateFeature(
     parsedSplit = storage.splits.getSplit(splitName);
   } catch (e) {
     // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
-    return treatmentException;
+    return EVALUATION_EXCEPTION;
   }
 
   if (thenable(parsedSplit)) {
@@ -53,7 +58,7 @@ export function evaluateFeature(
     )).catch(
       // Exception on async `getSplit` storage. For example, when the storage is redis or
       // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-      () => treatmentException
+      () => EVALUATION_EXCEPTION
     );
   }
 
@@ -140,21 +145,16 @@ export function evaluateFeaturesByFlagSets(
 
 function getEvaluation(
   log: ILogger,
-  key: SplitIO.SplitKey | undefined,
+  key: SplitIO.SplitKey,
   splitJSON: ISplit | null,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
   options?: SplitIO.EvaluationOptions,
 ): MaybeThenable<IEvaluationResult> {
-  let evaluation: MaybeThenable<IEvaluationResult> = {
-    treatment: CONTROL,
-    label: DEFINITION_NOT_FOUND,
-    config: null
-  };
 
   if (splitJSON) {
     const split = engineParser(log, splitJSON, storage);
-    evaluation = split.getTreatment(key, attributes, evaluateFeature);
+    const evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
     // If the storage is async and the evaluated flag uses segments or dependencies, evaluation is thenable
     if (thenable(evaluation)) {
@@ -172,9 +172,11 @@ function getEvaluation(
       // @ts-expect-error impressionsDisabled is not exposed in the public typings yet.
       evaluation.impressionsDisabled = options?.impressionsDisabled || splitJSON.impressionsDisabled;
     }
+
+    return evaluation;
   }
 
-  return evaluation;
+  return EVALUATION_NOT_FOUND;
 }
 
 function getEvaluations(
@@ -208,3 +210,35 @@ function getEvaluations(
 
   return thenables.length > 0 ? Promise.all(thenables).then(() => result) : result;
 }
+
+export function evaluateDefaultTreatment(
+  splitName: string,
+  storage: IStorageSync | IStorageAsync,
+): MaybeThenable<IEvaluationResult> {
+  let parsedSplit;
+
+  try {
+    parsedSplit = storage.splits.getSplit(splitName);
+  } catch (e) {
+    return EVALUATION_EXCEPTION;
+  }
+
+  return thenable(parsedSplit) ?
+    parsedSplit.then(getDefaultTreatment).catch(() => EVALUATION_EXCEPTION) :
+    getDefaultTreatment(parsedSplit);
+}
+
+function getDefaultTreatment(
+  splitJSON: ISplit | null,
+): MaybeThenable<IEvaluationResult> {
+  if (splitJSON) {
+    return {
+      treatment: splitJSON.defaultTreatment,
+      label: NO_CONDITION_MATCH, // "default rule"
+      config: splitJSON.configurations && splitJSON.configurations[splitJSON.defaultTreatment] || null,
+      changeNumber: splitJSON.changeNumber
+    };
+  }
+
+  return EVALUATION_NOT_FOUND;
+}

src/evaluator/matchers/prerequisites.ts

@@ -6,7 +6,7 @@ import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
 
 export function prerequisitesMatcherContext(prerequisites: ISplit['prerequisites'], storage: IStorageSync | IStorageAsync, log: ILogger) {
 
-  return function prerequisitesMatcher({ key, attributes }: Partial<IDependencyMatcherValue>, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
+  return function prerequisitesMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
 
     prerequisites = prerequisites == null ? [] : prerequisites;
 

src/evaluator/types.ts

@@ -27,8 +27,8 @@ export interface IEvaluation {
 
 export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey | undefined, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key?: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>
+export type IEvaluator = (key: SplitIO.SplitKeyObject, seed?: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | boolean | undefined>
 
 export type IMatcher = (value: string | number | boolean | string[] | IDependencyMatcherValue, splitEvaluator?: ISplitEvaluator) => MaybeThenable<boolean>

src/sdkClient/client.ts

@@ -39,7 +39,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
 
-  function getTreatment(key: SplitIO.SplitKey | undefined, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENT) {
+  function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes?: SplitIO.Attributes, options?: SplitIO.EvaluationOptions, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
@@ -134,12 +134,15 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   function processEvaluation(
     evaluation: IEvaluationResult,
     featureFlagName: string,
-    key: SplitIO.SplitKey | undefined,
+    key: SplitIO.SplitKey,
     properties: string | undefined,
     withConfig: boolean,
     invokingMethodName: string,
     queue: ImpressionDecorated[]
   ): SplitIO.Treatment | Pick<IEvaluation, 'treatment' | 'config'> {
+    const matchingKey = getMatching(key);
+    const bucketingKey = getBucketing(key);
+
     const { changeNumber, impressionsDisabled } = evaluation;
     let { treatment, label, config = null } = evaluation;
 
@@ -150,11 +153,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       config = fallbackTreatment.config;
     }
 
-    // If no target/key, no impression is tracked
-    if (key && validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-      const matchingKey = getMatching(key);
-      const bucketingKey = getBucketing(key);
-
+    if (validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
       log.info(IMPRESSION_QUEUEING, [featureFlagName, matchingKey, treatment, label]);
       queue.push({
         imp: {