@featurevisor/core 2.5.0 → 2.6.0

package/src/builder/buildScopedSegments.ts

@@ -0,0 +1,153 @@
+import type {
+  GroupSegment,
+  AndGroupSegment,
+  OrGroupSegment,
+  NotGroupSegment,
+  Context,
+} from "@featurevisor/types";
+import type { DatafileReader } from "@featurevisor/sdk";
+
+export function buildScopedSegments(
+  datafileReader: DatafileReader,
+  segments: GroupSegment | GroupSegment[],
+  context: Context,
+  removeSegments: string[] = [],
+): GroupSegment | GroupSegment[] {
+  const scoped = buildScopedGroupSegments(datafileReader, segments, context, removeSegments);
+  const removed = removeRedundantGroupSegments(scoped);
+
+  return removed;
+}
+
+export function removeRedundantGroupSegments(
+  groupSegments: GroupSegment | GroupSegment[],
+): GroupSegment | GroupSegment[] {
+  if (groupSegments === "*") {
+    return groupSegments;
+  }
+
+  if (Array.isArray(groupSegments)) {
+    // Recursively process each group segment
+    const processed = groupSegments.map((gs) => removeRedundantGroupSegments(gs)) as GroupSegment[];
+
+    // Filter out "*" values
+    const filtered = processed.filter((gs) => gs !== "*");
+
+    // If all were "*", return "*"
+    if (filtered.length === 0) {
+      return "*";
+    }
+
+    return filtered;
+  }
+
+  if (typeof groupSegments === "object") {
+    if ("and" in groupSegments) {
+      const processed = groupSegments.and.map((gs) =>
+        removeRedundantGroupSegments(gs),
+      ) as GroupSegment[];
+      const filtered = processed.filter((gs) => gs !== "*");
+
+      // If all were "*", return "*"
+      if (filtered.length === 0) {
+        return "*";
+      }
+
+      return {
+        and: filtered,
+      } as AndGroupSegment;
+    }
+
+    if ("or" in groupSegments) {
+      const processed = groupSegments.or.map((gs) =>
+        removeRedundantGroupSegments(gs),
+      ) as GroupSegment[];
+      const filtered = processed.filter((gs) => gs !== "*");
+
+      // If all were "*", return "*"
+      if (filtered.length === 0) {
+        return "*";
+      }
+
+      return {
+        or: filtered,
+      } as OrGroupSegment;
+    }
+
+    if ("not" in groupSegments) {
+      const processed = groupSegments.not.map((gs) =>
+        removeRedundantGroupSegments(gs),
+      ) as GroupSegment[];
+      const filtered = processed.filter((gs) => gs !== "*");
+
+      // If all were "*", return "*"
+      if (filtered.length === 0) {
+        return "*";
+      }
+
+      return {
+        not: filtered,
+      } as NotGroupSegment;
+    }
+  }
+
+  return groupSegments;
+}
+
+export function buildScopedGroupSegments(
+  datafileReader: DatafileReader,
+  groupSegments: GroupSegment | GroupSegment[],
+  context: Context,
+  removeSegments: string[] = [],
+): GroupSegment | GroupSegment[] {
+  if (groupSegments === "*") {
+    return groupSegments;
+  }
+
+  if (Array.isArray(groupSegments)) {
+    return groupSegments.map((gs) =>
+      buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+    ) as GroupSegment[];
+  }
+
+  if (typeof groupSegments === "string") {
+    if (removeSegments.includes(groupSegments)) {
+      return "*";
+    }
+
+    const matched = datafileReader.allSegmentsAreMatched(groupSegments, context);
+
+    if (matched) {
+      return "*";
+    }
+  }
+
+  if (typeof groupSegments === "object") {
+    // AND, OR, NOT group segments
+    if ("and" in groupSegments) {
+      return {
+        and: groupSegments.and.map((gs) =>
+          buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+        ) as GroupSegment[],
+      } as AndGroupSegment;
+    }
+
+    if ("or" in groupSegments) {
+      return {
+        or: groupSegments.or.map((gs) =>
+          buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+        ) as GroupSegment[],
+      } as OrGroupSegment;
+    }
+
+    if ("not" in groupSegments) {
+      return {
+        not: groupSegments.not.map((gs) =>
+          buildScopedGroupSegments(datafileReader, gs, context, removeSegments),
+        ) as GroupSegment[],
+      } as NotGroupSegment;
+    }
+  }
+
+  return groupSegments;
+}

package/src/builder/index.ts

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

package/src/config/projectConfig.ts

@@ -1,10 +1,11 @@
 import * as path from "path";
 
-import type { BucketBy } from "@featurevisor/types";
+import type { BucketBy, Context, Tag } from "@featurevisor/types";
 
 import { Parser, parsers } from "./parsers";
 import { FilesystemAdapter } from "../datasource/filesystemAdapter";
 import type { Plugin } from "../cli";
+import type { BuildTags } from "../builder/buildDatafile";
 
 export const FEATURES_DIRECTORY_NAME = "features";
 export const SEGMENTS_DIRECTORY_NAME = "segments";
@@ -31,6 +32,13 @@ export const DEFAULT_PARSER: Parser = "yml";
 
 export const SCHEMA_VERSION = "2"; // default schema version
 
+export interface Scope {
+  name: string;
+  context: Context;
+  tag?: Tag;
+  tags?: BuildTags;
+}
+
 export interface ProjectConfig {
   featuresDirectoryPath: string;
   segmentsDirectoryPath: string;
@@ -45,6 +53,7 @@ export interface ProjectConfig {
 
   environments: string[] | false;
   tags: string[];
+  scopes?: Scope[];
 
   adapter: any; // @NOTE: type this properly later
   plugins: Plugin[];
@@ -68,6 +77,7 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
   const baseConfig: ProjectConfig = {
     environments: DEFAULT_ENVIRONMENTS,
     tags: DEFAULT_TAGS,
+    scopes: [],
     defaultBucketBy: "userId",
 
     parser: DEFAULT_PARSER,

package/src/datasource/adapter.ts

@@ -8,9 +8,12 @@ import type {
   EntityType,
 } from "@featurevisor/types";
 
+import type { Scope } from "../config";
+
 export interface DatafileOptions {
   environment: EnvironmentKey | false;
-  tag: string;
+  tag?: string;
+  scope?: Scope;
   datafilesDir?: string;
 }
 

package/src/datasource/filesystemAdapter.ts

@@ -223,7 +223,10 @@ export class FilesystemAdapter extends Adapter {
   getDatafilePath(options: DatafileOptions): string {
     const pattern = this.config.datafileNamePattern || "featurevisor-%s.json";
 
-    const fileName = pattern.replace("%s", `tag-${options.tag}`);
+    const fileName = options.scope
+      ? pattern.replace("%s", `scope-${options.scope.name}`)
+      : pattern.replace("%s", `tag-${options.tag}`);
+
     const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
 
     if (options.environment) {

package/src/linter/testSchema.ts

@@ -7,6 +7,8 @@ export function getTestsZodSchema(
   availableFeatureKeys: [string, ...string[]],
   availableSegmentKeys: [string, ...string[]],
 ) {
+  const scopeNames = projectConfig.scopes ? projectConfig.scopes.map((scope) => scope.name) : [];
+
   const matrixZodSchema = z.record(
     z.array(
       z.union([
@@ -82,6 +84,16 @@ export function getTestsZodSchema(
                   }),
                 )
               : z.never().optional(),
+            // @TODO: add tag later, similar to `scope` below
+            scope: z
+              .string()
+              .refine(
+                (value) => scopeNames.includes(value),
+                (value) => ({
+                  message: `Unknown scope "${value}"`,
+                }),
+              )
+              .optional(),
 
             // parent
             sticky: z.record(z.record(z.any())).optional(),

package/src/list/matrix.ts

@@ -96,6 +96,13 @@ export function applyCombinationToFeatureAssertion(
     );
   }
 
+  // scope
+  if (flattenedAssertion.scope) {
+    flattenedAssertion.scope = applyCombinationToValue(flattenedAssertion.scope, combination);
+  }
+
+  // @TODO: support `tag` later, similar to `scope` above
+
   return flattenedAssertion;
 }
 

package/src/tester/testFeature.ts

@@ -17,14 +17,22 @@ import { Datasource } from "../datasource";
 import { ProjectConfig } from "../config";
 
 import { checkIfArraysAreEqual, checkIfObjectsAreEqual } from "./helpers";
-import type { DatafileContentByEnvironment } from "./testProject";
+import type { DatafileContentByKey } from "./testProject";
+
+export interface TestFeatureOptions {
+  verbose?: boolean;
+  quiet?: boolean;
+  showDatafile?: boolean;
+  withScopes?: boolean;
+  [key: string]: any;
+}
 
 export async function testFeature(
   datasource: Datasource,
   projectConfig: ProjectConfig,
   test: TestFeature,
-  options: { verbose?: boolean; quiet?: boolean; showDatafile?: boolean; [key: string]: any } = {},
-  datafileContentByEnvironment: DatafileContentByEnvironment,
+  options: TestFeatureOptions = {},
+  datafileContentByKey: DatafileContentByKey,
 ): Promise<TestResult> {
   const testStartTime = Date.now();
   const featureKey = test.feature;
@@ -51,7 +59,14 @@ export async function testFeature(
       errors: [],
     };
 
-    const datafileContent = datafileContentByEnvironment.get(assertion.environment || false);
+    let datafileContent = datafileContentByKey.get(assertion.environment || false);
+
+    const scopedDatafileKey = `${assertion.environment}-scope-${assertion.scope}`;
+    if (assertion.scope && datafileContentByKey.has(scopedDatafileKey)) {
+      datafileContent = datafileContentByKey.get(scopedDatafileKey);
+    }
+
+    // @TODO: do similar like `scope`, but for `tag`
 
     if (options.showDatafile) {
       console.log("");
@@ -92,15 +107,39 @@ export async function testFeature(
       return testResult;
     }
 
+    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) {
-      sdk.setContext(assertion.context);
+      context = {
+        ...context,
+        ...assertion.context,
+      };
+    }
+
+    if (context) {
+      sdk.setContext(context);
     }
 
     /**
      * expectedToBeEnabled
      */
     function testExpectedToBeEnabled(sdk, assertion, details = {}) {
-      const isEnabled = sdk.isEnabled(featureKey, assertion.context || {});
+      const isEnabled = sdk.isEnabled(featureKey, context);
 
       if (isEnabled !== assertion.expectedToBeEnabled) {
         testResult.passed = false;
@@ -128,7 +167,7 @@ export async function testFeature(
         overrideOptions.defaultVariationValue = assertion.defaultVariationValue;
       }
 
-      const variation = sdk.getVariation(featureKey, assertion.context || {}, overrideOptions);
+      const variation = sdk.getVariation(featureKey, context, overrideOptions);
 
       if (variation !== assertion.expectedVariation) {
         testResult.passed = false;
@@ -160,12 +199,7 @@ export async function testFeature(
           overrideOptions.defaultVariableValue = assertion.defaultVariableValues[variableKey];
         }
 
-        const actualValue = sdk.getVariable(
-          featureKey,
-          variableKey,
-          assertion.context || {},
-          overrideOptions,
-        );
+        const actualValue = sdk.getVariable(featureKey, variableKey, context, overrideOptions);
 
         let passed;
 
@@ -271,12 +305,12 @@ export async function testFeature(
       }
 
       if (assertion.expectedEvaluations.flag) {
-        const evaluation = sdk.evaluateFlag(featureKey, assertion.context || {});
+        const evaluation = sdk.evaluateFlag(featureKey, context);
         testEvaluation("flag", evaluation, assertion.expectedEvaluations.flag);
       }
 
       if (assertion.expectedEvaluations.variation) {
-        const evaluation = sdk.evaluateVariation(featureKey, assertion.context || {});
+        const evaluation = sdk.evaluateVariation(featureKey, context);
         testEvaluation("variation", evaluation, assertion.expectedEvaluations.variation);
       }
 
@@ -284,7 +318,7 @@ export async function testFeature(
         const variableKeys = Object.keys(assertion.expectedEvaluations.variables);
 
         for (const variableKey of variableKeys) {
-          const evaluation = sdk.evaluateVariable(featureKey, variableKey, assertion.context || {});
+          const evaluation = sdk.evaluateVariable(featureKey, variableKey, context);
           testEvaluation(
             "variable",
             evaluation,

package/src/tester/testProject.ts

@@ -9,7 +9,7 @@ import { Dependencies } from "../dependencies";
 import { prettyDuration } from "./prettyDuration";
 import { printTestResult } from "./printTestResult";
 
-import { buildDatafile } from "../builder";
+import { buildDatafile, buildScopedDatafile } from "../builder";
 import { SCHEMA_VERSION } from "../config";
 import { Plugin } from "../cli";
 import { listEntities } from "../list";
@@ -22,6 +22,7 @@ export interface TestProjectOptions {
   onlyFailures?: boolean;
   schemaVersion?: string;
   inflate?: number;
+  withScopes?: boolean;
 }
 
 export interface ExecutionResult {
@@ -32,13 +33,14 @@ export interface ExecutionResult {
   };
 }
 
-export type DatafileContentByEnvironment = Map<string | false, DatafileContent>;
+// the key can be either "<EnvironmentKey>" or "<EnvironmentKey>scope-<Scope>"
+export type DatafileContentByKey = Map<string | false, DatafileContent>;
 
 export async function executeTest(
   test: Test,
   deps: Dependencies,
   options: TestProjectOptions,
-  datafileContentByEnvironment: DatafileContentByEnvironment,
+  datafileContentByKey: DatafileContentByKey,
 ): Promise<ExecutionResult | undefined> {
   const { datasource, projectConfig, rootDirectoryPath } = deps;
 
@@ -74,7 +76,7 @@ export async function executeTest(
       projectConfig,
       tAsFeature,
       options,
-      datafileContentByEnvironment,
+      datafileContentByKey,
     );
   }
 
@@ -124,7 +126,7 @@ export async function testProject(
   let passedAssertionsCount = 0;
   let failedAssertionsCount = 0;
 
-  const datafileContentByEnvironment: DatafileContentByEnvironment = new Map();
+  const datafileContentByKey: DatafileContentByKey = new Map();
 
   // with environments
   if (Array.isArray(projectConfig.environments)) {
@@ -142,7 +144,36 @@ export async function testProject(
         existingState,
       );
 
-      datafileContentByEnvironment.set(environment, datafileContent as DatafileContent);
+      datafileContentByKey.set(environment, datafileContent as DatafileContent);
+
+      // by scope
+      if (projectConfig.scopes && options.withScopes) {
+        for (const scope of projectConfig.scopes) {
+          const existingState = await datasource.readState(environment);
+          const datafileContent = await buildDatafile(
+            projectConfig,
+            datasource,
+            {
+              schemaVersion: options.schemaVersion || SCHEMA_VERSION,
+              revision: "include-scoped-features",
+              environment: environment,
+              inflate: options.inflate,
+              tag: scope.tag,
+              tags: scope.tags,
+            },
+            existingState,
+          );
+
+          const scopedDatafileContent = buildScopedDatafile(
+            datafileContent as DatafileContent,
+            scope.context,
+          );
+
+          datafileContentByKey.set(`${environment}-scope-${scope.name}`, scopedDatafileContent);
+        }
+      }
+
+      // @TODO: by tag
     }
   }
 
@@ -161,7 +192,36 @@ export async function testProject(
       existingState,
     );
 
-    datafileContentByEnvironment.set(false, datafileContent as DatafileContent);
+    datafileContentByKey.set(false, datafileContent as DatafileContent);
+
+    // by scope
+    if (projectConfig.scopes && options.withScopes) {
+      for (const scope of projectConfig.scopes) {
+        const existingState = await datasource.readState(false);
+        const datafileContent = await buildDatafile(
+          projectConfig,
+          datasource,
+          {
+            schemaVersion: options.schemaVersion || SCHEMA_VERSION,
+            revision: "include-scoped-features",
+            environment: false,
+            inflate: options.inflate,
+            tag: scope.tag,
+            tags: scope.tags,
+          },
+          existingState,
+        );
+
+        const scopedDatafileContent = buildScopedDatafile(
+          datafileContent as DatafileContent,
+          scope.context,
+        );
+
+        datafileContentByKey.set(`scope-${scope.name}`, scopedDatafileContent);
+      }
+    }
+
+    // @TODO: by tag
   }
 
   const tests = await listEntities<Test>(
@@ -178,7 +238,7 @@ export async function testProject(
   );
 
   for (const test of tests) {
-    const executionResult = await executeTest(test, deps, options, datafileContentByEnvironment);
+    const executionResult = await executeTest(test, deps, options, datafileContentByKey);
 
     if (!executionResult) {
       continue;