@featurevisor/core 2.17.0 → 2.19.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

@@ -48,6 +48,63 @@ function formatObjectKey(key: string): string {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
 }
 
+function buildObjectTypeFromSchema(
+  schema: Schema,
+  schemasByKey: Record<string, Schema>,
+  schemaTypeNames?: Record<string, string>,
+): string {
+  const props = schema.properties;
+  const additional = schema.additionalProperties;
+  const hasProps = props && typeof props === "object" && Object.keys(props).length > 0;
+  const hasAdditional = additional && typeof additional === "object";
+
+  if (hasProps && hasAdditional) {
+    const requiredSet = new Set(schema.required || []);
+    const propEntries = Object.entries(props as Record<string, Schema>).map(([k, v]) => {
+      const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
+      const optional = !requiredSet.has(k);
+      return optional
+        ? `${formatObjectKey(k)}?: ${propType}`
+        : `${formatObjectKey(k)}: ${propType}`;
+    });
+    const propUnion = Object.entries(props as Record<string, Schema>)
+      .map(([, v]) => schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames))
+      .join(" | ");
+    const additionalType = schemaToTypeScriptType(
+      additional as Schema,
+      schemasByKey,
+      schemaTypeNames,
+    );
+    const indexType = [additionalType, propUnion].filter(Boolean).join(" | ");
+    return `{ ${propEntries.join("; ")}; [key: string]: ${indexType} }`;
+  }
+
+  if (hasProps) {
+    const requiredSet = new Set(schema.required || []);
+    const entries = Object.entries(props as Record<string, Schema>)
+      .map(([k, v]) => {
+        const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
+        const optional = !requiredSet.has(k);
+        return optional
+          ? `${formatObjectKey(k)}?: ${propType}`
+          : `${formatObjectKey(k)}: ${propType}`;
+      })
+      .join("; ");
+    return `{ ${entries} }`;
+  }
+
+  if (hasAdditional) {
+    const additionalType = schemaToTypeScriptType(
+      additional as Schema,
+      schemasByKey,
+      schemaTypeNames,
+    );
+    return `Record<string, ${additionalType}>`;
+  }
+
+  return "Record<string, unknown>";
+}
+
 function formatTypeImport(typeNames: string[], fromPath: string): string {
   if (typeNames.length === 0) {
     return "";
@@ -132,19 +189,7 @@ function schemaToTypeScriptType(
       }
       return "string[]";
     case "object": {
-      const props = resolved.properties;
-      if (props && typeof props === "object" && Object.keys(props).length > 0) {
-        const requiredSet = new Set(resolved.required || []);
-        const entries = Object.entries(props)
-          .map(([k, v]) => {
-            const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
-            const optional = !requiredSet.has(k);
-            return optional ? `${k}?: ${propType}` : `${k}: ${propType}`;
-          })
-          .join("; ");
-        return `{ ${entries} }`;
-      }
-      return "Record<string, unknown>";
+      return buildObjectTypeFromSchema(resolved, schemasByKey, schemaTypeNames);
     }
     default:
       return "unknown";
@@ -265,13 +310,17 @@ function generateVariableTypeDeclarations(
 
   if (type === "object") {
     const resolvedEffective =
-      effective && "properties" in effective
+      effective && ("properties" in effective || "additionalProperties" in effective)
         ? (resolveSchema(effective as Schema, schemasByKey) as Schema)
         : undefined;
     const props = resolvedEffective?.properties;
-    if (props && typeof props === "object" && Object.keys(props).length > 0) {
+    const additional = resolvedEffective?.additionalProperties;
+    if (
+      (props && typeof props === "object" && Object.keys(props).length > 0) ||
+      (additional && typeof additional === "object")
+    ) {
       const requiredSet = new Set(resolvedEffective?.required || []);
-      const entries = Object.entries(props)
+      const entries = Object.entries(props ?? {})
         .map(([k, v]) => {
           const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
           if (schemaTypeNames)
@@ -280,11 +329,29 @@ function generateVariableTypeDeclarations(
             });
           const optional = !requiredSet.has(k);
           return optional
-            ? `${INDENT_NS_BODY}${k}?: ${propType};`
-            : `${INDENT_NS_BODY}${k}: ${propType};`;
+            ? `${INDENT_NS_BODY}${formatObjectKey(k)}?: ${propType};`
+            : `${INDENT_NS_BODY}${formatObjectKey(k)}: ${propType};`;
         })
-        .join("\n");
-      declarations.push(`${INDENT_NS}export interface ${typeName} {\n${entries}\n${INDENT_NS}}`);
+        .filter(Boolean);
+      if (additional && typeof additional === "object") {
+        const additionalType = schemaToTypeScriptType(
+          additional as Schema,
+          schemasByKey,
+          schemaTypeNames,
+        );
+        if (schemaTypeNames)
+          Object.values(schemaTypeNames).forEach((n) => {
+            if (additionalType.includes(n)) addSchemaUsed(n);
+          });
+        const propUnion = Object.entries(props ?? {})
+          .map(([, v]) => schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames))
+          .join(" | ");
+        const indexType = [additionalType, propUnion].filter(Boolean).join(" | ");
+        entries.push(`${INDENT_NS_BODY}[key: string]: ${indexType};`);
+      }
+      declarations.push(
+        `${INDENT_NS}export interface ${typeName} {\n${entries.join("\n")}\n${INDENT_NS}}`,
+      );
       return { declarations, returnTypeName: typeName, genericArg: typeName, schemaTypesUsed };
     }
     declarations.push(`${INDENT_NS}export type ${typeName} = Record<string, unknown>;`);