@featurevisor/core 0.53.3 → 0.53.5

package/src/datasource/datasource.ts

@@ -1,13 +1,31 @@
 import * as path from "path";
 import * as fs from "fs";
 
-import { ParsedFeature, Segment, Attribute, Group, FeatureKey, Test } from "@featurevisor/types";
+import * as mkdirp from "mkdirp";
+
+import {
+  ParsedFeature,
+  Segment,
+  Attribute,
+  Group,
+  FeatureKey,
+  Test,
+  EnvironmentKey,
+  ExistingState,
+} from "@featurevisor/types";
 
 import { ProjectConfig } from "../config";
 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;
@@ -43,11 +61,15 @@ export class Datasource {
   }
 
   /**
-   * Common methods
+   * Common methods for entities
    */
   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}`))
@@ -92,6 +114,37 @@ export class Datasource {
     return this.parse(entityContent) as T;
   }
 
+  /**
+   * State
+   */
+  async readState(environment: EnvironmentKey): Promise<ExistingState> {
+    const filePath = getExistingStateFilePath(this.config, environment);
+
+    if (!fs.existsSync(filePath)) {
+      return {
+        features: {},
+      };
+    }
+
+    return require(filePath);
+  }
+
+  async writeState(environment: EnvironmentKey, existingState: ExistingState) {
+    const filePath = getExistingStateFilePath(this.config, environment);
+
+    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),
+    );
+
+    fs.writeFileSync(filePath, JSON.stringify(existingState, null, 2));
+  }
+
   /**
    * Entity specific methods
    */

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/dependencies.ts

@@ -0,0 +1,13 @@
+import { ProjectConfig } from "./config";
+import { Datasource } from "./datasource";
+
+export interface Options {
+  [key: string]: any;
+}
+
+export interface Dependencies {
+  rootDirectoryPath: string;
+  projectConfig: ProjectConfig;
+  datasource: Datasource;
+  options: Options;
+}

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

@@ -1,13 +1,8 @@
-import { Datasource } from "../datasource";
-import { ProjectConfig } from "../config";
-
 import { findDuplicateSegments } from "./findDuplicateSegments";
+import { Dependencies } from "../dependencies";
 
-export async function findDuplicateSegmentsInProject(
-  rootDirectoryPath,
-  projectConfig: ProjectConfig,
-) {
-  const datasource = new Datasource(projectConfig);
+export async function findDuplicateSegmentsInProject(deps: Dependencies) {
+  const { datasource } = deps;
 
   const duplicates = await findDuplicateSegments(datasource);
 

package/src/generate-code/index.ts

@@ -3,9 +3,8 @@ import * as path from "path";
 
 import * as mkdirp from "mkdirp";
 
-import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource";
 import { generateTypeScriptCodeForProject } from "./typescript";
+import { Dependencies } from "../dependencies";
 
 export const ALLOWED_LANGUAGES_FOR_CODE_GENERATION = ["typescript"];
 
@@ -15,10 +14,11 @@ export interface GenerateCodeCLIOptions {
 }
 
 export async function generateCodeForProject(
-  rootDirectoryPath,
-  projectConfig: ProjectConfig,
+  deps: Dependencies,
   cliOptions: GenerateCodeCLIOptions,
 ) {
+  const { rootDirectoryPath } = deps;
+
   if (!cliOptions.language) {
     throw new Error("Option `--language` is required");
   }
@@ -27,8 +27,6 @@ export async function generateCodeForProject(
     throw new Error("Option `--out-dir` is required");
   }
 
-  const datasource = new Datasource(projectConfig);
-
   const absolutePath = path.resolve(rootDirectoryPath, cliOptions.outDir);
 
   if (!fs.existsSync(absolutePath)) {
@@ -47,12 +45,7 @@ export async function generateCodeForProject(
   }
 
   if (cliOptions.language === "typescript") {
-    return await generateTypeScriptCodeForProject(
-      rootDirectoryPath,
-      projectConfig,
-      datasource,
-      absolutePath,
-    );
+    return await generateTypeScriptCodeForProject(deps, absolutePath);
   }
 
   throw new Error(`Language ${cliOptions.language} is not supported`);

package/src/generate-code/typescript.ts

@@ -1,9 +1,8 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource";
 import { Attribute } from "@featurevisor/types";
+import { Dependencies } from "../dependencies";
 
 function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
   switch (featurevisorType) {
@@ -87,12 +86,9 @@ export function getInstance(): FeaturevisorInstance {
 }
 `.trimStart();
 
-export async function generateTypeScriptCodeForProject(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
-  datasource: Datasource,
-  outputPath: string,
-) {
+export async function generateTypeScriptCodeForProject(deps: Dependencies, outputPath: string) {
+  const { rootDirectoryPath, datasource } = deps;
+
   console.log("\nGenerating TypeScript code...\n");
 
   // instance

package/src/index.ts

@@ -7,3 +7,5 @@ export * from "./site";
 export * from "./generate-code";
 export * from "./restore";
 export * from "./find-duplicate-segments";
+export * from "./dependencies";
+export * from "./datasource";

package/src/linter/lintProject.ts

@@ -1,11 +1,6 @@
 // for use in node only
-import * as fs from "fs";
-
 import * as Joi from "joi";
 
-import { Datasource } from "../datasource";
-import { ProjectConfig } from "../config";
-
 import { getAttributeJoiSchema } from "./attributeSchema";
 import { getConditionsJoiSchema } from "./conditionSchema";
 import { getSegmentJoiSchema } from "./segmentSchema";
@@ -15,10 +10,12 @@ import { getTestsJoiSchema } from "./testSchema";
 
 import { checkForCircularDependencyInRequired } from "./checkCircularDependency";
 import { printJoiError } from "./printJoiError";
+import { Dependencies } from "../dependencies";
+
+export async function lintProject(deps: Dependencies): Promise<boolean> {
+  const { projectConfig, datasource } = deps;
 
-export async function lintProject(projectConfig: ProjectConfig): Promise<boolean> {
   let hasError = false;
-  const datasource = new Datasource(projectConfig);
 
   const availableAttributeKeys: string[] = [];
   const availableSegmentKeys: string[] = [];
@@ -116,62 +113,57 @@ export async function lintProject(projectConfig: ProjectConfig): Promise<boolean
   }
 
   // lint groups
+  const groups = await datasource.listGroups();
+  console.log(`\nLinting ${groups.length} groups...\n`);
 
-  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);
 
-    // @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);
 
-    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);
-        }
+    try {
+      await groupJoiSchema.validateAsync(parsed);
+    } catch (e) {
+      console.log("  =>", key);
 
-        hasError = true;
+      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 = await datasource.listTests();
-    console.log(`\nLinting ${tests.length} tests...\n`);
+  const tests = await datasource.listTests();
+  console.log(`\nLinting ${tests.length} tests...\n`);
 
-    const testsJoiSchema = getTestsJoiSchema(
-      projectConfig,
-      availableFeatureKeys,
-      availableSegmentKeys,
-    );
+  const testsJoiSchema = getTestsJoiSchema(
+    projectConfig,
+    availableFeatureKeys,
+    availableSegmentKeys,
+  );
 
-    for (const key of tests) {
-      const parsed = await datasource.readTest(key);
+  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);
-        }
+    try {
+      await testsJoiSchema.validateAsync(parsed);
+    } catch (e) {
+      console.log("  =>", key);
 
-        hasError = true;
+      if (e instanceof Joi.ValidationError) {
+        printJoiError(e);
+      } else {
+        console.log(e);
       }
+
+      hasError = true;
     }
   }
 

package/src/restore.ts

@@ -1,9 +1,11 @@
 import * as path from "path";
 import { execSync } from "child_process";
 
-import { ProjectConfig } from "./config";
+import { Dependencies } from "./dependencies";
+
+export async function restoreProject(deps: Dependencies) {
+  const { rootDirectoryPath, projectConfig } = deps;
 
-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

@@ -3,13 +3,14 @@ import * as path from "path";
 
 import * as mkdirp from "mkdirp";
 
-import { ProjectConfig } from "../config";
-
 import { generateHistory } from "./generateHistory";
 import { getRepoDetails } from "./getRepoDetails";
 import { generateSiteSearchIndex } from "./generateSiteSearchIndex";
+import { Dependencies } from "../dependencies";
+
+export async function exportSite(deps: Dependencies) {
+  const { rootDirectoryPath, projectConfig } = deps;
 
-export async function exportSite(rootDirectoryPath: string, projectConfig: ProjectConfig) {
   const hasError = false;
 
   mkdirp.sync(projectConfig.siteExportDirectoryPath);
@@ -30,12 +31,7 @@ export async function exportSite(rootDirectoryPath: string, projectConfig: Proje
 
   // site search index
   const repoDetails = getRepoDetails();
-  const searchIndex = await generateSiteSearchIndex(
-    rootDirectoryPath,
-    projectConfig,
-    fullHistory,
-    repoDetails,
-  );
+  const searchIndex = await generateSiteSearchIndex(deps, fullHistory, repoDetails);
   const searchIndexFilePath = path.join(projectConfig.siteExportDirectoryPath, "search-index.json");
   fs.writeFileSync(searchIndexFilePath, JSON.stringify(searchIndex));
   console.log(`Site search index written at: ${searchIndexFilePath}`);

package/src/site/generateSiteSearchIndex.ts

@@ -7,20 +7,20 @@ import {
   Condition,
 } from "@featurevisor/types";
 
-import { Datasource } from "../datasource";
-import { ProjectConfig } from "../config";
 import { extractAttributeKeysFromConditions, extractSegmentKeysFromGroupSegments } from "../utils";
 
 import { getRelativePaths } from "./getRelativePaths";
 import { getLastModifiedFromHistory } from "./getLastModifiedFromHistory";
 import { RepoDetails } from "./getRepoDetails";
+import { Dependencies } from "../dependencies";
 
 export async function generateSiteSearchIndex(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
+  deps: Dependencies,
   fullHistory: HistoryEntry[],
   repoDetails: RepoDetails | undefined,
 ): Promise<SearchIndex> {
+  const { rootDirectoryPath, projectConfig, datasource } = deps;
+
   const result: SearchIndex = {
     links: undefined,
     entities: {
@@ -29,7 +29,6 @@ export async function generateSiteSearchIndex(
       features: [],
     },
   };
-  const datasource = new Datasource(projectConfig);
 
   /**
    * Links

package/src/site/serveSite.ts

@@ -2,13 +2,11 @@ import * as fs from "fs";
 import * as path from "path";
 import * as http from "http";
 
-import { ProjectConfig } from "../config";
+import { Dependencies } from "../dependencies";
+
+export function serveSite(deps: Dependencies) {
+  const { projectConfig, options } = deps;
 
-export function serveSite(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
-  options: any = {},
-) {
   const port = options.p || 3000;
 
   http

package/src/tester/testFeature.ts

@@ -1,11 +1,9 @@
-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";
@@ -31,6 +29,7 @@ export async function testFeature(
     const requiredChain = await datasource.getRequiredFeaturesChain(test.feature);
     const featuresToInclude = Array.from(requiredChain);
 
+    const existingState = await datasource.readState(assertion.environment);
     const datafileContent = await buildDatafile(
       projectConfig,
       datasource,
@@ -40,9 +39,7 @@ export async function testFeature(
         environment: assertion.environment,
         features: featuresToInclude,
       },
-      JSON.parse(
-        fs.readFileSync(getExistingStateFilePath(projectConfig, assertion.environment), "utf8"),
-      ) as ExistingState,
+      existingState,
     );
 
     const sdk = createInstance({

package/src/tester/testProject.ts

@@ -2,19 +2,15 @@ import * as fs from "fs";
 
 import { TestSegment, TestFeature } from "@featurevisor/types";
 
-import { ProjectConfig } from "../config";
-import { Datasource } from "../datasource";
-
 import { testSegment } from "./testSegment";
 import { testFeature } from "./testFeature";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_GREEN, CLI_FORMAT_RED } from "./cliFormat";
+import { Dependencies } from "../dependencies";
+
+export async function testProject(deps: Dependencies): Promise<boolean> {
+  const { rootDirectoryPath, projectConfig, datasource } = deps;
 
-export async function testProject(
-  rootDirectoryPath: string,
-  projectConfig: ProjectConfig,
-): Promise<boolean> {
   let hasError = false;
-  const datasource = new Datasource(projectConfig);
 
   if (!fs.existsSync(projectConfig.testsDirectoryPath)) {
     console.error(`Tests directory does not exist: ${projectConfig.testsDirectoryPath}`);

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> {