@featurevisor/core 2.26.1 → 3.0.1

package/src/builder/{buildScopedSegments.ts → applyContextToSegments.ts}

@@ -5,16 +5,22 @@ import type {
   NotGroupSegment,
   Context,
 } from "@featurevisor/types";
-import type { DatafileReader } from "@featurevisor/sdk";
+import { allSegmentsAreMatched } from "@featurevisor/sdk";
+import type { Featurevisor } from "@featurevisor/sdk";
 
-export function buildScopedSegments(
-  datafileReader: DatafileReader,
+export function applyContextToSegments(
+  featurevisor: Featurevisor,
   segments: GroupSegment | GroupSegment[],
   context: Context,
   removeSegments: string[] = [],
 ): GroupSegment | GroupSegment[] {
-  const scoped = buildScopedGroupSegments(datafileReader, segments, context, removeSegments);
-  const removed = removeRedundantGroupSegments(scoped);
+  const withContextApplied = applyContextToGroupSegments(
+    featurevisor,
+    segments,
+    context,
+    removeSegments,
+  );
+  const removed = removeRedundantGroupSegments(withContextApplied);
 
   return removed;
 }
@@ -80,9 +86,13 @@ export function removeRedundantGroupSegments(
       ) as GroupSegment[];
       const filtered = processed.filter((gs) => gs !== "*");
 
-      // If all were "*", return "*"
+      // `not` negates the implicit AND of its children. Matched children are true
+      // and can be removed: not(true && X) becomes not(X). If every child was
+      // true, keep not("*") so it remains an always-false expression.
       if (filtered.length === 0) {
-        return "*";
+        return {
+          not: ["*"],
+        } as NotGroupSegment;
       }
 
       return {
@@ -94,8 +104,8 @@ export function removeRedundantGroupSegments(
   return groupSegments;
 }
 
-export function buildScopedGroupSegments(
-  datafileReader: DatafileReader,
+export function applyContextToGroupSegments(
+  featurevisor: Featurevisor,
   groupSegments: GroupSegment | GroupSegment[],
   context: Context,
   removeSegments: string[] = [],
@@ -106,7 +116,7 @@ export function buildScopedGroupSegments(
 
   if (Array.isArray(groupSegments)) {
     return groupSegments.map((gs) =>
-      buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+      applyContextToGroupSegments(featurevisor, gs, context, removeSegments),
     ) as GroupSegment[];
   }
 
@@ -115,7 +125,9 @@ export function buildScopedGroupSegments(
       return "*";
     }
 
-    const matched = datafileReader.allSegmentsAreMatched(groupSegments, context);
+    const matched = allSegmentsAreMatched(groupSegments, context, (segmentKey) =>
+      featurevisor.getSegment(segmentKey),
+    );
 
     if (matched) {
       return "*";
@@ -127,7 +139,7 @@ export function buildScopedGroupSegments(
     if ("and" in groupSegments) {
       return {
         and: groupSegments.and.map((gs) =>
-          buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+          applyContextToGroupSegments(featurevisor, gs, context, removeSegments),
         ) as GroupSegment[],
       } as AndGroupSegment;
     }
@@ -135,7 +147,7 @@ export function buildScopedGroupSegments(
     if ("or" in groupSegments) {
       return {
         or: groupSegments.or.map((gs) =>
-          buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+          applyContextToGroupSegments(featurevisor, gs, context, removeSegments),
         ) as GroupSegment[],
       } as OrGroupSegment;
     }
@@ -143,7 +155,7 @@ export function buildScopedGroupSegments(
     if ("not" in groupSegments) {
       return {
         not: groupSegments.not.map((gs) =>
-          buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+          applyContextToGroupSegments(featurevisor, gs, context, removeSegments),
         ) as GroupSegment[],
       } as NotGroupSegment;
     }

package/src/builder/buildDatafile.spec.ts

@@ -2,11 +2,12 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import type { DatafileContent, ExistingState, ParsedFeature } from "@featurevisor/types";
+import type { DatafileContent, ExistingState, ParsedFeature, Segment } from "@featurevisor/types";
 import { parsers } from "@featurevisor/parsers";
 
 import type { ProjectConfig } from "../config";
 import { buildDatafile } from "./buildDatafile";
+import { buildTargetDatafile } from "./buildProject";
 
 function createProjectConfig(root: string, stringify = true): ProjectConfig {
   return {
@@ -15,17 +16,18 @@ function createProjectConfig(root: string, stringify = true): ProjectConfig {
     attributesDirectoryPath: path.join(root, "attributes-missing"),
     groupsDirectoryPath: path.join(root, "groups-missing"),
     schemasDirectoryPath: path.join(root, "schemas-missing"),
+    targetsDirectoryPath: path.join(root, "targets-missing"),
     testsDirectoryPath: path.join(root, "tests-missing"),
     stateDirectoryPath: path.join(root, ".featurevisor"),
     datafilesDirectoryPath: path.join(root, "datafiles"),
     datafileNamePattern: "featurevisor-%s.json",
     revisionFileName: "REVISION",
-    siteExportDirectoryPath: path.join(root, "out"),
-    environmentsDirectoryPath: path.join(root, "environments"),
+    catalogDirectoryPath: path.join(root, "catalog"),
+    setsDirectoryPath: path.join(root, "sets"),
     environments: ["staging", "production"],
-    splitByEnvironment: false,
+    sets: false,
+    namespaceCharacter: ".",
     tags: ["all"],
-    scopes: [],
     adapter: {},
     plugins: [],
     defaultBucketBy: "userId",
@@ -37,18 +39,33 @@ function createProjectConfig(root: string, stringify = true): ProjectConfig {
   };
 }
 
-function createMockDatasource(feature: ParsedFeature) {
+function isParsedFeature(
+  feature: ParsedFeature | Record<string, ParsedFeature>,
+): feature is ParsedFeature {
+  return typeof (feature as ParsedFeature).description === "string";
+}
+
+function createMockDatasource(
+  feature: ParsedFeature | Record<string, ParsedFeature>,
+  segmentsByKey: Record<string, Segment> = {},
+) {
+  let featuresByKey: Record<string, ParsedFeature>;
+
+  if (isParsedFeature(feature)) {
+    featuresByKey = { [feature.key]: feature };
+  } else {
+    featuresByKey = feature;
+  }
+
   return {
     listSchemas: async () => [],
     readSchema: async () => {
       throw new Error("readSchema should not be called");
     },
-    listFeatures: async () => ["withRuleOverrides"],
-    readFeature: async () => feature,
-    listSegments: async () => [],
-    readSegment: async () => {
-      throw new Error("readSegment should not be called");
-    },
+    listFeatures: async () => Object.keys(featuresByKey),
+    readFeature: async (key: string) => featuresByKey[key],
+    listSegments: async () => Object.keys(segmentsByKey),
+    readSegment: async (key: string) => segmentsByKey[key],
     listAttributes: async () => [],
     readAttribute: async () => {
       throw new Error("readAttribute should not be called");
@@ -162,6 +179,7 @@ describe("core: buildDatafile", function () {
   beforeEach(function () {
     root = fs.mkdtempSync(path.join(os.tmpdir(), "featurevisor-buildDatafile-"));
     fs.mkdirSync(path.join(root, "features"), { recursive: true });
+    fs.mkdirSync(path.join(root, "segments-missing"), { recursive: true });
     existingState = { features: {} };
   });
 
@@ -177,13 +195,14 @@ describe("core: buildDatafile", function () {
       config,
       datasource,
       {
-        schemaVersion: "2",
         revision: "1",
         environment: "staging",
       },
       existingState,
     )) as DatafileContent;
 
+    expect(result.schemaVersion).toBe("2");
+
     const trafficRule = result.features.withRuleOverrides.traffic.find((t) => t.key === "rule1");
 
     expect(trafficRule).toBeDefined();
@@ -248,7 +267,6 @@ describe("core: buildDatafile", function () {
       config,
       datasource,
       {
-        schemaVersion: "2",
         revision: "1",
         environment: "staging",
       },
@@ -264,4 +282,164 @@ describe("core: buildDatafile", function () {
       { attribute: "country", operator: "equals", value: "de" },
     ]);
   });
+
+  test("includes features with missing tags when no tag filter is provided", async function () {
+    const config = createProjectConfig(root, true);
+    const feature = createFeatureFixture();
+    delete feature.tags;
+    const datasource = createMockDatasource(feature);
+
+    const result = (await buildDatafile(
+      config,
+      datasource,
+      {
+        revision: "1",
+        environment: "staging",
+      },
+      existingState,
+    )) as DatafileContent;
+
+    expect(result.features.withRuleOverrides).toBeDefined();
+  });
+
+  test("excludes features with missing tags when tag filter is provided", async function () {
+    const config = createProjectConfig(root, true);
+    const feature = createFeatureFixture();
+    delete feature.tags;
+    const datasource = createMockDatasource(feature);
+
+    const result = (await buildDatafile(
+      config,
+      datasource,
+      {
+        revision: "1",
+        environment: "staging",
+        tag: "all",
+      },
+      existingState,
+    )) as DatafileContent;
+
+    expect(result.features.withRuleOverrides).toBeUndefined();
+  });
+
+  test("filters target features by include/exclude patterns and combines them with tags using AND", async function () {
+    const config = createProjectConfig(root, true);
+    const createFeature = (key: string, tags: string[]) => ({
+      ...createFeatureFixture(),
+      key,
+      description: key,
+      tags,
+    });
+    const datasource = createMockDatasource({
+      "checkout.web": createFeature("checkout.web", ["all", "web"]),
+      "checkout.mobile": createFeature("checkout.mobile", ["all", "mobile"]),
+      "admin.web": createFeature("admin.web", ["all", "web"]),
+      "admin.internal": createFeature("admin.internal", ["all", "web"]),
+    });
+
+    const filtered = await buildTargetDatafile({
+      projectConfig: config,
+      datasource,
+      target: {
+        description: "Selected web features",
+        tag: "web",
+        includeFeatures: ["checkout*", "admin*"],
+        excludeFeatures: ["admin.internal"],
+      },
+      environment: "staging",
+      existingState,
+      revision: "1",
+    });
+
+    expect(Object.keys(filtered.features).sort()).toEqual(["admin.web", "checkout.web"]);
+
+    const all = await buildTargetDatafile({
+      projectConfig: config,
+      datasource,
+      target: {
+        description: "All except admin features",
+        includeFeatures: "*",
+        excludeFeatures: ["admin*"],
+      },
+      environment: "staging",
+      existingState,
+      revision: "1",
+    });
+
+    expect(Object.keys(all.features).sort()).toEqual(["checkout.mobile", "checkout.web"]);
+  });
+
+  test("builds target datafiles without broadening NOT segment rules", async function () {
+    const config = createProjectConfig(root, false);
+    const feature: ParsedFeature = {
+      key: "targeted",
+      description: "Targeted feature",
+      tags: ["all"],
+      bucketBy: "userId",
+      rules: {
+        staging: [
+          {
+            key: "not-web",
+            segments: {
+              not: ["web"],
+            },
+            percentage: 100,
+          },
+          {
+            key: "not-web-and-chrome",
+            segments: {
+              not: ["web", "chrome"],
+            },
+            percentage: 100,
+          },
+        ],
+      },
+    } as ParsedFeature;
+    const datasource = createMockDatasource(feature, {
+      web: {
+        conditions: [{ attribute: "platform", operator: "equals", value: "web" }],
+      },
+      chrome: {
+        conditions: [{ attribute: "browser", operator: "equals", value: "chrome" }],
+      },
+    });
+
+    const webDatafile = await buildTargetDatafile({
+      projectConfig: config,
+      datasource,
+      target: {
+        description: "Web target",
+        context: { platform: "web" },
+      },
+      environment: "staging",
+      existingState,
+      revision: "1",
+    });
+
+    expect(webDatafile.features.targeted.traffic[0].segments).toEqual({
+      not: ["*"],
+    });
+    expect(webDatafile.features.targeted.traffic[1].segments).toEqual({
+      not: ["chrome"],
+    });
+
+    const webChromeDatafile = await buildTargetDatafile({
+      projectConfig: config,
+      datasource,
+      target: {
+        description: "Web Chrome target",
+        context: { platform: "web", browser: "chrome" },
+      },
+      environment: "staging",
+      existingState,
+      revision: "1",
+    });
+
+    expect(webChromeDatafile.features.targeted.traffic[0].segments).toEqual({
+      not: ["*"],
+    });
+    expect(webChromeDatafile.features.targeted.traffic[1].segments).toEqual({
+      not: ["*"],
+    });
+  });
 });

package/src/builder/buildDatafile.ts

@@ -5,7 +5,6 @@ import {
   Segment,
   Feature,
   DatafileContent,
-  DatafileContentV1,
   Variation,
   VariableOverride,
   Traffic,
@@ -22,14 +21,13 @@ import {
   Force,
 } from "@featurevisor/types";
 
-import { ProjectConfig, SCHEMA_VERSION } from "../config";
+import { ProjectConfig } 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";
 import {
   resolveMutationsForMultipleVariables,
   resolveMutationsForSingleVariable,
@@ -37,19 +35,19 @@ import {
 
 export interface CustomDatafileOptions {
   featureKey?: string;
-  environment: string;
+  environment: string | false;
   projectConfig: ProjectConfig;
   datasource: Datasource;
   revision?: string;
-  schemaVersion?: string;
   inflate?: number;
   tag?: string;
   tags?: BuildTags;
+  includeFeatures?: "*" | FeatureKey[];
+  excludeFeatures?: "*" | FeatureKey[];
+  featurevisorVersion?: string;
 }
 
-export async function getCustomDatafile(
-  options: CustomDatafileOptions,
-): Promise<DatafileContent | DatafileContentV1> {
+export async function getCustomDatafile(options: CustomDatafileOptions): Promise<DatafileContent> {
   let featuresToInclude;
 
   if (options.featureKey) {
@@ -62,13 +60,15 @@ export async function getCustomDatafile(
     options.projectConfig,
     options.datasource,
     {
-      schemaVersion: options.schemaVersion || SCHEMA_VERSION,
       revision: options.revision || "tester",
       environment: options.environment,
       features: featuresToInclude,
       inflate: options.inflate,
       tag: options.tag,
       tags: options.tags,
+      includeFeatures: options.includeFeatures,
+      excludeFeatures: options.excludeFeatures,
+      featurevisorVersion: options.featurevisorVersion,
     },
     existingState,
   );
@@ -86,14 +86,48 @@ export interface BuildAndTags {
 
 export type BuildTags = BuildOrTags | BuildAndTags | string[];
 
+function matchesBuildTags(candidateTags: string[], buildTags?: BuildTags): boolean {
+  if (!buildTags) {
+    return true;
+  }
+
+  if (Array.isArray(buildTags)) {
+    return buildTags.some((searchTag) => candidateTags.indexOf(searchTag) !== -1);
+  }
+
+  if ("or" in buildTags) {
+    return buildTags.or.some((searchTag) => candidateTags.indexOf(searchTag) !== -1);
+  }
+
+  if ("and" in buildTags) {
+    return buildTags.and.every((searchTag) => candidateTags.indexOf(searchTag) !== -1);
+  }
+
+  return true;
+}
+
+function matchesFeaturePatterns(featureKey: FeatureKey, patterns?: "*" | FeatureKey[]): boolean {
+  if (!patterns) {
+    return false;
+  }
+
+  const normalizedPatterns = patterns === "*" ? [patterns] : patterns;
+
+  return normalizedPatterns.some((pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`).test(featureKey);
+  });
+}
+
 export interface BuildOptions {
-  schemaVersion: string;
   revision: string;
   featurevisorVersion?: string;
   revisionFromHash?: boolean;
   environment: string | false;
   tag?: string;
   tags?: BuildTags;
+  includeFeatures?: "*" | FeatureKey[];
+  excludeFeatures?: "*" | FeatureKey[];
   features?: FeatureKey[];
   inflate?: number;
 }
@@ -103,7 +137,7 @@ export async function buildDatafile(
   datasource: Datasource,
   options: BuildOptions,
   existingState: ExistingState,
-): Promise<DatafileContent | DatafileContentV1> {
+): Promise<DatafileContent> {
   const segmentKeysUsedByTag = new Set<SegmentKey>();
   const attributeKeysUsedByTag = new Set<AttributeKey>();
   const { featureRanges, featureIsInGroup } = await getFeatureRanges(projectConfig, datasource);
@@ -133,40 +167,25 @@ export async function buildDatafile(
         continue;
       }
 
-      if (options.tag && parsedFeature.tags.indexOf(options.tag) === -1) {
+      const featureTags = parsedFeature.tags || [];
+
+      if (options.tag && featureTags.indexOf(options.tag) === -1) {
         continue;
       }
 
-      if (options.tags) {
-        // plain array of tags: treat as OR tags
-        if (Array.isArray(options.tags)) {
-          if (
-            options.tags.some((searchTag) => parsedFeature.tags.indexOf(searchTag) !== -1) === false
-          ) {
-            continue;
-          }
-        } else {
-          // OR tags
-          const orTags = options.tags as BuildOrTags;
-          if (orTags.or) {
-            if (
-              orTags.or.some((searchTag) => parsedFeature.tags.indexOf(searchTag) !== -1) === false
-            ) {
-              continue;
-            }
-          }
+      if (options.tags && matchesBuildTags(featureTags, options.tags) === false) {
+        continue;
+      }
 
-          // AND tags
-          const andTags = options.tags as BuildAndTags;
-          if (andTags.and) {
-            if (
-              andTags.and.every((searchTag) => parsedFeature.tags.indexOf(searchTag) !== -1) ===
-              false
-            ) {
-              continue;
-            }
-          }
-        }
+      if (
+        options.includeFeatures &&
+        matchesFeaturePatterns(featureKey, options.includeFeatures) === false
+      ) {
+        continue;
+      }
+
+      if (options.excludeFeatures && matchesFeaturePatterns(featureKey, options.excludeFeatures)) {
+        continue;
       }
 
       if (options.features && options.features.indexOf(featureKey) === -1) {
@@ -197,6 +216,10 @@ export async function buildDatafile(
         if (options.tag && exposeTags.indexOf(options.tag) === -1) {
           continue;
         }
+
+        if (options.tags && matchesBuildTags(exposeTags, options.tags) === false) {
+          continue;
+        }
       }
 
       for (const parsedRule of rules) {
@@ -569,19 +592,7 @@ export async function buildDatafile(
     }
   }
 
-  // schema v1
-  if (options.schemaVersion === "1") {
-    return convertToV1({
-      revision: options.revision,
-      projectConfig,
-      attributes,
-      features,
-      segments,
-    });
-  }
-
-  // schema v2
-  const datafileContentV2: DatafileContent = {
+  const datafileContent: DatafileContent = {
     schemaVersion: "2",
     featurevisorVersion: options.featurevisorVersion,
     revision: options.revision,
@@ -589,8 +600,7 @@ export async function buildDatafile(
     features: {},
   };
 
-  datafileContentV2.segments = segments.reduce((acc, segment) => {
-    // key check needed for supporting v1 datafile generation
+  datafileContent.segments = segments.reduce((acc, segment) => {
     if (segment.key) {
       acc[segment.key] = segment;
       delete acc[segment.key].key; // remove key from segment, as it is not needed in v2 datafile
@@ -599,7 +609,7 @@ export async function buildDatafile(
     return acc;
   }, {});
 
-  datafileContentV2.features = features.reduce((acc, feature) => {
+  datafileContent.features = features.reduce((acc, feature) => {
     if (!feature.key) {
       return acc;
     }
@@ -625,11 +635,11 @@ export async function buildDatafile(
   }, {});
 
   // add feature hashes for change detection
-  const segmentHashes = getSegmentHashes(datafileContentV2.segments);
-  Object.keys(datafileContentV2.features).forEach((featureKey) => {
-    const hash = generateHashForFeature(featureKey, datafileContentV2.features, segmentHashes);
+  const segmentHashes = getSegmentHashes(datafileContent.segments);
+  Object.keys(datafileContent.features).forEach((featureKey) => {
+    const hash = generateHashForFeature(featureKey, datafileContent.features, segmentHashes);
 
-    datafileContentV2.features[featureKey].hash = hash;
+    datafileContent.features[featureKey].hash = hash;
 
     // check needed to support --inflate option
     if (existingState.features[featureKey]) {
@@ -638,9 +648,9 @@ export async function buildDatafile(
   });
 
   if (options.revisionFromHash) {
-    const datafileHash = generateHashForDatafile(datafileContentV2);
-    datafileContentV2.revision = `${datafileHash}`;
+    const datafileHash = generateHashForDatafile(datafileContent);
+    datafileContent.revision = `${datafileHash}`;
   }
 
-  return datafileContentV2;
+  return datafileContent;
 }