@featurevisor/core 0.0.3

package/src/traffic.ts

@@ -0,0 +1,136 @@
+import { Rule, ExistingFeature, Traffic, Variation } from "@featurevisor/types";
+import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
+
+export function getNewTraffic(
+  // from current YAML
+  variations: Variation[],
+  parsedRules: Rule[],
+
+  // from previous release
+  existingFeature: ExistingFeature | undefined,
+): Traffic[] {
+  const result: Traffic[] = [];
+
+  parsedRules.forEach((parsedRollout) => {
+    const rolloutPercentage = parsedRollout.percentage;
+
+    const traffic: Traffic = {
+      key: parsedRollout.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),
+      allocation: [],
+    };
+
+    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,
+          };
+        });
+      }
+    }
+
+    variations.forEach((variation) => {
+      const newPercentage = parseInt(
+        (
+          ((variation.weight as number) / 100) *
+          rolloutPercentage *
+          (MAX_BUCKETED_NUMBER / 100)
+        ).toFixed(2),
+      );
+
+      if (!existingTrafficRollout || variationsChanged === true) {
+        traffic.allocation.push({
+          variation: variation.value,
+          percentage: newPercentage,
+        });
+
+        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
+        traffic.allocation.push({
+          variation: variation.value,
+          percentage: parseInt(
+            (
+              (variation.weight as number) *
+              (diffPercentage / 100) *
+              (MAX_BUCKETED_NUMBER / 100)
+            ).toFixed(2),
+          ),
+        });
+
+        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;
+      }
+    });
+
+    result.push(traffic);
+  });
+
+  return result;
+}

package/src/utils.ts

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import * as yaml from "js-yaml";
+
+import { Condition, AttributeKey, GroupSegment, SegmentKey } from "@featurevisor/types";
+
+export function getYAMLFiles(directoryPath: string) {
+  const files = fs.readdirSync(directoryPath);
+  const yamlFiles = files.filter((file) => file.endsWith(".yml"));
+
+  return yamlFiles.map((file) => path.join(directoryPath, file));
+}
+
+export function parseYaml(content: string) {
+  const parsed = yaml.load(content);
+
+  return parsed;
+}
+
+export function extractSegmentKeysFromGroupSegments(
+  segments: GroupSegment | GroupSegment[],
+): Set<SegmentKey> {
+  const result = new Set<SegmentKey>();
+
+  if (Array.isArray(segments)) {
+    segments.forEach((segment) => {
+      extractSegmentKeysFromGroupSegments(segment).forEach((segmentKey) => {
+        result.add(segmentKey);
+      });
+    });
+  }
+
+  if (typeof segments === "object") {
+    if ("and" in segments) {
+      extractSegmentKeysFromGroupSegments(segments.and).forEach((segmentKey) => {
+        result.add(segmentKey);
+      });
+    }
+
+    if ("or" in segments) {
+      extractSegmentKeysFromGroupSegments(segments.or).forEach((segmentKey) => {
+        result.add(segmentKey);
+      });
+    }
+  }
+
+  if (typeof segments === "string") {
+    result.add(segments);
+  }
+
+  return result;
+}
+
+export function extractAttributeKeysFromConditions(conditions: Condition | Condition[]) {
+  const result = new Set<AttributeKey>();
+
+  if (Array.isArray(conditions)) {
+    conditions.forEach((condition) => {
+      extractAttributeKeysFromConditions(condition).forEach((attributeKey) => {
+        result.add(attributeKey);
+      });
+    });
+  }
+
+  if ("attribute" in conditions) {
+    result.add(conditions.attribute);
+  }
+
+  if ("and" in conditions) {
+    extractAttributeKeysFromConditions(conditions.and).forEach((attributeKey) => {
+      result.add(attributeKey);
+    });
+  }
+
+  if ("or" in conditions) {
+    extractAttributeKeysFromConditions(conditions.or).forEach((attributeKey) => {
+      result.add(attributeKey);
+    });
+  }
+
+  return result;
+}

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.cjs.json",
+  "compilerOptions": {
+    "outDir": "./lib"
+  },
+  "include": ["./src/**/*.ts"]
+}