@featurevisor/core 0.53.2 → 0.53.3

package/src/builder/getFeatureRanges.ts

@@ -12,19 +12,19 @@ export interface FeatureRangesResult {
   featureIsInGroup: { [key: string]: boolean };
 }
 
-export function getFeatureRanges(
+export async function getFeatureRanges(
   projectConfig: ProjectConfig,
   datasource: Datasource,
-): FeatureRangesResult {
+): Promise<FeatureRangesResult> {
   const featureRanges = new Map<FeatureKey, Range[]>();
   const featureIsInGroup = {}; // featureKey => boolean
 
   const groups: Group[] = [];
   if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
-    const groupFiles = datasource.listGroups();
+    const groupFiles = await datasource.listGroups();
 
     for (const groupKey of groupFiles) {
-      const parsedGroup = datasource.readGroup(groupKey);
+      const parsedGroup = await datasource.readGroup(groupKey);
 
       groups.push({
         ...parsedGroup,

package/src/datasource/datasource.ts

@@ -1,15 +1,7 @@
 import * as path from "path";
 import * as fs from "fs";
 
-import {
-  Tag,
-  ParsedFeature,
-  Segment,
-  Attribute,
-  Group,
-  FeatureKey,
-  Test,
-} from "@featurevisor/types";
+import { ParsedFeature, Segment, Attribute, Group, FeatureKey, Test } from "@featurevisor/types";
 
 import { ProjectConfig } from "../config";
 import { parsers } from "./parsers";
@@ -53,7 +45,7 @@ export class Datasource {
   /**
    * Common methods
    */
-  listEntities(entityType: EntityType): string[] {
+  async listEntities(entityType: EntityType): Promise<string[]> {
     const directoryPath = this.getEntityDirectoryPath(entityType);
 
     return fs
@@ -82,20 +74,20 @@ export class Datasource {
     return path.join(basePath, `${entityKey}.${this.extension}`);
   }
 
-  entityExists(entityType: EntityType, entityKey: string): boolean {
+  async entityExists(entityType: EntityType, entityKey: string): Promise<boolean> {
     const entityPath = this.getEntityPath(entityType, entityKey);
 
     return fs.existsSync(entityPath);
   }
 
-  readEntity(entityType: EntityType, entityKey: string): string {
+  async readEntity(entityType: EntityType, entityKey: string): Promise<string> {
     const filePath = this.getEntityPath(entityType, entityKey);
 
     return fs.readFileSync(filePath, "utf8");
   }
 
-  parseEntity<T>(entityType: EntityType, entityKey: string): T {
-    const entityContent = this.readEntity(entityType, entityKey);
+  async parseEntity<T>(entityType: EntityType, entityKey: string): Promise<T> {
+    const entityContent = await this.readEntity(entityType, entityKey);
 
     return this.parse(entityContent) as T;
   }
@@ -105,61 +97,46 @@ export class Datasource {
    */
 
   // features
-  listFeatures(tag?: Tag) {
-    const features = this.listEntities("feature");
-
-    if (tag) {
-      return features.filter((feature) => {
-        const featureContent = this.parseEntity<ParsedFeature>("feature", feature);
-
-        return featureContent.tags.indexOf(tag) !== -1;
-      });
-    }
-
-    return features;
+  async listFeatures() {
+    return await this.listEntities("feature");
   }
 
   readFeature(featureKey: string) {
     return this.parseEntity<ParsedFeature>("feature", featureKey);
   }
 
-  getRequiredFeaturesChain(featureKey: FeatureKey, chain = new Set<FeatureKey>()): Set<FeatureKey> {
+  async getRequiredFeaturesChain(
+    featureKey: FeatureKey,
+    chain = new Set<FeatureKey>(),
+  ): Promise<Set<FeatureKey>> {
     chain.add(featureKey);
 
     if (!this.entityExists("feature", featureKey)) {
       throw new Error(`Feature not found: ${featureKey}`);
     }
 
-    const feature = this.readFeature(featureKey);
+    const feature = await this.readFeature(featureKey);
 
     if (!feature.required) {
       return chain;
     }
 
-    feature.required.forEach((r) => {
+    for (const r of feature.required) {
       const requiredKey = typeof r === "string" ? r : r.key;
 
       if (chain.has(requiredKey)) {
         throw new Error(`Circular dependency detected: ${chain.toString()}`);
       }
 
-      this.getRequiredFeaturesChain(requiredKey, chain);
-    });
+      await this.getRequiredFeaturesChain(requiredKey, chain);
+    }
 
     return chain;
   }
 
   // segments
-  listSegments(segmentsList?: string[]) {
-    const segments = this.listEntities("segment");
-
-    if (segmentsList) {
-      return segments.filter((segment) => {
-        return segmentsList.indexOf(segment) !== -1;
-      });
-    }
-
-    return segments;
+  listSegments() {
+    return this.listEntities("segment");
   }
 
   readSegment(segmentKey: string) {
@@ -167,16 +144,8 @@ export class Datasource {
   }
 
   // attributes
-  listAttributes(attributesList?: string[]) {
-    const attributes = this.listEntities("attribute");
-
-    if (attributesList) {
-      return attributes.filter((segment) => {
-        return attributesList.indexOf(segment) !== -1;
-      });
-    }
-
-    return attributes;
+  listAttributes() {
+    return this.listEntities("attribute");
   }
 
   readAttribute(attributeKey: string) {
@@ -184,24 +153,8 @@ export class Datasource {
   }
 
   // groups
-  listGroups(featuresList?: string[]) {
-    const groups = this.listEntities("group");
-
-    if (featuresList) {
-      return groups.filter((group) => {
-        const groupContent = this.parseEntity<Group>("group", group);
-
-        return groupContent.slots.some((slot) => {
-          if (!slot.feature) {
-            return false;
-          }
-
-          return featuresList.indexOf(slot.feature) !== -1;
-        });
-      });
-    }
-
-    return groups;
+  async listGroups() {
+    return this.listEntities("group");
   }
 
   readGroup(groupKey: string) {

package/src/find-duplicate-segments/findDuplicateSegments.ts

@@ -4,17 +4,20 @@ import { SegmentKey } from "@featurevisor/types";
 
 import { Datasource } from "../datasource";
 
-export function findDuplicateSegments(datasource: Datasource): SegmentKey[][] {
-  const segmentsWithHash = datasource.listSegments().map((segmentKey) => {
-    const segment = datasource.readSegment(segmentKey);
+export async function findDuplicateSegments(datasource: Datasource): Promise<SegmentKey[][]> {
+  const segments = await datasource.listSegments();
+
+  const segmentsWithHash: { segmentKey: SegmentKey; hash: string }[] = [];
+  for (const segmentKey of segments) {
+    const segment = await datasource.readSegment(segmentKey);
     const conditions = JSON.stringify(segment.conditions);
     const hash = crypto.createHash("sha256").update(conditions).digest("hex");
 
-    return {
+    segmentsWithHash.push({
       segmentKey,
       hash,
-    };
-  });
+    });
+  }
 
   const groupedSegments: { [hash: string]: SegmentKey[] } = segmentsWithHash.reduce(
     (acc, { segmentKey, hash }) => {

package/src/find-duplicate-segments/index.ts

@@ -3,10 +3,13 @@ import { ProjectConfig } from "../config";
 
 import { findDuplicateSegments } from "./findDuplicateSegments";
 
-export function findDuplicateSegmentsInProject(rootDirectoryPath, projectConfig: ProjectConfig) {
+export async function findDuplicateSegmentsInProject(
+  rootDirectoryPath,
+  projectConfig: ProjectConfig,
+) {
   const datasource = new Datasource(projectConfig);
 
-  const duplicates = findDuplicateSegments(datasource);
+  const duplicates = await findDuplicateSegments(datasource);
 
   if (duplicates.length === 0) {
     console.log("No duplicate segments found");

package/src/generate-code/index.ts

@@ -14,7 +14,7 @@ export interface GenerateCodeCLIOptions {
   outDir: string;
 }
 
-export function generateCodeForProject(
+export async function generateCodeForProject(
   rootDirectoryPath,
   projectConfig: ProjectConfig,
   cliOptions: GenerateCodeCLIOptions,
@@ -47,7 +47,7 @@ export function generateCodeForProject(
   }
 
   if (cliOptions.language === "typescript") {
-    return generateTypeScriptCodeForProject(
+    return await generateTypeScriptCodeForProject(
       rootDirectoryPath,
       projectConfig,
       datasource,

package/src/generate-code/typescript.ts

@@ -3,6 +3,7 @@ import * as path from "path";
 
 import { ProjectConfig } from "../config";
 import { Datasource } from "../datasource";
+import { Attribute } from "@featurevisor/types";
 
 function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
   switch (featurevisorType) {
@@ -37,6 +38,16 @@ function getPascalCase(str) {
   return pascalCased;
 }
 
+function getRelativePath(from, to) {
+  const relativePath = path.relative(from, to);
+
+  if (relativePath.startsWith("..")) {
+    return path.join(".", relativePath);
+  }
+
+  return relativePath;
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function getFeaturevisorTypeFromValue(value) {
   if (typeof value === "boolean") {
@@ -76,39 +87,37 @@ export function getInstance(): FeaturevisorInstance {
 }
 `.trimStart();
 
-export function generateTypeScriptCodeForProject(
+export async function generateTypeScriptCodeForProject(
   rootDirectoryPath: string,
   projectConfig: ProjectConfig,
   datasource: Datasource,
   outputPath: string,
 ) {
-  console.log("Generating TypeScript code...");
+  console.log("\nGenerating TypeScript code...\n");
 
   // instance
   const instanceFilePath = path.join(outputPath, "instance.ts");
   fs.writeFileSync(instanceFilePath, instanceSnippet);
-  console.log(`Instance file written at: ${instanceFilePath}`);
+  console.log(`Instance file written at: ${getRelativePath(rootDirectoryPath, instanceFilePath)}`);
 
   // attributes
-  const attributeFiles = datasource.listAttributes();
-  const attributes = attributeFiles
-    .map((attributeKey) => {
-      const parsedAttribute = datasource.readAttribute(attributeKey);
-
-      return {
-        archived: parsedAttribute.archived,
-        key: attributeKey,
-        type: parsedAttribute.type,
-        typescriptType: convertFeaturevisorTypeToTypeScriptType(parsedAttribute.type),
-      };
-    })
-    .filter((attribute) => {
-      if (typeof attribute.archived === "undefined") {
-        return true;
-      }
+  const attributeFiles = await datasource.listAttributes();
+  const attributes: (Attribute & { typescriptType })[] = [];
 
-      return !attribute.archived;
+  for (const attributeKey of attributeFiles) {
+    const parsedAttribute = await datasource.readAttribute(attributeKey);
+
+    if (typeof parsedAttribute.archived === "undefined") {
+      continue;
+    }
+
+    attributes.push({
+      archived: parsedAttribute.archived,
+      key: attributeKey,
+      type: parsedAttribute.type,
+      typescriptType: convertFeaturevisorTypeToTypeScriptType(parsedAttribute.type),
     });
+  }
 
   // context
   const attributeProperties = attributes
@@ -127,13 +136,16 @@ ${attributeProperties}
 
   const contextTypeFilePath = path.join(outputPath, "Context.ts");
   fs.writeFileSync(contextTypeFilePath, contextContent);
-  console.log(`Context type file written at: ${contextTypeFilePath}`);
+  console.log(
+    `Context type file written at: ${getRelativePath(rootDirectoryPath, contextTypeFilePath)}`,
+  );
 
   // features
   const featureNamespaces: string[] = [];
-  const featureFiles = datasource.listFeatures();
+  const featureFiles = await datasource.listFeatures();
+
   for (const featureKey of featureFiles) {
-    const parsedFeature = datasource.readFeature(featureKey);
+    const parsedFeature = await datasource.readFeature(featureKey);
 
     if (typeof parsedFeature.archived !== "undefined" && parsedFeature.archived) {
       continue;
@@ -188,7 +200,12 @@ export namespace ${namespaceValue} {
 
     const featureNamespaceFilePath = path.join(outputPath, `${namespaceValue}.ts`);
     fs.writeFileSync(featureNamespaceFilePath, featureContent);
-    console.log(`Feature ${featureKey} file written at: ${featureNamespaceFilePath}`);
+    console.log(
+      `Feature ${featureKey} file written at: ${getRelativePath(
+        rootDirectoryPath,
+        featureNamespaceFilePath,
+      )}`,
+    );
   }
 
   // index
@@ -202,5 +219,5 @@ export namespace ${namespaceValue} {
       .join("\n") + "\n";
   const indexFilePath = path.join(outputPath, "index.ts");
   fs.writeFileSync(indexFilePath, indexContent);
-  console.log(`Index file written at: ${indexFilePath}`);
+  console.log(`Index file written at: ${getRelativePath(rootDirectoryPath, indexFilePath)}`);
 }

package/src/linter/checkCircularDependency.ts

@@ -2,7 +2,7 @@ import { FeatureKey, Required } from "@featurevisor/types";
 
 import { Datasource } from "../datasource";
 
-export function checkForCircularDependencyInRequired(
+export async function checkForCircularDependencyInRequired(
   datasource: Datasource,
   featureKey: FeatureKey,
   required?: Required[],
@@ -25,16 +25,16 @@ export function checkForCircularDependencyInRequired(
       throw new Error(`circular dependency found: ${chain.join(" -> ")}`);
     }
 
-    const requiredFeatureExists = datasource.entityExists("feature", requiredKey);
+    const requiredFeatureExists = await datasource.entityExists("feature", requiredKey);
 
     if (!requiredFeatureExists) {
       throw new Error(`required feature "${requiredKey}" not found`);
     }
 
-    const requiredParsedFeature = datasource.readFeature(requiredKey);
+    const requiredParsedFeature = await datasource.readFeature(requiredKey);
 
     if (requiredParsedFeature.required) {
-      checkForCircularDependencyInRequired(
+      await checkForCircularDependencyInRequired(
         datasource,
         featureKey,
         requiredParsedFeature.required,

package/src/linter/groupSchema.ts

@@ -17,7 +17,7 @@ export function getGroupJoiSchema(
           percentage: Joi.number().precision(3).min(0).max(100),
         }),
       )
-      .custom(function (value) {
+      .custom(async function (value) {
         const totalPercentage = value.reduce((acc, slot) => acc + slot.percentage, 0);
 
         if (totalPercentage !== 100) {
@@ -29,13 +29,13 @@ export function getGroupJoiSchema(
 
           if (slot.feature) {
             const featureKey = slot.feature;
-            const featureExists = datasource.entityExists("feature", featureKey);
+            const featureExists = availableFeatureKeys.indexOf(featureKey) > -1;
 
             if (!featureExists) {
               throw new Error(`feature ${featureKey} not found`);
             }
 
-            const parsedFeature = datasource.readFeature(featureKey);
+            const parsedFeature = await datasource.readFeature(featureKey);
 
             const environmentKeys = Object.keys(parsedFeature.environments);
             for (const environmentKey of environmentKeys) {

package/src/linter/lintProject.ts

@@ -25,13 +25,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 +50,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 +75,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 +87,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 +106,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,9 +115,39 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
     }
   }
 
+  // lint groups
+
+  if (fs.existsSync(projectConfig.groupsDirectoryPath)) {
+    const groups = await 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 = await 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 tests
   if (fs.existsSync(projectConfig.testsDirectoryPath)) {
-    const tests = datasource.listTests();
+    const tests = await datasource.listTests();
     console.log(`\nLinting ${tests.length} tests...\n`);
 
     const testsJoiSchema = getTestsJoiSchema(
@@ -157,7 +157,7 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
     );
 
     for (const key of tests) {
-      const parsed = datasource.readTest(key);
+      const parsed = await datasource.readTest(key);
 
       try {
         await testsJoiSchema.validateAsync(parsed);

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;
 }