@featurevisor/core 1.26.0 → 1.27.1

package/src/cli/index.ts

@@ -0,0 +1,2 @@
+export * from "./cli";
+export * from "./plugins";

package/src/cli/plugins.ts

@@ -0,0 +1,38 @@
+import type { Plugin } from "./cli";
+
+import { initPlugin } from "../init";
+import { lintPlugin } from "../linter";
+import { buildPlugin } from "../builder";
+import { restorePlugin } from "../restore";
+import { testPlugin } from "../tester";
+import { generateCodePlugin } from "../generate-code";
+import { findDuplicateSegmentsPlugin } from "../find-duplicate-segments";
+import { findUsagePlugin } from "../find-usage";
+import { benchmarkPlugin } from "../benchmark";
+import { configPlugin } from "../config";
+import { evaluatePlugin } from "../evaluate";
+import { assessDistributionPlugin } from "../assess-distribution";
+import { infoPlugin } from "../info";
+import { sitePlugin } from "../site";
+
+// that do not require an existing project
+export const nonProjectPlugins: Plugin[] = [initPlugin];
+
+// that require an existing Featurevisor project
+export const projectBasedPlugins: Plugin[] = [
+  lintPlugin,
+  buildPlugin,
+  restorePlugin,
+  testPlugin,
+  generateCodePlugin,
+  findDuplicateSegmentsPlugin,
+  findUsagePlugin,
+  benchmarkPlugin,
+  configPlugin,
+  evaluatePlugin,
+  assessDistributionPlugin,
+  infoPlugin,
+  sitePlugin,
+];
+
+export const commonPlugins: Plugin[] = [];

package/src/config/projectConfig.ts

@@ -4,6 +4,7 @@ import { BucketBy } from "@featurevisor/types";
 
 import { Parser, parsers } from "./parsers";
 import { FilesystemAdapter } from "../datasource/filesystemAdapter";
+import type { Plugin } from "../cli";
 
 export const FEATURES_DIRECTORY_NAME = "features";
 export const SEGMENTS_DIRECTORY_NAME = "segments";
@@ -46,6 +47,7 @@ export interface ProjectConfig {
   siteExportDirectoryPath: string;
   enforceCatchAllRule?: boolean;
   adapter: any; // @TODO: type this properly later
+  plugins: Plugin[];
 }
 
 // rootDirectoryPath: path to the root directory of the project (without ending with a slash)
@@ -73,6 +75,7 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     siteExportDirectoryPath: path.join(rootDirectoryPath, SITE_EXPORT_DIRECTORY_NAME),
 
     enforceCatchAllRule: false,
+    plugins: [],
   };
 
   const configModulePath = path.join(rootDirectoryPath, CONFIG_MODULE_NAME);
@@ -134,3 +137,28 @@ export function showProjectConfig(
     console.log(`  - ${key.padEnd(longestKeyLength, " ")}: ${projectConfig[key]}`);
   }
 }
+
+export const configPlugin: Plugin = {
+  command: "config",
+  handler: async ({ rootDirectoryPath, parsed }) => {
+    const projectConfig = getProjectConfig(rootDirectoryPath);
+    showProjectConfig(projectConfig, {
+      print: parsed.print,
+      pretty: parsed.pretty,
+    });
+  },
+  examples: [
+    {
+      command: "config",
+      description: "show the project configuration",
+    },
+    {
+      command: "config --print",
+      description: "show the project configuration as JSON",
+    },
+    {
+      command: "config --print --pretty",
+      description: "show the project configuration (as pretty JSON)",
+    },
+  ],
+};

package/src/evaluate/index.ts

@@ -11,6 +11,7 @@ import {
 import { Dependencies } from "../dependencies";
 import { SCHEMA_VERSION } from "../config";
 import { buildDatafile } from "../builder";
+import { Plugin } from "../cli";
 
 function printEvaluationDetails(evaluation: Evaluation) {
   const ignoreKeys = ["featureKey", "variableKey", "traffic", "force"];
@@ -191,3 +192,32 @@ export async function evaluateFeature(deps: Dependencies, options: EvaluateOptio
     console.log("No variables defined.");
   }
 }
+
+export const evaluatePlugin: Plugin = {
+  command: "evaluate",
+  handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
+    await evaluateFeature(
+      {
+        rootDirectoryPath,
+        projectConfig,
+        datasource,
+        options: parsed,
+      },
+      {
+        environment: parsed.environment,
+        feature: parsed.feature,
+        context: parsed.context ? JSON.parse(parsed.context) : {},
+        print: parsed.print,
+        pretty: parsed.pretty,
+        verbose: parsed.verbose,
+      },
+    );
+  },
+  examples: [
+    {
+      command:
+        'evaluate --environment=production --feature=my_feature --context=\'{"userId": "123"}\'',
+      description: "evaluate a feature against provided context",
+    },
+  ],
+};

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

@@ -1,5 +1,6 @@
 import { findDuplicateSegments, DuplicateSegmentsOptions } from "./findDuplicateSegments";
 import { Dependencies } from "../dependencies";
+import { Plugin } from "../cli";
 
 export async function findDuplicateSegmentsInProject(
   deps: Dependencies,
@@ -26,3 +27,30 @@ export async function findDuplicateSegmentsInProject(
     }
   });
 }
+
+export const findDuplicateSegmentsPlugin: Plugin = {
+  command: "find-duplicate-segments",
+  handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
+    await findDuplicateSegmentsInProject(
+      {
+        rootDirectoryPath,
+        projectConfig,
+        datasource,
+        options: parsed,
+      },
+      {
+        authors: parsed.authors,
+      },
+    );
+  },
+  examples: [
+    {
+      command: "find-duplicate-segments",
+      description: "Find duplicate segments in the project",
+    },
+    {
+      command: "find-duplicate-segments --authors",
+      description: "Find duplicate segments in the project and list authors",
+    },
+  ],
+};

package/src/find-usage/index.ts

@@ -1,6 +1,7 @@
 import { Condition, FeatureKey, SegmentKey, AttributeKey } from "@featurevisor/types";
 
 import { Dependencies } from "../dependencies";
+import { Plugin } from "../cli";
 import {
   extractAttributeKeysFromConditions,
   extractSegmentKeysFromGroupSegments,
@@ -371,3 +372,46 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
 
   console.log("Please specify a segment or attribute.");
 }
+
+export const findUsagePlugin: Plugin = {
+  command: "find-usage",
+  handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
+    await findUsageInProject(
+      {
+        rootDirectoryPath,
+        projectConfig,
+        datasource,
+        options: parsed,
+      },
+      {
+        segment: parsed.segment,
+        attribute: parsed.attribute,
+        unusedSegments: parsed.unusedSegments,
+        unusedAttributes: parsed.unusedAttributes,
+        authors: parsed.authors,
+      },
+    );
+  },
+  examples: [
+    {
+      command: "find-usage --segment=<segmentKey>",
+      description: "Find usage of a segment",
+    },
+    {
+      command: "find-usage --attribute=<attributeKey>",
+      description: "Find usage of an attribute",
+    },
+    {
+      command: "find-usage --unused-segments",
+      description: "Find unused segments",
+    },
+    {
+      command: "find-usage --unused-attributes",
+      description: "Find unused attributes",
+    },
+    {
+      command: "find-usage --authors",
+      description: "List authors of the usage",
+    },
+  ],
+};

package/src/generate-code/index.ts

@@ -5,6 +5,7 @@ import * as mkdirp from "mkdirp";
 
 import { generateTypeScriptCodeForProject } from "./typescript";
 import { Dependencies } from "../dependencies";
+import { Plugin } from "../cli";
 
 export const ALLOWED_LANGUAGES_FOR_CODE_GENERATION = ["typescript"];
 
@@ -50,3 +51,27 @@ export async function generateCodeForProject(
 
   throw new Error(`Language ${cliOptions.language} is not supported`);
 }
+
+export const generateCodePlugin: Plugin = {
+  command: "generate-code",
+  handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
+    await generateCodeForProject(
+      {
+        rootDirectoryPath,
+        projectConfig,
+        datasource,
+        options: parsed,
+      },
+      {
+        language: parsed.language,
+        outDir: parsed.outDir,
+      },
+    );
+  },
+  examples: [
+    {
+      command: "generate-code --language typescript --out-dir src/generated",
+      description: "Generate TypeScript code for the project",
+    },
+  ],
+};

package/src/index.ts

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

package/src/info/index.ts

@@ -1,5 +1,6 @@
 import { Dependencies } from "../dependencies";
 import { getMatrixCombinations } from "../tester/matrix";
+import { Plugin } from "../cli";
 
 export async function showProjectInfo(deps: Dependencies) {
   const { datasource } = deps;
@@ -52,3 +53,21 @@ export async function showProjectInfo(deps: Dependencies) {
 
   console.log("  - Total assertions: ", assertionsCount);
 }
+
+export const infoPlugin: Plugin = {
+  command: "info",
+  handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
+    await showProjectInfo({
+      rootDirectoryPath,
+      projectConfig,
+      datasource,
+      options: parsed,
+    });
+  },
+  examples: [
+    {
+      command: "info",
+      description: "show various stats for the project",
+    },
+  ],
+};

package/src/init/index.ts

@@ -1,6 +1,8 @@
 import axios from "axios";
 import * as tar from "tar";
 
+import { Plugin } from "../cli";
+
 export const DEFAULT_EXAMPLE = "example-yml";
 
 export const EXAMPLES_ORG_NAME = "fahad19";
@@ -42,3 +44,22 @@ export function initProject(
     });
   });
 }
+
+export const initPlugin: Plugin = {
+  command: "init",
+  handler: async function (options) {
+    const { rootDirectoryPath, parsed } = options;
+
+    await initProject(rootDirectoryPath, parsed.example);
+  },
+  examples: [
+    {
+      command: "init",
+      description: "scaffold a new project in current directory",
+    },
+    {
+      command: "init --example=exampleName",
+      description: "scaffold a new project in current directory from known example",
+    },
+  ],
+};

package/src/linter/featureSchema.ts

@@ -4,6 +4,124 @@ import { ProjectConfig } from "../config";
 
 const tagRegex = /^[a-z0-9-]+$/;
 
+function isFlatObject(value) {
+  let isFlat = true;
+
+  Object.keys(value).forEach((key) => {
+    if (typeof value[key] === "object") {
+      isFlat = false;
+    }
+  });
+
+  return isFlat;
+}
+
+function isArrayOfStrings(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+
+function superRefineVariableValue(variableSchema, variableValue, path, ctx) {
+  if (!variableSchema) {
+    let message = `Unknown variable with value: ${variableValue}`;
+
+    if (path.length > 0) {
+      const lastPath = path[path.length - 1];
+
+      if (typeof lastPath === "string") {
+        message = `Unknown variable "${lastPath}" with value: ${variableValue}`;
+      }
+    }
+
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message,
+      path,
+    });
+
+    return;
+  }
+
+  // string
+  if (variableSchema.type === "string") {
+    if (typeof variableValue !== "string") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): ${variableValue}`,
+        path,
+      });
+    }
+
+    return;
+  }
+
+  // integer, double
+  if (["integer", "double"].indexOf(variableSchema.type) > -1) {
+    if (typeof variableValue !== "number") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): ${variableValue}`,
+        path,
+      });
+    }
+
+    return;
+  }
+
+  // boolean
+  if (variableSchema.type === "boolean") {
+    if (typeof variableValue !== "boolean") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): ${variableValue}`,
+        path,
+      });
+    }
+
+    return;
+  }
+
+  // array
+  if (variableSchema.type === "array") {
+    if (!Array.isArray(variableValue) || !isArrayOfStrings(variableValue)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): \n\n${variableValue}\n\n`,
+        path,
+      });
+    }
+
+    return;
+  }
+
+  // object
+  if (variableSchema.type === "object") {
+    if (typeof variableValue !== "object" || !isFlatObject(variableValue)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): \n\n${variableValue}\n\n`,
+        path,
+      });
+    }
+
+    return;
+  }
+
+  // json
+  if (variableSchema.type === "json") {
+    try {
+      JSON.parse(variableValue as string);
+    } catch (e) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid value for variable "${variableSchema.key}" (${variableSchema.type}): \n\n${variableValue}\n\n`,
+        path,
+      });
+    }
+
+    return;
+  }
+}
+
 export function getFeatureZodSchema(
   projectConfig: ProjectConfig,
   conditionsZodSchema,
@@ -19,15 +137,7 @@ export function getFeatureZodSchema(
     z.array(z.string()),
     z.record(z.unknown()).refine(
       (value) => {
-        let isFlat = true;
-
-        Object.keys(value).forEach((key) => {
-          if (typeof value[key] === "object") {
-            isFlat = false;
-          }
-        });
-
-        return isFlat;
+        return isFlatObject(value);
       },
       {
         message: "object is not flat",
@@ -286,7 +396,81 @@ export function getFeatureZodSchema(
         .optional(),
       environments: allEnvironmentsZodSchema,
     })
-    .strict();
+    .strict()
+    .superRefine((value, ctx) => {
+      if (!value.variablesSchema) {
+        return;
+      }
+
+      const allVariablesSchema = value.variablesSchema;
+      const variableSchemaByKey = {};
+
+      // variablesSchema[n].defaultValue
+      allVariablesSchema.forEach((variableSchema, n) => {
+        variableSchemaByKey[variableSchema.key] = variableSchema;
+
+        superRefineVariableValue(
+          variableSchema,
+          variableSchema.defaultValue,
+          ["variablesSchema", n, "defaultValue"],
+          ctx,
+        );
+      });
+
+      // variations[n].variables[n].value
+      if (value.variations) {
+        value.variations.forEach((variation, variationN) => {
+          if (!variation.variables) {
+            return;
+          }
+
+          variation.variables.forEach((variable, variableN) => {
+            superRefineVariableValue(
+              variableSchemaByKey[variable.key],
+              variable.value,
+              ["variations", variationN, "variables", variableN, "value"],
+              ctx,
+            );
+
+            // variations[n].variables[n].overrides[n].value
+            if (variable.overrides) {
+              variable.overrides.forEach((override, overrideN) => {
+                superRefineVariableValue(
+                  variableSchemaByKey[variable.key],
+                  override.value,
+                  [
+                    "variations",
+                    variationN,
+                    "variables",
+                    variableN,
+                    "overrides",
+                    overrideN,
+                    "value",
+                  ],
+                  ctx,
+                );
+              });
+            }
+          });
+        });
+      }
+
+      // environments[key].rules[n].variables[key]
+      Object.keys(value.environments).forEach((environmentKey) => {
+        value.environments[environmentKey].rules.forEach((rule, ruleN) => {
+          if (rule.variables) {
+            Object.keys(rule.variables).forEach((variableKey) => {
+              superRefineVariableValue(
+                variableSchemaByKey[variableKey],
+                rule.variables[variableKey],
+                ["environments", environmentKey, "rules", ruleN, "variables", variableKey],
+                ctx,
+              );
+            });
+          }
+        });
+      });
+    });
 
   return featureZodSchema;
 }