@featurevisor/sdk 0.37.0 → 0.38.0

package/src/instance.ts

@@ -7,10 +7,11 @@ import {
   Feature,
   FeatureKey,
   InitialFeatures,
+  OverrideFeature,
   StickyFeatures,
+  Traffic,
   VariableType,
   VariableValue,
-  VariationType,
   VariationValue,
   Variation,
   RuleKey,
@@ -22,7 +23,7 @@ import { createLogger, Logger } from "./logger";
 import { DatafileReader } from "./datafileReader";
 import { Emitter } from "./emitter";
 import { getBucketedNumber } from "./bucket";
-import { findForceFromFeature, getMatchedTrafficAndAllocation } from "./feature";
+import { findForceFromFeature, getMatchedTraffic, getMatchedTrafficAndAllocation } from "./feature";
 import { allConditionsAreMatched } from "./conditions";
 import { allGroupSegmentsAreMatched } from "./segments";
 
@@ -78,6 +79,9 @@ export type DatafileFetchHandler = (datafileUrl: string) => Promise<DatafileCont
 
 export enum EvaluationReason {
   NOT_FOUND = "not_found",
+  NO_VARIATIONS = "no_variations",
+  DISABLED = "disabled",
+  OUT_OF_RANGE = "out_of_range",
   FORCED = "forced",
   INITIAL = "initial",
   STICKY = "sticky",
@@ -97,6 +101,10 @@ export interface Evaluation {
   bucketValue?: BucketValue;
   ruleKey?: RuleKey;
   error?: Error;
+  enabled?: boolean;
+  traffic?: Traffic;
+  sticky?: OverrideFeature;
+  initial?: OverrideFeature;
 
   // variation
   variation?: Variation;
@@ -119,7 +127,7 @@ function fetchDatafileContent(
   return fetch(datafileUrl).then((res) => res.json());
 }
 
-type FieldType = VariationType | VariableType;
+type FieldType = string | VariableType;
 type ValueType = VariableValue;
 
 export function getValueByType(value: ValueType, fieldType: FieldType): ValueType {
@@ -418,6 +426,186 @@ export class FeaturevisorInstance {
     clearInterval(this.intervalId);
   }
 
+  /**
+   * Flag
+   */
+  evaluateFlag(featureKey: FeatureKey | Feature, context: Context = {}): Evaluation {
+    let evaluation: Evaluation;
+
+    try {
+      const key = typeof featureKey === "string" ? featureKey : featureKey.key;
+
+      // sticky
+      if (
+        this.stickyFeatures &&
+        this.stickyFeatures[key] &&
+        typeof this.stickyFeatures[key].enabled !== "undefined"
+      ) {
+        evaluation = {
+          featureKey: key,
+          reason: EvaluationReason.STICKY,
+          enabled: this.stickyFeatures[key].enabled,
+          sticky: this.stickyFeatures[key],
+        };
+
+        this.logger.debug("using sticky enabled", evaluation);
+
+        return evaluation;
+      }
+
+      // initial
+      if (
+        this.statuses &&
+        !this.statuses.ready &&
+        this.initialFeatures &&
+        this.initialFeatures[key] &&
+        typeof this.initialFeatures[key].enabled !== "undefined"
+      ) {
+        evaluation = {
+          featureKey: key,
+          reason: EvaluationReason.INITIAL,
+          enabled: this.initialFeatures[key].enabled,
+          initial: this.initialFeatures[key],
+        };
+
+        this.logger.debug("using initial enabled", evaluation);
+
+        return evaluation;
+      }
+
+      const feature = this.getFeature(featureKey);
+
+      // not found
+      if (!feature) {
+        evaluation = {
+          featureKey: key,
+          reason: EvaluationReason.NOT_FOUND,
+        };
+
+        this.logger.warn("feature not found", evaluation);
+
+        return evaluation;
+      }
+
+      const finalContext = this.interceptContext ? this.interceptContext(context) : context;
+
+      // forced
+      const force = findForceFromFeature(feature, context, this.datafileReader);
+
+      if (force && typeof force.enabled !== "undefined") {
+        evaluation = {
+          featureKey: feature.key,
+          reason: EvaluationReason.FORCED,
+          enabled: force.enabled,
+        };
+
+        this.logger.debug("forced enabled found", evaluation);
+
+        return evaluation;
+      }
+
+      // bucketing
+      const bucketValue = this.getBucketValue(feature, finalContext);
+
+      const matchedTraffic = getMatchedTraffic(feature.traffic, finalContext, this.datafileReader);
+
+      if (matchedTraffic) {
+        // check if mutually exclusive
+        if (feature.ranges && feature.ranges.length > 0) {
+          const matchedRange = feature.ranges.find((range) => {
+            return bucketValue >= range[0] && bucketValue < range[1];
+          });
+
+          // matched
+          if (matchedRange) {
+            evaluation = {
+              featureKey: feature.key,
+              reason: EvaluationReason.ALLOCATED,
+              enabled:
+                typeof matchedTraffic.enabled === "undefined" ? true : matchedTraffic.enabled,
+              bucketValue,
+            };
+
+            return evaluation;
+          }
+
+          // no match
+          evaluation = {
+            featureKey: feature.key,
+            reason: EvaluationReason.OUT_OF_RANGE,
+            enabled: false,
+            bucketValue,
+          };
+
+          this.logger.debug("not matched", evaluation);
+
+          return evaluation;
+        }
+
+        // override from rule
+        if (typeof matchedTraffic.enabled !== "undefined") {
+          evaluation = {
+            featureKey: feature.key,
+            reason: EvaluationReason.OVERRIDE,
+            enabled: matchedTraffic.enabled,
+            bucketValue,
+            ruleKey: matchedTraffic.key,
+            traffic: matchedTraffic,
+          };
+
+          this.logger.debug("override from rule", evaluation);
+
+          return evaluation;
+        }
+
+        // treated as enabled because of matched traffic
+        if (bucketValue < matchedTraffic.percentage) {
+          // @TODO: verify if range check should be inclusive or not
+          evaluation = {
+            featureKey: feature.key,
+            reason: EvaluationReason.RULE,
+            enabled: true,
+            bucketValue,
+            ruleKey: matchedTraffic.key,
+            traffic: matchedTraffic,
+          };
+
+          return evaluation;
+        }
+      }
+
+      // nothing matched
+      evaluation = {
+        featureKey: feature.key,
+        reason: EvaluationReason.ERROR,
+        enabled: false,
+        bucketValue,
+      };
+
+      return evaluation;
+    } catch (e) {
+      evaluation = {
+        featureKey: typeof featureKey === "string" ? featureKey : featureKey.key,
+        reason: EvaluationReason.ERROR,
+        error: e,
+      };
+
+      return evaluation;
+    }
+  }
+
+  isEnabled(featureKey: FeatureKey | Feature, context: Context = {}): boolean {
+    try {
+      const evaluation = this.evaluateFlag(featureKey, context);
+
+      return evaluation.enabled === true;
+    } catch (e) {
+      this.logger.error("isEnabled", { featureKey, error: e });
+
+      return false;
+    }
+  }
+
   /**
    * Variation
    */
@@ -427,6 +615,19 @@ export class FeaturevisorInstance {
     try {
       const key = typeof featureKey === "string" ? featureKey : featureKey.key;
 
+      const flag = this.evaluateFlag(featureKey, context);
+
+      if (flag.enabled === false) {
+        evaluation = {
+          featureKey: key,
+          reason: EvaluationReason.DISABLED,
+        };
+
+        this.logger.debug("feature is disabled", evaluation);
+
+        return evaluation;
+      }
+
       // sticky
       if (this.stickyFeatures && this.stickyFeatures[key]) {
         const variationValue = this.stickyFeatures[key].variation;
@@ -474,7 +675,19 @@ export class FeaturevisorInstance {
           reason: EvaluationReason.NOT_FOUND,
         };
 
-        this.logger.warn("feature not found in datafile", evaluation);
+        this.logger.warn("feature not found", evaluation);
+
+        return evaluation;
+      }
+
+      // no variations
+      if (!feature.variations || feature.variations.length === 0) {
+        evaluation = {
+          featureKey: key,
+          reason: EvaluationReason.NO_VARIATIONS,
+        };
+
+        this.logger.warn("no variations", evaluation);
 
         return evaluation;
       }
@@ -550,30 +763,14 @@ export class FeaturevisorInstance {
         }
       }
 
-      // fall back to default
-      const variation = feature.variations.find((v) => v.value === feature.defaultVariation);
-
-      if (variation) {
-        evaluation = {
-          featureKey: feature.key,
-          reason: EvaluationReason.DEFAULTED,
-          bucketValue,
-          variation,
-        };
-
-        this.logger.debug("using default variation", evaluation);
-
-        return evaluation;
-      }
-
-      // nothing matched (this should never happen)
+      // nothing matched
       evaluation = {
         featureKey: feature.key,
         reason: EvaluationReason.ERROR,
         bucketValue,
       };
 
-      this.logger.error("no matched variation", evaluation);
+      this.logger.debug("no matched variation", evaluation);
 
       return evaluation;
     } catch (e) {
@@ -610,33 +807,6 @@ export class FeaturevisorInstance {
     }
   }
 
-  getVariationBoolean(
-    featureKey: FeatureKey | Feature,
-    context: Context = {},
-  ): boolean | undefined {
-    const variationValue = this.getVariation(featureKey, context);
-
-    return getValueByType(variationValue, "boolean") as boolean | undefined;
-  }
-
-  getVariationString(featureKey: FeatureKey | Feature, context: Context = {}): string | undefined {
-    const variationValue = this.getVariation(featureKey, context);
-
-    return getValueByType(variationValue, "string") as string | undefined;
-  }
-
-  getVariationInteger(featureKey: FeatureKey | Feature, context: Context = {}): number | undefined {
-    const variationValue = this.getVariation(featureKey, context);
-
-    return getValueByType(variationValue, "integer") as number | undefined;
-  }
-
-  getVariationDouble(featureKey: FeatureKey | Feature, context: Context = {}): number | undefined {
-    const variationValue = this.getVariation(featureKey, context);
-
-    return getValueByType(variationValue, "double") as number | undefined;
-  }
-
   /**
    * Activate
    */
@@ -719,21 +889,38 @@ export class FeaturevisorInstance {
     try {
       const key = typeof featureKey === "string" ? featureKey : featureKey.key;
 
+      const flag = this.evaluateFlag(featureKey, context);
+
+      if (flag.enabled === false) {
+        evaluation = {
+          featureKey: key,
+          reason: EvaluationReason.DISABLED,
+        };
+
+        this.logger.debug("feature is disabled", evaluation);
+
+        return evaluation;
+      }
+
       // sticky
-      if (this.stickyFeatures && this.stickyFeatures[key] && this.stickyFeatures[key].variables) {
-        const result = this.stickyFeatures[key].variables[variableKey];
+      if (this.stickyFeatures && this.stickyFeatures[key]) {
+        const variables = this.stickyFeatures[key].variables;
 
-        if (typeof result !== "undefined") {
-          evaluation = {
-            featureKey: key,
-            reason: EvaluationReason.STICKY,
-            variableKey,
-            variableValue: result,
-          };
+        if (variables) {
+          const result = variables[variableKey];
 
-          this.logger.debug("using sticky variable", evaluation);
+          if (typeof result !== "undefined") {
+            evaluation = {
+              featureKey: key,
+              reason: EvaluationReason.STICKY,
+              variableKey,
+              variableValue: result,
+            };
 
-          return evaluation;
+            this.logger.debug("using sticky variable", evaluation);
+
+            return evaluation;
+          }
         }
       }
 
@@ -742,20 +929,24 @@ export class FeaturevisorInstance {
         this.statuses &&
         !this.statuses.ready &&
         this.initialFeatures &&
-        this.initialFeatures[key] &&
-        this.initialFeatures[key].variables &&
-        typeof this.initialFeatures[key].variables[variableKey] !== "undefined"
+        this.initialFeatures[key]
       ) {
-        evaluation = {
-          featureKey: key,
-          reason: EvaluationReason.INITIAL,
-          variableKey,
-          variableValue: this.initialFeatures[key].variables[variableKey],
-        };
+        const variables = this.initialFeatures[key].variables;
 
-        this.logger.debug("using initial variable", evaluation);
+        if (variables) {
+          if (typeof variables[variableKey] !== "undefined") {
+            evaluation = {
+              featureKey: key,
+              reason: EvaluationReason.INITIAL,
+              variableKey,
+              variableValue: variables[variableKey],
+            };
 
-        return evaluation;
+            this.logger.debug("using initial variable", evaluation);
+
+            return evaluation;
+          }
+        }
       }
 
       const feature = this.getFeature(featureKey);
@@ -842,7 +1033,7 @@ export class FeaturevisorInstance {
         }
 
         // regular allocation
-        if (matchedAllocation && matchedAllocation.variation) {
+        if (matchedAllocation && matchedAllocation.variation && Array.isArray(feature.variations)) {
           const variation = feature.variations.find((v) => v.value === matchedAllocation.variation);
 
           if (variation && variation.variables) {