@featurevisor/core 1.35.3 → 2.0.1

package/src/builder/buildDatafile.ts

@@ -5,9 +5,7 @@ import {
   Feature,
   DatafileContent,
   DatafileContentV1,
-  DatafileContentV2,
   Variation,
-  Variable,
   VariableOverride,
   Traffic,
   SegmentKey,
@@ -18,7 +16,6 @@ import {
   ExistingState,
   FeatureKey,
   Allocation,
-  VariableSchema,
   Expose,
   Rule,
   Force,
@@ -27,9 +24,11 @@ import {
 import { ProjectConfig, SCHEMA_VERSION } from "../config";
 import { Datasource } from "../datasource";
 import { extractAttributeKeysFromConditions, extractSegmentKeysFromGroupSegments } from "../utils";
+import { generateHashForDatafile, generateHashForFeature, getSegmentHashes } from "./hashes";
 
 import { getTraffic } from "./traffic";
 import { getFeatureRanges } from "./getFeatureRanges";
+import { convertToV1 } from "./convertToV1";
 
 export interface CustomDatafileOptions {
   featureKey?: string;
@@ -41,7 +40,9 @@ export interface CustomDatafileOptions {
   inflate?: number;
 }
 
-export async function getCustomDatafile(options: CustomDatafileOptions): Promise<DatafileContent> {
+export async function getCustomDatafile(
+  options: CustomDatafileOptions,
+): Promise<DatafileContent | DatafileContentV1> {
   let featuresToInclude;
 
   if (options.featureKey) {
@@ -69,6 +70,7 @@ export async function getCustomDatafile(options: CustomDatafileOptions): Promise
 export interface BuildOptions {
   schemaVersion: string;
   revision: string;
+  revisionFromHash?: boolean;
   environment: string | false;
   tag?: string;
   features?: FeatureKey[];
@@ -80,15 +82,7 @@ export async function buildDatafile(
   datasource: Datasource,
   options: BuildOptions,
   existingState: ExistingState,
-): Promise<DatafileContent> {
-  const datafileContent: DatafileContentV1 = {
-    schemaVersion: options.schemaVersion,
-    revision: options.revision,
-    attributes: [],
-    segments: [],
-    features: [],
-  };
-
+): Promise<DatafileContent | DatafileContentV1> {
   const segmentKeysUsedByTag = new Set<SegmentKey>();
   const attributeKeysUsedByTag = new Set<AttributeKey>();
   const { featureRanges, featureIsInGroup } = await getFeatureRanges(projectConfig, datasource);
@@ -119,14 +113,14 @@ export async function buildDatafile(
       let rules: Rule[];
       let force: Force[] | undefined;
 
-      if (options.environment && parsedFeature.environments) {
-        expose = parsedFeature.environments[options.environment].expose;
-        rules = parsedFeature.environments[options.environment].rules;
-        force = parsedFeature.environments[options.environment].force;
+      if (options.environment) {
+        expose = parsedFeature.expose?.[options.environment] as Expose | undefined;
+        rules = parsedFeature.rules?.[options.environment] as Rule[];
+        force = parsedFeature.force?.[options.environment] as Force[] | undefined;
       } else {
-        expose = parsedFeature.expose;
+        expose = parsedFeature.expose as Expose | undefined;
         rules = parsedFeature.rules as Rule[];
-        force = parsedFeature.force;
+        force = parsedFeature.force as Force[] | undefined;
       }
 
       if (expose === false) {
@@ -151,66 +145,62 @@ export async function buildDatafile(
         deprecated: parsedFeature.deprecated === true ? true : undefined,
         bucketBy: parsedFeature.bucketBy || projectConfig.defaultBucketBy,
         required: parsedFeature.required,
+        disabledVariationValue: parsedFeature.disabledVariationValue,
         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
+                weight: variation.weight, // @NOTE: added so state files can maintain weight info, but datafiles don't need this. find a way to remove it from datafiles later
+                variables: variation.variables,
+                variableOverrides: variation.variableOverrides,
               };
 
-              if (!variation.variables) {
-                return mappedVariation;
-              }
-
-              mappedVariation.variables = variation.variables.map((variable: Variable) => {
-                const mappedVariable: any = {
-                  key: variable.key,
-                  value: variable.value,
-                };
-
-                if (!variable.overrides) {
-                  return mappedVariable;
+              if (variation.variableOverrides) {
+                const variableOverrides = variation.variableOverrides;
+                const variableKeys = Object.keys(variableOverrides);
+
+                for (const variableKey of variableKeys) {
+                  mappedVariation.variableOverrides[variableKey] = variableOverrides[
+                    variableKey
+                  ].map((override: VariableOverride) => {
+                    if (typeof override.conditions !== "undefined") {
+                      const extractedAttributeKeys = extractAttributeKeysFromConditions(
+                        override.conditions,
+                      );
+                      extractedAttributeKeys.forEach((attributeKey) =>
+                        attributeKeysUsedByTag.add(attributeKey),
+                      );
+
+                      return {
+                        conditions:
+                          projectConfig.stringify && typeof override.conditions !== "string"
+                            ? JSON.stringify(override.conditions)
+                            : 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:
+                          projectConfig.stringify && typeof override.segments !== "string"
+                            ? JSON.stringify(override.segments)
+                            : override.segments,
+                        value: override.value,
+                      };
+                    }
+
+                    return override;
+                  });
                 }
-
-                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: projectConfig.stringify
-                        ? JSON.stringify(override.conditions)
-                        : 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:
-                        typeof override.segments !== "string" && projectConfig.stringify
-                          ? JSON.stringify(override.segments)
-                          : override.segments,
-                      value: override.value,
-                    };
-                  }
-
-                  return override;
-                });
-
-                return mappedVariable;
-              });
+              }
 
               return mappedVariation;
             })
@@ -246,39 +236,60 @@ export async function buildDatafile(
           return {
             key: t.key,
             percentage: t.percentage,
-            allocation: t.allocation.map((a: Allocation) => {
-              return {
-                variation: a.variation,
-                range: a.range,
-              };
-            }),
+            allocation:
+              t.allocation &&
+              t.allocation.map((a: Allocation) => {
+                return {
+                  variation: a.variation,
+                  range: a.range,
+                };
+              }),
           };
         }),
       };
 
       if (featureIsInGroup[featureKey] === true) {
-        feature.ranges = featureRanges.get(feature.key);
+        feature.ranges = featureRanges.get(featureKey);
       }
 
       if (parsedFeature.variablesSchema) {
-        feature.variablesSchema = parsedFeature.variablesSchema.map(function (v: VariableSchema) {
-          return {
-            key: v.key,
+        const variableKeys = Object.keys(parsedFeature.variablesSchema);
+        feature.variablesSchema = {};
+
+        for (const variableKey of variableKeys) {
+          const v = parsedFeature.variablesSchema[variableKey];
+
+          feature.variablesSchema[variableKey] = {
+            key: variableKey,
             type: v.type,
             defaultValue: v.defaultValue,
             deprecated: v.deprecated === true ? true : undefined,
+            useDefaultWhenDisabled: v.useDefaultWhenDisabled === true ? true : undefined,
+            disabledValue: typeof v.disabledValue !== "undefined" ? v.disabledValue : undefined,
           };
-        });
+        }
       }
 
       if (force) {
-        feature.force = force;
-
-        feature.force?.forEach((f) => {
+        feature.force = force.map((f) => {
           if (f.segments) {
             const extractedSegmentKeys = extractSegmentKeysFromGroupSegments(f.segments);
             extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
+
+            f.segments =
+              typeof f.segments !== "string" && projectConfig.stringify
+                ? JSON.stringify(f.segments)
+                : f.segments;
+          }
+
+          if (f.conditions) {
+            f.conditions =
+              typeof f.conditions !== "string" && projectConfig.stringify
+                ? JSON.stringify(f.conditions)
+                : f.conditions;
           }
+
+          return f;
         });
       }
 
@@ -335,7 +346,7 @@ export async function buildDatafile(
         continue;
       }
 
-      if (attributeKeysUsedByTag.has(attributeKey) === false && !parsedAttribute.capture) {
+      if (attributeKeysUsedByTag.has(attributeKey) === false) {
         continue;
       }
 
@@ -344,21 +355,17 @@ export async function buildDatafile(
         type: parsedAttribute.type,
       };
 
-      if (parsedAttribute.capture === true) {
-        attribute.capture = true;
-      }
-
       attributes.push(attribute);
     }
   }
 
   // inflate
-  if (options.inflate) {
+  if (options.inflate && options.inflate >= 2) {
     const allFeatureKeys = features.map((f) => f.key);
     const allSegmentKeys = segments.map((s) => s.key);
     const allAttributeKeys = attributes.map((a) => a.key);
 
-    for (let i = 0; i < options.inflate; i++) {
+    for (let i = 0; i < options.inflate - 1; i++) {
       // feature
       for (const featureKey of allFeatureKeys) {
         const originalFeature = features.find((f) => f.key === featureKey) as Feature;
@@ -391,47 +398,77 @@ export async function buildDatafile(
     }
   }
 
-  // schema v2
-  if (options.schemaVersion === "2") {
-    // v2
-    const datafileContentV2: DatafileContentV2 = {
-      schemaVersion: "2",
+  // schema v1
+  if (options.schemaVersion === "1") {
+    return convertToV1({
       revision: options.revision,
-      attributes: {},
-      segments: {},
-      features: {},
-    };
+      projectConfig,
+      attributes,
+      features,
+      segments,
+    });
+  }
 
-    datafileContentV2.attributes = attributes.reduce((acc, attribute) => {
-      acc[attribute.key] = attribute;
-      return acc;
-    }, {});
+  // schema v2
+  const datafileContentV2: DatafileContent = {
+    schemaVersion: "2",
+    revision: options.revision,
+    segments: {},
+    features: {},
+  };
 
-    datafileContentV2.segments = segments.reduce((acc, segment) => {
+  datafileContentV2.segments = segments.reduce((acc, segment) => {
+    // key check needed for supporting v1 datafile generation
+    if (segment.key) {
       acc[segment.key] = segment;
+      delete acc[segment.key].key; // remove key from segment, as it is not needed in v2 datafile
+    }
+
+    return acc;
+  }, {});
+
+  datafileContentV2.features = features.reduce((acc, feature) => {
+    if (!feature.key) {
       return acc;
-    }, {});
+    }
 
-    datafileContentV2.features = features.reduce((acc, feature) => {
-      if (Array.isArray(feature.variablesSchema)) {
-        feature.variablesSchema = feature.variablesSchema.reduce((vAcc, variableSchema) => {
-          vAcc[variableSchema.key] = variableSchema;
+    const featureKey = feature.key as FeatureKey;
+    const featureV2 = feature;
 
-          return vAcc;
-        }, {});
+    // remove key, as it is not needed in v2 datafile
+    delete featureV2.key;
+
+    // remove variablesSchema[key].key
+    if (featureV2.variablesSchema) {
+      for (const [variableKey, variable] of Object.entries(featureV2.variablesSchema)) {
+        if (variable.key) {
+          delete featureV2.variablesSchema[variableKey].key;
+        }
       }
+    }
 
-      acc[feature.key] = feature;
-      return acc;
-    }, {});
+    acc[featureKey] = featureV2;
 
-    return datafileContentV2;
-  }
+    return acc;
+  }, {});
 
-  // default behaviour
-  datafileContent.attributes = attributes;
-  datafileContent.segments = segments;
-  datafileContent.features = features;
+  // add feature hashes for change detection
+  const segmentHashes = getSegmentHashes(datafileContentV2.segments);
+  Object.keys(datafileContentV2.features).forEach((featureKey) => {
+    const hash = generateHashForFeature(featureKey, datafileContentV2.features, segmentHashes);
 
-  return datafileContent;
+    datafileContentV2.features[featureKey].hash = hash;
+
+    // check needed to support --inflate option
+    if (existingState.features[featureKey]) {
+      existingState.features[featureKey].hash = hash;
+    }
+  });
+
+  if (options.revisionFromHash) {
+    const datafileHash = generateHashForDatafile(datafileContentV2);
+    datafileContentV2.revision = `${datafileHash}`;
+  }
+
+  return datafileContentV2;
 }

package/src/builder/buildProject.ts

@@ -5,15 +5,17 @@ import { getNextRevision } from "./revision";
 import { buildDatafile, getCustomDatafile } from "./buildDatafile";
 import { Dependencies } from "../dependencies";
 import { Plugin } from "../cli";
+import type { DatafileContent } from "@featurevisor/types";
 
 export interface BuildCLIOptions {
   revision?: string;
+  revisionFromHash?: boolean;
   schemaVersion?: string;
 
   // all three together
   environment?: string;
   feature?: string;
-  print?: boolean;
+  json?: boolean;
   pretty?: boolean;
   stateFiles?: boolean; // --no-state-files in CLI
   inflate?: number;
@@ -48,6 +50,7 @@ async function buildForEnvironment({
       {
         schemaVersion: cliOptions.schemaVersion || SCHEMA_VERSION,
         revision: nextRevision,
+        revisionFromHash: cliOptions.revisionFromHash,
         environment: environment,
         tag: tag,
         inflate: cliOptions.inflate,
@@ -56,7 +59,7 @@ async function buildForEnvironment({
     );
 
     // write datafile for environment/tag
-    await datasource.writeDatafile(datafileContent, {
+    await datasource.writeDatafile(datafileContent as DatafileContent, {
       environment,
       tag,
       datafilesDir: cliOptions.datafilesDir,
@@ -85,7 +88,7 @@ export async function buildProject(deps: Dependencies, cliOptions: BuildCLIOptio
    * This way we centralize the datafile generation in one place,
    * while tests can be run anywhere else.
    */
-  if (cliOptions.environment && cliOptions.print) {
+  if (cliOptions.environment && cliOptions.json) {
     const datafileContent = await getCustomDatafile({
       featureKey: cliOptions.feature,
       environment: cliOptions.environment,

package/src/builder/convertToV1.ts

@@ -0,0 +1,166 @@
+import type {
+  DatafileContentV1,
+  FeatureV1,
+  VariableSchema,
+  VariationV1,
+  Variation,
+  VariableV1,
+  Feature,
+  Segment,
+  Attribute,
+} from "@featurevisor/types";
+
+import { ProjectConfig } from "../config";
+
+export interface ConvertToV1Options {
+  revision: string;
+  projectConfig: ProjectConfig;
+  attributes: Attribute[];
+  features: Feature[];
+  segments: Segment[];
+}
+
+export function convertToV1(options: ConvertToV1Options): DatafileContentV1 {
+  const datafileContent: DatafileContentV1 = {
+    schemaVersion: "1",
+    revision: options.revision,
+    attributes: options.attributes,
+    segments: options.segments,
+    features: [],
+  };
+
+  const { features, projectConfig } = options;
+
+  for (const feature of features) {
+    const featureV1: FeatureV1 = {
+      key: feature.key,
+      deprecated: feature.deprecated,
+      bucketBy: feature.bucketBy,
+      required: feature.required,
+      traffic: feature.traffic,
+      force: feature.force,
+      ranges: feature.ranges,
+    };
+
+    if (feature.variablesSchema && !Array.isArray(feature.variablesSchema)) {
+      const variablesSchemaObject = feature.variablesSchema;
+      const variablesSchemaArray: VariableSchema[] = [];
+      const variableKeys = Object.keys(variablesSchemaObject);
+
+      for (const variableKey of variableKeys) {
+        const v = variablesSchemaObject[variableKey];
+        variablesSchemaArray.push({
+          key: variableKey,
+          type: v.type,
+          defaultValue: v.defaultValue,
+          deprecated: v.deprecated === true ? true : undefined,
+        });
+      }
+
+      featureV1.variablesSchema = variablesSchemaArray;
+    }
+
+    if (feature.variations) {
+      const variationsV1: VariationV1[] = feature.variations.map((variation: Variation) => {
+        const variationV1: VariationV1 = {
+          value: variation.value,
+          weight: variation.weight || 0, // weight is not used in v1 datafile, but needed for state files
+        };
+
+        // variables
+        const variablesResult: { [key: string]: VariableV1 } = {};
+
+        if (variation.variables) {
+          const variableKeys = Object.keys(variation.variables);
+
+          for (const variableKey of variableKeys) {
+            const variableValue = variation.variables[variableKey];
+
+            variablesResult[variableKey] = {
+              key: variableKey,
+              value: variableValue,
+            };
+          }
+        }
+
+        if (variation.variableOverrides) {
+          const variableKeys = Object.keys(variation.variableOverrides);
+
+          for (const variableKey of variableKeys) {
+            const overrides = variation.variableOverrides[variableKey];
+
+            if (typeof variablesResult[variableKey] === "undefined") {
+              const variableSchema = feature.variablesSchema?.[variableKey];
+
+              variablesResult[variableKey] = {
+                key: variableKey,
+                value: variableSchema?.defaultValue, // default value if no variable is defined
+              };
+            }
+
+            variablesResult[variableKey].overrides = overrides.map((override) => {
+              if (typeof override.conditions !== "undefined") {
+                return {
+                  conditions: projectConfig.stringify
+                    ? JSON.stringify(override.conditions)
+                    : override.conditions,
+                  value: override.value,
+                };
+              }
+
+              if (typeof override.segments !== "undefined") {
+                return {
+                  segments:
+                    typeof override.segments !== "string" && projectConfig.stringify
+                      ? JSON.stringify(override.segments)
+                      : override.segments,
+                  value: override.value,
+                };
+              }
+
+              return {
+                value: override.value,
+              };
+            });
+          }
+        }
+
+        variationV1.variables = Object.keys(variablesResult).map((variableKey) => {
+          const variable = variablesResult[variableKey];
+
+          return {
+            key: variable.key,
+            value: variable.value,
+            overrides: variable.overrides,
+          };
+        });
+
+        return variationV1;
+      });
+
+      featureV1.variations = variationsV1;
+
+      if (featureV1.force) {
+        featureV1.force = featureV1.force.map((force) => {
+          if (
+            force.conditions &&
+            typeof force.conditions === "string" &&
+            force.conditions !== "*"
+          ) {
+            force.conditions = JSON.parse(force.conditions);
+          }
+
+          if (force.segments && typeof force.segments === "string" && force.segments !== "*") {
+            force.segments = JSON.parse(force.segments);
+          }
+
+          return force;
+        });
+      }
+
+      datafileContent.features.push(featureV1);
+    }
+  }
+
+  return datafileContent;
+}

package/src/builder/getFeatureRanges.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 
-import { FeatureKey, Group, Range } from "@featurevisor/types";
+import type { FeatureKey, Group, Range } from "@featurevisor/types";
 
 import { ProjectConfig } from "../config";
 import { Datasource } from "../datasource";