@featurevisor/core 0.15.0 → 0.17.0

package/src/traffic.spec.ts

@@ -1,13 +1,12 @@
-import { DatafileContent, GroupSegment, ParsedFeature } from "@featurevisor/types";
-import { getNewTraffic } from "./traffic";
+import { getTraffic } from "./traffic";
 
 describe("core: Traffic", function () {
   it("should be a function", function () {
-    expect(typeof getNewTraffic).toEqual("function");
+    expect(typeof getTraffic).toEqual("function");
   });
 
   it("should allocate traffic for 100-0 weight on two variations", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -42,10 +41,10 @@ describe("core: Traffic", function () {
           {
             variation: "on",
             percentage: 80000,
-          },
-          {
-            variation: "off",
-            percentage: 0,
+            range: {
+              start: 0,
+              end: 80000,
+            },
           },
         ],
       },
@@ -53,7 +52,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate traffic for 50-50 weight on two variations", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -88,10 +87,18 @@ describe("core: Traffic", function () {
           {
             variation: "on",
             percentage: 40000,
+            range: {
+              start: 0,
+              end: 40000,
+            },
           },
           {
             variation: "off",
             percentage: 40000,
+            range: {
+              start: 40000,
+              end: 80000,
+            },
           },
         ],
       },
@@ -99,7 +106,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate traffic for weight with two decimal places among three variations", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -138,14 +145,26 @@ describe("core: Traffic", function () {
           {
             variation: "yes",
             percentage: 33330,
+            range: {
+              start: 0,
+              end: 33330,
+            },
           },
           {
             variation: "no",
             percentage: 33330,
+            range: {
+              start: 33330,
+              end: 66660,
+            },
           },
           {
             variation: "maybe",
             percentage: 33340,
+            range: {
+              start: 66660,
+              end: 100000,
+            },
           },
         ],
       },
@@ -153,7 +172,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate against previous known allocation, increasing from 80% to 90%, with same variations and weight", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -195,10 +214,18 @@ describe("core: Traffic", function () {
               {
                 variation: "on",
                 percentage: 40000,
+                range: {
+                  start: 0,
+                  end: 40000,
+                },
               },
               {
                 variation: "off",
                 percentage: 40000,
+                range: {
+                  start: 40000,
+                  end: 80000,
+                },
               },
             ],
           },
@@ -216,20 +243,36 @@ describe("core: Traffic", function () {
           {
             variation: "on",
             percentage: 40000,
+            range: {
+              start: 0,
+              end: 40000,
+            },
           },
           {
             variation: "off",
             percentage: 40000,
+            range: {
+              start: 40000,
+              end: 80000,
+            },
           },
 
           // new
           {
             variation: "on",
             percentage: 5000,
+            range: {
+              start: 80000,
+              end: 85000,
+            },
           },
           {
             variation: "off",
             percentage: 5000,
+            range: {
+              start: 85000,
+              end: 90000,
+            },
           },
         ],
       },
@@ -237,7 +280,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate against previous known allocation, decreasing from 80% to 70%, with same variations and weight", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -279,10 +322,18 @@ describe("core: Traffic", function () {
               {
                 variation: "on",
                 percentage: 40000,
+                range: {
+                  start: 0,
+                  end: 40000,
+                },
               },
               {
                 variation: "off",
                 percentage: 40000,
+                range: {
+                  start: 40000,
+                  end: 80000,
+                },
               },
             ],
           },
@@ -299,10 +350,18 @@ describe("core: Traffic", function () {
           {
             variation: "on",
             percentage: 35000,
+            range: {
+              start: 0,
+              end: 35000,
+            },
           },
           {
             variation: "off",
             percentage: 35000,
+            range: {
+              start: 35000,
+              end: 70000,
+            },
           },
         ],
       },
@@ -310,7 +369,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate against previous known allocation, increasing from 80% to 90%, with new added variation", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -356,10 +415,18 @@ describe("core: Traffic", function () {
               {
                 variation: "a",
                 percentage: 40000,
+                range: {
+                  start: 0,
+                  end: 40000,
+                },
               },
               {
                 variation: "b",
                 percentage: 40000,
+                range: {
+                  start: 40000,
+                  end: 80000,
+                },
               },
             ],
           },
@@ -376,14 +443,26 @@ describe("core: Traffic", function () {
           {
             variation: "a",
             percentage: 29997,
+            range: {
+              start: 0,
+              end: 29997,
+            },
           },
           {
             variation: "b",
             percentage: 29997,
+            range: {
+              start: 29997,
+              end: 59994,
+            },
           },
           {
             variation: "c",
             percentage: 30006,
+            range: {
+              start: 59994,
+              end: 90000,
+            },
           },
         ],
       },
@@ -391,7 +470,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate against previous known allocation, increasing from 80% to 100%, with new added variation, totalling 4 variations", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -441,10 +520,18 @@ describe("core: Traffic", function () {
               {
                 variation: "a",
                 percentage: 40000,
+                range: {
+                  start: 0,
+                  end: 40000,
+                },
               },
               {
                 variation: "b",
                 percentage: 40000,
+                range: {
+                  start: 40000,
+                  end: 80000,
+                },
               },
             ],
           },
@@ -461,18 +548,34 @@ describe("core: Traffic", function () {
           {
             variation: "a",
             percentage: 25000,
+            range: {
+              start: 0,
+              end: 25000,
+            },
           },
           {
             variation: "b",
             percentage: 25000,
+            range: {
+              start: 25000,
+              end: 50000,
+            },
           },
           {
             variation: "c",
             percentage: 25000,
+            range: {
+              start: 50000,
+              end: 75000,
+            },
           },
           {
             variation: "d",
             percentage: 25000,
+            range: {
+              start: 75000,
+              end: 100000,
+            },
           },
         ],
       },
@@ -480,7 +583,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate against previous known allocation, staying at same 100%, removing variations from 4 to 2", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -530,18 +633,34 @@ describe("core: Traffic", function () {
               {
                 variation: "a",
                 percentage: 25000,
+                range: {
+                  start: 0,
+                  end: 25000,
+                },
               },
               {
                 variation: "b",
                 percentage: 25000,
+                range: {
+                  start: 25000,
+                  end: 50000,
+                },
               },
               {
                 variation: "c",
                 percentage: 25000,
+                range: {
+                  start: 50000,
+                  end: 75000,
+                },
               },
               {
                 variation: "d",
                 percentage: 25000,
+                range: {
+                  start: 75000,
+                  end: 100000,
+                },
               },
             ],
           },
@@ -558,10 +677,18 @@ describe("core: Traffic", function () {
           {
             variation: "a",
             percentage: 50000,
+            range: {
+              start: 0,
+              end: 50000,
+            },
           },
           {
             variation: "b",
             percentage: 50000,
+            range: {
+              start: 50000,
+              end: 100000,
+            },
           },
         ],
       },
@@ -569,7 +696,7 @@ describe("core: Traffic", function () {
   });
 
   it("should allocate against previous known allocation, decreasing from 100% to 80%, removing variations from 4 to 2", function () {
-    const result = getNewTraffic(
+    const result = getTraffic(
       // parsed variations from YAML
       [
         {
@@ -619,18 +746,34 @@ describe("core: Traffic", function () {
               {
                 variation: "a",
                 percentage: 25000,
+                range: {
+                  start: 0,
+                  end: 25000,
+                },
               },
               {
                 variation: "b",
                 percentage: 25000,
+                range: {
+                  start: 25000,
+                  end: 50000,
+                },
               },
               {
                 variation: "c",
                 percentage: 25000,
+                range: {
+                  start: 50000,
+                  end: 75000,
+                },
               },
               {
                 variation: "d",
                 percentage: 25000,
+                range: {
+                  start: 75000,
+                  end: 100000,
+                },
               },
             ],
           },
@@ -647,10 +790,18 @@ describe("core: Traffic", function () {
           {
             variation: "a",
             percentage: 40000,
+            range: {
+              start: 0,
+              end: 40000,
+            },
           },
           {
             variation: "b",
             percentage: 40000,
+            range: {
+              start: 40000,
+              end: 80000,
+            },
           },
         ],
       },

package/src/traffic.ts

@@ -1,140 +1,154 @@
-import { Rule, ExistingFeature, Traffic, Variation } from "@featurevisor/types";
+import { Rule, ExistingFeature, Traffic, Variation, Range, Percentage } from "@featurevisor/types";
 import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
 
-export function getNewTraffic(
+import { getAllocation, getUpdatedAvailableRangesAfterFilling } from "./allocator";
+
+export function detectIfVariationsChanged(
+  yamlVariations: Variation[], // as exists in latest YAML
+  existingFeature?: ExistingFeature, // from state file
+): boolean {
+  if (!existingFeature) {
+    return false;
+  }
+
+  return (
+    JSON.stringify(
+      existingFeature.variations.map(({ value, weight }) => ({
+        value,
+        weight,
+      })),
+    ) !== JSON.stringify(yamlVariations.map(({ value, weight }) => ({ value, weight })))
+  );
+}
+
+export function getRulePercentageDiff(
+  trafficPercentage: Percentage, // 0 to 100k
+  existingTrafficRule,
+): number {
+  if (!existingTrafficRule) {
+    return 0;
+  }
+
+  const existingPercentage = existingTrafficRule.percentage;
+
+  return trafficPercentage - existingPercentage;
+}
+
+export function detectIfRangesChanged(
+  availableRanges: Range[], // as exists in latest YAML
+  existingFeature?: ExistingFeature, // from state file
+): boolean {
+  if (!existingFeature) {
+    return false;
+  }
+
+  if (!existingFeature.ranges) {
+    return false;
+  }
+
+  return JSON.stringify(existingFeature.ranges) !== JSON.stringify(availableRanges);
+}
+
+export function getTraffic(
   // from current YAML
   variations: Variation[],
   parsedRules: Rule[],
-
   // from previous release
   existingFeature: ExistingFeature | undefined,
+  // ranges from group slots
+  ranges?: Range[],
 ): Traffic[] {
   const result: Traffic[] = [];
 
-  parsedRules.forEach((parsedRollout) => {
-    const rolloutPercentage = parsedRollout.percentage;
+  // @TODO: may be pass from builder directly?
+  const availableRanges =
+    ranges && ranges.length > 0 ? ranges : [{ start: 0, end: MAX_BUCKETED_NUMBER }];
+
+  parsedRules.forEach(function (parsedRule) {
+    const rulePercentage = parsedRule.percentage; // 0 - 100
 
     const traffic: Traffic = {
-      key: parsedRollout.key, // @TODO: not needed in datafile. keep it for now
+      key: parsedRule.key, // @TODO: not needed in datafile. keep it for now
       segments:
-        typeof parsedRollout.segments !== "string"
-          ? JSON.stringify(parsedRollout.segments)
-          : parsedRollout.segments,
-      percentage: rolloutPercentage * (MAX_BUCKETED_NUMBER / 100),
+        typeof parsedRule.segments !== "string"
+          ? JSON.stringify(parsedRule.segments)
+          : parsedRule.segments,
+      percentage: rulePercentage * (MAX_BUCKETED_NUMBER / 100),
       allocation: [],
     };
 
-    if (parsedRollout.variables) {
-      traffic.variables = parsedRollout.variables;
+    // overrides
+    if (parsedRule.variables) {
+      traffic.variables = parsedRule.variables;
     }
 
-    if (parsedRollout.variation) {
-      traffic.variation = parsedRollout.variation;
+    if (parsedRule.variation) {
+      traffic.variation = parsedRule.variation;
     }
 
-    const existingTrafficRollout = existingFeature?.traffic.find(
-      (t) => t.key === parsedRollout.key,
-    );
-
-    // @TODO: handle if Variations changed (added/removed, or weight changed)
-
-    //  - new variation added
-    //  - variation removed
-    //  - variation weight changed
-    //
-    // make it better by maintaining as much of the previous bucketing as possible
-    const variationsChanged = existingFeature
-      ? JSON.stringify(
-          existingFeature.variations.map(({ value, weight }) => ({
-            value,
-            weight,
-          })),
-        ) !== JSON.stringify(variations.map(({ value, weight }) => ({ value, weight })))
-      : false;
-
-    let diffPercentage = 0;
-
-    if (existingTrafficRollout) {
-      diffPercentage =
-        rolloutPercentage - existingTrafficRollout.percentage / (MAX_BUCKETED_NUMBER / 100);
-
-      if (
-        diffPercentage > 0 &&
-        !variationsChanged // if variations changed, we need to re-bucket
-      ) {
-        // increase: build on top of existing allocations
-
-        traffic.allocation = existingTrafficRollout.allocation.map(({ variation, percentage }) => {
-          return {
-            variation,
-            percentage,
-          };
-        });
-      }
+    // detect changes
+    const variationsChanged = detectIfVariationsChanged(variations, existingFeature);
+    const existingTrafficRule = existingFeature?.traffic.find((t) => t.key === parsedRule.key);
+    const rulePercentageDiff = getRulePercentageDiff(traffic.percentage, existingTrafficRule);
+    const rangesChanged = detectIfRangesChanged(availableRanges, existingFeature);
+
+    const needsRebucketing =
+      !existingTrafficRule || // new rule
+      variationsChanged || // variations changed
+      rulePercentageDiff <= 0 || // percentage decreased
+      rangesChanged; // belongs to a group, and group ranges changed
+
+    let updatedAvailableRanges = JSON.parse(JSON.stringify(availableRanges));
+
+    let lastEnd = 0;
+    if (existingTrafficRule && !needsRebucketing) {
+      // increase: build on top of existing allocations
+      let existingSum = 0;
+
+      traffic.allocation = existingTrafficRule.allocation.map(function ({
+        variation,
+        percentage, // @TODO: remove it in next breaking semver
+        range,
+      }) {
+        const result = {
+          variation,
+          percentage, // @TODO remove it in next breaking semver
+          range: range || {
+            start: lastEnd,
+            end: percentage,
+          },
+        };
+
+        existingSum += percentage || 0;
+        lastEnd = lastEnd + (percentage || 0);
+
+        return result;
+      });
+
+      updatedAvailableRanges = getUpdatedAvailableRangesAfterFilling(availableRanges, existingSum);
     }
 
-    variations.forEach((variation) => {
-      const newPercentage = parseInt(
-        (
-          ((variation.weight as number) / 100) *
-          rolloutPercentage *
-          (MAX_BUCKETED_NUMBER / 100)
-        ).toFixed(2),
-      );
+    variations.forEach(function (variation) {
+      const weight = variation.weight as number;
+      const percentage = weight * (MAX_BUCKETED_NUMBER / 100);
 
-      if (!existingTrafficRollout || variationsChanged === true) {
-        traffic.allocation.push({
-          variation: variation.value,
-          percentage: newPercentage,
-        });
+      let toFillValue = needsRebucketing
+        ? percentage * (rulePercentage / 100) // whole value
+        : (weight / 100) * rulePercentageDiff; // incrementing
+      const rangesToFill = getAllocation(updatedAvailableRanges, toFillValue);
 
-        return;
-      }
-
-      // const prevTotalWeightForVariation = existingTrafficRollout.allocation
-      //   .filter((a) => a.variation === variation.value)
-      //   .reduce((acc, curr) => acc + curr.percentage, 0);
-
-      // const diffWeightForVariation = (variation.weight as number) - prevTotalWeightForVariation / (MAX_BUCKETED_NUMBER / 100));
-
-      if (diffPercentage === 0) {
-        // no change
-        traffic.allocation.push({
-          variation: variation.value,
-          percentage: newPercentage,
-        });
-
-        return;
-      }
-
-      if (diffPercentage > 0) {
-        // increase - need to consistently bucket
+      rangesToFill.forEach(function (range) {
         traffic.allocation.push({
           variation: variation.value,
-          percentage: parseInt(
-            (
-              (variation.weight as number) *
-              (diffPercentage / 100) *
-              (MAX_BUCKETED_NUMBER / 100)
-            ).toFixed(2),
-          ),
+          percentage: toFillValue, // @TODO remove it in next breaking semver
+          range,
         });
+      });
 
-        return;
-      }
-
-      if (diffPercentage < 0) {
-        // decrease - need to re-bucket
-
-        // @TODO: can we maintain as much pre bucketed values as possible? to be close to consistent bucketing?
-
-        traffic.allocation.push({
-          variation: variation.value,
-          percentage: newPercentage,
-        });
-
-        return;
-      }
+      updatedAvailableRanges = getUpdatedAvailableRangesAfterFilling(
+        updatedAvailableRanges,
+        toFillValue,
+      );
     });
 
     result.push(traffic);