@featurevisor/core 2.18.0 → 2.20.0

package/src/builder/buildScopedDatafile.spec.ts

@@ -956,6 +956,336 @@ describe("core: buildScopedDatafile", function () {
     });
   });
 
+  describe("features with traffic and variableOverrides", function () {
+    test("traffic variableOverride with matching segments becomes *", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {
+          mobile: {
+            conditions: [{ attribute: "device", operator: "equals", value: "mobile" }],
+          },
+        },
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [{ segments: "mobile", value: { source: "mobile" } }],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, { device: "mobile" });
+
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].segments).toEqual(
+        "*",
+      );
+    });
+
+    test("traffic variableOverride with non-matching segments remains", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {
+          mobile: {
+            conditions: [{ attribute: "device", operator: "equals", value: "mobile" }],
+          },
+        },
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [{ segments: "mobile", value: { source: "mobile" } }],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, { device: "desktop" });
+
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].segments).toEqual(
+        "mobile",
+      );
+    });
+
+    test("traffic variableOverride with matching conditions becomes *", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {},
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [
+                    {
+                      conditions: [{ attribute: "country", operator: "equals", value: "nl" }],
+                      value: { source: "nl" },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, { country: "nl" });
+
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].conditions).toEqual(
+        "*",
+      );
+    });
+
+    test("traffic variableOverride with non-matching conditions remains", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {},
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [
+                    {
+                      conditions: [{ attribute: "country", operator: "equals", value: "nl" }],
+                      value: { source: "nl" },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, { country: "de" });
+
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].conditions).toEqual([
+        { attribute: "country", operator: "equals", value: "nl" },
+      ]);
+    });
+
+    test("traffic variableOverride supports array/group segments and conditions", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {
+          mobile: {
+            conditions: [{ attribute: "device", operator: "equals", value: "mobile" }],
+          },
+          touch: {
+            conditions: [{ attribute: "touch", operator: "equals", value: true }],
+          },
+        },
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [
+                    {
+                      segments: { and: ["mobile", "touch"] },
+                      value: { source: "group-segments" },
+                    },
+                    {
+                      conditions: {
+                        and: [
+                          { attribute: "country", operator: "equals", value: "nl" },
+                          { attribute: "tier", operator: "equals", value: "premium" },
+                        ],
+                      },
+                      value: { source: "group-conditions" },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, {
+        device: "mobile",
+        touch: true,
+        country: "nl",
+        tier: "premium",
+      });
+
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].segments).toEqual(
+        "*",
+      );
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[1].conditions).toEqual(
+        "*",
+      );
+    });
+
+    test("traffic variableOverride supports stringified segments and conditions", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {
+          mobile: {
+            conditions: [{ attribute: "device", operator: "equals", value: "mobile" }],
+          },
+          touch: {
+            conditions: [{ attribute: "touch", operator: "equals", value: true }],
+          },
+        },
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [
+                    {
+                      segments: JSON.stringify({ and: ["mobile", "touch"] }),
+                      value: { source: "stringified-segments" },
+                    },
+                    {
+                      conditions: JSON.stringify([
+                        { attribute: "country", operator: "equals", value: "nl" },
+                      ]),
+                      value: { source: "stringified-conditions" },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, {
+        device: "mobile",
+        touch: true,
+        country: "nl",
+      });
+
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].segments).toEqual(
+        "*",
+      );
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[1].conditions).toEqual(
+        "*",
+      );
+    });
+
+    test("multiple traffic entries still apply consecutive * dedupe", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {
+          web: {
+            conditions: [{ attribute: "platform", operator: "equals", value: "web" }],
+          },
+          mobile: {
+            conditions: [{ attribute: "device", operator: "equals", value: "mobile" }],
+          },
+        },
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "web",
+                percentage: 50000,
+                variableOverrides: {
+                  config: [{ segments: "mobile", value: { source: "rule1" } }],
+                },
+              },
+              {
+                key: "rule2",
+                segments: "web",
+                percentage: 50000,
+                variableOverrides: {
+                  config: [{ segments: "mobile", value: { source: "rule2" } }],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const result = buildScopedDatafile(datafile, {
+        platform: "web",
+        device: "mobile",
+      });
+
+      expect(result.features.feature1.traffic).toHaveLength(1);
+      expect(result.features.feature1.traffic[0].key).toEqual("rule1");
+      expect(result.features.feature1.traffic[0].variableOverrides?.config[0].segments).toEqual(
+        "*",
+      );
+    });
+
+    test("does not mutate original datafile traffic variableOverrides", function () {
+      const datafile: DatafileContent = {
+        schemaVersion: "2",
+        revision: "unknown",
+        segments: {
+          mobile: {
+            conditions: [{ attribute: "device", operator: "equals", value: "mobile" }],
+          },
+        },
+        features: {
+          feature1: {
+            bucketBy: ["userId"],
+            traffic: [
+              {
+                key: "rule1",
+                segments: "*",
+                percentage: 100000,
+                variableOverrides: {
+                  config: [{ segments: "mobile", value: { source: "mobile" } }],
+                },
+              },
+            ],
+          },
+        },
+      };
+
+      const original = JSON.stringify(datafile);
+
+      buildScopedDatafile(datafile, { device: "mobile" });
+
+      expect(JSON.stringify(datafile)).toEqual(original);
+    });
+  });
+
   describe("features with variations and variableOverrides", function () {
     test("variableOverride with matching segments becomes *", function () {
       const datafile: DatafileContent = {

package/src/builder/buildScopedDatafile.ts

@@ -4,6 +4,23 @@ import { DatafileReader, createLogger } from "@featurevisor/sdk";
 import { buildScopedConditions } from "./buildScopedConditions";
 import { buildScopedSegments } from "./buildScopedSegments";
 
+function parseIfStringified<T>(value: T): T {
+  if (typeof value !== "string" || value === "*") {
+    return value;
+  }
+
+  const firstChar = value[0];
+  if (firstChar !== "{" && firstChar !== "[") {
+    return value;
+  }
+
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return value;
+  }
+}
+
 export function buildScopedDatafile(
   originalDatafileContent: DatafileContent,
   context: Context,
@@ -76,13 +93,52 @@ export function buildScopedDatafile(
 
         // segments
         if (traffic.segments) {
+          const segments = parseIfStringified(traffic.segments);
           feature.traffic[trafficI].segments = buildScopedSegments(
             originalDatafileReader,
-            traffic.segments,
+            segments,
             context,
             removeSegments,
           );
         }
+
+        // variable overrides
+        if (traffic.variableOverrides) {
+          for (const variableKey in traffic.variableOverrides) {
+            const variableOverrides = traffic.variableOverrides[variableKey];
+
+            for (
+              let variableOverrideI = 0;
+              variableOverrideI < variableOverrides.length;
+              variableOverrideI++
+            ) {
+              const variableOverride = variableOverrides[variableOverrideI];
+
+              // segments
+              if (variableOverride.segments) {
+                const segments = parseIfStringified(variableOverride.segments);
+                variableOverride.segments = buildScopedSegments(
+                  originalDatafileReader,
+                  segments,
+                  context,
+                  removeSegments,
+                );
+              }
+
+              // conditions
+              if (variableOverride.conditions) {
+                const conditions = parseIfStringified(variableOverride.conditions);
+                variableOverride.conditions = buildScopedConditions(
+                  originalDatafileReader,
+                  conditions,
+                  context,
+                );
+              }
+
+              variableOverrides[variableOverrideI] = variableOverride;
+            }
+          }
+        }
       }
     }
 

package/src/builder/mutateVariables.spec.ts

@@ -987,6 +987,51 @@ describe("mutateVariables", function () {
         const result = resolveMutationsForSingleVariable(schema, "foo", {});
         expect(result).toEqual({});
       });
+
+      test("uses provided baseValue instead of defaultValue for path mutations", function () {
+        const schema: Record<string, VariableSchema> = {
+          cfg: {
+            type: "object",
+            defaultValue: { source: "default", nested: { value: 1 } },
+          },
+        };
+
+        const result = resolveMutationsForSingleVariable(
+          schema,
+          "cfg",
+          {
+            "nested.value": 2,
+          },
+          { source: "rule", nested: { value: 10 }, extra: true },
+        );
+
+        expect(result).toEqual({
+          source: "rule",
+          nested: { value: 2 },
+          extra: true,
+        });
+      });
+
+      test("baseValue with full replacement key still applies replacement first", function () {
+        const schema: Record<string, VariableSchema> = {
+          cfg: {
+            type: "object",
+            defaultValue: { a: 1, b: 2 },
+          },
+        };
+
+        const result = resolveMutationsForSingleVariable(
+          schema,
+          "cfg",
+          {
+            cfg: { a: 100, c: 300 },
+            c: 999,
+          },
+          { a: 10, b: 20 },
+        );
+
+        expect(result).toEqual({ a: 100, c: 999 });
+      });
     });
 
     describe("does not mutate input", function () {

package/src/builder/mutateVariables.ts

@@ -89,14 +89,21 @@ export function resolveMutationsForSingleVariable(
   variablesSchema: Record<string, VariableSchema> | undefined,
   variableKey: string,
   overrideValue: VariableValue,
+  baseValue?: VariableValue,
 ): VariableValue {
   if (!variablesSchema || !variablesSchema[variableKey]) return overrideValue;
   if (overrideValue === null || overrideValue === undefined) return overrideValue;
   if (typeof overrideValue !== "object" || Array.isArray(overrideValue)) {
     return overrideValue;
   }
+
   const pathMap = overrideValue as Record<string, VariableValue>;
   const flat: Record<string, VariableValue> = {};
+
+  if (typeof baseValue !== "undefined") {
+    flat[variableKey] = JSON.parse(JSON.stringify(baseValue)) as VariableValue;
+  }
+
   for (const [k, v] of Object.entries(pathMap)) {
     flat[k === variableKey ? variableKey : variableKey + "." + k] = v;
   }

package/src/builder/traffic.spec.ts

@@ -910,4 +910,37 @@ describe("core: Traffic", function () {
       },
     ]);
   });
+
+  it("should include variableOverrides from parsed rule in traffic", function () {
+    const variableOverrides = {
+      config: [
+        {
+          segments: "mobile",
+          value: {
+            "layout.width": 900,
+          },
+        },
+      ],
+    };
+
+    const result = getTraffic(
+      [
+        {
+          value: "control",
+          weight: 100,
+        },
+      ],
+      [
+        {
+          key: "1",
+          segments: "*",
+          percentage: 100,
+          variableOverrides,
+        },
+      ],
+      undefined,
+    );
+
+    expect(result[0].variableOverrides).toEqual(variableOverrides);
+  });
 });

package/src/builder/traffic.ts

@@ -91,6 +91,7 @@ export function getTraffic(
       percentage: rulePercentage * (MAX_BUCKETED_NUMBER / 100),
       allocation: [],
       variationWeights: parsedRule.variationWeights,
+      variableOverrides: parsedRule.variableOverrides,
     };
 
     // overrides

package/src/generate-code/typescript.ts

@@ -600,7 +600,7 @@ export async function generateTypeScriptCodeForProject(
   for (const attributeKey of attributeFiles) {
     const parsedAttribute = await datasource.readAttribute(attributeKey);
 
-    if (typeof parsedAttribute.archived === "undefined") {
+    if (parsedAttribute.archived) {
       continue;
     }