@featurevisor/core 0.53.2 → 0.53.4

package/src/linter/lintProject.ts

@@ -1,6 +1,4 @@
 // for use in node only
-import * as fs from "fs";
-
 import * as Joi from "joi";
 
 import { Datasource } from "../datasource";
@@ -25,13 +23,13 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
   const availableFeatureKeys: string[] = [];
 
   // lint attributes
-  const attributes = datasource.listAttributes();
+  const attributes = await datasource.listAttributes();
   console.log(`Linting ${attributes.length} attributes...\n`);
 
   const attributeJoiSchema = getAttributeJoiSchema();
 
   for (const key of attributes) {
-    const parsed = datasource.readAttribute(key);
+    const parsed = await datasource.readAttribute(key);
     availableAttributeKeys.push(key);
 
     try {
@@ -50,14 +48,14 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
   }
 
   // lint segments
-  const segments = datasource.listSegments();
+  const segments = await datasource.listSegments();
   console.log(`\nLinting ${segments.length} segments...\n`);
 
   const conditionsJoiSchema = getConditionsJoiSchema(projectConfig, availableAttributeKeys);
   const segmentJoiSchema = getSegmentJoiSchema(projectConfig, conditionsJoiSchema);
 
   for (const key of segments) {
-    const parsed = datasource.readSegment(key);
+    const parsed = await datasource.readSegment(key);
     availableSegmentKeys.push(key);
 
     try {
@@ -75,38 +73,8 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
     }
   }
 
-  // lint groups
-
-  if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
-    const groups = datasource.listGroups();
-    console.log(`\nLinting ${groups.length} groups...\n`);
-
-    // @TODO: feature it slots can be from availableFeatureKeys only
-    const groupJoiSchema = getGroupJoiSchema(projectConfig, datasource, availableFeatureKeys);
-
-    for (const key of groups) {
-      const parsed = datasource.readGroup(key);
-
-      try {
-        await groupJoiSchema.validateAsync(parsed);
-      } catch (e) {
-        console.log("  =>", key);
-
-        if (e instanceof Joi.ValidationError) {
-          printJoiError(e);
-        } else {
-          console.log(e);
-        }
-
-        hasError = true;
-      }
-    }
-  }
-
-  // @TODO: feature cannot exist in multiple groups
-
   // lint features
-  const features = datasource.listFeatures();
+  const features = await datasource.listFeatures();
   console.log(`\nLinting ${features.length} features...\n`);
 
   const featureJoiSchema = getFeatureJoiSchema(
@@ -117,7 +85,7 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
   );
 
   for (const key of features) {
-    const parsed = datasource.readFeature(key);
+    const parsed = await datasource.readFeature(key);
     availableFeatureKeys.push(key);
 
     try {
@@ -136,7 +104,7 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
 
     if (parsed.required) {
       try {
-        checkForCircularDependencyInRequired(datasource, key, parsed.required);
+        await checkForCircularDependencyInRequired(datasource, key, parsed.required);
       } catch (e) {
         console.log("  =>", key);
         console.log("     => Error:", e.message);
@@ -145,33 +113,58 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
     }
   }
 
-  // lint tests
-  if (fs.existsSync(projectConfig.testsDirectoryPath)) {
-    const tests = datasource.listTests();
-    console.log(`\nLinting ${tests.length} tests...\n`);
+  // lint groups
+  const groups = await datasource.listGroups();
+  console.log(`\nLinting ${groups.length} groups...\n`);
 
-    const testsJoiSchema = getTestsJoiSchema(
-      projectConfig,
-      availableFeatureKeys,
-      availableSegmentKeys,
-    );
+  // @TODO: feature it slots can be from availableFeatureKeys only
+  const groupJoiSchema = getGroupJoiSchema(projectConfig, datasource, availableFeatureKeys);
 
-    for (const key of tests) {
-      const parsed = datasource.readTest(key);
+  for (const key of groups) {
+    const parsed = await datasource.readGroup(key);
 
-      try {
-        await testsJoiSchema.validateAsync(parsed);
-      } catch (e) {
-        console.log("  =>", key);
+    try {
+      await groupJoiSchema.validateAsync(parsed);
+    } catch (e) {
+      console.log("  =>", key);
+
+      if (e instanceof Joi.ValidationError) {
+        printJoiError(e);
+      } else {
+        console.log(e);
+      }
+
+      hasError = true;
+    }
+  }
 
-        if (e instanceof Joi.ValidationError) {
-          printJoiError(e);
-        } else {
-          console.log(e);
-        }
+  // @TODO: feature cannot exist in multiple groups
 
-        hasError = true;
+  // lint tests
+  const tests = await datasource.listTests();
+  console.log(`\nLinting ${tests.length} tests...\n`);
+
+  const testsJoiSchema = getTestsJoiSchema(
+    projectConfig,
+    availableFeatureKeys,
+    availableSegmentKeys,
+  );
+
+  for (const key of tests) {
+    const parsed = await datasource.readTest(key);
+
+    try {
+      await testsJoiSchema.validateAsync(parsed);
+    } catch (e) {
+      console.log("  =>", key);
+
+      if (e instanceof Joi.ValidationError) {
+        printJoiError(e);
+      } else {
+        console.log(e);
       }
+
+      hasError = true;
     }
   }
 

package/src/restore.ts

@@ -3,7 +3,7 @@ import { execSync } from "child_process";
 
 import { ProjectConfig } from "./config";
 
-export function restoreProject(rootDirectoryPath, projectConfig: ProjectConfig) {
+export async function restoreProject(rootDirectoryPath, projectConfig: ProjectConfig) {
   const relativeStateDirPath = path.relative(rootDirectoryPath, projectConfig.stateDirectoryPath);
   const cmd = `git checkout -- ${relativeStateDirPath}${path.sep}`;
 

package/src/site/exportSite.ts

@@ -9,7 +9,7 @@ import { generateHistory } from "./generateHistory";
 import { getRepoDetails } from "./getRepoDetails";
 import { generateSiteSearchIndex } from "./generateSiteSearchIndex";
 
-export function exportSite(rootDirectoryPath: string, projectConfig: ProjectConfig) {
+export async function exportSite(rootDirectoryPath: string, projectConfig: ProjectConfig) {
   const hasError = false;
 
   mkdirp.sync(projectConfig.siteExportDirectoryPath);
@@ -30,7 +30,7 @@ export function exportSite(rootDirectoryPath: string, projectConfig: ProjectConf
 
   // site search index
   const repoDetails = getRepoDetails();
-  const searchIndex = generateSiteSearchIndex(
+  const searchIndex = await generateSiteSearchIndex(
     rootDirectoryPath,
     projectConfig,
     fullHistory,

package/src/site/generateSiteSearchIndex.ts

@@ -15,12 +15,12 @@ import { getRelativePaths } from "./getRelativePaths";
 import { getLastModifiedFromHistory } from "./getLastModifiedFromHistory";
 import { RepoDetails } from "./getRepoDetails";
 
-export function generateSiteSearchIndex(
+export async function generateSiteSearchIndex(
   rootDirectoryPath: string,
   projectConfig: ProjectConfig,
   fullHistory: HistoryEntry[],
   repoDetails: RepoDetails | undefined,
-): SearchIndex {
+): Promise<SearchIndex> {
   const result: SearchIndex = {
     links: undefined,
     entities: {
@@ -77,9 +77,9 @@ export function generateSiteSearchIndex(
   } = {};
 
   // features
-  const featureFiles = datasource.listFeatures();
-  featureFiles.forEach((entityName) => {
-    const parsed = datasource.readFeature(entityName);
+  const featureFiles = await datasource.listFeatures();
+  for (const entityName of featureFiles) {
+    const parsed = await datasource.readFeature(entityName);
 
     if (Array.isArray(parsed.variations)) {
       parsed.variations.forEach((variation) => {
@@ -160,12 +160,12 @@ export function generateSiteSearchIndex(
       key: entityName,
       lastModified: getLastModifiedFromHistory(fullHistory, "feature", entityName),
     });
-  });
+  }
 
   // segments
-  const segmentFiles = datasource.listSegments();
-  segmentFiles.forEach((entityName) => {
-    const parsed = datasource.readSegment(entityName);
+  const segmentFiles = await datasource.listSegments();
+  for (const entityName of segmentFiles) {
+    const parsed = await datasource.readSegment(entityName);
 
     extractAttributeKeysFromConditions(parsed.conditions as Condition | Condition[]).forEach(
       (attributeKey) => {
@@ -183,12 +183,12 @@ export function generateSiteSearchIndex(
       lastModified: getLastModifiedFromHistory(fullHistory, "segment", entityName),
       usedInFeatures: Array.from(segmentsUsedInFeatures[entityName] || []),
     });
-  });
+  }
 
   // attributes
-  const attributeFiles = datasource.listAttributes();
-  attributeFiles.forEach((entityName) => {
-    const parsed = datasource.readAttribute(entityName);
+  const attributeFiles = await datasource.listAttributes();
+  for (const entityName of attributeFiles) {
+    const parsed = await datasource.readAttribute(entityName);
 
     result.entities.attributes.push({
       ...parsed,
@@ -197,7 +197,7 @@ export function generateSiteSearchIndex(
       usedInFeatures: Array.from(attributesUsedInFeatures[entityName] || []),
       usedInSegments: Array.from(attributesUsedInSegments[entityName] || []),
     });
-  });
+  }
 
   return result;
 }

package/src/tester/testFeature.ts

@@ -1,35 +1,36 @@
-import * as fs from "fs";
-
-import { TestFeature, ExistingState } from "@featurevisor/types";
+import { TestFeature } from "@featurevisor/types";
 import { createInstance, MAX_BUCKETED_NUMBER } from "@featurevisor/sdk";
 
 import { Datasource } from "../datasource";
 import { ProjectConfig } from "../config";
-import { buildDatafile, getExistingStateFilePath } from "../builder";
+import { buildDatafile } from "../builder";
 import { SCHEMA_VERSION } from "../config";
 
 import { checkIfArraysAreEqual } from "./checkIfArraysAreEqual";
 import { checkIfObjectsAreEqual } from "./checkIfObjectsAreEqual";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
 
-export function testFeature(
+export async function testFeature(
   datasource: Datasource,
   projectConfig: ProjectConfig,
   test: TestFeature,
-): boolean {
+): Promise<boolean> {
   let hasError = false;
   const featureKey = test.feature;
 
   console.log(CLI_FORMAT_BOLD, `  Feature "${featureKey}":`);
 
-  test.assertions.forEach(function (assertion, aIndex) {
+  for (let aIndex = 0; aIndex < test.assertions.length; aIndex++) {
+    const assertion = test.assertions[aIndex];
     const description = assertion.description || `at ${assertion.at}%`;
 
     console.log(`  Assertion #${aIndex + 1}: (${assertion.environment}) ${description}`);
 
-    const featuresToInclude = Array.from(datasource.getRequiredFeaturesChain(test.feature));
+    const requiredChain = await datasource.getRequiredFeaturesChain(test.feature);
+    const featuresToInclude = Array.from(requiredChain);
 
-    const datafileContent = buildDatafile(
+    const existingState = await datasource.readState(assertion.environment);
+    const datafileContent = await buildDatafile(
       projectConfig,
       datasource,
       {
@@ -38,9 +39,7 @@ export function testFeature(
         environment: assertion.environment,
         features: featuresToInclude,
       },
-      JSON.parse(
-        fs.readFileSync(getExistingStateFilePath(projectConfig, assertion.environment), "utf8"),
-      ) as ExistingState,
+      existingState,
     );
 
     const sdk = createInstance({
@@ -110,7 +109,7 @@ export function testFeature(
         }
       });
     }
-  });
+  }
 
   return hasError;
 }

package/src/tester/testProject.ts

@@ -9,7 +9,10 @@ import { testSegment } from "./testSegment";
 import { testFeature } from "./testFeature";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_GREEN, CLI_FORMAT_RED } from "./cliFormat";
 
-export function testProject(rootDirectoryPath: string, projectConfig: ProjectConfig): boolean {
+export async function testProject(
+  rootDirectoryPath: string,
+  projectConfig: ProjectConfig,
+): Promise<boolean> {
   let hasError = false;
   const datasource = new Datasource(projectConfig);
 
@@ -20,7 +23,7 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
     return hasError;
   }
 
-  const testFiles = datasource.listTests();
+  const testFiles = await datasource.listTests();
 
   if (testFiles.length === 0) {
     console.error(`No tests found in: ${projectConfig.testsDirectoryPath}`);
@@ -35,13 +38,13 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
     console.log("");
     console.log(CLI_FORMAT_BOLD, `Testing: ${testFilePath.replace(rootDirectoryPath, "")}`);
 
-    const t = datasource.readTest(testFile);
+    const t = await datasource.readTest(testFile);
 
     if ((t as TestSegment).segment) {
       // segment testing
       const test = t as TestSegment;
 
-      const segmentHasError = testSegment(datasource, test);
+      const segmentHasError = await testSegment(datasource, test);
 
       if (segmentHasError) {
         hasError = true;
@@ -50,7 +53,7 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
       // feature testing
       const test = t as TestFeature;
 
-      const featureHasError = testFeature(datasource, projectConfig, test);
+      const featureHasError = await testFeature(datasource, projectConfig, test);
 
       if (featureHasError) {
         hasError = true;

package/src/tester/testSegment.ts

@@ -5,14 +5,14 @@ import { Datasource } from "../datasource";
 
 import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
 
-export function testSegment(datasource: Datasource, test: TestSegment): boolean {
+export async function testSegment(datasource: Datasource, test: TestSegment): Promise<boolean> {
   let hasError = false;
 
   const segmentKey = test.segment;
 
   console.log(CLI_FORMAT_BOLD, `  Segment "${segmentKey}":`);
 
-  const segmentExists = datasource.entityExists("segment", segmentKey);
+  const segmentExists = await datasource.entityExists("segment", segmentKey);
 
   if (!segmentExists) {
     console.error(CLI_FORMAT_RED, `  Segment does not exist: ${segmentKey}`);
@@ -21,7 +21,7 @@ export function testSegment(datasource: Datasource, test: TestSegment): boolean
     return hasError;
   }
 
-  const parsedSegment = datasource.readSegment(segmentKey);
+  const parsedSegment = await datasource.readSegment(segmentKey);
   const conditions = parsedSegment.conditions as Condition | Condition[];
 
   test.assertions.forEach(function (assertion, aIndex) {

package/src/utils.ts

@@ -1,23 +1,5 @@
-import * as fs from "fs";
-import * as path from "path";
-
-import * as yaml from "js-yaml";
-
 import { Condition, AttributeKey, GroupSegment, SegmentKey } from "@featurevisor/types";
 
-export function getYAMLFiles(directoryPath: string) {
-  const files = fs.readdirSync(directoryPath);
-  const yamlFiles = files.filter((file) => file.endsWith(".yml"));
-
-  return yamlFiles.map((file) => path.join(directoryPath, file));
-}
-
-export function parseYaml(content: string) {
-  const parsed = yaml.load(content);
-
-  return parsed;
-}
-
 export function extractSegmentKeysFromGroupSegments(
   segments: GroupSegment | GroupSegment[],
 ): Set<SegmentKey> {