@featurevisor/core 1.34.1 → 1.35.0

package/src/datasource/filesystemAdapter.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
 
 import * as mkdirp from "mkdirp";
 
@@ -255,13 +255,32 @@ export class FilesystemAdapter extends Adapter {
   /**
    * History
    */
-  getRawHistory(pathPatterns: string[]) {
+  async getRawHistory(pathPatterns: string[]): Promise<string> {
     const gitPaths = pathPatterns.join(" ");
 
     const logCommand = `git log --name-only --pretty=format:"%h|%an|%aI" --relative --no-merges -- ${gitPaths}`;
     const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
 
-    return execSync(fullCommand, { encoding: "utf8" }).toString();
+    return new Promise(function (resolve, reject) {
+      const child = spawn(fullCommand, { shell: true });
+      let result = "";
+
+      child.stdout.on("data", function (data) {
+        result += data.toString();
+      });
+
+      child.stderr.on("data", function (data) {
+        console.error(data.toString());
+      });
+
+      child.on("close", function (code) {
+        if (code === 0) {
+          resolve(result);
+        } else {
+          reject(code);
+        }
+      });
+    });
   }
 
   getPathPatterns(entityType?: EntityType, entityKey?: string): string[] {
@@ -296,7 +315,7 @@ export class FilesystemAdapter extends Adapter {
 
   async listHistoryEntries(entityType?: EntityType, entityKey?: string): Promise<HistoryEntry[]> {
     const pathPatterns = this.getPathPatterns(entityType, entityKey);
-    const rawHistory = this.getRawHistory(pathPatterns);
+    const rawHistory = await this.getRawHistory(pathPatterns);
 
     const fullHistory: HistoryEntry[] = [];
     const blocks = rawHistory.split("\n\n");

package/src/index.ts

@@ -14,4 +14,5 @@ export * from "./benchmark";
 export * from "./evaluate";
 export * from "./assess-distribution";
 export * from "./info";
+export * from "./list";
 export * from "./cli";

package/src/list/index.ts

@@ -0,0 +1,496 @@
+import {
+  ParsedFeature,
+  Segment,
+  Attribute,
+  TestFeature,
+  TestSegment,
+  FeatureAssertion,
+  SegmentAssertion,
+} from "@featurevisor/types";
+
+import { Dependencies } from "../dependencies";
+import { Plugin } from "../cli";
+import { getFeatureAssertionsFromMatrix, getSegmentAssertionsFromMatrix } from "../tester";
+
+async function getEntitiesWithTests(
+  deps: Dependencies,
+): Promise<{ features: string[]; segments: string[] }> {
+  const { datasource } = deps;
+
+  const featuresWithTests = new Set<string>();
+  const segmentsWithTests = new Set<string>();
+
+  const tests = await datasource.listTests();
+  for (const testKey of tests) {
+    const test = await datasource.readTest(testKey);
+
+    if ((test as TestFeature).feature) {
+      featuresWithTests.add((test as TestFeature).feature);
+    }
+
+    if ((test as TestSegment).segment) {
+      segmentsWithTests.add((test as TestSegment).segment);
+    }
+  }
+
+  return {
+    features: Array.from(featuresWithTests),
+    segments: Array.from(segmentsWithTests),
+  };
+}
+
+async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
+  const { datasource, options } = deps;
+
+  const result: T[] = [];
+  let entityKeys: string[] = [];
+
+  if (entityType === "feature") {
+    entityKeys = await datasource.listFeatures();
+  } else if (entityType === "segment") {
+    entityKeys = await datasource.listSegments();
+  } else if (entityType === "attribute") {
+    entityKeys = await datasource.listAttributes();
+  } else if (entityType === "test") {
+    entityKeys = await datasource.listTests();
+  }
+
+  if (entityKeys.length === 0) {
+    return result;
+  }
+
+  let entitiesWithTests: { features: string[]; segments: string[] } = {
+    features: [],
+    segments: [],
+  };
+  let entitiesWithTestsInitialized = false;
+
+  async function initializeEntitiesWithTests() {
+    if (entitiesWithTestsInitialized) {
+      return;
+    }
+
+    entitiesWithTests = await getEntitiesWithTests(deps);
+    entitiesWithTestsInitialized = true;
+  }
+
+  for (const key of entityKeys) {
+    let entity = {} as T;
+
+    if (entityType === "feature") {
+      entity = (await datasource.readFeature(key)) as T;
+    } else if (entityType === "segment") {
+      entity = (await datasource.readSegment(key)) as T;
+    } else if (entityType === "attribute") {
+      entity = (await datasource.readAttribute(key)) as T;
+    } else if (entityType === "test") {
+      entity = (await datasource.readTest(key)) as T;
+    }
+
+    // filter
+    if (entityType === "feature") {
+      const parsedFeature = entity as ParsedFeature;
+
+      // --archived=true|false
+      if (parsedFeature.archived) {
+        const archivedStatus = options.archived === "false";
+
+        if (parsedFeature.archived !== archivedStatus) {
+          continue;
+        }
+      }
+
+      // --description=<pattern>
+      if (options.description) {
+        const description = parsedFeature.description || "";
+
+        const regex = new RegExp(options.description, "i");
+        if (!regex.test(description)) {
+          continue;
+        }
+      }
+
+      // --disabledIn=<environment>
+      if (
+        options.disabledIn &&
+        parsedFeature.environments &&
+        parsedFeature.environments[options.disabledIn]
+      ) {
+        const disabledInEnvironment = parsedFeature.environments[options.disabledIn].rules.every(
+          (rule) => {
+            return rule.percentage === 0;
+          },
+        );
+
+        if (!disabledInEnvironment) {
+          continue;
+        }
+      }
+
+      // --enabledIn=<environment>
+      if (
+        options.enabledIn &&
+        parsedFeature.environments &&
+        parsedFeature.environments[options.enabledIn]
+      ) {
+        const enabledInEnvironment = parsedFeature.environments[options.enabledIn].rules.some(
+          (rule) => {
+            return rule.percentage > 0;
+          },
+        );
+
+        if (!enabledInEnvironment) {
+          continue;
+        }
+      }
+
+      // --keyPattern=<pattern>
+      if (options.keyPattern) {
+        const regex = new RegExp(options.keyPattern, "i");
+        if (!regex.test(key)) {
+          continue;
+        }
+      }
+
+      // --tag=<tag>
+      if (options.tag) {
+        const tags = Array.isArray(options.tag) ? options.tag : [options.tag];
+        const hasTags = tags.every((tag) => parsedFeature.tags.includes(tag));
+
+        if (!hasTags) {
+          continue;
+        }
+      }
+
+      // --variable=<variableKey>
+      if (options.variable) {
+        const lookForVariables = Array.isArray(options.variable)
+          ? options.variable
+          : [options.variable];
+
+        let variablesInFeature: string[] = [];
+        if (Array.isArray(parsedFeature.variablesSchema)) {
+          variablesInFeature = parsedFeature.variablesSchema.map((variable) => variable.key);
+        } else if (parsedFeature.variablesSchema) {
+          variablesInFeature = Object.keys(parsedFeature.variablesSchema);
+        }
+
+        const hasVariables = lookForVariables.every((variable) =>
+          variablesInFeature.includes(variable),
+        );
+
+        if (!hasVariables) {
+          continue;
+        }
+      }
+
+      // --variation=<variationValue>
+      if (options.variation) {
+        const lookForVariations = Array.isArray(options.variation)
+          ? options.variation
+          : [options.variation];
+
+        let variationsInFeature: string[] = parsedFeature.variations
+          ? parsedFeature.variations.map((v) => v.value)
+          : [];
+
+        const hasVariations = lookForVariations.every((variation) =>
+          variationsInFeature.includes(variation),
+        );
+
+        if (!hasVariations) {
+          continue;
+        }
+      }
+
+      // --with-tests
+      if (options.withTests) {
+        await initializeEntitiesWithTests();
+
+        if (!entitiesWithTests.features.includes(key)) {
+          continue;
+        }
+      }
+
+      // --with-variables
+      if (options.withVariables) {
+        const hasVariables = parsedFeature.variablesSchema;
+
+        if (!hasVariables) {
+          continue;
+        }
+      }
+
+      // --with-variations
+      if (options.withVariations) {
+        const hasVariations = parsedFeature.variations;
+
+        if (!hasVariations) {
+          continue;
+        }
+      }
+
+      // --without-tests
+      if (options.withoutTests) {
+        await initializeEntitiesWithTests();
+
+        if (entitiesWithTests.features.includes(key)) {
+          continue;
+        }
+      }
+
+      // --without-variables
+      if (options.withoutVariables) {
+        const hasVariables = parsedFeature.variablesSchema;
+
+        if (hasVariables) {
+          continue;
+        }
+      }
+
+      // --without-variations
+      if (options.withoutVariations) {
+        const hasVariations = parsedFeature.variations;
+
+        if (hasVariations) {
+          continue;
+        }
+      }
+    } else if (entityType === "segment") {
+      const segment = entity as Segment;
+
+      // --archived=true|false
+      if (segment.archived) {
+        const archivedStatus = options.archived === "false";
+
+        if (segment.archived !== archivedStatus) {
+          continue;
+        }
+      }
+
+      // --description=<pattern>
+      if (options.description) {
+        const description = segment.description || "";
+
+        const regex = new RegExp(options.description, "i");
+        if (!regex.test(description)) {
+          continue;
+        }
+      }
+
+      // --keyPattern=<pattern>
+      if (options.keyPattern) {
+        const regex = new RegExp(options.keyPattern, "i");
+        if (!regex.test(key)) {
+          continue;
+        }
+      }
+
+      // --with-tests
+      if (options.withTests) {
+        await initializeEntitiesWithTests();
+
+        if (!entitiesWithTests.segments.includes(key)) {
+          continue;
+        }
+      }
+
+      // --without-tests
+      if (options.withoutTests) {
+        await initializeEntitiesWithTests();
+
+        if (entitiesWithTests.segments.includes(key)) {
+          continue;
+        }
+      }
+    } else if (entityType === "attribute") {
+      const attribute = entity as Attribute;
+
+      // --archived=true|false
+      if (options.archived) {
+        const archivedStatus = options.archived === "false";
+
+        if (attribute.archived !== archivedStatus) {
+          continue;
+        }
+      }
+
+      // --description=<pattern>
+      if (options.description) {
+        const description = attribute.description || "";
+
+        const regex = new RegExp(options.description, "i");
+        if (!regex.test(description)) {
+          continue;
+        }
+      }
+
+      // --keyPattern=<pattern>
+      if (options.keyPattern) {
+        const regex = new RegExp(options.keyPattern, "i");
+        if (!regex.test(key)) {
+          continue;
+        }
+      }
+    } else if (entityType === "test") {
+      let test = entity as TestFeature | TestSegment;
+      const testEntityKey = (test as TestFeature).feature || (test as TestSegment).segment;
+      const testEntityType = (test as TestSegment).segment ? "segment" : "feature";
+      let testAssertions = test.assertions;
+
+      // --apply-matrix
+      if (options.applyMatrix) {
+        if (testEntityType === "feature") {
+          let assertionsAfterApplyingMatrix: FeatureAssertion[] = [];
+          for (let aIndex = 0; aIndex < testAssertions.length; aIndex++) {
+            const processedAssertions = getFeatureAssertionsFromMatrix(
+              aIndex,
+              testAssertions[aIndex] as FeatureAssertion,
+            );
+            assertionsAfterApplyingMatrix =
+              assertionsAfterApplyingMatrix.concat(processedAssertions);
+          }
+
+          testAssertions = assertionsAfterApplyingMatrix;
+        } else if (testEntityType === "segment") {
+          let assertionsAfterApplyingMatrix: SegmentAssertion[] = [];
+          for (let aIndex = 0; aIndex < testAssertions.length; aIndex++) {
+            const processedAssertions = getSegmentAssertionsFromMatrix(
+              aIndex,
+              testAssertions[aIndex] as SegmentAssertion,
+            );
+            assertionsAfterApplyingMatrix =
+              assertionsAfterApplyingMatrix.concat(processedAssertions);
+          }
+
+          testAssertions = assertionsAfterApplyingMatrix;
+        }
+      }
+
+      // --keyPattern=<pattern>
+      if (options.keyPattern) {
+        const regex = new RegExp(options.keyPattern, "i");
+        if (!regex.test(testEntityKey)) {
+          continue;
+        }
+      }
+
+      // --assertionPattern=<pattern>
+      if (options.assertionPattern) {
+        const regex = new RegExp(options.assertionPattern, "i");
+        testAssertions = testAssertions.filter((assertion) => {
+          if (!assertion.description) {
+            return false;
+          }
+
+          return regex.test(assertion.description);
+        }) as FeatureAssertion[] | SegmentAssertion[];
+
+        if (testAssertions.length === 0) {
+          continue;
+        }
+      }
+
+      (entity as TestFeature | TestSegment).assertions = testAssertions;
+    }
+
+    result.push({
+      ...entity,
+      key,
+    });
+  }
+
+  return result;
+}
+
+function ucfirst(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function printResult({ result, entityType, options }) {
+  if (options.json) {
+    console.log(options.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result));
+    return;
+  }
+
+  if (result.length === 0) {
+    console.log(`No ${entityType}s found.`);
+    return;
+  }
+
+  console.log(`\n${ucfirst(entityType)}s:\n`);
+
+  for (const item of result) {
+    console.log(`- ${item.key}`);
+  }
+
+  console.log(`\n\nFound ${result.length} ${entityType}s.`);
+}
+
+export async function listProject(deps: Dependencies) {
+  const { rootDirectoryPath, projectConfig, datasource, options } = deps;
+
+  // features
+  if (options.features) {
+    const result = await listEntities<ParsedFeature>(deps, "feature");
+
+    return printResult({
+      result,
+      entityType: "feature",
+      options,
+    });
+  }
+
+  // segments
+  if (options.segments) {
+    const result = await listEntities<Segment>(deps, "segment");
+
+    return printResult({
+      result,
+      entityType: "segment",
+      options,
+    });
+  }
+
+  // attributes
+  if (options.attributes) {
+    const result = await listEntities<Attribute>(deps, "attribute");
+
+    return printResult({
+      result,
+      entityType: "attribute",
+      options,
+    });
+  }
+
+  // tests
+  if (options.tests) {
+    const result = await listEntities<Attribute>(deps, "test");
+
+    return printResult({
+      result,
+      entityType: "test",
+      options,
+    });
+  }
+
+  console.log("\nNothing to list. \n\nPlease pass `--features`, `--segments`, or `--attributes`.");
+}
+
+export const listPlugin: Plugin = {
+  command: "list",
+  handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
+    await listProject({
+      rootDirectoryPath,
+      projectConfig,
+      datasource,
+      options: parsed,
+    });
+  },
+  examples: [
+    {
+      command: "list",
+      description: "list entities",
+    },
+  ],
+};

package/src/tester/index.ts

@@ -1,2 +1,3 @@
 export * from "./testProject";
 export * from "./testFeature";
+export * from "./matrix";