@featurevisor/core 2.17.0 → 2.19.0

package/src/builder/buildDatafile.spec.ts

@@ -0,0 +1,267 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import type { DatafileContent, ExistingState, ParsedFeature } from "@featurevisor/types";
+
+import type { ProjectConfig } from "../config";
+import { parsers } from "../parsers";
+import { buildDatafile } from "./buildDatafile";
+
+function createProjectConfig(root: string, stringify = true): ProjectConfig {
+  return {
+    featuresDirectoryPath: path.join(root, "features"),
+    segmentsDirectoryPath: path.join(root, "segments-missing"),
+    attributesDirectoryPath: path.join(root, "attributes-missing"),
+    groupsDirectoryPath: path.join(root, "groups-missing"),
+    schemasDirectoryPath: path.join(root, "schemas-missing"),
+    testsDirectoryPath: path.join(root, "tests-missing"),
+    stateDirectoryPath: path.join(root, ".featurevisor"),
+    datafilesDirectoryPath: path.join(root, "datafiles"),
+    datafileNamePattern: "featurevisor-%s.json",
+    revisionFileName: "REVISION",
+    siteExportDirectoryPath: path.join(root, "out"),
+    environmentsDirectoryPath: path.join(root, "environments"),
+    environments: ["staging", "production"],
+    splitByEnvironment: false,
+    tags: ["all"],
+    scopes: [],
+    adapter: {},
+    plugins: [],
+    defaultBucketBy: "userId",
+    parser: parsers.yml,
+    prettyState: true,
+    prettyDatafile: false,
+    stringify,
+    enforceCatchAllRule: false,
+  };
+}
+
+function createMockDatasource(feature: ParsedFeature) {
+  return {
+    listSchemas: async () => [],
+    readSchema: async () => {
+      throw new Error("readSchema should not be called");
+    },
+    listFeatures: async () => ["withRuleOverrides"],
+    readFeature: async () => feature,
+    listSegments: async () => [],
+    readSegment: async () => {
+      throw new Error("readSegment should not be called");
+    },
+    listAttributes: async () => [],
+    readAttribute: async () => {
+      throw new Error("readAttribute should not be called");
+    },
+  } as any;
+}
+
+function createFeatureFixture(): ParsedFeature {
+  return {
+    key: "withRuleOverrides",
+    description: "Rule variableOverrides fixture",
+    tags: ["all"],
+    bucketBy: "userId",
+    variablesSchema: {
+      config: {
+        type: "object",
+        defaultValue: {
+          source: "default",
+          nested: { value: 1 },
+          list: ["d"],
+          rows: [
+            { id: 1, label: "one" },
+            { id: 2, label: "two" },
+          ],
+          flag: false,
+        },
+      },
+      fallbackConfig: {
+        type: "object",
+        defaultValue: {
+          origin: "default",
+          count: 1,
+        },
+      },
+    },
+    variations: [{ value: "control", weight: 100 }],
+    rules: {
+      staging: [
+        {
+          key: "rule1",
+          segments: "*",
+          percentage: 100,
+          variables: {
+            config: {
+              source: "rule",
+              nested: { value: 10 },
+              list: ["base"],
+              rows: [
+                { id: 1, label: "one" },
+                { id: 2, label: "two" },
+              ],
+              flag: true,
+            },
+          },
+          variableOverrides: {
+            config: [
+              {
+                segments: { and: ["mobile", "touch"] },
+                value: {
+                  "nested.value": 20,
+                  "list:append": "m",
+                  "rows[id=1]:after": { id: 15, label: "one-half" },
+                  "rows[id=2]:remove": null,
+                },
+              },
+              {
+                conditions: [{ attribute: "country", operator: "equals", value: "de" }],
+                value: {
+                  "nested.value": 30,
+                  "list:prepend": "de",
+                  "rows[id=1]:before": { id: 0, label: "zero" },
+                },
+              },
+              {
+                conditions: [{ attribute: "device", operator: "equals", value: "desktop" }],
+                value: {
+                  source: "full",
+                  nested: { value: 999 },
+                  list: ["x"],
+                  rows: [{ id: 7, label: "seven" }],
+                  flag: false,
+                },
+              },
+            ],
+            fallbackConfig: [
+              {
+                conditions: [{ attribute: "country", operator: "equals", value: "nl" }],
+                value: {
+                  count: 5,
+                },
+              },
+            ],
+          },
+        },
+      ],
+      production: [
+        {
+          key: "everyone",
+          segments: "*",
+          percentage: 100,
+        },
+      ],
+    },
+  } as ParsedFeature;
+}
+
+describe("core: buildDatafile", function () {
+  let root: string;
+  let existingState: ExistingState;
+
+  beforeEach(function () {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "featurevisor-buildDatafile-"));
+    fs.mkdirSync(path.join(root, "features"), { recursive: true });
+    existingState = { features: {} };
+  });
+
+  afterEach(function () {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  test("resolves rule variableOverrides mutations using rule variables as base and default fallback when missing", async function () {
+    const config = createProjectConfig(root, true);
+    const datasource = createMockDatasource(createFeatureFixture());
+
+    const result = (await buildDatafile(
+      config,
+      datasource,
+      {
+        schemaVersion: "2",
+        revision: "1",
+        environment: "staging",
+      },
+      existingState,
+    )) as DatafileContent;
+
+    const trafficRule = result.features.withRuleOverrides.traffic.find((t) => t.key === "rule1");
+
+    expect(trafficRule).toBeDefined();
+    expect(trafficRule?.variableOverrides).toBeDefined();
+
+    // Base comes from rule variables (source remains "rule"), not from schema default.
+    expect(trafficRule?.variableOverrides?.config[0].value).toEqual({
+      source: "rule",
+      nested: { value: 20 },
+      list: ["base", "m"],
+      rows: [
+        { id: 1, label: "one" },
+        { id: 15, label: "one-half" },
+      ],
+      flag: true,
+    });
+
+    // Independent override still uses the same rule-level base and preserves order.
+    expect(trafficRule?.variableOverrides?.config[1].value).toEqual({
+      source: "rule",
+      nested: { value: 30 },
+      list: ["de", "base"],
+      rows: [
+        { id: 0, label: "zero" },
+        { id: 1, label: "one" },
+        { id: 2, label: "two" },
+      ],
+      flag: true,
+    });
+
+    // Full object override passes through unchanged.
+    expect(trafficRule?.variableOverrides?.config[2].value).toEqual({
+      source: "full",
+      nested: { value: 999 },
+      list: ["x"],
+      rows: [{ id: 7, label: "seven" }],
+      flag: false,
+    });
+
+    // No rule variable for fallbackConfig -> mutation base is variable schema defaultValue.
+    expect(trafficRule?.variableOverrides?.fallbackConfig[0].value).toEqual({
+      origin: "default",
+      count: 5,
+    });
+
+    // Supports stringification for segments + conditions.
+    expect(typeof trafficRule?.variableOverrides?.config[0].segments).toBe("string");
+    expect(trafficRule?.variableOverrides?.config[0].segments).toEqual(
+      JSON.stringify({ and: ["mobile", "touch"] }),
+    );
+    expect(typeof trafficRule?.variableOverrides?.config[1].conditions).toBe("string");
+    expect(trafficRule?.variableOverrides?.config[1].conditions).toEqual(
+      JSON.stringify([{ attribute: "country", operator: "equals", value: "de" }]),
+    );
+  });
+
+  test("keeps segments and conditions non-stringified when projectConfig.stringify is false", async function () {
+    const config = createProjectConfig(root, false);
+    const datasource = createMockDatasource(createFeatureFixture());
+
+    const result = (await buildDatafile(
+      config,
+      datasource,
+      {
+        schemaVersion: "2",
+        revision: "1",
+        environment: "staging",
+      },
+      existingState,
+    )) as DatafileContent;
+
+    const trafficRule = result.features.withRuleOverrides.traffic.find((t) => t.key === "rule1");
+
+    expect(trafficRule?.variableOverrides?.config[0].segments).toEqual({
+      and: ["mobile", "touch"],
+    });
+    expect(trafficRule?.variableOverrides?.config[1].conditions).toEqual([
+      { attribute: "country", operator: "equals", value: "de" },
+    ]);
+  });
+});

package/src/builder/buildDatafile.ts

@@ -201,6 +201,30 @@ export async function buildDatafile(
       for (const parsedRule of rules) {
         const extractedSegmentKeys = extractSegmentKeysFromGroupSegments(parsedRule.segments);
         extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
+
+        if (parsedRule.variableOverrides) {
+          for (const variableOverrides of Object.values(parsedRule.variableOverrides)) {
+            for (const override of variableOverrides) {
+              if (typeof override.conditions !== "undefined") {
+                const extractedAttributeKeys = extractAttributeKeysFromConditions(
+                  override.conditions,
+                );
+                extractedAttributeKeys.forEach((attributeKey) =>
+                  attributeKeysUsedByTag.add(attributeKey),
+                );
+              }
+
+              if (typeof override.segments !== "undefined") {
+                const extractedOverrideSegmentKeys = extractSegmentKeysFromGroupSegments(
+                  override.segments as GroupSegment | GroupSegment[],
+                );
+                extractedOverrideSegmentKeys.forEach((segmentKey) =>
+                  segmentKeysUsedByTag.add(segmentKey),
+                );
+              }
+            }
+          }
+        }
       }
 
       const feature: Feature = {
@@ -226,6 +250,10 @@ export async function buildDatafile(
                 const variableKeys = Object.keys(variableOverrides);
 
                 for (const variableKey of variableKeys) {
+                  const baseValue = mappedVariation.variables
+                    ? mappedVariation.variables[variableKey]
+                    : undefined;
+
                   mappedVariation.variableOverrides[variableKey] = variableOverrides[
                     variableKey
                   ].map((override: VariableOverride) => {
@@ -246,6 +274,7 @@ export async function buildDatafile(
                           parsedFeature.variablesSchema,
                           variableKey,
                           override.value,
+                          baseValue,
                         ),
                       };
                     }
@@ -267,6 +296,7 @@ export async function buildDatafile(
                           parsedFeature.variablesSchema,
                           variableKey,
                           override.value,
+                          baseValue,
                         ),
                       };
                     }
@@ -285,12 +315,63 @@ export async function buildDatafile(
           existingState.features[featureKey],
           featureRanges.get(featureKey) || [],
         ).map((t: Traffic) => {
+          const resolvedVariables = resolveMutationsForMultipleVariables(
+            parsedFeature.variablesSchema,
+            t.variables,
+          );
+
+          let resolvedVariableOverrides = t.variableOverrides;
+
+          if (t.variableOverrides) {
+            resolvedVariableOverrides = {};
+            const variableKeys = Object.keys(t.variableOverrides);
+
+            for (const variableKey of variableKeys) {
+              const overrides = t.variableOverrides[variableKey];
+              const baseValue = resolvedVariables ? resolvedVariables[variableKey] : undefined;
+
+              resolvedVariableOverrides[variableKey] = overrides.map(
+                (override: VariableOverride) => {
+                  if (typeof override.conditions !== "undefined") {
+                    return {
+                      conditions:
+                        projectConfig.stringify && typeof override.conditions !== "string"
+                          ? JSON.stringify(override.conditions)
+                          : override.conditions,
+                      value: resolveMutationsForSingleVariable(
+                        parsedFeature.variablesSchema,
+                        variableKey,
+                        override.value,
+                        baseValue,
+                      ),
+                    };
+                  }
+
+                  if (typeof override.segments !== "undefined") {
+                    return {
+                      segments:
+                        projectConfig.stringify && typeof override.segments !== "string"
+                          ? JSON.stringify(override.segments)
+                          : override.segments,
+                      value: resolveMutationsForSingleVariable(
+                        parsedFeature.variablesSchema,
+                        variableKey,
+                        override.value,
+                        baseValue,
+                      ),
+                    };
+                  }
+
+                  return override;
+                },
+              );
+            }
+          }
+
           return {
             ...t,
-            variables: resolveMutationsForMultipleVariables(
-              parsedFeature.variablesSchema,
-              t.variables,
-            ),
+            variables: resolvedVariables,
+            variableOverrides: resolvedVariableOverrides,
             segments:
               typeof t.segments !== "string" && projectConfig.stringify
                 ? JSON.stringify(t.segments)