@featurevisor/sdk 2.18.0 → 2.19.0

package/src/evaluate.ts

@@ -35,7 +35,8 @@ export enum EvaluationReason {
   VARIABLE_NOT_FOUND = "variable_not_found", // variable's schema is not defined in the feature
   VARIABLE_DEFAULT = "variable_default", // default variable value used
   VARIABLE_DISABLED = "variable_disabled", // feature is disabled, and variable's disabledValue is used
-  VARIABLE_OVERRIDE = "variable_override", // variable overridden from inside a variation
+  VARIABLE_OVERRIDE_VARIATION = "variable_override_variation", // variable overridden from inside a variation
+  VARIABLE_OVERRIDE_RULE = "variable_override_rule", // variable overridden from inside a rule
 
   // common
   NO_MATCH = "no_match", // no rules matched
@@ -75,6 +76,7 @@ export interface Evaluation {
   variableKey?: VariableKey;
   variableValue?: VariableValue;
   variableSchema?: ResolvedVariableSchema;
+  variableOverrideIndex?: number;
 }
 
 export interface EvaluateDependencies {
@@ -688,27 +690,76 @@ export function evaluate(options: EvaluateOptions): Evaluation {
     // variable
     if (type === "variable" && variableKey) {
       // override from rule
-      if (
-        matchedTraffic &&
-        matchedTraffic.variables &&
-        typeof matchedTraffic.variables[variableKey] !== "undefined"
-      ) {
-        evaluation = {
-          type,
-          featureKey,
-          reason: EvaluationReason.RULE,
-          bucketKey,
-          bucketValue,
-          ruleKey: matchedTraffic.key,
-          traffic: matchedTraffic,
-          variableKey,
-          variableSchema,
-          variableValue: matchedTraffic.variables[variableKey],
-        };
+      if (matchedTraffic) {
+        // "variableOverrides"
+        if (matchedTraffic.variableOverrides && matchedTraffic.variableOverrides[variableKey]) {
+          const overrides = matchedTraffic.variableOverrides[variableKey];
+
+          const overrideIndex = overrides.findIndex((o) => {
+            if (o.conditions) {
+              return datafileReader.allConditionsAreMatched(
+                typeof o.conditions === "string" && o.conditions !== "*"
+                  ? JSON.parse(o.conditions)
+                  : o.conditions,
+                context,
+              );
+            }
 
-        logger.debug("override from rule", evaluation);
+            if (o.segments) {
+              return datafileReader.allSegmentsAreMatched(
+                datafileReader.parseSegmentsIfStringified(o.segments),
+                context,
+              );
+            }
 
-        return evaluation;
+            return false;
+          });
+
+          if (overrideIndex !== -1) {
+            const override = overrides[overrideIndex];
+
+            evaluation = {
+              type,
+              featureKey,
+              reason: EvaluationReason.VARIABLE_OVERRIDE_RULE,
+              bucketKey,
+              bucketValue,
+              ruleKey: matchedTraffic?.key,
+              traffic: matchedTraffic,
+              variableKey,
+              variableSchema,
+              variableValue: override.value,
+              variableOverrideIndex: overrideIndex,
+            };
+
+            logger.debug("variable override from rule", evaluation);
+
+            return evaluation;
+          }
+        }
+
+        // from "variables"
+        if (
+          matchedTraffic.variables &&
+          typeof matchedTraffic.variables[variableKey] !== "undefined"
+        ) {
+          evaluation = {
+            type,
+            featureKey,
+            reason: EvaluationReason.RULE,
+            bucketKey,
+            bucketValue,
+            ruleKey: matchedTraffic.key,
+            traffic: matchedTraffic,
+            variableKey,
+            variableSchema,
+            variableValue: matchedTraffic.variables[variableKey],
+          };
+
+          logger.debug("override from rule", evaluation);
+
+          return evaluation;
+        }
       }
 
       // check variations
@@ -728,7 +779,7 @@ export function evaluate(options: EvaluateOptions): Evaluation {
         if (variation && variation.variableOverrides && variation.variableOverrides[variableKey]) {
           const overrides = variation.variableOverrides[variableKey];
 
-          const override = overrides.find((o) => {
+          const overrideIndex = overrides.findIndex((o) => {
             if (o.conditions) {
               return datafileReader.allConditionsAreMatched(
                 typeof o.conditions === "string" && o.conditions !== "*"
@@ -748,11 +799,13 @@ export function evaluate(options: EvaluateOptions): Evaluation {
             return false;
           });
 
-          if (override) {
+          if (overrideIndex !== -1) {
+            const override = overrides[overrideIndex];
+
             evaluation = {
               type,
               featureKey,
-              reason: EvaluationReason.VARIABLE_OVERRIDE,
+              reason: EvaluationReason.VARIABLE_OVERRIDE_VARIATION,
               bucketKey,
               bucketValue,
               ruleKey: matchedTraffic?.key,
@@ -760,9 +813,10 @@ export function evaluate(options: EvaluateOptions): Evaluation {
               variableKey,
               variableSchema,
               variableValue: override.value,
+              variableOverrideIndex: overrideIndex,
             };
 
-            logger.debug("variable override", evaluation);
+            logger.debug("variable override from variation", evaluation);
 
             return evaluation;
           }

package/src/instance.spec.ts

@@ -1147,6 +1147,137 @@ describe("sdk: instance", function () {
     ).toEqual("orange");
   });
 
+  it("should apply rule variableOverrides on top of rule variables", function () {
+    const sdk = createInstance({
+      datafile: {
+        schemaVersion: "2",
+        revision: "1.0",
+        segments: {
+          germany: {
+            key: "germany",
+            conditions: JSON.stringify([
+              {
+                attribute: "country",
+                operator: "equals",
+                value: "de",
+              },
+            ]),
+          },
+          mobile: {
+            key: "mobile",
+            conditions: JSON.stringify([
+              {
+                attribute: "device",
+                operator: "equals",
+                value: "mobile",
+              },
+            ]),
+          },
+        },
+        features: {
+          test: {
+            key: "test",
+            bucketBy: "userId",
+            variablesSchema: {
+              config: {
+                key: "config",
+                type: "object",
+                defaultValue: {
+                  source: "default",
+                  nested: { value: 0 },
+                },
+              },
+            },
+            traffic: [
+              {
+                key: "germany",
+                segments: "germany",
+                percentage: 100000,
+                variables: {
+                  config: {
+                    source: "rule",
+                    nested: { value: 10 },
+                    flag: true,
+                  },
+                },
+                variableOverrides: {
+                  config: [
+                    {
+                      segments: "mobile",
+                      value: {
+                        source: "rule",
+                        nested: { value: 20 },
+                        flag: true,
+                      },
+                    },
+                    {
+                      conditions: [
+                        {
+                          attribute: "country",
+                          operator: "equals",
+                          value: "de",
+                        },
+                      ],
+                      value: {
+                        source: "rule",
+                        nested: { value: 30 },
+                        flag: true,
+                      },
+                    },
+                  ],
+                },
+              },
+              {
+                key: "everyone",
+                segments: "*",
+                percentage: 100000,
+                variables: {
+                  config: {
+                    source: "everyone",
+                    nested: { value: 1 },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    expect(
+      sdk.getVariableObject("test", "config", {
+        userId: "user-1",
+        country: "de",
+      }),
+    ).toEqual({
+      source: "rule",
+      nested: { value: 30 },
+      flag: true,
+    });
+
+    expect(
+      sdk.getVariableObject("test", "config", {
+        userId: "user-1",
+        country: "de",
+        device: "mobile",
+      }),
+    ).toEqual({
+      source: "rule",
+      nested: { value: 20 },
+      flag: true,
+    });
+
+    expect(
+      sdk.getVariableObject("test", "config", {
+        userId: "user-1",
+        country: "nl",
+      }),
+    ).toEqual({
+      source: "everyone",
+      nested: { value: 1 },
+    });
+  });
+
   describe("array and object variables", function () {
     const arrayAndObjectDatafile: DatafileContent = {
       schemaVersion: "2",