@featurevisor/core 1.35.3 → 2.0.0

package/src/builder/hashes.ts

@@ -0,0 +1,109 @@
+import * as crypto from "crypto";
+
+import type {
+  FeatureKey,
+  Feature,
+  SegmentKey,
+  Segment,
+  DatafileContent,
+} from "@featurevisor/types";
+
+import { extractSegmentsFromFeature } from "../utils";
+
+const base62chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+function generateHashFromString(str: string, length = 10): string {
+  const hashBuffer = crypto.createHash("sha256").update(str).digest();
+
+  // Convert buffer to base62 (alphanumeric)
+  let num = BigInt("0x" + hashBuffer.toString("hex"));
+  let base62 = "";
+  while (num > 0) {
+    // Convert the remainder to a number for indexing
+    const remainder = Number(num % 62n);
+    base62 = base62chars[remainder] + base62;
+    num = num / 62n;
+  }
+
+  // Return first 10 chars for a short hash (adjust length as needed)
+  return base62.slice(0, length);
+}
+
+export function getSegmentHashes(
+  segments: Record<SegmentKey, Segment>,
+): Record<SegmentKey, string> {
+  const result: Record<SegmentKey, string> = {};
+
+  for (const segmentKey of Object.keys(segments)) {
+    const segment = segments[segmentKey];
+    result[segmentKey] = generateHashFromString(
+      JSON.stringify({
+        conditions: segment.conditions,
+      }),
+    );
+  }
+
+  return result;
+}
+
+export function generateHashForFeature(
+  featureKey: FeatureKey,
+  features: Record<FeatureKey, Feature>,
+  segmentHashes: Record<SegmentKey, string>,
+): string {
+  const feature = features[featureKey];
+
+  if (!feature) {
+    return "";
+  }
+
+  const requiredFeatureKeys: string[] = [];
+  if (feature.required) {
+    for (const r of feature.required) {
+      if (typeof r === "string") {
+        requiredFeatureKeys.push(r);
+      }
+
+      if (typeof r === "object" && r.key) {
+        requiredFeatureKeys.push(r.key);
+      }
+    }
+  }
+
+  const requiredFeatureHashes = requiredFeatureKeys.map((key) =>
+    generateHashForFeature(key, features, segmentHashes),
+  );
+
+  const usedSegments = extractSegmentsFromFeature(feature);
+  const usedSegmentHashes = Object.keys(usedSegments).map(
+    (segmentKey) => segmentHashes[segmentKey],
+  );
+
+  return generateHashFromString(
+    JSON.stringify({
+      featureKey,
+      feature,
+      requiredFeatureHashes,
+      usedSegmentHashes,
+    }),
+  );
+}
+
+export function generateHashForDatafile(datafileContent: DatafileContent): string {
+  const featureHashes = Object.keys(datafileContent.features).reduce(
+    (acc, featureKey) => {
+      acc[featureKey] = datafileContent.features[featureKey].hash || "";
+      return acc;
+    },
+    {} as Record<FeatureKey, string>,
+  );
+
+  const hash = generateHashFromString(
+    JSON.stringify({
+      schemaVersion: datafileContent.schemaVersion,
+      featureHashes,
+    }),
+  );
+
+  return hash;
+}

package/src/builder/traffic.ts

@@ -1,4 +1,11 @@
-import { Rule, ExistingFeature, Traffic, Variation, Range, Percentage } from "@featurevisor/types";
+import type {
+  Rule,
+  ExistingFeature,
+  Traffic,
+  Variation,
+  Range,
+  Percentage,
+} from "@featurevisor/types";
 import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
 
 import { getAllocation, getUpdatedAvailableRangesAfterFilling } from "./allocator";
@@ -71,7 +78,7 @@ export function getTraffic(
 ): Traffic[] {
   const result: Traffic[] = [];
 
-  // @TODO: may be pass from builder directly?
+  // @NOTE: may be pass from builder directly?
   const availableRanges =
     ranges && ranges.length > 0 ? ranges : ([[0, MAX_BUCKETED_NUMBER]] as Range[]);
 
@@ -83,6 +90,7 @@ export function getTraffic(
       segments: parsedRule.segments,
       percentage: rulePercentage * (MAX_BUCKETED_NUMBER / 100),
       allocation: [],
+      variationWeights: parsedRule.variationWeights,
     };
 
     // overrides
@@ -104,11 +112,15 @@ export function getTraffic(
       !existingTrafficRule || // new rule
       variationsChanged || // variations changed
       rulePercentageDiff < 0 || // percentage decreased
-      rangesChanged; // belongs to a group, and group ranges changed
+      rangesChanged || // belongs to a group, and group ranges changed
+      // @NOTE: this means, if variationWeights is present, it will always rebucket.
+      // worth checking if we can maintain consistent bucketing for this use case as well.
+      // but this use case is unlikely to hit in practice because it doesn't matter if the feature itself is 100% rolled out.
+      traffic.variationWeights; // variation weights overridden
 
     let updatedAvailableRanges = JSON.parse(JSON.stringify(availableRanges));
 
-    if (existingTrafficRule && !needsRebucketing) {
+    if (existingTrafficRule && existingTrafficRule.allocation && !needsRebucketing) {
       // increase: build on top of existing allocations
       let existingSum = 0;
 
@@ -128,7 +140,13 @@ export function getTraffic(
 
     if (Array.isArray(variations)) {
       variations.forEach(function (variation) {
-        const weight = variation.weight as number;
+        let weight = variation.weight as number;
+
+        if (traffic.variationWeights && traffic.variationWeights[variation.value]) {
+          // override weight from rule
+          weight = traffic.variationWeights[variation.value];
+        }
+
         const percentage = weight * (MAX_BUCKETED_NUMBER / 100);
 
         const toFillValue = needsRebucketing
@@ -137,10 +155,12 @@ export function getTraffic(
         const rangesToFill = getAllocation(updatedAvailableRanges, toFillValue);
 
         rangesToFill.forEach(function (range) {
-          traffic.allocation.push({
-            variation: variation.value,
-            range,
-          });
+          if (traffic.allocation) {
+            traffic.allocation.push({
+              variation: variation.value,
+              range,
+            });
+          }
         });
 
         updatedAvailableRanges = getUpdatedAvailableRangesAfterFilling(
@@ -150,15 +170,19 @@ export function getTraffic(
       });
     }
 
-    traffic.allocation = traffic.allocation.filter((a) => {
-      if (a.range && a.range[0] === a.range[1]) {
-        return false;
-      }
+    if (traffic.allocation) {
+      traffic.allocation = traffic.allocation.filter((a) => {
+        if (a.range && a.range[0] === a.range[1]) {
+          return false;
+        }
 
-      return true;
-    });
+        return true;
+      });
 
-    // @TODO: in v2, remove "allocation" property if an empty array
+      if (traffic.allocation.length === 0) {
+        delete traffic.allocation;
+      }
+    }
 
     result.push(traffic);
   });

package/src/cli/cli.ts

@@ -51,7 +51,7 @@ export async function runCLI(runnerOptions: RunnerOptions) {
     y = y.command({
       command: plugin.command,
       handler: async function (parsed: ParsedOptions) {
-        // @TODO: in future, allow yargs options to be defined via plugins
+        // @NOTE: in future, allow yargs options to be defined via plugins
         if (parsed.schemaVersion && typeof parsed.schemaVersion !== "string") {
           parsed.schemaVersion = parsed.schemaVersion.toString();
         }

package/src/cli/plugins.ts

@@ -3,7 +3,6 @@ import type { Plugin } from "./cli";
 import { initPlugin } from "../init";
 import { lintPlugin } from "../linter";
 import { buildPlugin } from "../builder";
-import { restorePlugin } from "../restore";
 import { testPlugin } from "../tester";
 import { generateCodePlugin } from "../generate-code";
 import { findDuplicateSegmentsPlugin } from "../find-duplicate-segments";
@@ -23,7 +22,6 @@ export const nonProjectPlugins: Plugin[] = [initPlugin];
 export const projectBasedPlugins: Plugin[] = [
   lintPlugin,
   buildPlugin,
-  restorePlugin,
   testPlugin,
   generateCodePlugin,
   findDuplicateSegmentsPlugin,

package/src/config/projectConfig.ts

@@ -1,6 +1,6 @@
 import * as path from "path";
 
-import { BucketBy } from "@featurevisor/types";
+import type { BucketBy } from "@featurevisor/types";
 
 import { Parser, parsers } from "./parsers";
 import { FilesystemAdapter } from "../datasource/filesystemAdapter";
@@ -12,7 +12,8 @@ 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";
+export const DATAFILES_DIRECTORY_NAME = "datafiles";
+export const DATAFILE_NAME_PATTERN = "featurevisor-%s.json";
 export const SITE_EXPORT_DIRECTORY_NAME = "out";
 
 export const CONFIG_MODULE_NAME = "featurevisor.config.js";
@@ -22,12 +23,12 @@ export const DEFAULT_ENVIRONMENTS = ["staging", "production"];
 export const DEFAULT_TAGS = ["all"];
 export const DEFAULT_BUCKET_BY_ATTRIBUTE = "userId";
 
-export const DEFAULT_PRETTY_STATE = false;
+export const DEFAULT_PRETTY_STATE = true;
 export const DEFAULT_PRETTY_DATAFILE = false;
 
 export const DEFAULT_PARSER: Parser = "yml";
 
-export const SCHEMA_VERSION = "1"; // default schema version
+export const SCHEMA_VERSION = "2"; // default schema version
 
 export interface ProjectConfig {
   featuresDirectoryPath: string;
@@ -36,13 +37,14 @@ export interface ProjectConfig {
   groupsDirectoryPath: string;
   testsDirectoryPath: string;
   stateDirectoryPath: string;
-  outputDirectoryPath: string;
+  datafilesDirectoryPath: string;
+  datafileNamePattern: string;
   siteExportDirectoryPath: string;
 
   environments: string[] | false;
   tags: string[];
 
-  adapter: any; // @TODO: type this properly later
+  adapter: any; // @NOTE: type this properly later
   plugins: Plugin[];
 
   defaultBucketBy: BucketBy;
@@ -80,7 +82,8 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     groupsDirectoryPath: path.join(rootDirectoryPath, GROUPS_DIRECTORY_NAME),
     testsDirectoryPath: path.join(rootDirectoryPath, TESTS_DIRECTORY_NAME),
     stateDirectoryPath: path.join(rootDirectoryPath, STATE_DIRECTORY_NAME),
-    outputDirectoryPath: path.join(rootDirectoryPath, OUTPUT_DIRECTORY_NAME),
+    datafilesDirectoryPath: path.join(rootDirectoryPath, DATAFILES_DIRECTORY_NAME),
+    datafileNamePattern: DATAFILE_NAME_PATTERN,
     siteExportDirectoryPath: path.join(rootDirectoryPath, SITE_EXPORT_DIRECTORY_NAME),
 
     enforceCatchAllRule: false,
@@ -121,7 +124,7 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
 }
 
 export interface ShowProjectConfigOptions {
-  print?: boolean;
+  json?: boolean;
   pretty?: boolean;
 }
 
@@ -129,7 +132,7 @@ export function showProjectConfig(
   projectConfig: ProjectConfig,
   options: ShowProjectConfigOptions = {},
 ) {
-  if (options.print) {
+  if (options.json) {
     console.log(
       options.pretty ? JSON.stringify(projectConfig, null, 2) : JSON.stringify(projectConfig),
     );
@@ -157,7 +160,7 @@ export const configPlugin: Plugin = {
   handler: async ({ rootDirectoryPath, parsed }) => {
     const projectConfig = getProjectConfig(rootDirectoryPath);
     showProjectConfig(projectConfig, {
-      print: parsed.print,
+      json: parsed.json,
       pretty: parsed.pretty,
     });
   },

package/src/datasource/adapter.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   DatafileContent,
   EnvironmentKey,
   ExistingState,

package/src/datasource/datasource.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ParsedFeature,
   Segment,
   Attribute,
@@ -27,7 +27,7 @@ export class Datasource {
     this.adapter = new config.adapter(config, rootDirectoryPath);
   }
 
-  // @TODO: only site generator needs it, find a way to get it out of here later
+  // @NOTE: only site generator needs it, find a way to get it out of here later
   getExtension() {
     return (this.config.parser as CustomParser).extension;
   }
@@ -145,6 +145,27 @@ export class Datasource {
     return this.adapter.listEntities("attribute");
   }
 
+  async listFlattenedAttributes() {
+    const attributes = await this.listAttributes();
+    const result: string[] = [];
+
+    for (const key of attributes) {
+      const attribute = await this.readAttribute(key);
+
+      result.push(key);
+
+      if (attribute.type === "object") {
+        // @NOTE: in future, this can be recursive
+        const propertyKeys = Object.keys(attribute.properties || {});
+        for (const propertyKey of propertyKeys) {
+          result.push(`${key}.${propertyKey}`);
+        }
+      }
+    }
+
+    return result;
+  }
+
   attributeExists(attributeKey: AttributeKey) {
     return this.adapter.entityExists("attribute", attributeKey);
   }

package/src/datasource/filesystemAdapter.ts

@@ -2,9 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { execSync, spawn } from "child_process";
 
-import * as mkdirp from "mkdirp";
-
-import {
+import type {
   ExistingState,
   EnvironmentKey,
   DatafileContent,
@@ -19,8 +17,6 @@ import { Adapter, DatafileOptions } from "./adapter";
 import { ProjectConfig, CustomParser } from "../config";
 import { getCommit } from "../utils/git";
 
-const commitRegex = /^commit (\w+)\nAuthor: (.+) <(.+)>\nDate:   (.+)\n\n(.+)/gm;
-
 export function getExistingStateFilePath(
   projectConfig: ProjectConfig,
   environment: EnvironmentKey | false,
@@ -129,7 +125,7 @@ export class FilesystemAdapter extends Adapter {
     const filePath = this.getEntityPath(entityType, entityKey);
 
     if (!fs.existsSync(this.getEntityDirectoryPath(entityType))) {
-      mkdirp.sync(this.getEntityDirectoryPath(entityType));
+      fs.mkdirSync(this.getEntityDirectoryPath(entityType), { recursive: true });
     }
 
     fs.writeFileSync(filePath, this.parser.stringify(entity));
@@ -166,7 +162,7 @@ export class FilesystemAdapter extends Adapter {
     const filePath = getExistingStateFilePath(this.config, environment);
 
     if (!fs.existsSync(this.config.stateDirectoryPath)) {
-      mkdirp.sync(this.config.stateDirectoryPath);
+      fs.mkdirSync(this.config.stateDirectoryPath, { recursive: true });
     }
     fs.writeFileSync(
       filePath,
@@ -198,6 +194,7 @@ export class FilesystemAdapter extends Adapter {
       }
 
       return "0";
+      // eslint-disable-next-line
     } catch (e) {
       return "0";
     }
@@ -207,7 +204,7 @@ export class FilesystemAdapter extends Adapter {
     const filePath = getRevisionFilePath(this.config);
 
     if (!fs.existsSync(this.config.stateDirectoryPath)) {
-      mkdirp.sync(this.config.stateDirectoryPath);
+      fs.mkdirSync(this.config.stateDirectoryPath, { recursive: true });
     }
 
     fs.writeFileSync(filePath, revision);
@@ -217,8 +214,10 @@ export class FilesystemAdapter extends Adapter {
    * Datafile
    */
   getDatafilePath(options: DatafileOptions): string {
-    const fileName = `datafile-tag-${options.tag}.json`;
-    const dir = options.datafilesDir || this.config.outputDirectoryPath;
+    const pattern = this.config.datafileNamePattern || "featurevisor-%s.json";
+
+    const fileName = pattern.replace("%s", `tag-${options.tag}`);
+    const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
 
     if (options.environment) {
       return path.join(dir, options.environment, fileName);
@@ -236,12 +235,12 @@ export class FilesystemAdapter extends Adapter {
   }
 
   async writeDatafile(datafileContent: DatafileContent, options: DatafileOptions): Promise<void> {
-    const dir = options.datafilesDir || this.config.outputDirectoryPath;
+    const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
 
     const outputEnvironmentDirPath = options.environment
       ? path.join(dir, options.environment)
       : dir;
-    mkdirp.sync(outputEnvironmentDirPath);
+    fs.mkdirSync(outputEnvironmentDirPath, { recursive: true });
 
     const outputFilePath = this.getDatafilePath(options);
 

package/src/evaluate/index.ts

@@ -1,4 +1,4 @@
-import { Context } from "@featurevisor/types";
+import type { Context, DatafileContent } from "@featurevisor/types";
 import {
   Evaluation,
   createInstance,
@@ -53,7 +53,7 @@ export interface EvaluateOptions {
   environment?: string;
   feature: string;
   context: Record<string, unknown>;
-  print?: boolean;
+  json?: boolean;
   pretty?: boolean;
   verbose?: boolean;
   schemaVersion?: string;
@@ -84,9 +84,9 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
 
   let logs: Log[] = [];
   const f = createInstance({
-    datafile: datafileContent,
+    datafile: datafileContent as DatafileContent,
     logger: createLogger({
-      levels: ["error", "warn", "info", "debug"],
+      level: "debug",
       handler: (level, message, details) => {
         logs.push({
           level,
@@ -134,7 +134,7 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
     variables: variableEvaluations,
   };
 
-  if (options.print) {
+  if (options.json) {
     console.log(
       options.pretty ? JSON.stringify(allEvaluations, null, 2) : JSON.stringify(allEvaluations),
     );
@@ -214,7 +214,8 @@ export const evaluatePlugin: Plugin = {
         environment: parsed.environment,
         feature: parsed.feature,
         context: parsed.context ? JSON.parse(parsed.context) : {},
-        print: parsed.print,
+        // @NOTE: introduce optional --at?
+        json: parsed.json,
         pretty: parsed.pretty,
         verbose: parsed.verbose,
       },

package/src/find-duplicate-segments/findDuplicateSegments.ts

@@ -1,6 +1,6 @@
 import * as crypto from "crypto";
 
-import { HistoryEntry, SegmentKey } from "@featurevisor/types";
+import type { HistoryEntry, SegmentKey } from "@featurevisor/types";
 
 import { Dependencies } from "../dependencies";