@featurevisor/core 0.15.0 → 0.17.0

package/src/builder.ts

@@ -23,11 +23,12 @@ import {
   FeatureKey,
   Allocation,
   EnvironmentKey,
+  Group,
+  Range,
 } from "@featurevisor/types";
-import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
 
 import { SCHEMA_VERSION, ProjectConfig } from "./config";
-import { getNewTraffic } from "./traffic";
+import { getTraffic } from "./traffic";
 import {
   parseYaml,
   extractAttributeKeysFromConditions,
@@ -73,6 +74,49 @@ export function buildDatafile(
 
   const segmentKeysUsedByTag = new Set<SegmentKey>();
   const attributeKeysUsedByTag = new Set<AttributeKey>();
+  const featureRanges = new Map<FeatureKey, Range[]>();
+
+  // groups
+  const groups: Group[] = [];
+  if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
+    const groupFiles = fs
+      .readdirSync(projectConfig.groupsDirectoryPath)
+      .filter((f) => f.endsWith(".yml"));
+
+    for (const groupFile of groupFiles) {
+      const groupKey = path.basename(groupFile, ".yml");
+      const groupFilePath = path.join(projectConfig.groupsDirectoryPath, groupFile);
+      const parsedGroup = parseYaml(fs.readFileSync(groupFilePath, "utf8")) as Group;
+
+      groups.push({
+        ...parsedGroup,
+        key: groupKey,
+      });
+
+      let accumulatedPercentage = 0;
+      parsedGroup.slots.forEach(function (slot, slotIndex) {
+        const isFirstSlot = slotIndex === 0;
+        const isLastSlot = slotIndex === parsedGroup.slots.length - 1;
+
+        if (slot.feature) {
+          const featureKey = slot.feature;
+          const featureRangesForFeature = featureRanges.get(featureKey) || [];
+
+          const start = isFirstSlot ? accumulatedPercentage : accumulatedPercentage + 1;
+          const end = accumulatedPercentage + slot.percentage * 1000;
+
+          featureRangesForFeature.push({
+            start,
+            end,
+          });
+
+          featureRanges.set(slot.feature, featureRangesForFeature);
+        }
+
+        accumulatedPercentage += slot.percentage * 1000;
+      });
+    }
+  }
 
   // features
   const features: Feature[] = [];
@@ -115,27 +159,9 @@ export function buildDatafile(
         continue;
       }
 
-      const featureTraffic: Traffic[] = [];
-
       for (const parsedRule of parsedFeature.environments[options.environment].rules) {
         const extractedSegmentKeys = extractSegmentKeysFromGroupSegments(parsedRule.segments);
         extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
-
-        const traffic: Traffic = {
-          key: parsedRule.key,
-          segments:
-            typeof parsedRule.segments === "string"
-              ? parsedRule.segments
-              : JSON.stringify(parsedRule.segments),
-          percentage: parsedRule.percentage * (MAX_BUCKETED_NUMBER / 100),
-          allocation: [],
-        };
-
-        if (parsedRule.variables) {
-          traffic.variables = parsedRule.variables;
-        }
-
-        featureTraffic.push(traffic);
       }
 
       const feature: Feature = {
@@ -145,6 +171,7 @@ export function buildDatafile(
         variations: parsedFeature.variations.map((variation: Variation) => {
           const mappedVariation: any = {
             value: variation.value,
+            weight: variation.weight, // @TODO: added so state files can maintain weight info, but datafiles don't need this. find a way to remove it from datafiles later
           };
 
           if (!variation.variables) {
@@ -196,10 +223,11 @@ export function buildDatafile(
 
           return mappedVariation;
         }),
-        traffic: getNewTraffic(
+        traffic: getTraffic(
           parsedFeature.variations,
           parsedFeature.environments[options.environment].rules,
           existingFeatures && existingFeatures[featureKey],
+          featureRanges.get(featureKey) || [],
         ),
       };
 
@@ -315,15 +343,17 @@ export function buildDatafile(
       traffic: feature.traffic.map((t: Traffic) => {
         return {
           key: t.key,
-          percentage: t.percentage,
+          percentage: t.percentage, // @TODO: remove this in next breaking semver
           allocation: t.allocation.map((a: Allocation) => {
             return {
               variation: a.variation,
-              percentage: a.percentage,
+              percentage: a.percentage, // @TODO: remove this in next breaking semver
+              range: a.range,
             };
           }),
         };
       }),
+      ranges: featureRanges.get(feature.key) || undefined,
     };
 
     acc[feature.key] = item;

package/src/config.ts

@@ -5,6 +5,7 @@ import { BucketBy } from "@featurevisor/types";
 export const FEATURES_DIRECTORY_NAME = "features";
 export const SEGMENTS_DIRECTORY_NAME = "segments";
 export const ATTRIBUTES_DIRECTORY_NAME = "attributes";
+export const GROUPS_DIRECTORY_NAME = "groups";
 export const TESTS_DIRECTORY_NAME = "tests";
 export const STATE_DIRECTORY_NAME = ".featurevisor";
 export const OUTPUT_DIRECTORY_NAME = "dist";
@@ -23,6 +24,7 @@ export interface ProjectConfig {
   featuresDirectoryPath: string;
   segmentsDirectoryPath: string;
   attributesDirectoryPath: string;
+  groupsDirectoryPath: string;
   testsDirectoryPath: string;
   stateDirectoryPath: string;
   outputDirectoryPath: string;
@@ -39,6 +41,7 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     featuresDirectoryPath: path.join(rootDirectoryPath, FEATURES_DIRECTORY_NAME),
     segmentsDirectoryPath: path.join(rootDirectoryPath, SEGMENTS_DIRECTORY_NAME),
     attributesDirectoryPath: path.join(rootDirectoryPath, ATTRIBUTES_DIRECTORY_NAME),
+    groupsDirectoryPath: path.join(rootDirectoryPath, GROUPS_DIRECTORY_NAME),
     testsDirectoryPath: path.join(rootDirectoryPath, TESTS_DIRECTORY_NAME),
 
     stateDirectoryPath: path.join(rootDirectoryPath, STATE_DIRECTORY_NAME),

package/src/linter.ts

@@ -7,6 +7,7 @@ import * as Joi from "joi";
 import { getYAMLFiles, parseYaml } from "./utils";
 
 import { ProjectConfig } from "./config";
+import { ParsedFeature } from "@featurevisor/types";
 
 export function getAttributeJoiSchema(projectConfig: ProjectConfig) {
   const attributeJoiSchema = Joi.object({
@@ -101,6 +102,60 @@ export function getSegmentJoiSchema(projectConfig: ProjectConfig, conditionsJoiS
   return segmentJoiSchema;
 }
 
+export function getGroupJoiSchema(projectConfig: ProjectConfig) {
+  const groupJoiSchema = Joi.object({
+    description: Joi.string().required(),
+    slots: Joi.array()
+      .items(
+        Joi.object({
+          feature: Joi.string(),
+          percentage: Joi.number().precision(3).min(0).max(100),
+        }),
+      )
+      .custom(function (value, helper) {
+        const totalPercentage = value.reduce((acc, slot) => acc + slot.percentage, 0);
+
+        if (totalPercentage !== 100) {
+          throw new Error("total percentage is not 100");
+        }
+
+        for (const slot of value) {
+          const maxPercentageForRule = slot.percentage;
+
+          if (slot.feature) {
+            const featureKey = slot.feature;
+            const featurePath = path.join(projectConfig.featuresDirectoryPath, `${featureKey}.yml`);
+            const parsedFeature = parseYaml(fs.readFileSync(featurePath, "utf8")) as ParsedFeature;
+
+            if (!parsedFeature) {
+              throw new Error(`feature ${featureKey} not found`);
+            }
+
+            const environmentKeys = Object.keys(parsedFeature.environments);
+            for (const environmentKey of environmentKeys) {
+              const environment = parsedFeature.environments[environmentKey];
+              const rules = environment.rules;
+
+              for (const rule of rules) {
+                if (rule.percentage > maxPercentageForRule) {
+                  // @TODO: this does not help with same feature belonging to multiple slots. fix that.
+                  throw new Error(
+                    `Feature ${featureKey}'s rule ${rule.key} in ${environmentKey} has a percentage of ${rule.percentage} which is greater than the maximum percentage of ${maxPercentageForRule} for the slot`,
+                  );
+                }
+              }
+            }
+          }
+        }
+
+        return value;
+      })
+      .required(),
+  });
+
+  return groupJoiSchema;
+}
+
 export function getFeatureJoiSchema(projectConfig: ProjectConfig, conditionsJoiSchema) {
   const variationValueJoiSchema = Joi.alternatives().try(Joi.string(), Joi.number(), Joi.boolean());
   const variableValueJoiSchema = Joi.alternatives()
@@ -350,6 +405,33 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
     }
   }
 
+  // lint groups
+  console.log("\nLinting groups...\n");
+  if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
+    const groupFilePaths = getYAMLFiles(path.join(projectConfig.groupsDirectoryPath));
+    const groupJoiSchema = getGroupJoiSchema(projectConfig);
+
+    for (const filePath of groupFilePaths) {
+      const key = path.basename(filePath, ".yml");
+      const parsed = parseYaml(fs.readFileSync(filePath, "utf8")) as any;
+      console.log("  =>", key);
+
+      try {
+        await groupJoiSchema.validateAsync(parsed);
+      } catch (e) {
+        if (e instanceof Joi.ValidationError) {
+          printJoiError(e);
+        } else {
+          console.log(e);
+        }
+
+        hasError = true;
+      }
+    }
+  }
+
+  // @TODO: feature cannot exist in multiple groups
+
   // lint features
   console.log("\nLinting features...\n");
   const featureFilePaths = getYAMLFiles(path.join(projectConfig.featuresDirectoryPath));
@@ -375,24 +457,26 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
 
   // lint tests
   console.log("\nLinting tests...\n");
-  const testFilePaths = getYAMLFiles(path.join(projectConfig.testsDirectoryPath));
-  const testsJoiSchema = getTestsJoiSchema(projectConfig);
-
-  for (const filePath of testFilePaths) {
-    const key = path.basename(filePath, ".yml");
-    const parsed = parseYaml(fs.readFileSync(filePath, "utf8")) as any;
-    console.log("  =>", key);
+  if (fs.existsSync(projectConfig.testsDirectoryPath)) {
+    const testFilePaths = getYAMLFiles(path.join(projectConfig.testsDirectoryPath));
+    const testsJoiSchema = getTestsJoiSchema(projectConfig);
+
+    for (const filePath of testFilePaths) {
+      const key = path.basename(filePath, ".yml");
+      const parsed = parseYaml(fs.readFileSync(filePath, "utf8")) as any;
+      console.log("  =>", key);
+
+      try {
+        await testsJoiSchema.validateAsync(parsed);
+      } catch (e) {
+        if (e instanceof Joi.ValidationError) {
+          printJoiError(e);
+        } else {
+          console.log(e);
+        }
 
-    try {
-      await testsJoiSchema.validateAsync(parsed);
-    } catch (e) {
-      if (e instanceof Joi.ValidationError) {
-        printJoiError(e);
-      } else {
-        console.log(e);
+        hasError = true;
       }
-
-      hasError = true;
     }
   }
 

package/src/tester.ts

@@ -128,14 +128,9 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
         configureBucketValue: (feature, attributes, bucketValue) => {
           return currentAt;
         },
-        logger: createLogger({
-          levels: [
-            // "debug",
-            // "info",
-            // "warn",
-            "error",
-          ],
-        }),
+        // logger: createLogger({
+        //   levels: ["debug", "info", "warn", "error"],
+        // }),
       });
 
       test.features.forEach(function (feature, fIndex) {