@featurevisor/core 1.35.3 → 2.0.1

package/lib/find-usage/index.js

@@ -1,541 +1,367 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findUsagePlugin = void 0;
 exports.findAllUsageInFeatures = findAllUsageInFeatures;
 exports.findAllUsageInSegments = findAllUsageInSegments;
+exports.findFeatureUsage = findFeatureUsage;
 exports.findSegmentUsage = findSegmentUsage;
 exports.findAttributeUsage = findAttributeUsage;
 exports.findUnusedSegments = findUnusedSegments;
 exports.findUnusedAttributes = findUnusedAttributes;
 exports.findUsageInProject = findUsageInProject;
-var extractKeys_1 = require("../utils/extractKeys");
-function findAllUsageInFeatures(deps) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datasource, projectConfig, usageInFeatures, featureKeys, _loop_1, _i, featureKeys_1, featureKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datasource = deps.datasource, projectConfig = deps.projectConfig;
-                    usageInFeatures = {};
-                    return [4 /*yield*/, datasource.listFeatures()];
-                case 1:
-                    featureKeys = _a.sent();
-                    _loop_1 = function (featureKey) {
-                        var feature;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0: return [4 /*yield*/, datasource.readFeature(featureKey)];
-                                case 1:
-                                    feature = _b.sent();
-                                    usageInFeatures[featureKey] = {
-                                        features: new Set(),
-                                        segments: new Set(),
-                                        attributes: new Set(),
-                                    };
-                                    // required
-                                    if (feature.required) {
-                                        feature.required.forEach(function (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(function (b) { return usageInFeatures[featureKey].attributes.add(b); });
-                                        }
-                                        else if (typeof feature.bucketBy === "object" && feature.bucketBy.or) {
-                                            feature.bucketBy.or.forEach(function (b) { return usageInFeatures[featureKey].attributes.add(b); });
-                                        }
-                                    }
-                                    // variable overrides inside variations
-                                    if (feature.variations) {
-                                        feature.variations.forEach(function (variation) {
-                                            if (variation.variables) {
-                                                variation.variables.forEach(function (variable) {
-                                                    if (variable.overrides) {
-                                                        variable.overrides.forEach(function (override) {
-                                                            if (override.segments) {
-                                                                (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(override.segments).forEach(function (segmentKey) {
-                                                                    return usageInFeatures[featureKey].segments.add(segmentKey);
-                                                                });
-                                                            }
-                                                            if (override.conditions) {
-                                                                (0, extractKeys_1.extractAttributeKeysFromConditions)(override.conditions).forEach(function (attributeKey) {
-                                                                    return usageInFeatures[featureKey].attributes.add(attributeKey);
-                                                                });
-                                                            }
-                                                        });
-                                                    }
-                                                });
-                                            }
-                                        });
-                                    }
-                                    // with environments
-                                    if (Array.isArray(projectConfig.environments)) {
-                                        projectConfig.environments.forEach(function (environment) {
-                                            var _a, _b;
-                                            if (!feature.environments) {
-                                                return;
-                                            }
-                                            // force
-                                            if (feature.environments[environment].force) {
-                                                (_a = feature.environments[environment].force) === null || _a === void 0 ? void 0 : _a.forEach(function (force) {
-                                                    if (force.segments) {
-                                                        (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(force.segments).forEach(function (segmentKey) {
-                                                            return usageInFeatures[featureKey].segments.add(segmentKey);
-                                                        });
-                                                    }
-                                                    if (force.conditions) {
-                                                        (0, extractKeys_1.extractAttributeKeysFromConditions)(force.conditions).forEach(function (attributeKey) {
-                                                            return usageInFeatures[featureKey].attributes.add(attributeKey);
-                                                        });
-                                                    }
-                                                });
-                                            }
-                                            // rules
-                                            if (feature.environments[environment].rules) {
-                                                (_b = feature.environments[environment].rules) === null || _b === void 0 ? void 0 : _b.forEach(function (rule) {
-                                                    (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(rule.segments).forEach(function (segmentKey) {
-                                                        return usageInFeatures[featureKey].segments.add(segmentKey);
-                                                    });
-                                                });
-                                            }
-                                        });
-                                    }
-                                    // no environments
-                                    if (projectConfig.environments === false) {
-                                        // force
-                                        if (feature.force) {
-                                            feature.force.forEach(function (force) {
-                                                if (force.segments) {
-                                                    (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(force.segments).forEach(function (segmentKey) {
-                                                        return usageInFeatures[featureKey].segments.add(segmentKey);
-                                                    });
-                                                }
-                                                if (force.conditions) {
-                                                    (0, extractKeys_1.extractAttributeKeysFromConditions)(force.conditions).forEach(function (attributeKey) {
-                                                        return usageInFeatures[featureKey].attributes.add(attributeKey);
-                                                    });
-                                                }
-                                            });
-                                        }
-                                        // rules
-                                        if (feature.rules) {
-                                            feature.rules.forEach(function (rule) {
-                                                (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(rule.segments).forEach(function (segmentKey) {
-                                                    return usageInFeatures[featureKey].segments.add(segmentKey);
-                                                });
-                                            });
-                                        }
-                                    }
-                                    return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _i = 0, featureKeys_1 = featureKeys;
-                    _a.label = 2;
-                case 2:
-                    if (!(_i < featureKeys_1.length)) return [3 /*break*/, 5];
-                    featureKey = featureKeys_1[_i];
-                    return [5 /*yield**/, _loop_1(featureKey)];
-                case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 5: return [2 /*return*/, usageInFeatures];
+const extractKeys_1 = require("../utils/extractKeys");
+async function findAllUsageInFeatures(deps) {
+    const { datasource, projectConfig } = deps;
+    const usageInFeatures = {};
+    const featureKeys = await datasource.listFeatures();
+    for (const featureKey of featureKeys) {
+        const feature = await datasource.readFeature(featureKey);
+        usageInFeatures[featureKey] = {
+            features: new Set(),
+            segments: new Set(),
+            attributes: new Set(),
+        };
+        // 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);
             }
-        });
-    });
-}
-function findAllUsageInSegments(deps) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datasource, usageInSegments, segmentKeys, _loop_2, _i, segmentKeys_1, segmentKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datasource = deps.datasource;
-                    usageInSegments = {};
-                    return [4 /*yield*/, datasource.listSegments()];
-                case 1:
-                    segmentKeys = _a.sent();
-                    _loop_2 = function (segmentKey) {
-                        var segment;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0: return [4 /*yield*/, datasource.readSegment(segmentKey)];
-                                case 1:
-                                    segment = _b.sent();
-                                    usageInSegments[segmentKey] = {
-                                        attributes: new Set(),
-                                    };
-                                    (0, extractKeys_1.extractAttributeKeysFromConditions)(segment.conditions).forEach(function (attributeKey) {
-                                        usageInSegments[segmentKey].attributes.add(attributeKey);
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _i = 0, segmentKeys_1 = segmentKeys;
-                    _a.label = 2;
-                case 2:
-                    if (!(_i < segmentKeys_1.length)) return [3 /*break*/, 5];
-                    segmentKey = segmentKeys_1[_i];
-                    return [5 /*yield**/, _loop_2(segmentKey)];
-                case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 5: return [2 /*return*/, usageInSegments];
+            else if (Array.isArray(feature.bucketBy)) {
+                feature.bucketBy.forEach((b) => usageInFeatures[featureKey].attributes.add(b));
             }
-        });
-    });
-}
-function findSegmentUsage(deps, segmentKey) {
-    return __awaiter(this, void 0, void 0, function () {
-        var usedInFeatures, usageInFeatures, featureKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    usedInFeatures = new Set();
-                    return [4 /*yield*/, findAllUsageInFeatures(deps)];
-                case 1:
-                    usageInFeatures = _a.sent();
-                    for (featureKey in usageInFeatures) {
-                        if (usageInFeatures[featureKey].segments.has(segmentKey)) {
-                            usedInFeatures.add(featureKey);
-                        }
-                    }
-                    return [2 /*return*/, usedInFeatures];
+            else if (typeof feature.bucketBy === "object" && feature.bucketBy.or) {
+                feature.bucketBy.or.forEach((b) => usageInFeatures[featureKey].attributes.add(b));
             }
-        });
-    });
-}
-function findAttributeUsage(deps, attributeKey) {
-    return __awaiter(this, void 0, void 0, function () {
-        var usedIn, usageInFeatures, usageInSegments, featureKey, segmentKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    usedIn = {
-                        features: new Set(),
-                        segments: new Set(),
-                    };
-                    return [4 /*yield*/, findAllUsageInFeatures(deps)];
-                case 1:
-                    usageInFeatures = _a.sent();
-                    return [4 /*yield*/, findAllUsageInSegments(deps)];
-                case 2:
-                    usageInSegments = _a.sent();
-                    for (featureKey in usageInFeatures) {
-                        if (usageInFeatures[featureKey].attributes.has(attributeKey)) {
-                            usedIn.features.add(featureKey);
+        }
+        // variable overrides inside variations
+        if (feature.variations) {
+            feature.variations.forEach((variation) => {
+                if (variation.variableOverrides) {
+                    Object.keys(variation.variableOverrides).forEach((variableKey) => {
+                        const overrides = variation.variableOverrides?.[variableKey];
+                        if (overrides) {
+                            overrides.forEach((override) => {
+                                if (override.segments) {
+                                    (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(override.segments).forEach((segmentKey) => usageInFeatures[featureKey].segments.add(segmentKey));
+                                }
+                                if (override.conditions) {
+                                    (0, extractKeys_1.extractAttributeKeysFromConditions)(override.conditions).forEach((attributeKey) => usageInFeatures[featureKey].attributes.add(attributeKey));
+                                }
+                            });
                         }
-                    }
-                    for (segmentKey in usageInSegments) {
-                        if (usageInSegments[segmentKey].attributes.has(attributeKey)) {
-                            usedIn.segments.add(segmentKey);
+                    });
+                }
+            });
+        }
+        // with environments
+        if (Array.isArray(projectConfig.environments)) {
+            projectConfig.environments.forEach((environment) => {
+                // force
+                if (feature.force && feature.force[environment]) {
+                    feature.force[environment].forEach((force) => {
+                        if (force.segments) {
+                            (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(force.segments).forEach((segmentKey) => usageInFeatures[featureKey].segments.add(segmentKey));
                         }
+                        if (force.conditions) {
+                            (0, extractKeys_1.extractAttributeKeysFromConditions)(force.conditions).forEach((attributeKey) => usageInFeatures[featureKey].attributes.add(attributeKey));
+                        }
+                    });
+                }
+                // rules
+                if (feature.rules && feature.rules[environment]) {
+                    feature.rules[environment].forEach((rule) => {
+                        (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(rule.segments).forEach((segmentKey) => usageInFeatures[featureKey].segments.add(segmentKey));
+                    });
+                }
+            });
+        }
+        // no environments
+        if (projectConfig.environments === false) {
+            // force
+            if (Array.isArray(feature.force)) {
+                feature.force.forEach((force) => {
+                    if (force.segments) {
+                        (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(force.segments).forEach((segmentKey) => usageInFeatures[featureKey].segments.add(segmentKey));
+                    }
+                    if (force.conditions) {
+                        (0, extractKeys_1.extractAttributeKeysFromConditions)(force.conditions).forEach((attributeKey) => usageInFeatures[featureKey].attributes.add(attributeKey));
                     }
-                    return [2 /*return*/, usedIn];
+                });
             }
+            // rules
+            if (Array.isArray(feature.rules)) {
+                feature.rules.forEach((rule) => {
+                    (0, extractKeys_1.extractSegmentKeysFromGroupSegments)(rule.segments).forEach((segmentKey) => usageInFeatures[featureKey].segments.add(segmentKey));
+                });
+            }
+        }
+    }
+    return usageInFeatures;
+}
+async function findAllUsageInSegments(deps) {
+    const { datasource } = deps;
+    const usageInSegments = {};
+    const segmentKeys = await datasource.listSegments();
+    for (const segmentKey of segmentKeys) {
+        const segment = await datasource.readSegment(segmentKey);
+        usageInSegments[segmentKey] = {
+            attributes: new Set(),
+        };
+        (0, extractKeys_1.extractAttributeKeysFromConditions)(segment.conditions).forEach((attributeKey) => {
+            usageInSegments[segmentKey].attributes.add(attributeKey);
         });
-    });
+    }
+    return usageInSegments;
 }
-function findUnusedSegments(deps) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datasource, unusedSegments, allSegmentKeys, usageInFeatures, usedSegmentKeys, featureKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datasource = deps.datasource;
-                    unusedSegments = new Set();
-                    return [4 /*yield*/, datasource.listSegments()];
-                case 1:
-                    allSegmentKeys = _a.sent();
-                    return [4 /*yield*/, findAllUsageInFeatures(deps)];
-                case 2:
-                    usageInFeatures = _a.sent();
-                    usedSegmentKeys = new Set();
-                    for (featureKey in usageInFeatures) {
-                        usageInFeatures[featureKey].segments.forEach(function (segmentKey) {
-                            usedSegmentKeys.add(segmentKey);
-                        });
-                    }
-                    allSegmentKeys.forEach(function (segmentKey) {
-                        if (!usedSegmentKeys.has(segmentKey)) {
-                            unusedSegments.add(segmentKey);
-                        }
-                    });
-                    return [2 /*return*/, unusedSegments];
-            }
+async function findFeatureUsage(usageInFeatures, searchFeatureKey) {
+    const usedInFeatures = new Set();
+    for (const featureKey in usageInFeatures) {
+        if (usageInFeatures[featureKey].features.has(searchFeatureKey)) {
+            usedInFeatures.add(featureKey);
+        }
+    }
+    return usedInFeatures;
+}
+async function findSegmentUsage(usageInFeatures, segmentKey) {
+    const usedInFeatures = new Set();
+    for (const featureKey in usageInFeatures) {
+        if (usageInFeatures[featureKey].segments.has(segmentKey)) {
+            usedInFeatures.add(featureKey);
+        }
+    }
+    return usedInFeatures;
+}
+async function findAttributeUsage(usageInFeatures, usageInSegments, attributeKey) {
+    const usedIn = {
+        features: new Set(),
+        segments: new Set(),
+    };
+    for (const featureKey in usageInFeatures) {
+        if (usageInFeatures[featureKey].attributes.has(attributeKey)) {
+            usedIn.features.add(featureKey);
+        }
+    }
+    for (const segmentKey in usageInSegments) {
+        if (usageInSegments[segmentKey].attributes.has(attributeKey)) {
+            usedIn.segments.add(segmentKey);
+        }
+    }
+    return usedIn;
+}
+async function findUnusedSegments(deps, usageInFeatures) {
+    const { datasource } = deps;
+    const unusedSegments = new Set();
+    const allSegmentKeys = await datasource.listSegments();
+    const usedSegmentKeys = new Set();
+    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;
 }
-function findUnusedAttributes(deps) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datasource, unusedAttributes, allAttributeKeys, usageInFeatures, usageInSegments, usedAttributeKeys, featureKey, segmentKey;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datasource = deps.datasource;
-                    unusedAttributes = new Set();
-                    return [4 /*yield*/, datasource.listAttributes()];
-                case 1:
-                    allAttributeKeys = _a.sent();
-                    return [4 /*yield*/, findAllUsageInFeatures(deps)];
-                case 2:
-                    usageInFeatures = _a.sent();
-                    return [4 /*yield*/, findAllUsageInSegments(deps)];
-                case 3:
-                    usageInSegments = _a.sent();
-                    usedAttributeKeys = new Set();
-                    for (featureKey in usageInFeatures) {
-                        usageInFeatures[featureKey].attributes.forEach(function (attributeKey) {
-                            usedAttributeKeys.add(attributeKey);
-                        });
-                    }
-                    for (segmentKey in usageInSegments) {
-                        usageInSegments[segmentKey].attributes.forEach(function (attributeKey) {
-                            usedAttributeKeys.add(attributeKey);
-                        });
-                    }
-                    allAttributeKeys.forEach(function (attributeKey) {
-                        if (!usedAttributeKeys.has(attributeKey)) {
-                            unusedAttributes.add(attributeKey);
-                        }
-                    });
-                    return [2 /*return*/, unusedAttributes];
-            }
+async function findUnusedAttributes(deps, usageInFeatures, usageInSegments) {
+    const { datasource } = deps;
+    const unusedAttributes = new Set();
+    const allAttributeKeys = await datasource.listAttributes();
+    const usedAttributeKeys = new Set();
+    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;
 }
-function findUsageInProject(deps, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datasource, usedInFeatures, _i, _a, featureKey, entries, authors, usedIn, _b, _c, featureKey, entries, authors, _d, _e, segmentKey, entries, authors, unusedSegments, _f, _g, segmentKey, entries, authors, unusedAttributes, _h, _j, attributeKey, entries, authors;
-        return __generator(this, function (_k) {
-            switch (_k.label) {
-                case 0:
-                    datasource = deps.datasource;
-                    console.log("");
-                    if (!options.segment) return [3 /*break*/, 8];
-                    return [4 /*yield*/, findSegmentUsage(deps, options.segment)];
-                case 1:
-                    usedInFeatures = _k.sent();
-                    if (!(usedInFeatures.size === 0)) return [3 /*break*/, 2];
-                    console.log("Segment \"".concat(options.segment, "\" is not used in any features."));
-                    return [3 /*break*/, 7];
-                case 2:
-                    console.log("Segment \"".concat(options.segment, "\" is used in the following features:\n"));
-                    _i = 0, _a = Array.from(usedInFeatures);
-                    _k.label = 3;
-                case 3:
-                    if (!(_i < _a.length)) return [3 /*break*/, 7];
-                    featureKey = _a[_i];
-                    if (!options.authors) return [3 /*break*/, 5];
-                    return [4 /*yield*/, datasource.listHistoryEntries("feature", featureKey)];
-                case 4:
-                    entries = _k.sent();
-                    authors = Array.from(new Set(entries.map(function (entry) { return entry.author; })));
-                    console.log("  - ".concat(featureKey, " (Authors: ").concat(authors.join(", "), ")"));
-                    return [3 /*break*/, 6];
-                case 5:
-                    console.log("  - ".concat(featureKey));
-                    _k.label = 6;
-                case 6:
-                    _i++;
-                    return [3 /*break*/, 3];
-                case 7: return [2 /*return*/];
-                case 8:
-                    if (!options.attribute) return [3 /*break*/, 21];
-                    return [4 /*yield*/, findAttributeUsage(deps, options.attribute)];
-                case 9:
-                    usedIn = _k.sent();
-                    if (usedIn.features.size === 0 && usedIn.segments.size === 0) {
-                        console.log("Attribute \"".concat(options.attribute, "\" is not used in any features or segments."));
-                        return [2 /*return*/];
+async function findUsageInProject(deps, options) {
+    const { datasource } = deps;
+    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(usageInFeatures, options.segment);
+        if (usedInFeatures.size === 0) {
+            console.log(`Segment "${options.segment}" is not used in any features.`);
+        }
+        else {
+            console.log(`Segment "${options.segment}" 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;
+    }
+    // attribute
+    if (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.`);
+            return;
+        }
+        if (usedIn.segments.size > 0) {
+            console.log(`Attribute "${options.attribute}" is used in the following segments:\n`);
+            for (const segmentKey of Array.from(usedIn.segments)) {
+                if (options.authors) {
+                    const entries = await datasource.listHistoryEntries("segment", segmentKey);
+                    const authors = Array.from(new Set(entries.map((entry) => entry.author)));
+                    console.log(`  - ${segmentKey} (Authors: ${authors.join(", ")})`);
+                }
+                else {
+                    console.log(`  - ${segmentKey}`);
+                }
+            }
+            // features affected by above segments
+            const affectedFeatures = new Set();
+            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}`);
                     }
-                    if (!(usedIn.features.size > 0)) return [3 /*break*/, 15];
-                    console.log("Attribute \"".concat(options.attribute, "\" is used in the following features:\n"));
-                    _b = 0, _c = Array.from(usedIn.features);
-                    _k.label = 10;
-                case 10:
-                    if (!(_b < _c.length)) return [3 /*break*/, 14];
-                    featureKey = _c[_b];
-                    if (!options.authors) return [3 /*break*/, 12];
-                    return [4 /*yield*/, datasource.listHistoryEntries("feature", featureKey)];
-                case 11:
-                    entries = _k.sent();
-                    authors = Array.from(new Set(entries.map(function (entry) { return entry.author; })));
-                    console.log("  - ".concat(featureKey, " (Authors: ").concat(authors.join(", "), ")"));
-                    return [3 /*break*/, 13];
-                case 12:
-                    console.log("  - ".concat(featureKey));
-                    _k.label = 13;
-                case 13:
-                    _b++;
-                    return [3 /*break*/, 10];
-                case 14:
-                    console.log("");
-                    _k.label = 15;
-                case 15:
-                    if (!(usedIn.segments.size > 0)) return [3 /*break*/, 20];
-                    console.log("Attribute \"".concat(options.attribute, "\" is used in the following segments:\n"));
-                    _d = 0, _e = Array.from(usedIn.segments);
-                    _k.label = 16;
-                case 16:
-                    if (!(_d < _e.length)) return [3 /*break*/, 20];
-                    segmentKey = _e[_d];
-                    if (!options.authors) return [3 /*break*/, 18];
-                    return [4 /*yield*/, datasource.listHistoryEntries("segment", segmentKey)];
-                case 17:
-                    entries = _k.sent();
-                    authors = Array.from(new Set(entries.map(function (entry) { return entry.author; })));
-                    console.log("  - ".concat(segmentKey, " (Authors: ").concat(authors.join(", "), ")"));
-                    return [3 /*break*/, 19];
-                case 18:
-                    console.log("  - ".concat(segmentKey));
-                    _k.label = 19;
-                case 19:
-                    _d++;
-                    return [3 /*break*/, 16];
-                case 20: return [2 /*return*/];
-                case 21:
-                    if (!options.unusedSegments) return [3 /*break*/, 29];
-                    return [4 /*yield*/, findUnusedSegments(deps)];
-                case 22:
-                    unusedSegments = _k.sent();
-                    if (!(unusedSegments.size === 0)) return [3 /*break*/, 23];
-                    console.log("No unused segments found.");
-                    return [3 /*break*/, 28];
-                case 23:
-                    console.log("Unused segments:\n");
-                    _f = 0, _g = Array.from(unusedSegments);
-                    _k.label = 24;
-                case 24:
-                    if (!(_f < _g.length)) return [3 /*break*/, 28];
-                    segmentKey = _g[_f];
-                    if (!options.authors) return [3 /*break*/, 26];
-                    return [4 /*yield*/, datasource.listHistoryEntries("segment", segmentKey)];
-                case 25:
-                    entries = _k.sent();
-                    authors = Array.from(new Set(entries.map(function (entry) { return entry.author; })));
-                    console.log("  - ".concat(segmentKey, " (Authors: ").concat(authors.join(", "), ")"));
-                    return [3 /*break*/, 27];
-                case 26:
-                    console.log("  - ".concat(segmentKey));
-                    _k.label = 27;
-                case 27:
-                    _f++;
-                    return [3 /*break*/, 24];
-                case 28: return [2 /*return*/];
-                case 29:
-                    if (!options.unusedAttributes) return [3 /*break*/, 37];
-                    return [4 /*yield*/, findUnusedAttributes(deps)];
-                case 30:
-                    unusedAttributes = _k.sent();
-                    if (!(unusedAttributes.size === 0)) return [3 /*break*/, 31];
-                    console.log("No unused attributes found.");
-                    return [3 /*break*/, 36];
-                case 31:
-                    console.log("Unused attributes:\n");
-                    _h = 0, _j = Array.from(unusedAttributes);
-                    _k.label = 32;
-                case 32:
-                    if (!(_h < _j.length)) return [3 /*break*/, 36];
-                    attributeKey = _j[_h];
-                    if (!options.authors) return [3 /*break*/, 34];
-                    return [4 /*yield*/, datasource.listHistoryEntries("attribute", attributeKey)];
-                case 33:
-                    entries = _k.sent();
-                    authors = Array.from(new Set(entries.map(function (entry) { return entry.author; })));
-                    console.log("  - ".concat(attributeKey, " (Authors: ").concat(authors.join(", "), ")"));
-                    return [3 /*break*/, 35];
-                case 34:
-                    console.log("  - ".concat(attributeKey));
-                    _k.label = 35;
-                case 35:
-                    _h++;
-                    return [3 /*break*/, 32];
-                case 36: return [2 /*return*/];
-                case 37:
-                    console.log("Please specify a segment or attribute.");
-                    return [2 /*return*/];
+                }
+                console.log("");
             }
-        });
-    });
+        }
+        if (usedIn.features.size > 0) {
+            console.log(`Attribute "${options.attribute}" is used directly in the following features:\n`);
+            for (const featureKey of Array.from(usedIn.features)) {
+                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("");
+        }
+        return;
+    }
+    // unused segments
+    if (options.unusedSegments) {
+        const unusedSegments = await findUnusedSegments(deps, usageInFeatures);
+        if (unusedSegments.size === 0) {
+            console.log("No unused segments found.");
+        }
+        else {
+            console.log("Unused segments:\n");
+            for (const segmentKey of Array.from(unusedSegments)) {
+                if (options.authors) {
+                    const entries = await datasource.listHistoryEntries("segment", segmentKey);
+                    const authors = Array.from(new Set(entries.map((entry) => entry.author)));
+                    console.log(`  - ${segmentKey} (Authors: ${authors.join(", ")})`);
+                }
+                else {
+                    console.log(`  - ${segmentKey}`);
+                }
+            }
+        }
+        return;
+    }
+    // unused attributes
+    if (options.unusedAttributes) {
+        const unusedAttributes = await findUnusedAttributes(deps, usageInFeatures, usageInSegments);
+        if (unusedAttributes.size === 0) {
+            console.log("No unused attributes found.");
+        }
+        else {
+            console.log("Unused attributes:\n");
+            for (const attributeKey of Array.from(unusedAttributes)) {
+                if (options.authors) {
+                    const entries = await datasource.listHistoryEntries("attribute", attributeKey);
+                    const authors = Array.from(new Set(entries.map((entry) => entry.author)));
+                    console.log(`  - ${attributeKey} (Authors: ${authors.join(", ")})`);
+                }
+                else {
+                    console.log(`  - ${attributeKey}`);
+                }
+            }
+        }
+        return;
+    }
+    console.log("Please specify a segment or attribute.");
 }
 exports.findUsagePlugin = {
     command: "find-usage",
-    handler: function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
-        var rootDirectoryPath = _b.rootDirectoryPath, projectConfig = _b.projectConfig, datasource = _b.datasource, parsed = _b.parsed;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, findUsageInProject({
-                        rootDirectoryPath: rootDirectoryPath,
-                        projectConfig: projectConfig,
-                        datasource: datasource,
-                        options: parsed,
-                    }, {
-                        segment: parsed.segment,
-                        attribute: parsed.attribute,
-                        unusedSegments: parsed.unusedSegments,
-                        unusedAttributes: parsed.unusedAttributes,
-                        authors: parsed.authors,
-                    })];
-                case 1:
-                    _c.sent();
-                    return [2 /*return*/];
-            }
+    handler: async ({ rootDirectoryPath, projectConfig, datasource, parsed }) => {
+        await findUsageInProject({
+            rootDirectoryPath,
+            projectConfig,
+            datasource,
+            options: parsed,
+        }, {
+            feature: parsed.feature,
+            segment: parsed.segment,
+            attribute: parsed.attribute,
+            unusedSegments: parsed.unusedSegments,
+            unusedAttributes: parsed.unusedAttributes,
+            authors: parsed.authors,
         });
-    }); },
+    },
     examples: [
         {
             command: "find-usage --segment=<segmentKey>",