@featurevisor/core 0.37.1 → 0.39.0

package/src/builder.ts

@@ -57,8 +57,16 @@ export function getExistingStateFilePath(
   return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
 }
 
-export function getFeatureRanges(projectConfig: ProjectConfig): Map<FeatureKey, Range[]> {
+export type FeatureRanges = Map<FeatureKey, Range[]>;
+
+interface FeatureRangesResult {
+  featureRanges: FeatureRanges;
+  featureIsInGroup: { [key: string]: boolean };
+}
+
+export function getFeatureRanges(projectConfig: ProjectConfig): FeatureRangesResult {
   const featureRanges = new Map<FeatureKey, Range[]>();
+  const featureIsInGroup = {}; // featureKey => boolean
 
   const groups: Group[] = [];
   if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
@@ -82,6 +90,11 @@ export function getFeatureRanges(projectConfig: ProjectConfig): Map<FeatureKey,
 
         if (slot.feature) {
           const featureKey = slot.feature;
+
+          if (typeof featureKey === "string") {
+            featureIsInGroup[featureKey] = true;
+          }
+
           const featureRangesForFeature = featureRanges.get(featureKey) || [];
 
           const start = isFirstSlot ? accumulatedPercentage : accumulatedPercentage + 1;
@@ -97,7 +110,7 @@ export function getFeatureRanges(projectConfig: ProjectConfig): Map<FeatureKey,
     }
   }
 
-  return featureRanges;
+  return { featureRanges, featureIsInGroup };
 }
 
 export function buildDatafile(
@@ -115,7 +128,7 @@ export function buildDatafile(
 
   const segmentKeysUsedByTag = new Set<SegmentKey>();
   const attributeKeysUsedByTag = new Set<AttributeKey>();
-  const featureRanges = getFeatureRanges(projectConfig);
+  const { featureRanges, featureIsInGroup } = getFeatureRanges(projectConfig);
 
   // features
   const features: Feature[] = [];
@@ -148,79 +161,85 @@ export function buildDatafile(
 
       const feature: Feature = {
         key: featureKey,
-        defaultVariation: parsedFeature.defaultVariation,
         bucketBy: parsedFeature.bucketBy || projectConfig.defaultBucketBy,
-        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) {
-            return mappedVariation;
-          }
+        variations: Array.isArray(parsedFeature.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
+              };
 
-          mappedVariation.variables = variation.variables.map((variable: Variable) => {
-            const mappedVariable: any = {
-              key: variable.key,
-              value: variable.value,
-            };
-
-            if (!variable.overrides) {
-              return mappedVariable;
-            }
-
-            mappedVariable.overrides = variable.overrides.map((override: VariableOverride) => {
-              if (typeof override.conditions !== "undefined") {
-                const extractedAttributeKeys = extractAttributeKeysFromConditions(
-                  override.conditions,
-                );
-                extractedAttributeKeys.forEach((attributeKey) =>
-                  attributeKeysUsedByTag.add(attributeKey),
-                );
-
-                return {
-                  conditions: JSON.stringify(override.conditions),
-                  value: override.value,
-                };
+              if (!variation.variables) {
+                return mappedVariation;
               }
 
-              if (typeof override.segments !== "undefined") {
-                const extractedSegmentKeys = extractSegmentKeysFromGroupSegments(
-                  override.segments as GroupSegment | GroupSegment[],
-                );
-                extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
-
-                return {
-                  segments: JSON.stringify(override.segments),
-                  value: override.value,
+              mappedVariation.variables = variation.variables.map((variable: Variable) => {
+                const mappedVariable: any = {
+                  key: variable.key,
+                  value: variable.value,
                 };
-              }
-
-              return override;
-            });
-
-            return mappedVariable;
-          });
 
-          return mappedVariation;
-        }),
+                if (!variable.overrides) {
+                  return mappedVariable;
+                }
+
+                mappedVariable.overrides = variable.overrides.map((override: VariableOverride) => {
+                  if (typeof override.conditions !== "undefined") {
+                    const extractedAttributeKeys = extractAttributeKeysFromConditions(
+                      override.conditions,
+                    );
+                    extractedAttributeKeys.forEach((attributeKey) =>
+                      attributeKeysUsedByTag.add(attributeKey),
+                    );
+
+                    return {
+                      conditions: JSON.stringify(override.conditions),
+                      value: override.value,
+                    };
+                  }
+
+                  if (typeof override.segments !== "undefined") {
+                    const extractedSegmentKeys = extractSegmentKeysFromGroupSegments(
+                      override.segments as GroupSegment | GroupSegment[],
+                    );
+                    extractedSegmentKeys.forEach((segmentKey) =>
+                      segmentKeysUsedByTag.add(segmentKey),
+                    );
+
+                    return {
+                      segments: JSON.stringify(override.segments),
+                      value: override.value,
+                    };
+                  }
+
+                  return override;
+                });
+
+                return mappedVariable;
+              });
+
+              return mappedVariation;
+            })
+          : undefined,
         traffic: getTraffic(
           parsedFeature.variations,
           parsedFeature.environments[options.environment].rules,
           existingState.features[featureKey],
           featureRanges.get(featureKey) || [],
         ),
+        ranges: featureRanges.get(featureKey) || undefined,
       };
 
       // update state in memory, so that next datafile build can use it (in case it contains the same feature)
       existingState.features[featureKey] = {
-        variations: feature.variations.map((v: Variation) => {
-          return {
-            value: v.value,
-            weight: v.weight || 0,
-          };
-        }),
+        variations: Array.isArray(feature.variations)
+          ? feature.variations.map((v: Variation) => {
+              return {
+                value: v.value,
+                weight: v.weight || 0,
+              };
+            })
+          : undefined,
         traffic: feature.traffic.map((t: Traffic) => {
           return {
             key: t.key,
@@ -233,9 +252,12 @@ export function buildDatafile(
             }),
           };
         }),
-        ranges: featureRanges.get(feature.key) || undefined,
       };
 
+      if (featureIsInGroup[featureKey] === true) {
+        feature.ranges = featureRanges.get(feature.key);
+      }
+
       if (parsedFeature.variablesSchema) {
         feature.variablesSchema = parsedFeature.variablesSchema;
       }

package/src/generate-code/typescript.ts

@@ -138,7 +138,7 @@ ${attributeProperties}
     const featureKey = path.basename(featureFile, ".yml");
     const parsedFeature = parseYaml(fs.readFileSync(featureFile, "utf8")) as ParsedFeature;
 
-    const variationType = getFeaturevisorTypeFromValue(parsedFeature.defaultVariation);
+    const variationType = "string";
     const variationTypeScriptType = convertFeaturevisorTypeToTypeScriptType(variationType);
 
     if (typeof parsedFeature.archived !== "undefined" && parsedFeature.archived) {
@@ -182,8 +182,12 @@ import { getInstance } from "./instance";
 export namespace ${namespaceValue} {
   export const key = "${featureKey}";
 
+  export function isEnabled(context: Context = {}) {
+    return getInstance().isEnabled(key, context);
+  }
+
   export function getVariation(context: Context = {}) {
-    return getInstance().getVariation${getPascalCase(variationType)}(key, context);
+    return getInstance().getVariation(key, context);
   }${variableMethods}
 }
 `.trimStart();

package/src/linter.ts

@@ -173,9 +173,10 @@ export function getFeatureJoiSchema(
   conditionsJoiSchema,
   availableSegmentKeys: string[],
 ) {
-  const variationValueJoiSchema = Joi.alternatives().try(Joi.string(), Joi.number(), Joi.boolean());
+  const variationValueJoiSchema = Joi.string().required();
   const variableValueJoiSchema = Joi.alternatives()
     .try(
+      // @TODO: make it stricter based on variableSchema.type
       Joi.string(),
       Joi.number(),
       Joi.boolean(),
@@ -230,7 +231,9 @@ export function getFeatureJoiSchema(
           key: Joi.string(),
           segments: groupSegmentsJoiSchema,
           percentage: Joi.number().precision(3).min(0).max(100),
-          variation: variationValueJoiSchema.optional(),
+
+          enabled: Joi.boolean().optional(),
+          variation: variationValueJoiSchema.optional(), // @TODO: only allowed if feature.variations is present
           variables: Joi.object().optional(), // @TODO: make it stricter
         }),
       )
@@ -242,7 +245,8 @@ export function getFeatureJoiSchema(
         segments: groupSegmentsJoiSchema.optional(),
         conditions: conditionsJoiSchema.optional(),
 
-        variation: variationValueJoiSchema,
+        enabled: Joi.boolean().optional(),
+        variation: variationValueJoiSchema.optional(),
         variables: Joi.object().optional(), // @TODO: make it stricter
       }),
     ),
@@ -269,8 +273,6 @@ export function getFeatureJoiSchema(
       )
       .required(),
 
-    defaultVariation: variationValueJoiSchema,
-
     bucketBy: Joi.alternatives()
       .try(
         // plain
@@ -331,23 +333,15 @@ export function getFeatureJoiSchema(
         }),
       )
       .custom((value, helpers) => {
-        var total = value.reduce((a, b) => a + b.weight, 0);
+        var total = value.reduce((acc, v) => acc + v.weight, 0);
 
         if (total !== 100) {
           throw new Error(`Sum of all variation weights must be 100, got ${total}`);
         }
 
-        const typeOf = new Set(value.map((v) => typeof v.value));
-
-        if (typeOf.size > 1) {
-          throw new Error(
-            `All variations must have the same type, got ${Array.from(typeOf).join(", ")}`,
-          );
-        }
-
         return value;
       })
-      .required(),
+      .optional(),
 
     environments: allEnvironmentsJoiSchema.required(),
   });
@@ -382,7 +376,8 @@ export function getTestsJoiSchema(
                   at: Joi.number().precision(3).min(0).max(100),
                   context: Joi.object(),
 
-                  // @TODO: one or both below
+                  // @TODO: one or all below
+                  expectedToBeEnabled: Joi.boolean().required(),
                   expectedVariation: Joi.alternatives().try(
                     Joi.string(),
                     Joi.number(),

package/src/site.ts

@@ -310,37 +310,39 @@ export function generateSiteSearchIndex(
       const fileContent = fs.readFileSync(filePath, "utf8");
       const parsed = parseYaml(fileContent) as ParsedFeature;
 
-      parsed.variations.forEach((variation) => {
-        if (!variation.variables) {
-          return;
-        }
+      if (Array.isArray(parsed.variations)) {
+        parsed.variations.forEach((variation) => {
+          if (!variation.variables) {
+            return;
+          }
 
-        variation.variables.forEach((v) => {
-          if (v.overrides) {
-            v.overrides.forEach((o) => {
-              if (o.conditions) {
-                extractAttributeKeysFromConditions(o.conditions).forEach((attributeKey) => {
-                  if (!attributesUsedInFeatures[attributeKey]) {
-                    attributesUsedInFeatures[attributeKey] = new Set();
-                  }
-
-                  attributesUsedInFeatures[attributeKey].add(entityName);
-                });
-              }
+          variation.variables.forEach((v) => {
+            if (v.overrides) {
+              v.overrides.forEach((o) => {
+                if (o.conditions) {
+                  extractAttributeKeysFromConditions(o.conditions).forEach((attributeKey) => {
+                    if (!attributesUsedInFeatures[attributeKey]) {
+                      attributesUsedInFeatures[attributeKey] = new Set();
+                    }
+
+                    attributesUsedInFeatures[attributeKey].add(entityName);
+                  });
+                }
 
-              if (o.segments && o.segments !== "*") {
-                extractSegmentKeysFromGroupSegments(o.segments).forEach((segmentKey) => {
-                  if (!segmentsUsedInFeatures[segmentKey]) {
-                    segmentsUsedInFeatures[segmentKey] = new Set();
-                  }
+                if (o.segments && o.segments !== "*") {
+                  extractSegmentKeysFromGroupSegments(o.segments).forEach((segmentKey) => {
+                    if (!segmentsUsedInFeatures[segmentKey]) {
+                      segmentsUsedInFeatures[segmentKey] = new Set();
+                    }
 
-                  segmentsUsedInFeatures[segmentKey].add(entityName);
-                });
-              }
-            });
-          }
+                    segmentsUsedInFeatures[segmentKey].add(entityName);
+                  });
+                }
+              });
+            }
+          });
         });
-      });
+      }
 
       Object.keys(parsed.environments).forEach((environmentKey) => {
         const env = parsed.environments[environmentKey];

package/src/tester.ts

@@ -118,7 +118,7 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
             }
           });
         });
-      } else {
+      } else if (test.environment && test.tag && test.features) {
         // feature testing
         const datafilePath = getDatafilePath(projectConfig, test.environment, test.tag);
 
@@ -158,6 +158,20 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
             let assertionHasError = false;
             currentAt = assertion.at * (MAX_BUCKETED_NUMBER / 100);
 
+            // isEnabled
+            if ("expectedToBeEnabled" in assertion) {
+              const isEnabled = sdk.isEnabled(featureKey, assertion.context);
+
+              if (isEnabled !== assertion.expectedToBeEnabled) {
+                hasError = true;
+                assertionHasError = true;
+
+                console.error(
+                  `           isEnabled failed: expected "${assertion.expectedToBeEnabled}", got "${isEnabled}"`,
+                );
+              }
+            }
+
             // variation
             if ("expectedVariation" in assertion) {
               const variation = sdk.getVariation(featureKey, assertion.context);
@@ -203,6 +217,9 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
             }
           });
         });
+      } else {
+        console.error(`     => Invalid test: ${JSON.stringify(test)}`);
+        hasError = true;
       }
     });
   }

package/src/traffic.ts

@@ -4,20 +4,24 @@ import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
 import { getAllocation, getUpdatedAvailableRangesAfterFilling } from "./allocator";
 
 export function detectIfVariationsChanged(
-  yamlVariations: Variation[], // as exists in latest YAML
+  yamlVariations: Variation[] | undefined, // as exists in latest YAML
   existingFeature?: ExistingFeature, // from state file
 ): boolean {
-  if (!existingFeature) {
+  if (!existingFeature || typeof existingFeature.variations === "undefined") {
     return false;
   }
 
+  const checkVariations = Array.isArray(yamlVariations)
+    ? JSON.stringify(yamlVariations.map(({ value, weight }) => ({ value, weight })))
+    : undefined;
+
   return (
     JSON.stringify(
       existingFeature.variations.map(({ value, weight }) => ({
         value,
         weight,
       })),
-    ) !== JSON.stringify(yamlVariations.map(({ value, weight }) => ({ value, weight })))
+    ) !== checkVariations
   );
 }
 
@@ -51,7 +55,7 @@ export function detectIfRangesChanged(
 
 export function getTraffic(
   // from current YAML
-  variations: Variation[],
+  variations: Variation[] | undefined,
   parsedRules: Rule[],
   // from previous release
   existingFeature: ExistingFeature | undefined,
@@ -118,27 +122,29 @@ export function getTraffic(
       updatedAvailableRanges = getUpdatedAvailableRangesAfterFilling(availableRanges, existingSum);
     }
 
-    variations.forEach(function (variation) {
-      const weight = variation.weight as number;
-      const percentage = weight * (MAX_BUCKETED_NUMBER / 100);
-
-      let toFillValue = needsRebucketing
-        ? percentage * (rulePercentage / 100) // whole value
-        : (weight / 100) * rulePercentageDiff; // incrementing
-      const rangesToFill = getAllocation(updatedAvailableRanges, toFillValue);
-
-      rangesToFill.forEach(function (range) {
-        traffic.allocation.push({
-          variation: variation.value,
-          range,
+    if (Array.isArray(variations)) {
+      variations.forEach(function (variation) {
+        const weight = variation.weight as number;
+        const percentage = weight * (MAX_BUCKETED_NUMBER / 100);
+
+        let toFillValue = needsRebucketing
+          ? percentage * (rulePercentage / 100) // whole value
+          : (weight / 100) * rulePercentageDiff; // incrementing
+        const rangesToFill = getAllocation(updatedAvailableRanges, toFillValue);
+
+        rangesToFill.forEach(function (range) {
+          traffic.allocation.push({
+            variation: variation.value,
+            range,
+          });
         });
-      });
 
-      updatedAvailableRanges = getUpdatedAvailableRangesAfterFilling(
-        updatedAvailableRanges,
-        toFillValue,
-      );
-    });
+        updatedAvailableRanges = getUpdatedAvailableRangesAfterFilling(
+          updatedAvailableRanges,
+          toFillValue,
+        );
+      });
+    }
 
     traffic.allocation = traffic.allocation.filter((a) => {
       if (a.range && a.range[0] === a.range[1]) {