@featurevisor/core 2.26.1 → 3.0.1

package/src/sets.ts

@@ -0,0 +1,76 @@
+import * as path from "path";
+
+import type { ProjectConfig } from "./config";
+import type { Datasource } from "./datasource";
+import { CLI_FORMAT_BOLD } from "./tester/cliFormat";
+
+export interface ProjectSetExecution {
+  set: string;
+  projectConfig: ProjectConfig;
+  datasource: Datasource;
+}
+
+export async function getProjectSetExecutions(
+  projectConfig: ProjectConfig,
+  datasource: Datasource,
+  selectedSet?: string,
+): Promise<ProjectSetExecution[]> {
+  if (!projectConfig.sets) {
+    return [{ set: "", projectConfig, datasource }];
+  }
+
+  const availableSetKeys = await datasource.listSets();
+
+  if (selectedSet && !availableSetKeys.includes(selectedSet)) {
+    throw new Error(
+      `Unknown set "${selectedSet}". Available sets: ${availableSetKeys.join(", ") || "none"}.`,
+    );
+  }
+
+  const setKeys = selectedSet ? [selectedSet] : availableSetKeys;
+
+  if (setKeys.length === 0) {
+    throw new Error(`No sets found in ${projectConfig.setsDirectoryPath}.`);
+  }
+
+  return setKeys.map((set) => {
+    const setDatasource = datasource.forSet(set);
+
+    return {
+      set,
+      projectConfig: setDatasource.getConfig(),
+      datasource: setDatasource,
+    };
+  });
+}
+
+export function assertProjectSetJsonSelection(
+  projectConfig: ProjectConfig,
+  selectedSet: string | undefined,
+  json: boolean | undefined,
+) {
+  if (projectConfig.sets && json && !selectedSet) {
+    throw new Error("Pass --set=<set> when using --json in a project with sets enabled.");
+  }
+}
+
+export function getProjectSetRelativeFilePath(
+  projectConfig: ProjectConfig,
+  set: string,
+  filePath: string,
+) {
+  const setDirectoryPath = path.join(projectConfig.setsDirectoryPath, set);
+
+  if (filePath === setDirectoryPath || filePath.startsWith(`${setDirectoryPath}${path.sep}`)) {
+    return filePath;
+  }
+
+  return path.join(setDirectoryPath, filePath);
+}
+
+export function printSetHeader(projectConfig: ProjectConfig, set: string, silent = false) {
+  if (projectConfig.sets && !silent) {
+    console.log("");
+    console.log(CLI_FORMAT_BOLD, `Set "${set}"`);
+  }
+}

package/src/targeting.spec.ts

@@ -0,0 +1,74 @@
+import type { ParsedFeature, Target } from "@featurevisor/types";
+
+import { getTargetFeatureKeys, resolveTargets, targetIncludesFeature } from "./targeting";
+
+const features: Record<string, ParsedFeature> = {
+  webCheckout: {
+    key: "webCheckout",
+    description: "Web checkout",
+    tags: ["web", "checkout"],
+    bucketBy: "userId",
+    rules: [],
+  },
+  webInternal: {
+    key: "webInternal",
+    description: "Internal web",
+    tags: ["web", "internal"],
+    bucketBy: "userId",
+    rules: [],
+  },
+  mobileCheckout: {
+    key: "mobileCheckout",
+    description: "Mobile checkout",
+    tags: ["mobile", "checkout"],
+    bucketBy: "userId",
+    rules: [],
+  },
+};
+
+const targets: Record<string, Target> = {
+  web: {
+    description: "Web",
+    tags: { and: ["web", "checkout"] },
+    includeFeatures: ["web*"],
+    excludeFeatures: ["webInternal*"],
+  },
+  mobile: { description: "Mobile", tag: "mobile" },
+};
+
+function createDatasource() {
+  return {
+    listTargets: async () => Object.keys(targets),
+    readTarget: async (key: string) => targets[key],
+    listFeatures: async () => Object.keys(features),
+    readFeature: async (key: string) => features[key],
+  } as any;
+}
+
+describe("targeting", () => {
+  it("matches full target selectors", () => {
+    expect(targetIncludesFeature(targets.web, "webCheckout", features.webCheckout)).toEqual(true);
+    expect(targetIncludesFeature(targets.web, "webInternal", features.webInternal)).toEqual(false);
+    expect(targetIncludesFeature(targets.web, "mobileCheckout", features.mobileCheckout)).toEqual(
+      false,
+    );
+  });
+
+  it("resolves repeated targets once and returns their feature union", async () => {
+    const datasource = createDatasource();
+    const resolved = await resolveTargets(datasource, ["web", "mobile", "web"]);
+    const featureKeys = await getTargetFeatureKeys(datasource, resolved);
+
+    expect(resolved.map((target) => target.key)).toEqual(["web", "mobile"]);
+    expect(Array.from(featureKeys).sort()).toEqual(["mobileCheckout", "webCheckout"]);
+  });
+
+  it("validates unknown and missing targets", async () => {
+    await expect(resolveTargets(createDatasource(), "missing")).rejects.toThrow(
+      'Unknown target "missing"',
+    );
+    await expect(resolveTargets({ listTargets: async () => [] } as any, undefined)).rejects.toThrow(
+      "No targets found",
+    );
+  });
+});

package/src/targeting.ts

@@ -0,0 +1,106 @@
+import type { ParsedFeature, Target } from "@featurevisor/types";
+
+import type { Datasource } from "./datasource";
+
+export type ResolvedTarget = Target & { key: string };
+
+export function normalizeOptionValues(value: string | string[] | undefined): string[] {
+  if (typeof value === "undefined") return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export function matchesFeaturePatterns(
+  featureKey: string,
+  patterns: Target["includeFeatures"],
+): boolean {
+  if (!patterns) return false;
+  return normalizeOptionValues(patterns).some((pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`).test(featureKey);
+  });
+}
+
+export function matchesTargetTags(candidateTags: string[], selector: Target["tags"]): boolean {
+  if (!selector) return true;
+  if (Array.isArray(selector)) {
+    return selector.some((tag) => candidateTags.includes(tag));
+  }
+  if ("or" in selector) {
+    return selector.or.some((tag) => candidateTags.includes(tag));
+  }
+  return selector.and.every((tag) => candidateTags.includes(tag));
+}
+
+export function targetIncludesFeature(
+  target: Target,
+  featureKey: string,
+  feature: ParsedFeature,
+): boolean {
+  if (feature.archived === true) return false;
+
+  const featureTags = feature.tags || [];
+  if (target.tag && !featureTags.includes(target.tag)) return false;
+  if (target.tags && !matchesTargetTags(featureTags, target.tags)) return false;
+  if (target.includeFeatures && !matchesFeaturePatterns(featureKey, target.includeFeatures)) {
+    return false;
+  }
+  if (target.excludeFeatures && matchesFeaturePatterns(featureKey, target.excludeFeatures)) {
+    return false;
+  }
+
+  return true;
+}
+
+export async function resolveTargets(
+  datasource: Datasource,
+  requestedTargets?: string | string[],
+  options: { defaultToAll?: boolean; requireTargets?: boolean } = {},
+): Promise<ResolvedTarget[]> {
+  const targetKeys = await datasource.listTargets();
+  const requestedTargetKeys = normalizeOptionValues(requestedTargets);
+  const selectedKeys =
+    requestedTargetKeys.length > 0
+      ? requestedTargetKeys
+      : options.defaultToAll === false
+        ? []
+        : targetKeys;
+
+  if (options.requireTargets !== false && targetKeys.length === 0) {
+    throw new Error(
+      'No targets found. Add at least one target definition, for example "targets/all.yml".',
+    );
+  }
+
+  const uniqueKeys = Array.from(new Set(selectedKeys));
+  for (const targetKey of uniqueKeys) {
+    if (!targetKeys.includes(targetKey)) {
+      throw new Error(
+        `Unknown target "${targetKey}". Available targets: ${targetKeys.join(", ") || "none"}.`,
+      );
+    }
+  }
+
+  return Promise.all(
+    uniqueKeys.map(async (targetKey) => ({
+      ...(await datasource.readTarget(targetKey)),
+      key: targetKey,
+    })),
+  );
+}
+
+export async function getTargetFeatureKeys(
+  datasource: Datasource,
+  targets: ResolvedTarget[],
+): Promise<Set<string>> {
+  const result = new Set<string>();
+  const featureKeys = await datasource.listFeatures();
+
+  for (const featureKey of featureKeys) {
+    const feature = await datasource.readFeature(featureKey);
+    if (targets.some((target) => targetIncludesFeature(target, featureKey, feature))) {
+      result.add(featureKey);
+    }
+  }
+
+  return result;
+}

package/src/tester/cliFormat.ts

@@ -1,6 +1,16 @@
 export const CLI_FORMAT_RED = "\x1b[31m%s\x1b[0m";
 export const CLI_FORMAT_GREEN = "\x1b[32m%s\x1b[0m";
+export const CLI_FORMAT_YELLOW = "\x1b[33m%s\x1b[0m";
+export const CLI_FORMAT_DIM = "\x1b[2m%s\x1b[0m";
+
+export const CLI_COLOR_GREEN = 32;
+export const CLI_COLOR_YELLOW = 33;
+export const CLI_COLOR_CYAN = 36;
+export const CLI_COLOR_DIM = 2;
 
 export const CLI_FORMAT_BOLD = "\x1b[1m%s\x1b[0m";
-export const CLI_FORMAT_UNDERLINE = "\x1b[4m%s\x1b[0m";
 export const CLI_FORMAT_BOLD_UNDERLINE = "\x1b[1m\x1b[4m%s\x1b[0m";
+
+export function colorize(value: string | number | boolean, colorCode: number) {
+  return `\x1b[${colorCode}m${value}\x1b[0m`;
+}

package/src/tester/printTestResult.ts

@@ -1,6 +1,12 @@
 import type { TestResult } from "@featurevisor/types";
 
-import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
+import {
+  CLI_COLOR_CYAN,
+  CLI_FORMAT_BOLD,
+  CLI_FORMAT_GREEN,
+  CLI_FORMAT_RED,
+  colorize,
+} from "./cliFormat";
 import { prettyDuration } from "./prettyDuration";
 
 export function printTestResult(testResult: TestResult, relativeTestFilePath, rootDirectoryPath) {
@@ -9,7 +15,7 @@ export function printTestResult(testResult: TestResult, relativeTestFilePath, ro
   const title = `Testing: ${relativeTestFilePath.replace(rootDirectoryPath, "")} (${prettyDuration(
     testResult.duration,
   )})`;
-  console.log(title);
+  console.log(colorize(title, CLI_COLOR_CYAN));
 
   if (testResult.notFound) {
     console.log(CLI_FORMAT_RED, `  => ${testResult.type} ${testResult.key} not found`);
@@ -21,7 +27,10 @@ export function printTestResult(testResult: TestResult, relativeTestFilePath, ro
 
   testResult.assertions.forEach(function (assertion) {
     if (assertion.passed) {
-      console.log(`  ✔ ${assertion.description} (${prettyDuration(assertion.duration)})`);
+      console.log(
+        CLI_FORMAT_GREEN,
+        `  ✔ ${assertion.description} (${prettyDuration(assertion.duration)})`,
+      );
     } else {
       console.log(
         CLI_FORMAT_RED,

package/src/tester/testFeature.ts

@@ -5,13 +5,9 @@ import type {
   TestResultAssertion,
   TestResultAssertionError,
 } from "@featurevisor/types";
-import {
-  createInstance,
-  FeaturevisorInstance,
-  LogLevel,
-  MAX_BUCKETED_NUMBER,
-  OverrideOptions,
-} from "@featurevisor/sdk";
+import { createFeaturevisor } from "@featurevisor/sdk";
+import type { Featurevisor, FeaturevisorLogLevel, OverrideOptions } from "@featurevisor/sdk";
+import { MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
 
 import { Datasource } from "../datasource";
 import { ProjectConfig } from "../config";
@@ -23,7 +19,6 @@ export interface TestFeatureOptions {
   verbose?: boolean;
   quiet?: boolean;
   showDatafile?: boolean;
-  withScopes?: boolean;
   [key: string]: any;
 }
 
@@ -61,16 +56,10 @@ export async function testFeature(
 
     let datafileContent = datafileContentByKey.get(assertion.environment || false);
 
-    // scope
-    const scopedDatafileKey = `${assertion.environment}-scope-${assertion.scope}`;
-    if (assertion.scope && datafileContentByKey.has(scopedDatafileKey)) {
-      datafileContent = datafileContentByKey.get(scopedDatafileKey);
-    }
-
-    // tag
-    const taggedDatafileKey = `${assertion.environment}-tag-${assertion.tag}`;
-    if (assertion.tag && datafileContentByKey.has(taggedDatafileKey)) {
-      datafileContent = datafileContentByKey.get(taggedDatafileKey);
+    // target
+    const targetDatafileKey = `${assertion.environment || false}-target-${assertion.target}`;
+    if (assertion.target && datafileContentByKey.has(targetDatafileKey)) {
+      datafileContent = datafileContentByKey.get(targetDatafileKey);
     }
 
     if (options.showDatafile) {
@@ -79,17 +68,17 @@ export async function testFeature(
       console.log("");
     }
 
-    let logLevel: LogLevel = "warn";
+    let logLevel: FeaturevisorLogLevel = "warn";
     if (options.verbose) {
       logLevel = "debug";
     } else if (options.quiet) {
       logLevel = "fatal";
     }
 
-    const sdk: FeaturevisorInstance = createInstance({
+    const sdk: Featurevisor = createFeaturevisor({
       datafile: datafileContent as DatafileContent,
       sticky: assertion.sticky ? assertion.sticky : {},
-      hooks: [
+      modules: [
         {
           name: "tester",
           bucketValue: ({ bucketValue }) => {
@@ -114,21 +103,6 @@ export async function testFeature(
 
     let context = {};
 
-    if (assertion.scope) {
-      if (!options.withScopes) {
-        // if not testing with scoped datafiles,
-        // then we need to add the scope's context to the context
-        const scope = projectConfig.scopes?.find((s) => s.name === assertion.scope);
-
-        if (scope) {
-          context = {
-            ...(scope.context || {}),
-            ...context,
-          };
-        }
-      }
-    }
-
     if (assertion.context) {
       context = {
         ...context,

package/src/tester/testProject.spec.ts

@@ -0,0 +1,50 @@
+import type { Test, TestFeature } from "@featurevisor/types";
+
+import { filterTestForTargets } from "./testProject";
+
+describe("core: test target selection", () => {
+  const featureTest = {
+    key: "checkout",
+    feature: "checkout",
+    assertions: [
+      { description: "base", context: {}, expectedToBeEnabled: true },
+      { description: "web", target: "web", context: {}, expectedToBeEnabled: true },
+      { description: "mobile", target: "mobile", context: {}, expectedToBeEnabled: true },
+    ],
+  } as TestFeature;
+
+  it("keeps untargeted assertions and assertions for all selected targets", () => {
+    const filtered = filterTestForTargets(featureTest, ["web", "mobile"]) as TestFeature;
+
+    expect(filtered.assertions.map((assertion) => assertion.description)).toEqual([
+      "base",
+      "web",
+      "mobile",
+    ]);
+  });
+
+  it("removes assertions for targets that were not selected", () => {
+    const filtered = filterTestForTargets(featureTest, ["web"]) as TestFeature;
+
+    expect(filtered.assertions.map((assertion) => assertion.description)).toEqual(["base", "web"]);
+  });
+
+  it("skips a feature test when none of its targeted assertions were selected", () => {
+    const targetedOnly = {
+      ...featureTest,
+      assertions: featureTest.assertions.slice(1),
+    } as TestFeature;
+
+    expect(filterTestForTargets(targetedOnly, ["api"])).toBeUndefined();
+  });
+
+  it("does not filter segment tests", () => {
+    const segmentTest = {
+      key: "everyone",
+      segment: "everyone",
+      assertions: [],
+    } as unknown as Test;
+
+    expect(filterTestForTargets(segmentTest, ["web"])).toBe(segmentTest);
+  });
+});