@featurevisor/core 1.13.0 → 1.14.0

package/src/find-usage/index.ts

@@ -6,19 +6,49 @@ import {
   extractSegmentKeysFromGroupSegments,
 } from "../utils/extractKeys";
 
-export async function findSegmentUsage(
-  deps: Dependencies,
-  segmentKey: SegmentKey,
-): Promise<Set<FeatureKey>> {
+export interface UsageInFeatures {
+  [featureKey: string]: {
+    features: Set<FeatureKey>;
+    segments: Set<SegmentKey>;
+    attributes: Set<AttributeKey>;
+  };
+}
+
+export async function findAllUsageInFeatures(deps: Dependencies): Promise<UsageInFeatures> {
   const { datasource, projectConfig } = deps;
+  const usageInFeatures: UsageInFeatures = {};
 
   const featureKeys = await datasource.listFeatures();
 
-  const usedInFeatures = new Set<FeatureKey>();
-
   for (const featureKey of featureKeys) {
     const feature = await datasource.readFeature(featureKey);
-    const segmentKeys = new Set<SegmentKey>();
+    usageInFeatures[featureKey] = {
+      features: new Set<FeatureKey>(),
+      segments: new Set<SegmentKey>(),
+      attributes: new Set<AttributeKey>(),
+    };
+
+    // required
+    if (feature.required) {
+      feature.required.forEach((required) => {
+        if (typeof required === "string") {
+          usageInFeatures[featureKey].features.add(required);
+        } else if (typeof required === "object" && required.key) {
+          usageInFeatures[featureKey].features.add(required.key);
+        }
+      });
+    }
+
+    // bucketBy
+    if (feature.bucketBy) {
+      if (typeof feature.bucketBy === "string") {
+        usageInFeatures[featureKey].attributes.add(feature.bucketBy);
+      } else if (Array.isArray(feature.bucketBy)) {
+        feature.bucketBy.forEach((b) => usageInFeatures[featureKey].attributes.add(b));
+      } else if (typeof feature.bucketBy === "object" && feature.bucketBy.or) {
+        feature.bucketBy.or.forEach((b) => usageInFeatures[featureKey].attributes.add(b));
+      }
+    }
 
     // variable overrides inside variations
     projectConfig.environments.forEach((environment) => {
@@ -30,7 +60,13 @@ export async function findSegmentUsage(
                 variable.overrides.forEach((override) => {
                   if (override.segments) {
                     extractSegmentKeysFromGroupSegments(override.segments).forEach((segmentKey) =>
-                      segmentKeys.add(segmentKey),
+                      usageInFeatures[featureKey].segments.add(segmentKey),
+                    );
+                  }
+
+                  if (override.conditions) {
+                    extractAttributeKeysFromConditions(override.conditions).forEach(
+                      (attributeKey) => usageInFeatures[featureKey].attributes.add(attributeKey),
                     );
                   }
                 });
@@ -45,7 +81,13 @@ export async function findSegmentUsage(
         feature.environments[environment].force?.forEach((force) => {
           if (force.segments) {
             extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) =>
-              segmentKeys.add(segmentKey),
+              usageInFeatures[featureKey].segments.add(segmentKey),
+            );
+          }
+
+          if (force.conditions) {
+            extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) =>
+              usageInFeatures[featureKey].attributes.add(attributeKey),
             );
           }
         });
@@ -55,13 +97,54 @@ export async function findSegmentUsage(
       if (feature.environments[environment].rules) {
         feature.environments[environment].rules?.forEach((rule) => {
           extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) =>
-            segmentKeys.add(segmentKey),
+            usageInFeatures[featureKey].segments.add(segmentKey),
           );
         });
       }
     });
+  }
 
-    if (segmentKeys.has(segmentKey)) {
+  return usageInFeatures;
+}
+
+export interface UsageInSegments {
+  [segmentKey: string]: {
+    attributes: Set<AttributeKey>;
+  };
+}
+
+export async function findAllUsageInSegments(deps: Dependencies): Promise<UsageInSegments> {
+  const { datasource } = deps;
+  const usageInSegments: UsageInSegments = {};
+
+  const segmentKeys = await datasource.listSegments();
+
+  for (const segmentKey of segmentKeys) {
+    const segment = await datasource.readSegment(segmentKey);
+    usageInSegments[segmentKey] = {
+      attributes: new Set<AttributeKey>(),
+    };
+
+    extractAttributeKeysFromConditions(segment.conditions as Condition | Condition[]).forEach(
+      (attributeKey) => {
+        usageInSegments[segmentKey].attributes.add(attributeKey);
+      },
+    );
+  }
+
+  return usageInSegments;
+}
+
+export async function findSegmentUsage(
+  deps: Dependencies,
+  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);
     }
   }
@@ -78,69 +161,22 @@ export async function findAttributeUsage(
   deps: Dependencies,
   attributeKey: AttributeKey,
 ): Promise<AttributeUsage> {
-  const { datasource, projectConfig } = deps;
-
   const usedIn: AttributeUsage = {
     features: new Set<FeatureKey>(),
     segments: new Set<SegmentKey>(),
   };
 
-  // features
-  const featureKeys = await datasource.listFeatures();
-  for (const featureKey of featureKeys) {
-    const feature = await datasource.readFeature(featureKey);
-    const attributeKeys = new Set<AttributeKey>();
+  const usageInFeatures = await findAllUsageInFeatures(deps);
+  const usageInSegments = await findAllUsageInSegments(deps);
 
-    // variable overrides inside variations
-    projectConfig.environments.forEach((environment) => {
-      if (feature.variations) {
-        feature.variations.forEach((variation) => {
-          if (variation.variables) {
-            variation.variables.forEach((variable) => {
-              if (variable.overrides) {
-                variable.overrides.forEach((override) => {
-                  if (override.conditions) {
-                    extractAttributeKeysFromConditions(override.conditions).forEach(
-                      (attributeKey) => attributeKeys.add(attributeKey),
-                    );
-                  }
-                });
-              }
-            });
-          }
-        });
-      }
-
-      // force
-      if (feature.environments[environment].force) {
-        feature.environments[environment].force?.forEach((force) => {
-          if (force.conditions) {
-            extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) =>
-              attributeKeys.add(attributeKey),
-            );
-          }
-        });
-      }
-    });
-
-    if (attributeKeys.has(attributeKey)) {
+  for (const featureKey in usageInFeatures) {
+    if (usageInFeatures[featureKey].attributes.has(attributeKey)) {
       usedIn.features.add(featureKey);
     }
   }
 
-  // segments
-  const segmentKeys = await datasource.listSegments();
-  for (const segmentKey of segmentKeys) {
-    const segment = await datasource.readSegment(segmentKey);
-    const attributeKeys = new Set<AttributeKey>();
-
-    extractAttributeKeysFromConditions(segment.conditions as Condition | Condition[]).forEach(
-      (attributeKey) => {
-        attributeKeys.add(attributeKey);
-      },
-    );
-
-    if (attributeKeys.has(attributeKey)) {
+  for (const segmentKey in usageInSegments) {
+    if (usageInSegments[segmentKey].attributes.has(attributeKey)) {
       usedIn.segments.add(segmentKey);
     }
   }
@@ -150,34 +186,53 @@ export async function findAttributeUsage(
 
 export async function findUnusedSegments(deps: Dependencies): Promise<Set<SegmentKey>> {
   const { datasource } = deps;
-
-  const segmentKeys = await datasource.listSegments();
   const unusedSegments = new Set<SegmentKey>();
 
-  for (const segmentKey of segmentKeys) {
-    const usedInFeatures = await findSegmentUsage(deps, segmentKey);
+  const allSegmentKeys = await datasource.listSegments();
+  const usageInFeatures = await findAllUsageInFeatures(deps);
+  const usedSegmentKeys = new Set<SegmentKey>();
 
-    if (usedInFeatures.size === 0) {
+  for (const featureKey in usageInFeatures) {
+    usageInFeatures[featureKey].segments.forEach((segmentKey) => {
+      usedSegmentKeys.add(segmentKey);
+    });
+  }
+
+  allSegmentKeys.forEach((segmentKey) => {
+    if (!usedSegmentKeys.has(segmentKey)) {
       unusedSegments.add(segmentKey);
     }
-  }
+  });
 
   return unusedSegments;
 }
 
 export async function findUnusedAttributes(deps: Dependencies): Promise<Set<AttributeKey>> {
   const { datasource } = deps;
-
-  const attributeKeys = await datasource.listAttributes();
   const unusedAttributes = new Set<AttributeKey>();
 
-  for (const attributeKey of attributeKeys) {
-    const usedIn = await findAttributeUsage(deps, attributeKey);
+  const allAttributeKeys = await datasource.listAttributes();
+  const usageInFeatures = await findAllUsageInFeatures(deps);
+  const usageInSegments = await findAllUsageInSegments(deps);
+  const usedAttributeKeys = new Set<AttributeKey>();
 
-    if (usedIn.features.size === 0 && usedIn.segments.size === 0) {
+  for (const featureKey in usageInFeatures) {
+    usageInFeatures[featureKey].attributes.forEach((attributeKey) => {
+      usedAttributeKeys.add(attributeKey);
+    });
+  }
+
+  for (const segmentKey in usageInSegments) {
+    usageInSegments[segmentKey].attributes.forEach((attributeKey) => {
+      usedAttributeKeys.add(attributeKey);
+    });
+  }
+
+  allAttributeKeys.forEach((attributeKey) => {
+    if (!usedAttributeKeys.has(attributeKey)) {
       unusedAttributes.add(attributeKey);
     }
-  }
+  });
 
   return unusedAttributes;
 }

package/src/index.ts

@@ -10,3 +10,4 @@ export * from "./find-duplicate-segments";
 export * from "./find-usage";
 export * from "./dependencies";
 export * from "./datasource";
+export * from "./benchmark";