@featurevisor/core 0.53.2 → 0.53.4

package/src/builder/buildDatafile.ts

@@ -33,12 +33,12 @@ export interface BuildOptions {
   features?: FeatureKey[];
 }
 
-export function buildDatafile(
+export async function buildDatafile(
   projectConfig: ProjectConfig,
   datasource: Datasource,
   options: BuildOptions,
   existingState: ExistingState,
-): DatafileContent {
+): Promise<DatafileContent> {
   const datafileContent: DatafileContent = {
     schemaVersion: options.schemaVersion,
     revision: options.revision,
@@ -49,17 +49,17 @@ export function buildDatafile(
 
   const segmentKeysUsedByTag = new Set<SegmentKey>();
   const attributeKeysUsedByTag = new Set<AttributeKey>();
-  const { featureRanges, featureIsInGroup } = getFeatureRanges(projectConfig, datasource);
+  const { featureRanges, featureIsInGroup } = await getFeatureRanges(projectConfig, datasource);
 
   // features
   const features: Feature[] = [];
   const featuresDirectory = projectConfig.featuresDirectoryPath;
 
   if (fs.existsSync(featuresDirectory)) {
-    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 (parsedFeature.archived === true) {
         continue;
@@ -200,10 +200,10 @@ export function buildDatafile(
   const segmentsDirectory = projectConfig.segmentsDirectoryPath;
 
   if (fs.existsSync(segmentsDirectory)) {
-    const segmentFiles = datasource.listSegments();
+    const segmentFiles = await datasource.listSegments();
 
     for (const segmentKey of segmentFiles) {
-      const parsedSegment = datasource.readSegment(segmentKey);
+      const parsedSegment = await datasource.readSegment(segmentKey);
 
       if (parsedSegment.archived === true) {
         continue;
@@ -235,10 +235,10 @@ export function buildDatafile(
   const attributesDirectory = projectConfig.attributesDirectoryPath;
 
   if (fs.existsSync(attributesDirectory)) {
-    const attributeFiles = datasource.listAttributes();
+    const attributeFiles = await datasource.listAttributes();
 
     for (const attributeKey of attributeFiles) {
-      const parsedAttribute = datasource.readAttribute(attributeKey);
+      const parsedAttribute = await datasource.readAttribute(attributeKey);
 
       if (parsedAttribute.archived === true) {
         continue;

package/src/builder/buildProject.ts

@@ -20,18 +20,11 @@ export function getDatafilePath(
   return path.join(projectConfig.outputDirectoryPath, environment, fileName);
 }
 
-export function getExistingStateFilePath(
-  projectConfig: ProjectConfig,
-  environment: EnvironmentKey,
-): string {
-  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
-}
-
 export interface BuildCLIOptions {
   revision?: string;
 }
 
-export function buildProject(
+export async function buildProject(
   rootDirectoryPath,
   projectConfig: ProjectConfig,
   cliOptions: BuildCLIOptions = {},
@@ -45,16 +38,11 @@ export function buildProject(
   for (const environment of environments) {
     console.log(`\nBuilding datafiles for environment: ${environment}`);
 
-    const existingStateFilePath = getExistingStateFilePath(projectConfig, environment);
-    const existingState: ExistingState = fs.existsSync(existingStateFilePath)
-      ? require(existingStateFilePath)
-      : {
-          features: {},
-        };
+    const existingState: ExistingState = await datasource.readState(environment);
 
     for (const tag of tags) {
       console.log(`\n  => Tag: ${tag}`);
-      const datafileContent = buildDatafile(
+      const datafileContent = await buildDatafile(
         projectConfig,
         datasource,
         {
@@ -82,14 +70,6 @@ export function buildProject(
     }
 
     // write state for environment
-    if (!fs.existsSync(projectConfig.stateDirectoryPath)) {
-      mkdirp.sync(projectConfig.stateDirectoryPath);
-    }
-    fs.writeFileSync(
-      existingStateFilePath,
-      projectConfig.prettyState
-        ? JSON.stringify(existingState, null, 2)
-        : JSON.stringify(existingState),
-    );
+    await datasource.writeState(environment, existingState);
   }
 }

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,14 +1,17 @@
 import * as path from "path";
 import * as fs from "fs";
 
+import * as mkdirp from "mkdirp";
+
 import {
-  Tag,
   ParsedFeature,
   Segment,
   Attribute,
   Group,
   FeatureKey,
   Test,
+  EnvironmentKey,
+  ExistingState,
 } from "@featurevisor/types";
 
 import { ProjectConfig } from "../config";
@@ -16,6 +19,13 @@ import { parsers } from "./parsers";
 
 export type EntityType = "feature" | "group" | "segment" | "attribute" | "test";
 
+export function getExistingStateFilePath(
+  projectConfig: ProjectConfig,
+  environment: EnvironmentKey,
+): string {
+  return path.join(projectConfig.stateDirectoryPath, `existing-state-${environment}.json`);
+}
+
 export class Datasource {
   private extension;
   private parse;
@@ -51,11 +61,15 @@ export class Datasource {
   }
 
   /**
-   * Common methods
+   * Common methods for entities
    */
-  listEntities(entityType: EntityType): string[] {
+  async listEntities(entityType: EntityType): Promise<string[]> {
     const directoryPath = this.getEntityDirectoryPath(entityType);
 
+    if (!fs.existsSync(directoryPath)) {
+      return [];
+    }
+
     return fs
       .readdirSync(directoryPath)
       .filter((fileName) => fileName.endsWith(`.${this.extension}`))
@@ -82,84 +96,100 @@ 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;
   }
 
   /**
-   * Entity specific methods
+   * State
    */
+  async readState(environment: EnvironmentKey): Promise<ExistingState> {
+    const filePath = getExistingStateFilePath(this.config, environment);
 
-  // features
-  listFeatures(tag?: Tag) {
-    const features = this.listEntities("feature");
+    if (!fs.existsSync(filePath)) {
+      return {
+        features: {},
+      };
+    }
 
-    if (tag) {
-      return features.filter((feature) => {
-        const featureContent = this.parseEntity<ParsedFeature>("feature", feature);
+    return require(filePath);
+  }
+
+  async writeState(environment: EnvironmentKey, existingState: ExistingState) {
+    const filePath = getExistingStateFilePath(this.config, environment);
 
-        return featureContent.tags.indexOf(tag) !== -1;
-      });
+    if (!fs.existsSync(this.config.stateDirectoryPath)) {
+      mkdirp.sync(this.config.stateDirectoryPath);
     }
+    fs.writeFileSync(
+      filePath,
+      this.config.prettyState
+        ? JSON.stringify(existingState, null, 2)
+        : JSON.stringify(existingState),
+    );
 
-    return features;
+    fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+  }
+
+  /**
+   * Entity specific methods
+   */
+
+  // 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 +197,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 +206,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/datasource/parsers.ts

@@ -1,4 +1,4 @@
-import { parseYaml } from "../utils";
+import * as YAML from "js-yaml";
 
 /**
  * If we want to add more built-in parsers,
@@ -8,7 +8,7 @@ import { parseYaml } from "../utils";
 export const parsers = {
   // extension => function
   yml(content: string) {
-    return parseYaml(content);
+    return YAML.load(content);
   },
 
   json(content: 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) {