@featurevisor/core 0.51.0 → 0.51.2

package/src/builder/buildProject.ts

@@ -0,0 +1,95 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import * as mkdirp from "mkdirp";
+
+import { ExistingState, EnvironmentKey } from "@featurevisor/types";
+
+import { SCHEMA_VERSION, ProjectConfig } from "../config";
+import { Datasource } from "../datasource";
+
+import { buildDatafile } from "./buildDatafile";
+
+export function getDatafilePath(
+  projectConfig: ProjectConfig,
+  environment: EnvironmentKey,
+  tag: string,
+): string {
+  const fileName = `datafile-tag-${tag}.json`;
+
+  return path.join(projectConfig.outputDirectoryPath, environment, fileName);
+}
+
+export function getExistingStateFilePath(
+  projectConfig: ProjectConfig,
+  environment: EnvironmentKey,
+): string {
+  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
+}
+
+export interface BuildCLIOptions {
+  revision?: string;
+}
+
+export function buildProject(
+  rootDirectoryPath,
+  projectConfig: ProjectConfig,
+  cliOptions: BuildCLIOptions = {},
+) {
+  const tags = projectConfig.tags;
+  const environments = projectConfig.environments;
+
+  const pkg = require(path.join(rootDirectoryPath, "package.json"));
+  const datasource = new Datasource(projectConfig);
+
+  for (const environment of environments) {
+    console.log(`\nBuilding datafiles for environment: ${environment}`);
+
+    const existingStateFilePath = getExistingStateFilePath(projectConfig, environment);
+    const existingState: ExistingState = fs.existsSync(existingStateFilePath)
+      ? require(existingStateFilePath)
+      : {
+          features: {},
+        };
+
+    for (const tag of tags) {
+      console.log(`\n  => Tag: ${tag}`);
+      const datafileContent = buildDatafile(
+        projectConfig,
+        datasource,
+        {
+          schemaVersion: SCHEMA_VERSION,
+          revision: cliOptions.revision || pkg.version,
+          environment: environment,
+          tag: tag,
+        },
+        existingState,
+      );
+
+      // write datafile for environment/tag
+      const outputEnvironmentDirPath = path.join(projectConfig.outputDirectoryPath, environment);
+      mkdirp.sync(outputEnvironmentDirPath);
+
+      const outputFilePath = getDatafilePath(projectConfig, environment, tag);
+      fs.writeFileSync(
+        outputFilePath,
+        projectConfig.prettyDatafile
+          ? JSON.stringify(datafileContent, null, 2)
+          : JSON.stringify(datafileContent),
+      );
+      const shortPath = outputFilePath.replace(rootDirectoryPath + path.sep, "");
+      console.log(`     Datafile generated: ${shortPath}`);
+    }
+
+    // write state for environment
+    if (!fs.existsSync(projectConfig.stateDirectoryPath)) {
+      mkdirp.sync(projectConfig.stateDirectoryPath);
+    }
+    fs.writeFileSync(
+      existingStateFilePath,
+      projectConfig.prettyState
+        ? JSON.stringify(existingState, null, 2)
+        : JSON.stringify(existingState),
+    );
+  }
+}

package/src/builder/getFeatureRanges.ts

@@ -0,0 +1,61 @@
+import * as fs from "fs";
+
+import { FeatureKey, Group, Range } from "@featurevisor/types";
+
+import { ProjectConfig } from "../config";
+import { Datasource } from "../datasource";
+
+export type FeatureRanges = Map<FeatureKey, Range[]>;
+
+export interface FeatureRangesResult {
+  featureRanges: FeatureRanges;
+  featureIsInGroup: { [key: string]: boolean };
+}
+
+export function getFeatureRanges(
+  projectConfig: ProjectConfig,
+  datasource: Datasource,
+): FeatureRangesResult {
+  const featureRanges = new Map<FeatureKey, Range[]>();
+  const featureIsInGroup = {}; // featureKey => boolean
+
+  const groups: Group[] = [];
+  if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
+    const groupFiles = datasource.listGroups();
+
+    for (const groupKey of groupFiles) {
+      const parsedGroup = datasource.readGroup(groupKey);
+
+      groups.push({
+        ...parsedGroup,
+        key: groupKey,
+      });
+
+      let accumulatedPercentage = 0;
+      parsedGroup.slots.forEach(function (slot, slotIndex) {
+        const isFirstSlot = slotIndex === 0;
+
+        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;
+          const end = accumulatedPercentage + slot.percentage * 1000;
+
+          featureRangesForFeature.push([start, end]);
+
+          featureRanges.set(slot.feature, featureRangesForFeature);
+        }
+
+        accumulatedPercentage += slot.percentage * 1000;
+      });
+    }
+  }
+
+  return { featureRanges, featureIsInGroup };
+}

package/src/builder/index.ts

@@ -0,0 +1,2 @@
+export * from "./buildDatafile";
+export * from "./buildProject";

package/src/datasource/index.ts

@@ -0,0 +1,2 @@
+export * from "./datasource";
+export * from "./parsers";

package/src/generate-code/index.ts

@@ -4,7 +4,7 @@ import * as path from "path";
 import * as mkdirp from "mkdirp";
 
 import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource/datasource";
+import { Datasource } from "../datasource";
 import { generateTypeScriptCodeForProject } from "./typescript";
 
 export const ALLOWED_LANGUAGES_FOR_CODE_GENERATION = ["typescript"];

package/src/generate-code/typescript.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 
 import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource/datasource";
+import { Datasource } from "../datasource";
 
 function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
   switch (featurevisorType) {

package/src/linter/attributeSchema.ts

@@ -0,0 +1,12 @@
+import * as Joi from "joi";
+
+export function getAttributeJoiSchema() {
+  const attributeJoiSchema = Joi.object({
+    archived: Joi.boolean(),
+    type: Joi.string().allow("boolean", "string", "integer", "double", "date").required(),
+    description: Joi.string().required(),
+    capture: Joi.boolean(),
+  });
+
+  return attributeJoiSchema;
+}

package/src/linter/checkCircularDependency.ts

@@ -0,0 +1,45 @@
+import { FeatureKey, Required } from "@featurevisor/types";
+
+import { Datasource } from "../datasource";
+
+export function checkForCircularDependencyInRequired(
+  datasource: Datasource,
+  featureKey: FeatureKey,
+  required?: Required[],
+  chain: FeatureKey[] = [],
+) {
+  if (!required) {
+    return;
+  }
+
+  const requiredKeys = required.map((r) => (typeof r === "string" ? r : r.key));
+
+  if (requiredKeys.length === 0) {
+    return;
+  }
+
+  for (const requiredKey of requiredKeys) {
+    chain.push(requiredKey);
+
+    if (chain.indexOf(featureKey) > -1) {
+      throw new Error(`circular dependency found: ${chain.join(" -> ")}`);
+    }
+
+    const requiredFeatureExists = datasource.entityExists("feature", requiredKey);
+
+    if (!requiredFeatureExists) {
+      throw new Error(`required feature "${requiredKey}" not found`);
+    }
+
+    const requiredParsedFeature = datasource.readFeature(requiredKey);
+
+    if (requiredParsedFeature.required) {
+      checkForCircularDependencyInRequired(
+        datasource,
+        featureKey,
+        requiredParsedFeature.required,
+        chain,
+      );
+    }
+  }
+}

package/src/linter/conditionSchema.ts

@@ -0,0 +1,85 @@
+import * as Joi from "joi";
+
+import { ProjectConfig } from "../config";
+
+export function getConditionsJoiSchema(
+  projectConfig: ProjectConfig,
+  availableAttributeKeys: string[],
+) {
+  const plainConditionJoiSchema = Joi.object({
+    attribute: Joi.string()
+      .valid(...availableAttributeKeys)
+      .required(),
+    operator: Joi.string()
+      .valid(
+        "equals",
+        "notEquals",
+
+        // numeric
+        "greaterThan",
+        "greaterThanOrEquals",
+        "lessThan",
+        "lessThanOrEquals",
+
+        // string
+        "contains",
+        "notContains",
+        "startsWith",
+        "endsWith",
+
+        // semver (string)
+        "semverEquals",
+        "semverNotEquals",
+        "semverGreaterThan",
+        "semverGreaterThanOrEquals",
+        "semverLessThan",
+        "semverLessThanOrEquals",
+
+        // date comparisons
+        "before",
+        "after",
+
+        // array of strings
+        "in",
+        "notIn",
+      )
+      .required(),
+    value: Joi.alternatives()
+      .try(
+        // @TODO: make them more specific
+        Joi.string(),
+        Joi.number(),
+        Joi.boolean(),
+        Joi.date(),
+        Joi.array().items(Joi.string()),
+      )
+      .required(),
+  });
+
+  const andOrNotConditionJoiSchema = Joi.alternatives()
+    .try(
+      Joi.object({
+        and: Joi.array().items(Joi.link("#andOrNotCondition"), plainConditionJoiSchema),
+      }),
+      Joi.object({
+        or: Joi.array().items(Joi.link("#andOrNotCondition"), plainConditionJoiSchema),
+      }),
+      Joi.object({
+        // @TODO: allow plainConditionJoiSchema as well?
+        not: Joi.array().items(Joi.link("#andOrNotCondition"), plainConditionJoiSchema),
+      }),
+    )
+    .id("andOrNotCondition");
+
+  const conditionJoiSchema = Joi.alternatives().try(
+    andOrNotConditionJoiSchema,
+    plainConditionJoiSchema,
+  );
+
+  const conditionsJoiSchema = Joi.alternatives().try(
+    conditionJoiSchema,
+    Joi.array().items(conditionJoiSchema),
+  );
+
+  return conditionsJoiSchema;
+}

package/src/linter/featureSchema.ts

@@ -0,0 +1,205 @@
+import * as Joi from "joi";
+
+import { ProjectConfig } from "../config";
+
+const tagRegex = /^[a-z0-9-]+$/;
+
+export function getFeatureJoiSchema(
+  projectConfig: ProjectConfig,
+  conditionsJoiSchema,
+  availableSegmentKeys: string[],
+  availableFeatureKeys: string[],
+) {
+  const variationValueJoiSchema = Joi.string().required();
+  const variableValueJoiSchema = Joi.alternatives()
+    .try(
+      // @TODO: make it stricter based on variableSchema.type
+      Joi.string(),
+      Joi.number(),
+      Joi.boolean(),
+      Joi.array().items(Joi.string()),
+      Joi.object().custom(function (value) {
+        let isFlat = true;
+
+        Object.keys(value).forEach((key) => {
+          if (typeof value[key] === "object") {
+            isFlat = false;
+          }
+        });
+
+        if (!isFlat) {
+          throw new Error("object is not flat");
+        }
+
+        return value;
+      }),
+    )
+    .allow("");
+
+  const plainGroupSegment = Joi.string().valid("*", ...availableSegmentKeys);
+
+  const andOrNotGroupSegment = Joi.alternatives()
+    .try(
+      Joi.object({
+        and: Joi.array().items(Joi.link("#andOrNotGroupSegment"), plainGroupSegment),
+      }),
+      Joi.object({
+        or: Joi.array().items(Joi.link("#andOrNotGroupSegment"), plainGroupSegment),
+      }),
+      Joi.object({
+        // @TODO: allow plainGroupSegment as well?
+        not: Joi.array().items(Joi.link("#andOrNotGroupSegment"), plainGroupSegment),
+      }),
+    )
+    .id("andOrNotGroupSegment");
+
+  const groupSegment = Joi.alternatives().try(andOrNotGroupSegment, plainGroupSegment);
+
+  const groupSegmentsJoiSchema = Joi.alternatives().try(
+    Joi.array().items(groupSegment),
+    groupSegment,
+  );
+
+  const environmentJoiSchema = Joi.object({
+    expose: Joi.boolean(),
+    rules: Joi.array()
+      .items(
+        Joi.object({
+          key: Joi.string(),
+          segments: groupSegmentsJoiSchema,
+          percentage: Joi.number().precision(3).min(0).max(100),
+
+          enabled: Joi.boolean().optional(),
+          variation: variationValueJoiSchema.optional(), // @TODO: only allowed if feature.variations is present
+          variables: Joi.object().optional(), // @TODO: make it stricter
+        }),
+      )
+      .unique("key")
+      .required(),
+    force: Joi.array().items(
+      Joi.object({
+        // @TODO: either of the two below
+        segments: groupSegmentsJoiSchema.optional(),
+        conditions: conditionsJoiSchema.optional(),
+
+        enabled: Joi.boolean().optional(),
+        variation: variationValueJoiSchema.optional(),
+        variables: Joi.object().optional(), // @TODO: make it stricter
+      }),
+    ),
+  });
+
+  const allEnvironmentsSchema = {};
+  projectConfig.environments.forEach((environmentKey) => {
+    allEnvironmentsSchema[environmentKey] = environmentJoiSchema.required();
+  });
+  const allEnvironmentsJoiSchema = Joi.object(allEnvironmentsSchema);
+
+  const featureJoiSchema = Joi.object({
+    archived: Joi.boolean().optional(),
+    deprecated: Joi.boolean().optional(),
+    description: Joi.string().required(),
+    tags: Joi.array()
+      .items(
+        Joi.string().custom((value) => {
+          if (!tagRegex.test(value)) {
+            throw new Error("tag must be lower cased and alphanumeric, and may contain hyphens.");
+          }
+
+          return value;
+        }),
+      )
+      .required(),
+
+    required: Joi.array()
+      .items(
+        Joi.alternatives().try(
+          Joi.string()
+            .required()
+            .valid(...availableFeatureKeys),
+          Joi.object({
+            key: Joi.string()
+              .required()
+              .valid(...availableFeatureKeys),
+            variation: Joi.string().optional(), // @TODO: can be made stricter
+          }),
+        ),
+      )
+      .optional(),
+
+    bucketBy: Joi.alternatives()
+      .try(
+        // plain
+        Joi.string(),
+
+        // and
+        Joi.array().items(Joi.string()),
+
+        // or
+        Joi.object({
+          or: Joi.array().items(Joi.string()),
+        }),
+      )
+      .required(),
+
+    variablesSchema: Joi.array()
+      .items(
+        Joi.object({
+          key: Joi.string().disallow("variation"),
+          type: Joi.string().valid(
+            "string",
+            "integer",
+            "boolean",
+            "double",
+            "array",
+            "object",
+            "json",
+          ),
+          description: Joi.string().optional(),
+          defaultValue: variableValueJoiSchema, // @TODO: make it stricter based on `type`
+        }),
+      )
+      .unique("key"),
+
+    variations: Joi.array()
+      .items(
+        Joi.object({
+          description: Joi.string(),
+          value: variationValueJoiSchema.required(),
+          weight: Joi.number().precision(3).min(0).max(100).required(),
+          variables: Joi.array()
+            .items(
+              Joi.object({
+                key: Joi.string(),
+                value: variableValueJoiSchema,
+                overrides: Joi.array().items(
+                  Joi.object({
+                    // @TODO: either segments or conditions prsent at a time
+                    segments: groupSegmentsJoiSchema,
+                    conditions: conditionsJoiSchema,
+
+                    // @TODO: make it stricter based on `type`
+                    value: variableValueJoiSchema,
+                  }),
+                ),
+              }),
+            )
+            .unique("key"),
+        }),
+      )
+      .custom((value) => {
+        const 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}`);
+        }
+
+        return value;
+      })
+      .optional(),
+
+    environments: allEnvironmentsJoiSchema.required(),
+  });
+
+  return featureJoiSchema;
+}

package/src/linter/groupSchema.ts

@@ -0,0 +1,63 @@
+import * as Joi from "joi";
+
+import { ProjectConfig } from "../config";
+import { Datasource } from "../datasource";
+
+export function getGroupJoiSchema(
+  projectConfig: ProjectConfig,
+  datasource: Datasource,
+  availableFeatureKeys: string[],
+) {
+  const groupJoiSchema = Joi.object({
+    description: Joi.string().required(),
+    slots: Joi.array()
+      .items(
+        Joi.object({
+          feature: Joi.string().valid(...availableFeatureKeys),
+          percentage: Joi.number().precision(3).min(0).max(100),
+        }),
+      )
+      .custom(function (value) {
+        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 featureExists = datasource.entityExists("feature", featureKey);
+
+            if (!featureExists) {
+              throw new Error(`feature ${featureKey} not found`);
+            }
+
+            const parsedFeature = datasource.readFeature(featureKey);
+
+            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;
+}

package/src/linter/index.ts

@@ -0,0 +1 @@
+export * from "./lintProject";