@featurevisor/core 0.0.3

package/lib/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAttributeKeysFromConditions = exports.extractSegmentKeysFromGroupSegments = exports.parseYaml = exports.getYAMLFiles = void 0;
+var fs = require("fs");
+var path = require("path");
+var yaml = require("js-yaml");
+function getYAMLFiles(directoryPath) {
+    var files = fs.readdirSync(directoryPath);
+    var yamlFiles = files.filter(function (file) { return file.endsWith(".yml"); });
+    return yamlFiles.map(function (file) { return path.join(directoryPath, file); });
+}
+exports.getYAMLFiles = getYAMLFiles;
+function parseYaml(content) {
+    var parsed = yaml.load(content);
+    return parsed;
+}
+exports.parseYaml = parseYaml;
+function extractSegmentKeysFromGroupSegments(segments) {
+    var result = new Set();
+    if (Array.isArray(segments)) {
+        segments.forEach(function (segment) {
+            extractSegmentKeysFromGroupSegments(segment).forEach(function (segmentKey) {
+                result.add(segmentKey);
+            });
+        });
+    }
+    if (typeof segments === "object") {
+        if ("and" in segments) {
+            extractSegmentKeysFromGroupSegments(segments.and).forEach(function (segmentKey) {
+                result.add(segmentKey);
+            });
+        }
+        if ("or" in segments) {
+            extractSegmentKeysFromGroupSegments(segments.or).forEach(function (segmentKey) {
+                result.add(segmentKey);
+            });
+        }
+    }
+    if (typeof segments === "string") {
+        result.add(segments);
+    }
+    return result;
+}
+exports.extractSegmentKeysFromGroupSegments = extractSegmentKeysFromGroupSegments;
+function extractAttributeKeysFromConditions(conditions) {
+    var result = new Set();
+    if (Array.isArray(conditions)) {
+        conditions.forEach(function (condition) {
+            extractAttributeKeysFromConditions(condition).forEach(function (attributeKey) {
+                result.add(attributeKey);
+            });
+        });
+    }
+    if ("attribute" in conditions) {
+        result.add(conditions.attribute);
+    }
+    if ("and" in conditions) {
+        extractAttributeKeysFromConditions(conditions.and).forEach(function (attributeKey) {
+            result.add(attributeKey);
+        });
+    }
+    if ("or" in conditions) {
+        extractAttributeKeysFromConditions(conditions.or).forEach(function (attributeKey) {
+            result.add(attributeKey);
+        });
+    }
+    return result;
+}
+exports.extractAttributeKeysFromConditions = extractAttributeKeysFromConditions;
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@featurevisor/core",
+  "version": "0.0.3",
+  "description": "Core package of Featurevisor for Node.js usage",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "lint": "echo 'not linting in this package yet'",
+    "transpile": "rimraf lib && tsc --project tsconfig.cjs.json",
+    "dist": "echo 'Nothing to dist here'",
+    "build": "npm run transpile",
+    "test": "jest --config ../../jest.config.js --verbose"
+  },
+  "author": {
+    "name": "Fahad Heylaal",
+    "url": "https://fahad19.com"
+  },
+  "homepage": "https://featurevisor.com",
+  "keywords": [
+    "featurevisor",
+    "feature",
+    "features",
+    "flags",
+    "feature flags",
+    "feature toggles",
+    "feature management",
+    "experimentation",
+    "experiment",
+    "experiments"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fahad19/featurevisor.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bugs": {
+    "url": "https://github.com/fahad19/featurevisor/issues"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@featurevisor/sdk": "^0.0.3",
+    "@featurevisor/types": "^0.0.3",
+    "axios": "^1.3.4",
+    "joi": "^17.8.3",
+    "js-yaml": "^4.1.0",
+    "mkdirp": "^2.1.3",
+    "tar": "^6.1.13"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.5",
+    "@types/tar": "^6.1.4"
+  },
+  "gitHead": "303aca84f7c32163cb1079513d799296bd892e72"
+}

package/src/builder.ts

@@ -0,0 +1,359 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import * as mkdirp from "mkdirp";
+
+import {
+  Segment,
+  Feature,
+  DatafileContent,
+  Variation,
+  Variable,
+  VariableOverride,
+  Traffic,
+  SegmentKey,
+  AttributeKey,
+  Attribute,
+  GroupSegment,
+  Condition,
+  ExistingFeatures,
+  ExistingFeature,
+  ExistingState,
+  ParsedFeature,
+  FeatureKey,
+  Allocation,
+  EnvironmentKey,
+} from "@featurevisor/types";
+import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
+
+import { ProjectConfig, SCHEMA_VERSION } from "./config";
+import { getNewTraffic } from "./traffic";
+import {
+  parseYaml,
+  extractAttributeKeysFromConditions,
+  extractSegmentKeysFromGroupSegments,
+} from "./utils";
+
+export interface BuildOptions {
+  schemaVersion: string;
+  revision: string;
+  environment: string;
+  tag: string;
+}
+
+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,
+  tag: string,
+): string {
+  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}-${tag}.json`);
+}
+
+export function buildDatafile(
+  projectConfig: ProjectConfig,
+  options: BuildOptions,
+): DatafileContent {
+  const datafileContent: DatafileContent = {
+    schemaVersion: options.schemaVersion,
+    revision: options.revision,
+    attributes: [],
+    segments: [],
+    features: [],
+  };
+
+  const segmentKeysUsedByTag = new Set<SegmentKey>();
+  const attributeKeysUsedByTag = new Set<AttributeKey>();
+
+  // features
+  const features: Feature[] = [];
+  const featuresDirectory = projectConfig.featuresDirectoryPath;
+
+  let existingState = {} as ExistingState;
+  let existingFeatures = {} as ExistingFeatures;
+
+  const existingStateFilePath = getExistingStateFilePath(
+    projectConfig,
+    options.environment,
+    options.tag,
+  );
+
+  if (fs.existsSync(existingStateFilePath)) {
+    existingState = JSON.parse(fs.readFileSync(existingStateFilePath, "utf8")) as ExistingState;
+
+    if (existingState && existingState.features) {
+      existingFeatures = existingState.features;
+    }
+  }
+
+  if (fs.existsSync(featuresDirectory)) {
+    const featureFiles = fs.readdirSync(featuresDirectory).filter((f) => f.endsWith(".yml"));
+
+    for (const featureFile of featureFiles) {
+      const featureKey = path.basename(featureFile, ".yml") as FeatureKey;
+      const featureFilePath = path.join(featuresDirectory, featureFile);
+      const parsedFeature = parseYaml(fs.readFileSync(featureFilePath, "utf8")) as ParsedFeature;
+
+      if (parsedFeature.archived === true) {
+        continue;
+      }
+
+      if (parsedFeature.tags.indexOf(options.tag) === -1) {
+        continue;
+      }
+
+      if (parsedFeature.environments[options.environment].expose === false) {
+        continue;
+      }
+
+      const featureTraffic: Traffic[] = [];
+
+      for (const parsedRule of parsedFeature.environments[options.environment].rules) {
+        const extractedSegmentKeys = extractSegmentKeysFromGroupSegments(parsedRule.segments);
+        extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
+
+        featureTraffic.push({
+          key: parsedRule.key,
+          segments:
+            typeof parsedRule.segments === "string"
+              ? parsedRule.segments
+              : JSON.stringify(parsedRule.segments),
+          percentage: parsedRule.percentage * (MAX_BUCKETED_NUMBER / 100),
+          allocation: [],
+        });
+      }
+
+      const feature: Feature = {
+        key: featureKey,
+        defaultVariation: parsedFeature.defaultVariation,
+        bucketBy: parsedFeature.bucketBy || projectConfig.defaultBucketBy,
+        variations: parsedFeature.variations.map((variation: Variation) => {
+          const mappedVariation: any = {
+            type: variation.type,
+            value: variation.value,
+          };
+
+          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;
+            }
+
+            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;
+        }),
+        traffic: getNewTraffic(
+          parsedFeature.variations,
+          parsedFeature.environments[options.environment].rules,
+          existingFeatures && existingFeatures[featureKey],
+        ),
+      };
+
+      if (parsedFeature.variablesSchema) {
+        feature.variablesSchema = parsedFeature.variablesSchema;
+      }
+
+      if (parsedFeature.environments[options.environment].force) {
+        feature.force = parsedFeature.environments[options.environment].force;
+      }
+
+      features.push(feature);
+    }
+  }
+
+  // segments
+  const segments: Segment[] = [];
+  const segmentsDirectory = projectConfig.segmentsDirectoryPath;
+
+  if (fs.existsSync(segmentsDirectory)) {
+    const segmentFiles = fs.readdirSync(segmentsDirectory).filter((f) => f.endsWith(".yml"));
+
+    for (const segmentFile of segmentFiles) {
+      const segmentKey = path.basename(segmentFile, ".yml");
+      const segmentFilePath = path.join(segmentsDirectory, segmentFile);
+      const parsedSegment = parseYaml(fs.readFileSync(segmentFilePath, "utf8")) as Segment;
+
+      if (parsedSegment.archived === true) {
+        continue;
+      }
+
+      if (segmentKeysUsedByTag.has(segmentKey) === false) {
+        continue;
+      }
+
+      const extractedAttributeKeys = extractAttributeKeysFromConditions(
+        parsedSegment.conditions as Condition | Condition[],
+      );
+      extractedAttributeKeys.forEach((attributeKey) => attributeKeysUsedByTag.add(attributeKey));
+
+      const segment: Segment = {
+        key: segmentKey,
+        conditions:
+          typeof parsedSegment.conditions !== "string"
+            ? JSON.stringify(parsedSegment.conditions)
+            : parsedSegment.conditions,
+      };
+
+      segments.push(segment);
+    }
+  }
+
+  // attributes
+  const attributes: Attribute[] = [];
+  const attributesDirectory = projectConfig.attributesDirectoryPath;
+
+  if (fs.existsSync(attributesDirectory)) {
+    const attributeFiles = fs.readdirSync(attributesDirectory).filter((f) => f.endsWith(".yml"));
+
+    for (const attributeFile of attributeFiles) {
+      const attributeKey = path.basename(attributeFile, ".yml");
+      const attributeFilePath = path.join(attributesDirectory, attributeFile);
+      const parsedAttribute = parseYaml(fs.readFileSync(attributeFilePath, "utf8")) as Attribute;
+
+      if (parsedAttribute.archived === true) {
+        continue;
+      }
+
+      if (attributeKeysUsedByTag.has(attributeKey) === false && !parsedAttribute.capture) {
+        continue;
+      }
+
+      const attribute: Attribute = {
+        key: attributeKey,
+        type: parsedAttribute.type,
+      };
+
+      if (parsedAttribute.capture === true) {
+        attribute.capture = true;
+      }
+
+      attributes.push(attribute);
+    }
+  }
+
+  datafileContent.attributes = attributes;
+  datafileContent.segments = segments;
+  datafileContent.features = features;
+
+  // write
+  const outputEnvironmentDirPath = path.join(
+    projectConfig.outputDirectoryPath,
+    options.environment,
+  );
+  mkdirp.sync(outputEnvironmentDirPath);
+
+  const outputFilePath = getDatafilePath(projectConfig, options.environment, options.tag);
+  fs.writeFileSync(outputFilePath, JSON.stringify(datafileContent));
+
+  // write to state directory
+  if (!fs.existsSync(projectConfig.stateDirectoryPath)) {
+    mkdirp.sync(projectConfig.stateDirectoryPath);
+  }
+
+  const updatedExistingFeatures = datafileContent.features.reduce((acc, feature) => {
+    const item: ExistingFeature = {
+      variations: feature.variations.map((v: Variation) => {
+        return {
+          value: v.value,
+          weight: v.weight || 0,
+        };
+      }),
+      traffic: feature.traffic.map((t: Traffic) => {
+        return {
+          key: t.key,
+          percentage: t.percentage,
+          allocation: t.allocation.map((a: Allocation) => {
+            return {
+              variation: a.variation,
+              percentage: a.percentage,
+            };
+          }),
+        };
+      }),
+    };
+
+    acc[feature.key] = item;
+
+    return acc;
+  }, existingFeatures);
+
+  const updatedState: ExistingState = {
+    features: updatedExistingFeatures,
+  };
+
+  fs.writeFileSync(existingStateFilePath, JSON.stringify(updatedState));
+
+  console.log(`     File generated: ${outputFilePath}`);
+
+  return datafileContent;
+}
+
+export function buildProject(rootDirectoryPath, projectConfig: ProjectConfig) {
+  const tags = projectConfig.tags;
+  const environments = projectConfig.environments;
+
+  const pkg = require(path.join(rootDirectoryPath, "package.json"));
+
+  for (const environment of environments) {
+    console.log(`\nBuilding datafiles for environment: ${environment}`);
+
+    for (const tag of tags) {
+      console.log(`  => Tag: ${tag}`);
+      buildDatafile(projectConfig, {
+        schemaVersion: SCHEMA_VERSION,
+        revision: pkg.version,
+        environment: environment,
+        tag: tag,
+      });
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,62 @@
+import * as path from "path";
+
+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 TESTS_DIRECTORY_NAME = "tests";
+export const STATE_DIRECTORY_NAME = ".featurevisor";
+export const OUTPUT_DIRECTORY_NAME = "dist";
+
+export const CONFIG_MODULE_NAME = "featurevisor.config.js";
+export const ROOT_DIR_PLACECOLDER = "<rootDir>";
+
+export const DEFAULT_ENVIRONMENTS = ["staging", "production"];
+export const DEFAULT_TAGS = ["all"];
+export const DEFAULT_BUCKET_BY_ATTRIBUTE = "userId";
+
+export const SCHEMA_VERSION = "1";
+
+export interface ProjectConfig {
+  featuresDirectoryPath: string;
+  segmentsDirectoryPath: string;
+  attributesDirectoryPath: string;
+  testsDirectoryPath: string;
+  stateDirectoryPath: string;
+  outputDirectoryPath: string;
+  environments: string[];
+  tags: string[];
+  defaultBucketBy: BucketBy;
+}
+
+// rootDirectoryPath: path to the root directory of the project (without ending with a slash)
+export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
+  const baseConfig = {
+    featuresDirectoryPath: path.join(rootDirectoryPath, FEATURES_DIRECTORY_NAME),
+    segmentsDirectoryPath: path.join(rootDirectoryPath, SEGMENTS_DIRECTORY_NAME),
+    attributesDirectoryPath: path.join(rootDirectoryPath, ATTRIBUTES_DIRECTORY_NAME),
+    testsDirectoryPath: path.join(rootDirectoryPath, TESTS_DIRECTORY_NAME),
+
+    stateDirectoryPath: path.join(rootDirectoryPath, STATE_DIRECTORY_NAME),
+    outputDirectoryPath: path.join(rootDirectoryPath, OUTPUT_DIRECTORY_NAME),
+
+    environments: DEFAULT_ENVIRONMENTS,
+    tags: DEFAULT_TAGS,
+  };
+
+  const configModulePath = path.join(rootDirectoryPath, CONFIG_MODULE_NAME);
+  const customConfig = require(configModulePath);
+
+  const finalConfig = {};
+
+  Object.keys(baseConfig).forEach((key) => {
+    finalConfig[key] = customConfig[key] || baseConfig[key];
+
+    if (key.endsWith("Path") && finalConfig[key].indexOf(ROOT_DIR_PLACECOLDER) !== -1) {
+      finalConfig[key] = finalConfig[key].replace(ROOT_DIR_PLACECOLDER, rootDirectoryPath);
+    }
+  });
+
+  return finalConfig as ProjectConfig;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./config";
+export * from "./linter";
+export * from "./builder";
+export * from "./tester";
+export * from "./init";

package/src/init.ts

@@ -0,0 +1,44 @@
+import axios from "axios";
+import * as tar from "tar";
+
+export const DEFAULT_EXAMPLE = "example-1";
+
+export const EXAMPLES_ORG_NAME = "fahad19";
+export const EXAMPLES_REPO_NAME = "featurevisor";
+export const EXAMPLES_BRANCH_NAME = "main";
+
+export const EXAMPLES_TAR_URL = `https://codeload.github.com/${EXAMPLES_ORG_NAME}/${EXAMPLES_REPO_NAME}/tar.gz/${EXAMPLES_BRANCH_NAME}`;
+
+function getExamplePath(exampleName: string) {
+  return `${EXAMPLES_REPO_NAME}-${EXAMPLES_BRANCH_NAME}/examples/${exampleName}/`;
+}
+
+export function initProject(
+  directoryPath: string,
+  exampleName: string = DEFAULT_EXAMPLE,
+): Promise<boolean> {
+  return new Promise(function (resolve, reject) {
+    axios.get(EXAMPLES_TAR_URL, { responseType: "stream" }).then((response) => {
+      response.data
+        .pipe(
+          tar.x({
+            C: directoryPath,
+            filter: (path) => path.indexOf(getExamplePath(exampleName)) === 0,
+            strip: 3,
+          }),
+        )
+        .on("error", (e) => {
+          console.error(e);
+
+          resolve(false);
+        })
+        .on("finish", () => {
+          console.log(`Project scaffolded in ${directoryPath}`);
+          console.log(``);
+          console.log(`Please run "npm ci" in the directory above.`);
+
+          resolve(true);
+        });
+    });
+  });
+}