@featurevisor/core 1.35.2 → 2.0.0

package/src/find-usage/index.ts

@@ -1,4 +1,4 @@
-import { Condition, FeatureKey, SegmentKey, AttributeKey } from "@featurevisor/types";
+import type { Condition, FeatureKey, SegmentKey, AttributeKey } from "@featurevisor/types";
 
 import { Dependencies } from "../dependencies";
 import { Plugin } from "../cli";
@@ -54,10 +54,12 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
     // variable overrides inside variations
     if (feature.variations) {
       feature.variations.forEach((variation) => {
-        if (variation.variables) {
-          variation.variables.forEach((variable) => {
-            if (variable.overrides) {
-              variable.overrides.forEach((override) => {
+        if (variation.variableOverrides) {
+          Object.keys(variation.variableOverrides).forEach((variableKey) => {
+            const overrides = variation.variableOverrides?.[variableKey];
+
+            if (overrides) {
+              overrides.forEach((override) => {
                 if (override.segments) {
                   extractSegmentKeysFromGroupSegments(override.segments).forEach((segmentKey) =>
                     usageInFeatures[featureKey].segments.add(segmentKey),
@@ -79,13 +81,9 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
     // with environments
     if (Array.isArray(projectConfig.environments)) {
       projectConfig.environments.forEach((environment) => {
-        if (!feature.environments) {
-          return;
-        }
-
         // force
-        if (feature.environments[environment].force) {
-          feature.environments[environment].force?.forEach((force) => {
+        if (feature.force && feature.force[environment]) {
+          feature.force[environment].forEach((force) => {
             if (force.segments) {
               extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) =>
                 usageInFeatures[featureKey].segments.add(segmentKey),
@@ -101,8 +99,8 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
         }
 
         // rules
-        if (feature.environments[environment].rules) {
-          feature.environments[environment].rules?.forEach((rule) => {
+        if (feature.rules && feature.rules[environment]) {
+          feature.rules[environment].forEach((rule) => {
             extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) =>
               usageInFeatures[featureKey].segments.add(segmentKey),
             );
@@ -114,7 +112,7 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
     // no environments
     if (projectConfig.environments === false) {
       // force
-      if (feature.force) {
+      if (Array.isArray(feature.force)) {
         feature.force.forEach((force) => {
           if (force.segments) {
             extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) =>
@@ -131,7 +129,7 @@ export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageI
       }
 
       // rules
-      if (feature.rules) {
+      if (Array.isArray(feature.rules)) {
         feature.rules.forEach((rule) => {
           extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) =>
             usageInFeatures[featureKey].segments.add(segmentKey),
@@ -172,14 +170,27 @@ export async function findAllUsageInSegments(deps: Dependencies): Promise<UsageI
   return usageInSegments;
 }
 
+export async function findFeatureUsage(
+  usageInFeatures: UsageInFeatures,
+  searchFeatureKey: FeatureKey,
+): Promise<Set<FeatureKey>> {
+  const usedInFeatures = new Set<FeatureKey>();
+
+  for (const featureKey in usageInFeatures) {
+    if (usageInFeatures[featureKey].features.has(searchFeatureKey)) {
+      usedInFeatures.add(featureKey);
+    }
+  }
+
+  return usedInFeatures;
+}
+
 export async function findSegmentUsage(
-  deps: Dependencies,
+  usageInFeatures: UsageInFeatures,
   segmentKey: SegmentKey,
 ): Promise<Set<FeatureKey>> {
   const usedInFeatures = new Set<FeatureKey>();
 
-  const usageInFeatures = await findAllUsageInFeatures(deps);
-
   for (const featureKey in usageInFeatures) {
     if (usageInFeatures[featureKey].segments.has(segmentKey)) {
       usedInFeatures.add(featureKey);
@@ -195,7 +206,8 @@ export interface AttributeUsage {
 }
 
 export async function findAttributeUsage(
-  deps: Dependencies,
+  usageInFeatures: UsageInFeatures,
+  usageInSegments: UsageInSegments,
   attributeKey: AttributeKey,
 ): Promise<AttributeUsage> {
   const usedIn: AttributeUsage = {
@@ -203,9 +215,6 @@ export async function findAttributeUsage(
     segments: new Set<SegmentKey>(),
   };
 
-  const usageInFeatures = await findAllUsageInFeatures(deps);
-  const usageInSegments = await findAllUsageInSegments(deps);
-
   for (const featureKey in usageInFeatures) {
     if (usageInFeatures[featureKey].attributes.has(attributeKey)) {
       usedIn.features.add(featureKey);
@@ -221,12 +230,14 @@ export async function findAttributeUsage(
   return usedIn;
 }
 
-export async function findUnusedSegments(deps: Dependencies): Promise<Set<SegmentKey>> {
+export async function findUnusedSegments(
+  deps: Dependencies,
+  usageInFeatures: UsageInFeatures,
+): Promise<Set<SegmentKey>> {
   const { datasource } = deps;
   const unusedSegments = new Set<SegmentKey>();
 
   const allSegmentKeys = await datasource.listSegments();
-  const usageInFeatures = await findAllUsageInFeatures(deps);
   const usedSegmentKeys = new Set<SegmentKey>();
 
   for (const featureKey in usageInFeatures) {
@@ -244,13 +255,15 @@ export async function findUnusedSegments(deps: Dependencies): Promise<Set<Segmen
   return unusedSegments;
 }
 
-export async function findUnusedAttributes(deps: Dependencies): Promise<Set<AttributeKey>> {
+export async function findUnusedAttributes(
+  deps: Dependencies,
+  usageInFeatures: UsageInFeatures,
+  usageInSegments: UsageInSegments,
+): Promise<Set<AttributeKey>> {
   const { datasource } = deps;
   const unusedAttributes = new Set<AttributeKey>();
 
   const allAttributeKeys = await datasource.listAttributes();
-  const usageInFeatures = await findAllUsageInFeatures(deps);
-  const usageInSegments = await findAllUsageInSegments(deps);
   const usedAttributeKeys = new Set<AttributeKey>();
 
   for (const featureKey in usageInFeatures) {
@@ -275,6 +288,7 @@ export async function findUnusedAttributes(deps: Dependencies): Promise<Set<Attr
 }
 
 export interface FindUsageOptions {
+  feature?: string;
   segment?: string;
   attribute?: string;
 
@@ -289,9 +303,36 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
 
   console.log("");
 
+  const usageInFeatures = await findAllUsageInFeatures(deps);
+  const usageInSegments = await findAllUsageInSegments(deps);
+
+  // feature
+  if (options.feature) {
+    const usedInFeatures = await findFeatureUsage(usageInFeatures, options.feature);
+
+    if (usedInFeatures.size === 0) {
+      console.log(`Feature "${options.feature}" is not used in any features.`);
+    } else {
+      console.log(`Feature "${options.feature}" is used in the following features:\n`);
+
+      for (const featureKey of Array.from(usedInFeatures)) {
+        if (options.authors) {
+          const entries = await datasource.listHistoryEntries("feature", featureKey);
+          const authors = Array.from(new Set(entries.map((entry) => entry.author)));
+
+          console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+        } else {
+          console.log(`  - ${featureKey}`);
+        }
+      }
+    }
+
+    return;
+  }
+
   // segment
   if (options.segment) {
-    const usedInFeatures = await findSegmentUsage(deps, options.segment);
+    const usedInFeatures = await findSegmentUsage(usageInFeatures, options.segment);
 
     if (usedInFeatures.size === 0) {
       console.log(`Segment "${options.segment}" is not used in any features.`);
@@ -315,7 +356,7 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
 
   // attribute
   if (options.attribute) {
-    const usedIn = await findAttributeUsage(deps, options.attribute);
+    const usedIn = await findAttributeUsage(usageInFeatures, usageInSegments, options.attribute);
 
     if (usedIn.features.size === 0 && usedIn.segments.size === 0) {
       console.log(`Attribute "${options.attribute}" is not used in any features or segments.`);
@@ -323,36 +364,61 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
       return;
     }
 
-    if (usedIn.features.size > 0) {
-      console.log(`Attribute "${options.attribute}" is used in the following features:\n`);
+    if (usedIn.segments.size > 0) {
+      console.log(`Attribute "${options.attribute}" is used in the following segments:\n`);
 
-      for (const featureKey of Array.from(usedIn.features)) {
+      for (const segmentKey of Array.from(usedIn.segments)) {
         if (options.authors) {
-          const entries = await datasource.listHistoryEntries("feature", featureKey);
+          const entries = await datasource.listHistoryEntries("segment", segmentKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+          console.log(`  - ${segmentKey} (Authors: ${authors.join(", ")})`);
         } else {
-          console.log(`  - ${featureKey}`);
+          console.log(`  - ${segmentKey}`);
         }
       }
 
-      console.log("");
+      // features affected by above segments
+      const affectedFeatures = new Set<FeatureKey>();
+
+      for (const segmentKey of Array.from(usedIn.segments)) {
+        const featureKeys = await findSegmentUsage(usageInFeatures, segmentKey);
+        featureKeys.forEach((featureKey) => affectedFeatures.add(featureKey));
+      }
+
+      if (affectedFeatures.size > 0) {
+        console.log(`\nSegments above are used in the following features:\n`);
+
+        for (const featureKey of Array.from(affectedFeatures)) {
+          if (options.authors) {
+            const entries = await datasource.listHistoryEntries("feature", featureKey);
+            const authors = Array.from(new Set(entries.map((entry) => entry.author)));
+
+            console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
+          } else {
+            console.log(`  - ${featureKey}`);
+          }
+        }
+
+        console.log("");
+      }
     }
 
-    if (usedIn.segments.size > 0) {
-      console.log(`Attribute "${options.attribute}" is used in the following segments:\n`);
+    if (usedIn.features.size > 0) {
+      console.log(`Attribute "${options.attribute}" is used directly in the following features:\n`);
 
-      for (const segmentKey of Array.from(usedIn.segments)) {
+      for (const featureKey of Array.from(usedIn.features)) {
         if (options.authors) {
-          const entries = await datasource.listHistoryEntries("segment", segmentKey);
+          const entries = await datasource.listHistoryEntries("feature", featureKey);
           const authors = Array.from(new Set(entries.map((entry) => entry.author)));
 
-          console.log(`  - ${segmentKey} (Authors: ${authors.join(", ")})`);
+          console.log(`  - ${featureKey} (Authors: ${authors.join(", ")})`);
         } else {
-          console.log(`  - ${segmentKey}`);
+          console.log(`  - ${featureKey}`);
         }
       }
+
+      console.log("");
     }
 
     return;
@@ -360,7 +426,7 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
 
   // unused segments
   if (options.unusedSegments) {
-    const unusedSegments = await findUnusedSegments(deps);
+    const unusedSegments = await findUnusedSegments(deps, usageInFeatures);
 
     if (unusedSegments.size === 0) {
       console.log("No unused segments found.");
@@ -384,7 +450,7 @@ export async function findUsageInProject(deps: Dependencies, options: FindUsageO
 
   // unused attributes
   if (options.unusedAttributes) {
-    const unusedAttributes = await findUnusedAttributes(deps);
+    const unusedAttributes = await findUnusedAttributes(deps, usageInFeatures, usageInSegments);
 
     if (unusedAttributes.size === 0) {
       console.log("No unused attributes found.");
@@ -420,6 +486,7 @@ export const findUsagePlugin: Plugin = {
         options: parsed,
       },
       {
+        feature: parsed.feature,
         segment: parsed.segment,
         attribute: parsed.attribute,
         unusedSegments: parsed.unusedSegments,

package/src/generate-code/index.ts

@@ -1,8 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import * as mkdirp from "mkdirp";
-
 import { generateTypeScriptCodeForProject } from "./typescript";
 import { Dependencies } from "../dependencies";
 import { Plugin } from "../cli";
@@ -32,7 +30,7 @@ export async function generateCodeForProject(
 
   if (!fs.existsSync(absolutePath)) {
     console.log(`Creating output directory: ${absolutePath}`);
-    mkdirp.sync(absolutePath);
+    fs.mkdirSync(absolutePath, { recursive: true });
   } else {
     console.log(`Output directory already exists at: ${absolutePath}`);
   }

package/src/generate-code/typescript.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import { Attribute } from "@featurevisor/types";
+import type { Attribute } from "@featurevisor/types";
 import { Dependencies } from "../dependencies";
 
 function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
@@ -19,7 +19,7 @@ function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
     case "array":
       return "string[]";
     case "object":
-      return "any"; // @TODO: do a flat dictionary
+      return "any"; // @NOTE: do a flat dictionary
     case "json":
       return "any";
     default:
@@ -47,30 +47,6 @@ function getRelativePath(from, to) {
   return relativePath;
 }
 
-function getFeaturevisorTypeFromValue(value) {
-  if (typeof value === "boolean") {
-    return "boolean";
-  }
-
-  if (typeof value === "string") {
-    return "string";
-  }
-
-  if (typeof value === "number") {
-    if (Number.isInteger(value)) {
-      return "integer";
-    }
-
-    return "double";
-  }
-
-  if (value instanceof Date) {
-    return "date";
-  }
-
-  throw new Error("Could not detect Featurevisor type from value");
-}
-
 const instanceSnippet = `
 import { FeaturevisorInstance } from "@featurevisor/sdk";
 
@@ -121,7 +97,7 @@ export async function generateTypeScriptCodeForProject(deps: Dependencies, outpu
     })
     .join("\n");
   const contextContent = `
-import { AttributeKey, AttributeValue } from "@featurevisor/types";
+import type { AttributeKey, AttributeValue } from "@featurevisor/types";
 
 export interface Context {
 ${attributeProperties}
@@ -152,8 +128,10 @@ ${attributeProperties}
     let variableMethods = "";
 
     if (parsedFeature.variablesSchema) {
-      for (const variableSchema of parsedFeature.variablesSchema) {
-        const variableKey = variableSchema.key;
+      const variableKeys = Object.keys(parsedFeature.variablesSchema);
+
+      for (const variableKey of variableKeys) {
+        const variableSchema = parsedFeature.variablesSchema[variableKey];
         const variableType = variableSchema.type;
 
         const internalMethodName = `getVariable${

package/src/index.ts

@@ -5,7 +5,6 @@ export * from "./tester";
 export * from "./init";
 export * from "./site";
 export * from "./generate-code";
-export * from "./restore";
 export * from "./find-duplicate-segments";
 export * from "./find-usage";
 export * from "./dependencies";

package/src/info/index.ts

@@ -1,5 +1,5 @@
 import { Dependencies } from "../dependencies";
-import { getMatrixCombinations } from "../tester/matrix";
+import { getMatrixCombinations } from "../list/matrix";
 import { Plugin } from "../cli";
 
 export async function showProjectInfo(deps: Dependencies) {
@@ -22,7 +22,7 @@ export async function showProjectInfo(deps: Dependencies) {
     const feature = await datasource.readFeature(featureKey);
 
     if (feature.variablesSchema) {
-      variablesCount += feature.variablesSchema.length;
+      variablesCount += Object.keys(feature.variablesSchema).length;
     }
   }
 

package/src/init/index.ts

@@ -3,7 +3,7 @@ import * as tar from "tar";
 
 import { Plugin } from "../cli";
 
-export const DEFAULT_EXAMPLE = "example-yml";
+export const DEFAULT_EXAMPLE = "yml";
 
 export const EXAMPLES_ORG_NAME = "fahad19";
 export const EXAMPLES_REPO_NAME = "featurevisor";
@@ -12,7 +12,7 @@ export const EXAMPLES_BRANCH_NAME = "main";
 export const EXAMPLES_TAR_URL = `https://codeload.github.com/${EXAMPLES_ORG_NAME}/${EXAMPLES_REPO_NAME}/tar.gz/${EXAMPLES_BRANCH_NAME}`;
 
 function getExamplePath(exampleName: string) {
-  return `${EXAMPLES_REPO_NAME}-${EXAMPLES_BRANCH_NAME}/examples/${exampleName}/`;
+  return `${EXAMPLES_REPO_NAME}-${EXAMPLES_BRANCH_NAME}/examples/example-${exampleName}/`;
 }
 
 export function initProject(

package/src/linter/attributeSchema.ts

@@ -1,12 +1,28 @@
 import { z } from "zod";
 
 export function getAttributeZodSchema() {
+  const propertySchema = z.object({
+    type: z.enum([
+      "boolean",
+      "string",
+      "integer",
+      "double",
+      "date",
+      "semver",
+      "array",
+
+      // @NOTE: intentionally ignored for now to not allow nesting
+      // "object",
+    ]),
+    description: z.string().optional(),
+  });
+
   const attributeZodSchema = z
     .object({
       archived: z.boolean().optional(),
-      type: z.enum(["boolean", "string", "integer", "double", "date", "semver"]),
+      type: z.enum(["boolean", "string", "integer", "double", "date", "semver", "object", "array"]),
       description: z.string(),
-      capture: z.boolean().optional(),
+      properties: z.record(z.string(), propertySchema).optional(),
     })
     .strict();
 

package/src/linter/checkCircularDependency.ts

@@ -1,4 +1,4 @@
-import { FeatureKey, Required } from "@featurevisor/types";
+import type { FeatureKey, Required } from "@featurevisor/types";
 
 import { Datasource } from "../datasource";
 

package/src/linter/checkPercentageExceedingSlot.ts

@@ -1,8 +1,8 @@
-import { Group } from "@featurevisor/types";
+import type { Group, Rule } from "@featurevisor/types";
 
 import { Datasource } from "../datasource";
 
-// @TODO: ideally in future, this check should be done from Feature level,
+// @NOTE: ideally in future, this check should be done from Feature level,
 // as well as Group level as done here
 export async function checkForFeatureExceedingGroupSlotPercentage(
   datasource: Datasource,
@@ -22,16 +22,36 @@ export async function checkForFeatureExceedingGroupSlotPercentage(
 
       const parsedFeature = await datasource.readFeature(featureKey);
 
-      const environmentKeys = Object.keys(parsedFeature.environments);
-      for (const environmentKey of environmentKeys) {
-        const environment = parsedFeature.environments[environmentKey];
-        const rules = environment.rules;
+      const hasEnvironments =
+        parsedFeature.rules &&
+        !Array.isArray(parsedFeature.rules) &&
+        Object.keys(parsedFeature.rules).length > 0;
+
+      if (hasEnvironments && parsedFeature.rules) {
+        // with environments
+        const environmentKeys = Object.keys(parsedFeature.rules);
+
+        for (const environmentKey of environmentKeys) {
+          const rules = parsedFeature.rules[environmentKey];
+
+          for (const rule of rules) {
+            if (rule.percentage > maxPercentageForRule) {
+              // @NOTE: this does not help with same feature belonging to multiple slots. fix that.
+              throw new Error(
+                `Feature ${featureKey}'s rule ${rule.key} in ${environmentKey} has a percentage of ${rule.percentage} which is greater than the maximum percentage of ${maxPercentageForRule} for the slot`,
+              );
+            }
+          }
+        }
+      } else if (parsedFeature.rules) {
+        // no environments
+        const rules = parsedFeature.rules as Rule[];
 
         for (const rule of rules) {
           if (rule.percentage > maxPercentageForRule) {
-            // @TODO: this does not help with same feature belonging to multiple slots. fix that.
+            // @NOTE: this does not help with same feature belonging to multiple slots. fix that.
             throw new Error(
-              `Feature ${featureKey}'s rule ${rule.key} in ${environmentKey} has a percentage of ${rule.percentage} which is greater than the maximum percentage of ${maxPercentageForRule} for the slot`,
+              `Feature ${featureKey}'s rule ${rule.key} has a percentage of ${rule.percentage} which is greater than the maximum percentage of ${maxPercentageForRule} for the slot`,
             );
           }
         }

package/src/linter/conditionSchema.ts

@@ -4,7 +4,14 @@ import { ProjectConfig } from "../config";
 
 const commonOperators: [string, ...string[]] = ["equals", "notEquals"];
 const numericOperators = ["greaterThan", "greaterThanOrEquals", "lessThan", "lessThanOrEquals"];
-const stringOperators = ["contains", "notContains", "startsWith", "endsWith"];
+const stringOperators = [
+  "contains",
+  "notContains",
+  "startsWith",
+  "endsWith",
+  "includes",
+  "notIncludes",
+];
 const semverOperators = [
   "semverEquals",
   "semverNotEquals",
@@ -15,6 +22,8 @@ const semverOperators = [
 ];
 const dateOperators = ["before", "after"];
 const arrayOperators = ["in", "notIn"];
+const regexOperators = ["matches", "notMatches"];
+const operatorsWithoutValue = ["exists", "notExists"];
 
 export function getConditionsZodSchema(
   projectConfig: ProjectConfig,
@@ -35,15 +44,27 @@ export function getConditionsZodSchema(
         ...semverOperators,
         ...dateOperators,
         ...arrayOperators,
+        ...regexOperators,
+        ...operatorsWithoutValue,
       ]),
-      value: z.union([
-        z.string(),
-        z.array(z.string()),
-        z.number(),
-        z.boolean(),
-        z.date(),
-        z.null(),
-      ]),
+      value: z
+        .union([z.string(), z.array(z.string()), z.number(), z.boolean(), z.date(), z.null()])
+        .optional(),
+      regexFlags: z
+        .string()
+        .refine(
+          (value) => {
+            if (typeof value === "undefined") {
+              return true;
+            }
+
+            return /^[gimsuy]{1,}$/.test(value);
+          },
+          {
+            message: `regexFlags must of one or more of these characters: g, i, m, s, u, y`,
+          },
+        )
+        .optional(),
     })
     .superRefine((data, context) => {
       // common
@@ -109,6 +130,35 @@ export function getConditionsZodSchema(
           path: ["value"],
         });
       }
+
+      // regex
+      if (regexOperators.includes(data.operator)) {
+        if (typeof data.value !== "string") {
+          context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `when operator is "${data.operator}", value must be a string`,
+            path: ["value"],
+          });
+        }
+      } else {
+        // regex flags are not needed
+        if (data.regexFlags) {
+          context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `when operator is nether "matches" nor "notMatches", regexFlags are not needed`,
+            path: ["regexFlags"],
+          });
+        }
+      }
+
+      // operators without value
+      if (operatorsWithoutValue.includes(data.operator) && data.value !== undefined) {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `when operator is "${data.operator}", value is not needed`,
+          path: ["value"],
+        });
+      }
     });
 
   const andOrNotConditionZodSchema = z.union([
@@ -129,9 +179,15 @@ export function getConditionsZodSchema(
       .strict(),
   ]);
 
+  const everyoneZodSchema = z.literal("*");
+
   const conditionZodSchema = z.union([andOrNotConditionZodSchema, plainConditionZodSchema]);
 
-  const conditionsZodSchema = z.union([conditionZodSchema, z.array(conditionZodSchema)]);
+  const conditionsZodSchema = z.union([
+    conditionZodSchema,
+    z.array(conditionZodSchema),
+    everyoneZodSchema,
+  ]);
 
   return conditionsZodSchema;
 }