@featurevisor/sdk 0.36.0 → 0.38.0

package/src/instance.ts

@@ -1,5 +1,5 @@
 import {
-  Attributes,
+  Context,
   AttributeValue,
   BucketKey,
   BucketValue,
@@ -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";
 
@@ -31,13 +32,13 @@ export type ReadyCallback = () => void;
 export type ActivationCallback = (
   featureName: string,
   variation: VariationValue,
-  attributes: Attributes,
-  captureAttributes: Attributes,
+  context: Context,
+  captureContext: Context,
 ) => void;
 
-export type ConfigureBucketKey = (feature, attributes, bucketKey: BucketKey) => BucketKey;
+export type ConfigureBucketKey = (feature, context, bucketKey: BucketKey) => BucketKey;
 
-export type ConfigureBucketValue = (feature, attributes, bucketValue: BucketValue) => BucketValue;
+export type ConfigureBucketValue = (feature, context, bucketValue: BucketValue) => BucketValue;
 
 export interface Statuses {
   ready: boolean;
@@ -46,6 +47,8 @@ export interface Statuses {
 
 const DEFAULT_BUCKET_KEY_SEPARATOR = ".";
 
+export type InterceptContext = (context: Context) => Context;
+
 export interface InstanceOptions {
   bucketKeySeparator?: string;
   configureBucketKey?: ConfigureBucketKey;
@@ -54,7 +57,7 @@ export interface InstanceOptions {
   datafileUrl?: string;
   handleDatafileFetch?: (datafileUrl: string) => Promise<DatafileContent>;
   initialFeatures?: InitialFeatures;
-  interceptAttributes?: (attributes: Attributes) => Attributes;
+  interceptContext?: InterceptContext;
   logger?: Logger;
   onActivation?: ActivationCallback;
   onReady?: ReadyCallback;
@@ -76,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",
@@ -95,6 +101,10 @@ export interface Evaluation {
   bucketValue?: BucketValue;
   ruleKey?: RuleKey;
   error?: Error;
+  enabled?: boolean;
+  traffic?: Traffic;
+  sticky?: OverrideFeature;
+  initial?: OverrideFeature;
 
   // variation
   variation?: Variation;
@@ -117,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 {
@@ -156,7 +166,7 @@ export class FeaturevisorInstance {
   private datafileUrl?: string;
   private handleDatafileFetch?: DatafileFetchHandler;
   private initialFeatures?: InitialFeatures;
-  private interceptAttributes?: (attributes: Attributes) => Attributes;
+  private interceptContext?: InterceptContext;
   private logger: Logger;
   private refreshInterval?: number; // seconds
   private stickyFeatures?: StickyFeatures;
@@ -182,7 +192,7 @@ export class FeaturevisorInstance {
     this.datafileUrl = options.datafileUrl;
     this.handleDatafileFetch = options.handleDatafileFetch;
     this.initialFeatures = options.initialFeatures;
-    this.interceptAttributes = options.interceptAttributes;
+    this.interceptContext = options.interceptContext;
     this.logger = options.logger || createLogger();
     this.refreshInterval = options.refreshInterval;
     this.stickyFeatures = options.stickyFeatures;
@@ -281,7 +291,7 @@ export class FeaturevisorInstance {
   /**
    * Bucketing
    */
-  private getBucketKey(feature: Feature, attributes: Attributes): BucketKey {
+  private getBucketKey(feature: Feature, context: Context): BucketKey {
     const featureKey = feature.key;
 
     let type;
@@ -305,7 +315,7 @@ export class FeaturevisorInstance {
     const bucketKey: AttributeValue[] = [];
 
     attributeKeys.forEach((attributeKey) => {
-      const attributeValue = attributes[attributeKey];
+      const attributeValue = context[attributeKey];
 
       if (typeof attributeValue === "undefined") {
         return;
@@ -326,19 +336,19 @@ export class FeaturevisorInstance {
     const result = bucketKey.join(this.bucketKeySeparator);
 
     if (this.configureBucketKey) {
-      return this.configureBucketKey(feature, attributes, result);
+      return this.configureBucketKey(feature, context, result);
     }
 
     return result;
   }
 
-  private getBucketValue(feature: Feature, attributes: Attributes): BucketValue {
-    const bucketKey = this.getBucketKey(feature, attributes);
+  private getBucketValue(feature: Feature, context: Context): BucketValue {
+    const bucketKey = this.getBucketKey(feature, context);
 
     const value = getBucketedNumber(bucketKey);
 
     if (this.configureBucketValue) {
-      return this.configureBucketValue(feature, attributes, value);
+      return this.configureBucketValue(feature, context, value);
     }
 
     return value;
@@ -416,15 +426,208 @@ 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
    */
-  evaluateVariation(featureKey: FeatureKey | Feature, attributes: Attributes = {}): Evaluation {
+  evaluateVariation(featureKey: FeatureKey | Feature, context: Context = {}): Evaluation {
     let evaluation: Evaluation;
 
     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;
@@ -472,17 +675,27 @@ 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;
       }
 
-      const finalAttributes = this.interceptAttributes
-        ? this.interceptAttributes(attributes)
-        : attributes;
+      const finalContext = this.interceptContext ? this.interceptContext(context) : context;
 
       // forced
-      const force = findForceFromFeature(feature, attributes, this.datafileReader);
+      const force = findForceFromFeature(feature, context, this.datafileReader);
 
       if (force && force.variation) {
         const variation = feature.variations.find((v) => v.value === force.variation);
@@ -501,11 +714,11 @@ export class FeaturevisorInstance {
       }
 
       // bucketing
-      const bucketValue = this.getBucketValue(feature, finalAttributes);
+      const bucketValue = this.getBucketValue(feature, finalContext);
 
       const { matchedTraffic, matchedAllocation } = getMatchedTrafficAndAllocation(
         feature.traffic,
-        finalAttributes,
+        finalContext,
         bucketValue,
         this.datafileReader,
         this.logger,
@@ -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) {
@@ -589,10 +786,10 @@ export class FeaturevisorInstance {
 
   getVariation(
     featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
+    context: Context = {},
   ): VariationValue | undefined {
     try {
-      const evaluation = this.evaluateVariation(featureKey, attributes);
+      const evaluation = this.evaluateVariation(featureKey, context);
 
       if (typeof evaluation.variationValue !== "undefined") {
         return evaluation.variationValue;
@@ -610,48 +807,12 @@ export class FeaturevisorInstance {
     }
   }
 
-  getVariationBoolean(
-    featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
-  ): boolean | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
-
-    return getValueByType(variationValue, "boolean") as boolean | undefined;
-  }
-
-  getVariationString(
-    featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
-  ): string | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
-
-    return getValueByType(variationValue, "string") as string | undefined;
-  }
-
-  getVariationInteger(
-    featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
-  ): number | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
-
-    return getValueByType(variationValue, "integer") as number | undefined;
-  }
-
-  getVariationDouble(
-    featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
-  ): number | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
-
-    return getValueByType(variationValue, "double") as number | undefined;
-  }
-
   /**
    * Activate
    */
-  activate(featureKey: FeatureKey, attributes: Attributes = {}): VariationValue | undefined {
+  activate(featureKey: FeatureKey, context: Context = {}): VariationValue | undefined {
     try {
-      const evaluation = this.evaluateVariation(featureKey, attributes);
+      const evaluation = this.evaluateVariation(featureKey, context);
       const variationValue = evaluation.variation
         ? evaluation.variation.value
         : evaluation.variationValue;
@@ -660,19 +821,17 @@ export class FeaturevisorInstance {
         return undefined;
       }
 
-      const finalAttributes = this.interceptAttributes
-        ? this.interceptAttributes(attributes)
-        : attributes;
+      const finalContext = this.interceptContext ? this.interceptContext(context) : context;
 
-      const captureAttributes: Attributes = {};
+      const captureContext: Context = {};
 
       const attributesForCapturing = this.datafileReader
         .getAllAttributes()
         .filter((a) => a.capture === true);
 
       attributesForCapturing.forEach((a) => {
-        if (typeof finalAttributes[a.key] !== "undefined") {
-          captureAttributes[a.key] = attributes[a.key];
+        if (typeof finalContext[a.key] !== "undefined") {
+          captureContext[a.key] = context[a.key];
         }
       });
 
@@ -680,8 +839,8 @@ export class FeaturevisorInstance {
         "activation",
         featureKey,
         variationValue,
-        finalAttributes,
-        captureAttributes,
+        finalContext,
+        captureContext,
         evaluation,
       );
 
@@ -693,26 +852,26 @@ export class FeaturevisorInstance {
     }
   }
 
-  activateBoolean(featureKey: FeatureKey, attributes: Attributes = {}): boolean | undefined {
-    const variationValue = this.activate(featureKey, attributes);
+  activateBoolean(featureKey: FeatureKey, context: Context = {}): boolean | undefined {
+    const variationValue = this.activate(featureKey, context);
 
     return getValueByType(variationValue, "boolean") as boolean | undefined;
   }
 
-  activateString(featureKey: FeatureKey, attributes: Attributes = {}): string | undefined {
-    const variationValue = this.activate(featureKey, attributes);
+  activateString(featureKey: FeatureKey, context: Context = {}): string | undefined {
+    const variationValue = this.activate(featureKey, context);
 
     return getValueByType(variationValue, "string") as string | undefined;
   }
 
-  activateInteger(featureKey: FeatureKey, attributes: Attributes = {}): number | undefined {
-    const variationValue = this.activate(featureKey, attributes);
+  activateInteger(featureKey: FeatureKey, context: Context = {}): number | undefined {
+    const variationValue = this.activate(featureKey, context);
 
     return getValueByType(variationValue, "integer") as number | undefined;
   }
 
-  activateDouble(featureKey: FeatureKey, attributes: Attributes = {}): number | undefined {
-    const variationValue = this.activate(featureKey, attributes);
+  activateDouble(featureKey: FeatureKey, context: Context = {}): number | undefined {
+    const variationValue = this.activate(featureKey, context);
 
     return getValueByType(variationValue, "double") as number | undefined;
   }
@@ -723,28 +882,45 @@ export class FeaturevisorInstance {
   evaluateVariable(
     featureKey: FeatureKey | Feature,
     variableKey: VariableKey,
-    attributes: Attributes = {},
+    context: Context = {},
   ): Evaluation {
     let evaluation: Evaluation;
 
     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;
+          }
         }
       }
 
@@ -753,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);
@@ -801,12 +981,10 @@ export class FeaturevisorInstance {
         return evaluation;
       }
 
-      const finalAttributes = this.interceptAttributes
-        ? this.interceptAttributes(attributes)
-        : attributes;
+      const finalContext = this.interceptContext ? this.interceptContext(context) : context;
 
       // forced
-      const force = findForceFromFeature(feature, attributes, this.datafileReader);
+      const force = findForceFromFeature(feature, context, this.datafileReader);
 
       if (force && force.variables && typeof force.variables[variableKey] !== "undefined") {
         evaluation = {
@@ -823,11 +1001,11 @@ export class FeaturevisorInstance {
       }
 
       // bucketing
-      const bucketValue = this.getBucketValue(feature, finalAttributes);
+      const bucketValue = this.getBucketValue(feature, finalContext);
 
       const { matchedTraffic, matchedAllocation } = getMatchedTrafficAndAllocation(
         feature.traffic,
-        finalAttributes,
+        finalContext,
         bucketValue,
         this.datafileReader,
         this.logger,
@@ -855,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) {
@@ -867,7 +1045,7 @@ export class FeaturevisorInstance {
                   if (o.conditions) {
                     return allConditionsAreMatched(
                       typeof o.conditions === "string" ? JSON.parse(o.conditions) : o.conditions,
-                      finalAttributes,
+                      finalContext,
                     );
                   }
 
@@ -876,7 +1054,7 @@ export class FeaturevisorInstance {
                       typeof o.segments === "string" && o.segments !== "*"
                         ? JSON.parse(o.segments)
                         : o.segments,
-                      finalAttributes,
+                      finalContext,
                       this.datafileReader,
                     );
                   }
@@ -949,10 +1127,10 @@ export class FeaturevisorInstance {
   getVariable(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): VariableValue | undefined {
     try {
-      const evaluation = this.evaluateVariable(featureKey, variableKey, attributes);
+      const evaluation = this.evaluateVariable(featureKey, variableKey, context);
 
       if (typeof evaluation.variableValue !== "undefined") {
         if (
@@ -977,9 +1155,9 @@ export class FeaturevisorInstance {
   getVariableBoolean(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): boolean | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "boolean") as boolean | undefined;
   }
@@ -987,9 +1165,9 @@ export class FeaturevisorInstance {
   getVariableString(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): string | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "string") as string | undefined;
   }
@@ -997,9 +1175,9 @@ export class FeaturevisorInstance {
   getVariableInteger(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): number | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "integer") as number | undefined;
   }
@@ -1007,9 +1185,9 @@ export class FeaturevisorInstance {
   getVariableDouble(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): number | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "double") as number | undefined;
   }
@@ -1017,9 +1195,9 @@ export class FeaturevisorInstance {
   getVariableArray(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): string[] | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "array") as string[] | undefined;
   }
@@ -1027,9 +1205,9 @@ export class FeaturevisorInstance {
   getVariableObject<T>(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): T | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "object") as T | undefined;
   }
@@ -1037,9 +1215,9 @@ export class FeaturevisorInstance {
   getVariableJSON<T>(
     featureKey: FeatureKey | Feature,
     variableKey: string,
-    attributes: Attributes = {},
+    context: Context = {},
   ): T | undefined {
-    const variableValue = this.getVariable(featureKey, variableKey, attributes);
+    const variableValue = this.getVariable(featureKey, variableKey, context);
 
     return getValueByType(variableValue, "json") as T | undefined;
   }