@featurevisor/core 1.22.0 → 1.23.0

package/src/builder/traffic.spec.ts

@@ -47,6 +47,265 @@ describe("core: Traffic", function () {
     ]);
   });
 
+  it("should allocate traffic for 0-100 weight on two variations", function () {
+    const result = getTraffic(
+      // parsed variations from YAML
+      [
+        {
+          value: "control",
+          weight: 0,
+        },
+        {
+          value: "treatment",
+          weight: 100,
+        },
+      ],
+
+      // parsed rollouts from YAML
+      [
+        {
+          key: "1",
+          segments: "*",
+          percentage: 80,
+        },
+      ],
+
+      // existing feature from previous release
+      undefined,
+    );
+
+    expect(result).toEqual([
+      {
+        key: "1",
+        segments: "*",
+        percentage: 80000,
+        allocation: [
+          // should be filtered out automatically
+          // {
+          //   variation: "control",
+          //   range: [0, 0],
+          // },
+
+          {
+            variation: "treatment",
+            range: [0, 80000],
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("should allocate traffic for 0-100 weight on two variations, with rule percentage going from 80% to 100%", function () {
+    const result = getTraffic(
+      // parsed variations from YAML
+      [
+        {
+          value: "control",
+          weight: 0,
+        },
+        {
+          value: "treatment",
+          weight: 100,
+        },
+      ],
+
+      // parsed rollouts from YAML
+      [
+        {
+          key: "1",
+          segments: "*",
+          percentage: 100,
+        },
+      ],
+
+      // existing feature from previous release
+      {
+        variations: [
+          {
+            value: "control",
+            weight: 0,
+          },
+          {
+            value: "treatment",
+            weight: 80,
+          },
+        ],
+        traffic: [
+          {
+            key: "1",
+            percentage: 80000,
+            allocation: [
+              {
+                variation: "treatment",
+                range: [0, 80000],
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(result).toEqual([
+      {
+        key: "1",
+        segments: "*",
+        percentage: 100000,
+        allocation: [
+          // should be filtered out automatically
+          // {
+          //   variation: "control",
+          //   range: [0, 0],
+          // },
+
+          {
+            variation: "treatment",
+            range: [0, 100000],
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("should allocate traffic for 0-100 weight on two variations, with rule percentage going from 100% to 80%", function () {
+    const result = getTraffic(
+      // parsed variations from YAML
+      [
+        {
+          value: "control",
+          weight: 0,
+        },
+        {
+          value: "treatment",
+          weight: 100,
+        },
+      ],
+
+      // parsed rollouts from YAML
+      [
+        {
+          key: "1",
+          segments: "*",
+          percentage: 80,
+        },
+      ],
+
+      // existing feature from previous release
+      {
+        variations: [
+          {
+            value: "control",
+            weight: 0,
+          },
+          {
+            value: "treatment",
+            weight: 80,
+          },
+        ],
+        traffic: [
+          {
+            key: "1",
+            percentage: 100000,
+            allocation: [
+              {
+                variation: "treatment",
+                range: [0, 100000],
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(result).toEqual([
+      {
+        key: "1",
+        segments: "*",
+        percentage: 80000,
+        allocation: [
+          // should be filtered out automatically
+          // {
+          //   variation: "control",
+          //   range: [0, 0],
+          // },
+
+          {
+            variation: "treatment",
+            range: [0, 80000],
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("should allocate traffic for existing variations state of 0-100 weights", function () {
+    const result = getTraffic(
+      // parsed variations from YAML
+      [
+        {
+          value: "control",
+          weight: 50,
+        },
+        {
+          value: "treatment",
+          weight: 50,
+        },
+      ],
+
+      // parsed rollouts from YAML
+      [
+        {
+          key: "1",
+          segments: "*",
+          percentage: 80,
+        },
+      ],
+
+      // existing feature from previous release
+      {
+        variations: [
+          {
+            value: "control",
+            weight: 0,
+          },
+          {
+            value: "treatment",
+            weight: 80,
+          },
+        ],
+        traffic: [
+          {
+            key: "1",
+            percentage: 80000,
+            allocation: [
+              {
+                variation: "treatment",
+                range: [0, 80000],
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(result).toEqual([
+      {
+        key: "1",
+        segments: "*",
+        percentage: 80000,
+        allocation: [
+          {
+            variation: "control",
+            range: [0, 40000],
+          },
+          {
+            variation: "treatment",
+            range: [40000, 80000],
+          },
+        ],
+      },
+    ]);
+  });
+
   it("should allocate traffic for 50-50 weight on two variations", function () {
     const result = getTraffic(
       // parsed variations from YAML

package/src/config/projectConfig.ts

@@ -44,6 +44,7 @@ export interface ProjectConfig {
   prettyDatafile: boolean;
   stringify: boolean;
   siteExportDirectoryPath: string;
+  enforceCatchAllRule?: boolean;
   adapter: any; // @TODO: type this properly later
 }
 
@@ -70,6 +71,8 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     stateDirectoryPath: path.join(rootDirectoryPath, STATE_DIRECTORY_NAME),
     outputDirectoryPath: path.join(rootDirectoryPath, OUTPUT_DIRECTORY_NAME),
     siteExportDirectoryPath: path.join(rootDirectoryPath, SITE_EXPORT_DIRECTORY_NAME),
+
+    enforceCatchAllRule: false,
   };
 
   const configModulePath = path.join(rootDirectoryPath, CONFIG_MODULE_NAME);

package/src/linter/featureSchema.ts

@@ -87,6 +87,16 @@ export function getFeatureZodSchema(
             })
             .strict(),
         )
+
+        // must have at least one rule
+        .refine(
+          (value) => value.length > 0,
+          () => ({
+            message: "Must have at least one rule",
+          }),
+        )
+
+        // duplicate rules
         .refine(
           (value) => {
             const keys = value.map((v) => v.key);
@@ -95,6 +105,21 @@ export function getFeatureZodSchema(
           (value) => ({
             message: "Duplicate rule keys found: " + value.map((v) => v.key).join(", "),
           }),
+        )
+
+        // enforce catch-all rule
+        .refine(
+          (value) => {
+            if (!projectConfig.enforceCatchAllRule) {
+              return true;
+            }
+
+            const hasCatchAllAsLastRule = value[value.length - 1].segments === "*";
+            return hasCatchAllAsLastRule;
+          },
+          () => ({
+            message: `Missing catch-all rule with \`segments: "*"\` at the end`,
+          }),
         ),
       force: z
         .array(