@featurevisor/sdk 0.35.0 → 0.37.0

package/src/conditions.ts

@@ -1,71 +1,71 @@
 import { compareVersions } from "compare-versions";
 
-import { Attributes, Condition, PlainCondition } from "@featurevisor/types";
+import { Context, Condition, PlainCondition } from "@featurevisor/types";
 
-export function conditionIsMatched(condition: PlainCondition, attributes: Attributes): boolean {
+export function conditionIsMatched(condition: PlainCondition, context: Context): boolean {
   const { attribute, operator, value } = condition;
 
   if (operator === "equals") {
-    return attributes[attribute] === value;
+    return context[attribute] === value;
   } else if (operator === "notEquals") {
-    return attributes[attribute] !== value;
+    return context[attribute] !== value;
   } else if (operator === "before" || operator === "after") {
     // date comparisons
-    const valueInAttributes = attributes[attribute] as string | Date;
+    const valueInContext = context[attribute] as string | Date;
 
-    const dateInAttributes =
-      valueInAttributes instanceof Date ? valueInAttributes : new Date(valueInAttributes);
+    const dateInContext =
+      valueInContext instanceof Date ? valueInContext : new Date(valueInContext);
     const dateInCondition = value instanceof Date ? value : new Date(value as string);
 
     return operator === "before"
-      ? dateInAttributes < dateInCondition
-      : dateInAttributes > dateInCondition;
-  } else if (typeof attributes[attribute] === "string" && Array.isArray(value)) {
+      ? dateInContext < dateInCondition
+      : dateInContext > dateInCondition;
+  } else if (typeof context[attribute] === "string" && Array.isArray(value)) {
     // array
-    const valueInAttributes = attributes[attribute] as string;
+    const valueInContext = context[attribute] as string;
 
     if (operator === "in") {
-      return value.indexOf(valueInAttributes) !== -1;
+      return value.indexOf(valueInContext) !== -1;
     } else if (operator === "notIn") {
-      return value.indexOf(valueInAttributes) === -1;
+      return value.indexOf(valueInContext) === -1;
     }
-  } else if (typeof attributes[attribute] === "string" && typeof value === "string") {
+  } else if (typeof context[attribute] === "string" && typeof value === "string") {
     // string
-    const valueInAttributes = attributes[attribute] as string;
+    const valueInContext = context[attribute] as string;
 
     if (operator === "contains") {
-      return valueInAttributes.indexOf(value) !== -1;
+      return valueInContext.indexOf(value) !== -1;
     } else if (operator === "notContains") {
-      return valueInAttributes.indexOf(value) === -1;
+      return valueInContext.indexOf(value) === -1;
     } else if (operator === "startsWith") {
-      return valueInAttributes.startsWith(value);
+      return valueInContext.startsWith(value);
     } else if (operator === "endsWith") {
-      return valueInAttributes.endsWith(value);
+      return valueInContext.endsWith(value);
     } else if (operator === "semverEquals") {
-      return compareVersions(valueInAttributes, value) === 0;
+      return compareVersions(valueInContext, value) === 0;
     } else if (operator === "semverNotEquals") {
-      return compareVersions(valueInAttributes, value) !== 0;
+      return compareVersions(valueInContext, value) !== 0;
     } else if (operator === "semverGreaterThan") {
-      return compareVersions(valueInAttributes, value) === 1;
+      return compareVersions(valueInContext, value) === 1;
     } else if (operator === "semverGreaterThanOrEquals") {
-      return compareVersions(valueInAttributes, value) >= 0;
+      return compareVersions(valueInContext, value) >= 0;
     } else if (operator === "semverLessThan") {
-      return compareVersions(valueInAttributes, value) === -1;
+      return compareVersions(valueInContext, value) === -1;
     } else if (operator === "semverLessThanOrEquals") {
-      return compareVersions(valueInAttributes, value) <= 0;
+      return compareVersions(valueInContext, value) <= 0;
     }
-  } else if (typeof attributes[attribute] === "number" && typeof value === "number") {
+  } else if (typeof context[attribute] === "number" && typeof value === "number") {
     // numeric
-    const valueInAttributes = attributes[attribute] as number;
+    const valueInContext = context[attribute] as number;
 
     if (operator === "greaterThan") {
-      return valueInAttributes > value;
+      return valueInContext > value;
     } else if (operator === "greaterThanOrEquals") {
-      return valueInAttributes >= value;
+      return valueInContext >= value;
     } else if (operator === "lessThan") {
-      return valueInAttributes < value;
+      return valueInContext < value;
     } else if (operator === "lessThanOrEquals") {
-      return valueInAttributes <= value;
+      return valueInContext <= value;
     }
   }
 
@@ -74,18 +74,18 @@ export function conditionIsMatched(condition: PlainCondition, attributes: Attrib
 
 export function allConditionsAreMatched(
   conditions: Condition[] | Condition,
-  attributes: Attributes,
+  context: Context,
 ): boolean {
   if ("attribute" in conditions) {
-    return conditionIsMatched(conditions, attributes);
+    return conditionIsMatched(conditions, context);
   }
 
   if ("and" in conditions && Array.isArray(conditions.and)) {
-    return conditions.and.every((c) => allConditionsAreMatched(c, attributes));
+    return conditions.and.every((c) => allConditionsAreMatched(c, context));
   }
 
   if ("or" in conditions && Array.isArray(conditions.or)) {
-    return conditions.or.some((c) => allConditionsAreMatched(c, attributes));
+    return conditions.or.some((c) => allConditionsAreMatched(c, context));
   }
 
   if ("not" in conditions && Array.isArray(conditions.not)) {
@@ -95,13 +95,13 @@ export function allConditionsAreMatched(
           {
             and: conditions.not,
           },
-          attributes,
+          context,
         ) === false,
     );
   }
 
   if (Array.isArray(conditions)) {
-    return conditions.every((c) => allConditionsAreMatched(c, attributes));
+    return conditions.every((c) => allConditionsAreMatched(c, context));
   }
 
   return false;

package/src/feature.ts

@@ -1,4 +1,4 @@
-import { Allocation, Attributes, Traffic, Feature, Force } from "@featurevisor/types";
+import { Allocation, Context, Traffic, Feature, Force } from "@featurevisor/types";
 import { DatafileReader } from "./datafileReader";
 import { allGroupSegmentsAreMatched } from "./segments";
 import { allConditionsAreMatched } from "./conditions";
@@ -26,7 +26,7 @@ export interface MatchedTrafficAndAllocation {
 
 export function getMatchedTrafficAndAllocation(
   traffic: Traffic[],
-  attributes: Attributes,
+  context: Context,
   bucketValue: number,
   datafileReader: DatafileReader,
   logger: Logger,
@@ -37,7 +37,7 @@ export function getMatchedTrafficAndAllocation(
     if (
       !allGroupSegmentsAreMatched(
         typeof t.segments === "string" && t.segments !== "*" ? JSON.parse(t.segments) : t.segments,
-        attributes,
+        context,
         datafileReader,
       )
     ) {
@@ -61,7 +61,7 @@ export function getMatchedTrafficAndAllocation(
 
 export function findForceFromFeature(
   feature: Feature,
-  attributes: Attributes,
+  context: Context,
   datafileReader: DatafileReader,
 ): Force | undefined {
   if (!feature.force) {
@@ -70,11 +70,11 @@ export function findForceFromFeature(
 
   return feature.force.find((f: Force) => {
     if (f.conditions) {
-      return allConditionsAreMatched(f.conditions, attributes);
+      return allConditionsAreMatched(f.conditions, context);
     }
 
     if (f.segments) {
-      return allGroupSegmentsAreMatched(f.segments, attributes, datafileReader);
+      return allGroupSegmentsAreMatched(f.segments, context, datafileReader);
     }
 
     return false;

package/src/instance.spec.ts

@@ -73,7 +73,7 @@ describe("sdk: instance", function () {
         attributes: [],
         segments: [],
       },
-      configureBucketKey: function (feature, attributes, bucketKey) {
+      configureBucketKey: function (feature, context, bucketKey) {
         capturedBucketKey = bucketKey;
 
         return bucketKey;
@@ -117,7 +117,7 @@ describe("sdk: instance", function () {
         attributes: [],
         segments: [],
       },
-      configureBucketKey: function (feature, attributes, bucketKey) {
+      configureBucketKey: function (feature, context, bucketKey) {
         capturedBucketKey = bucketKey;
 
         return bucketKey;
@@ -162,7 +162,7 @@ describe("sdk: instance", function () {
         attributes: [],
         segments: [],
       },
-      configureBucketKey: function (feature, attributes, bucketKey) {
+      configureBucketKey: function (feature, context, bucketKey) {
         capturedBucketKey = bucketKey;
 
         return bucketKey;
@@ -185,7 +185,7 @@ describe("sdk: instance", function () {
     expect(capturedBucketKey).toEqual("456.test");
   });
 
-  it("should intercept attributes", function () {
+  it("should intercept context", function () {
     let intercepted = false;
 
     const sdk = createInstance({
@@ -214,11 +214,11 @@ describe("sdk: instance", function () {
         attributes: [],
         segments: [],
       },
-      interceptAttributes: function (attributes) {
+      interceptContext: function (context) {
         intercepted = true;
 
         return {
-          ...attributes,
+          ...context,
         };
       },
     });

package/src/instance.ts

@@ -1,5 +1,5 @@
 import {
-  Attributes,
+  Context,
   AttributeValue,
   BucketKey,
   BucketValue,
@@ -31,13 +31,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 +46,8 @@ export interface Statuses {
 
 const DEFAULT_BUCKET_KEY_SEPARATOR = ".";
 
+export type InterceptContext = (context: Context) => Context;
+
 export interface InstanceOptions {
   bucketKeySeparator?: string;
   configureBucketKey?: ConfigureBucketKey;
@@ -54,7 +56,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;
@@ -156,7 +158,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 +184,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 +283,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 +307,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 +328,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;
@@ -419,7 +421,7 @@ export class FeaturevisorInstance {
   /**
    * Variation
    */
-  evaluateVariation(featureKey: FeatureKey | Feature, attributes: Attributes = {}): Evaluation {
+  evaluateVariation(featureKey: FeatureKey | Feature, context: Context = {}): Evaluation {
     let evaluation: Evaluation;
 
     try {
@@ -477,12 +479,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.variation) {
         const variation = feature.variations.find((v) => v.value === force.variation);
@@ -501,11 +501,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,
@@ -589,10 +589,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;
@@ -612,36 +612,27 @@ export class FeaturevisorInstance {
 
   getVariationBoolean(
     featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
+    context: Context = {},
   ): boolean | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
+    const variationValue = this.getVariation(featureKey, context);
 
     return getValueByType(variationValue, "boolean") as boolean | undefined;
   }
 
-  getVariationString(
-    featureKey: FeatureKey | Feature,
-    attributes: Attributes = {},
-  ): string | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
+  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,
-    attributes: Attributes = {},
-  ): number | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
+  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,
-    attributes: Attributes = {},
-  ): number | undefined {
-    const variationValue = this.getVariation(featureKey, attributes);
+  getVariationDouble(featureKey: FeatureKey | Feature, context: Context = {}): number | undefined {
+    const variationValue = this.getVariation(featureKey, context);
 
     return getValueByType(variationValue, "double") as number | undefined;
   }
@@ -649,9 +640,9 @@ export class FeaturevisorInstance {
   /**
    * 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 +651,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 +669,8 @@ export class FeaturevisorInstance {
         "activation",
         featureKey,
         variationValue,
-        finalAttributes,
-        captureAttributes,
+        finalContext,
+        captureContext,
         evaluation,
       );
 
@@ -693,26 +682,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,7 +712,7 @@ export class FeaturevisorInstance {
   evaluateVariable(
     featureKey: FeatureKey | Feature,
     variableKey: VariableKey,
-    attributes: Attributes = {},
+    context: Context = {},
   ): Evaluation {
     let evaluation: Evaluation;
 
@@ -801,12 +790,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 +810,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,
@@ -867,7 +854,7 @@ export class FeaturevisorInstance {
                   if (o.conditions) {
                     return allConditionsAreMatched(
                       typeof o.conditions === "string" ? JSON.parse(o.conditions) : o.conditions,
-                      finalAttributes,
+                      finalContext,
                     );
                   }
 
@@ -876,7 +863,7 @@ export class FeaturevisorInstance {
                       typeof o.segments === "string" && o.segments !== "*"
                         ? JSON.parse(o.segments)
                         : o.segments,
-                      finalAttributes,
+                      finalContext,
                       this.datafileReader,
                     );
                   }
@@ -949,10 +936,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 +964,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 +974,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 +984,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 +994,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 +1004,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 +1014,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 +1024,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;
   }