@featurevisor/core 1.35.2 → 2.0.0

package/lib/list/index.js

@@ -1,548 +1,380 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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.listPlugin = void 0;
+exports.listEntities = listEntities;
 exports.listProject = listProject;
-var tester_1 = require("../tester");
-function getEntitiesWithTests(deps) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datasource, featuresWithTests, segmentsWithTests, tests, _i, tests_1, testKey, test_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datasource = deps.datasource;
-                    featuresWithTests = new Set();
-                    segmentsWithTests = new Set();
-                    return [4 /*yield*/, datasource.listTests()];
-                case 1:
-                    tests = _a.sent();
-                    _i = 0, tests_1 = tests;
-                    _a.label = 2;
-                case 2:
-                    if (!(_i < tests_1.length)) return [3 /*break*/, 5];
-                    testKey = tests_1[_i];
-                    return [4 /*yield*/, datasource.readTest(testKey)];
-                case 3:
-                    test_1 = _a.sent();
-                    if (test_1.feature) {
-                        featuresWithTests.add(test_1.feature);
+const matrix_1 = require("./matrix");
+async function getEntitiesWithTests(deps) {
+    const { datasource } = deps;
+    const featuresWithTests = new Set();
+    const segmentsWithTests = new Set();
+    const tests = await datasource.listTests();
+    for (const testKey of tests) {
+        const test = await datasource.readTest(testKey);
+        if (test.feature) {
+            featuresWithTests.add(test.feature);
+        }
+        if (test.segment) {
+            segmentsWithTests.add(test.segment);
+        }
+    }
+    return {
+        features: Array.from(featuresWithTests),
+        segments: Array.from(segmentsWithTests),
+    };
+}
+async function listEntities(deps, entityType) {
+    const { datasource, options } = deps;
+    const result = [];
+    let entityKeys = [];
+    if (entityType === "feature") {
+        entityKeys = await datasource.listFeatures();
+    }
+    else if (entityType === "segment") {
+        entityKeys = await datasource.listSegments();
+    }
+    else if (entityType === "attribute") {
+        entityKeys = await datasource.listAttributes();
+    }
+    else if (entityType === "test") {
+        entityKeys = await datasource.listTests();
+    }
+    if (entityKeys.length === 0) {
+        return result;
+    }
+    let entitiesWithTests = {
+        features: [],
+        segments: [],
+    };
+    let entitiesWithTestsInitialized = false;
+    async function initializeEntitiesWithTests() {
+        if (entitiesWithTestsInitialized) {
+            return;
+        }
+        entitiesWithTests = await getEntitiesWithTests(deps);
+        entitiesWithTestsInitialized = true;
+    }
+    for (const key of entityKeys) {
+        let entity = {};
+        if (entityType === "feature") {
+            entity = (await datasource.readFeature(key));
+        }
+        else if (entityType === "segment") {
+            entity = (await datasource.readSegment(key));
+        }
+        else if (entityType === "attribute") {
+            entity = (await datasource.readAttribute(key));
+        }
+        else if (entityType === "test") {
+            entity = (await datasource.readTest(key));
+        }
+        // filter
+        if (entityType === "feature") {
+            const parsedFeature = entity;
+            // --archived=true|false
+            if (parsedFeature.archived) {
+                const archivedStatus = options.archived === "false";
+                if (parsedFeature.archived !== archivedStatus) {
+                    continue;
+                }
+            }
+            // --description=<pattern>
+            if (options.description) {
+                const description = parsedFeature.description || "";
+                const regex = new RegExp(options.description, "i");
+                if (!regex.test(description)) {
+                    continue;
+                }
+            }
+            // --disabledIn=<environment>
+            if (options.disabledIn && parsedFeature.rules && parsedFeature.rules[options.disabledIn]) {
+                const disabledInEnvironment = parsedFeature.rules[options.disabledIn].every((rule) => {
+                    return rule.percentage === 0;
+                });
+                if (!disabledInEnvironment) {
+                    continue;
+                }
+            }
+            // --enabledIn=<environment>
+            if (options.enabledIn && parsedFeature.rules && parsedFeature.rules[options.enabledIn]) {
+                const enabledInEnvironment = parsedFeature.rules[options.enabledIn].some((rule) => {
+                    return rule.percentage > 0;
+                });
+                if (!enabledInEnvironment) {
+                    continue;
+                }
+            }
+            // --keyPattern=<pattern>
+            if (options.keyPattern) {
+                const regex = new RegExp(options.keyPattern, "i");
+                if (!regex.test(key)) {
+                    continue;
+                }
+            }
+            // --tag=<tag>
+            if (options.tag) {
+                const tags = Array.isArray(options.tag) ? options.tag : [options.tag];
+                const hasTags = tags.every((tag) => parsedFeature.tags.includes(tag));
+                if (!hasTags) {
+                    continue;
+                }
+            }
+            // --variable=<variableKey>
+            if (options.variable) {
+                const lookForVariables = Array.isArray(options.variable)
+                    ? options.variable
+                    : [options.variable];
+                let variablesInFeature = Object.keys(parsedFeature.variablesSchema || {});
+                const hasVariables = lookForVariables.every((variable) => variablesInFeature.includes(variable));
+                if (!hasVariables) {
+                    continue;
+                }
+            }
+            // --variation=<variationValue>
+            if (options.variation) {
+                const lookForVariations = Array.isArray(options.variation)
+                    ? options.variation
+                    : [options.variation];
+                let variationsInFeature = parsedFeature.variations
+                    ? parsedFeature.variations.map((v) => v.value)
+                    : [];
+                const hasVariations = lookForVariations.every((variation) => variationsInFeature.includes(variation));
+                if (!hasVariations) {
+                    continue;
+                }
+            }
+            // --with-tests
+            if (options.withTests) {
+                await initializeEntitiesWithTests();
+                if (!entitiesWithTests.features.includes(key)) {
+                    continue;
+                }
+            }
+            // --with-variables
+            if (options.withVariables) {
+                const hasVariables = parsedFeature.variablesSchema;
+                if (!hasVariables) {
+                    continue;
+                }
+            }
+            // --with-variations
+            if (options.withVariations) {
+                const hasVariations = parsedFeature.variations;
+                if (!hasVariations) {
+                    continue;
+                }
+            }
+            // --without-tests
+            if (options.withoutTests) {
+                await initializeEntitiesWithTests();
+                if (entitiesWithTests.features.includes(key)) {
+                    continue;
+                }
+            }
+            // --without-variables
+            if (options.withoutVariables) {
+                const hasVariables = parsedFeature.variablesSchema;
+                if (hasVariables) {
+                    continue;
+                }
+            }
+            // --without-variations
+            if (options.withoutVariations) {
+                const hasVariations = parsedFeature.variations;
+                if (hasVariations) {
+                    continue;
+                }
+            }
+        }
+        else if (entityType === "segment") {
+            const segment = entity;
+            // --archived=true|false
+            if (segment.archived) {
+                const archivedStatus = options.archived === "false";
+                if (segment.archived !== archivedStatus) {
+                    continue;
+                }
+            }
+            // --description=<pattern>
+            if (options.description) {
+                const description = segment.description || "";
+                const regex = new RegExp(options.description, "i");
+                if (!regex.test(description)) {
+                    continue;
+                }
+            }
+            // --keyPattern=<pattern>
+            if (options.keyPattern) {
+                const regex = new RegExp(options.keyPattern, "i");
+                if (!regex.test(key)) {
+                    continue;
+                }
+            }
+            // --with-tests
+            if (options.withTests) {
+                await initializeEntitiesWithTests();
+                if (!entitiesWithTests.segments.includes(key)) {
+                    continue;
+                }
+            }
+            // --without-tests
+            if (options.withoutTests) {
+                await initializeEntitiesWithTests();
+                if (entitiesWithTests.segments.includes(key)) {
+                    continue;
+                }
+            }
+        }
+        else if (entityType === "attribute") {
+            const attribute = entity;
+            // --archived=true|false
+            if (options.archived) {
+                const archivedStatus = options.archived === "false";
+                if (attribute.archived !== archivedStatus) {
+                    continue;
+                }
+            }
+            // --description=<pattern>
+            if (options.description) {
+                const description = attribute.description || "";
+                const regex = new RegExp(options.description, "i");
+                if (!regex.test(description)) {
+                    continue;
+                }
+            }
+            // --keyPattern=<pattern>
+            if (options.keyPattern) {
+                const regex = new RegExp(options.keyPattern, "i");
+                if (!regex.test(key)) {
+                    continue;
+                }
+            }
+        }
+        else if (entityType === "test") {
+            let test = entity;
+            const testEntityKey = test.feature || test.segment;
+            const testEntityType = test.segment ? "segment" : "feature";
+            let testAssertions = test.assertions;
+            // --entityType=<type>
+            if (options.entityType && options.entityType !== testEntityType) {
+                continue;
+            }
+            // --apply-matrix
+            if (options.applyMatrix) {
+                if (testEntityType === "feature") {
+                    let assertionsAfterApplyingMatrix = [];
+                    for (let aIndex = 0; aIndex < testAssertions.length; aIndex++) {
+                        const processedAssertions = (0, matrix_1.getFeatureAssertionsFromMatrix)(aIndex, testAssertions[aIndex]);
+                        assertionsAfterApplyingMatrix =
+                            assertionsAfterApplyingMatrix.concat(processedAssertions);
                     }
-                    if (test_1.segment) {
-                        segmentsWithTests.add(test_1.segment);
+                    testAssertions = assertionsAfterApplyingMatrix;
+                }
+                else if (testEntityType === "segment") {
+                    let assertionsAfterApplyingMatrix = [];
+                    for (let aIndex = 0; aIndex < testAssertions.length; aIndex++) {
+                        const processedAssertions = (0, matrix_1.getSegmentAssertionsFromMatrix)(aIndex, testAssertions[aIndex]);
+                        assertionsAfterApplyingMatrix =
+                            assertionsAfterApplyingMatrix.concat(processedAssertions);
                     }
-                    _a.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 5: return [2 /*return*/, {
-                        features: Array.from(featuresWithTests),
-                        segments: Array.from(segmentsWithTests),
-                    }];
+                    testAssertions = assertionsAfterApplyingMatrix;
+                }
             }
-        });
-    });
-}
-function listEntities(deps, entityType) {
-    return __awaiter(this, void 0, void 0, function () {
-        function initializeEntitiesWithTests() {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (entitiesWithTestsInitialized) {
-                                return [2 /*return*/];
-                            }
-                            return [4 /*yield*/, getEntitiesWithTests(deps)];
-                        case 1:
-                            entitiesWithTests = _a.sent();
-                            entitiesWithTestsInitialized = true;
-                            return [2 /*return*/];
+            // --keyPattern=<pattern>
+            if (options.keyPattern) {
+                const regex = new RegExp(options.keyPattern, "i");
+                if (!regex.test(testEntityKey)) {
+                    continue;
+                }
+            }
+            // --assertionPattern=<pattern>
+            if (options.assertionPattern) {
+                const regex = new RegExp(options.assertionPattern, "i");
+                testAssertions = testAssertions.filter((assertion) => {
+                    if (!assertion.description) {
+                        return false;
                     }
+                    return regex.test(assertion.description);
                 });
-            });
-        }
-        var datasource, options, result, entityKeys, entitiesWithTests, entitiesWithTestsInitialized, _loop_1, _i, entityKeys_1, key;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    datasource = deps.datasource, options = deps.options;
-                    result = [];
-                    entityKeys = [];
-                    if (!(entityType === "feature")) return [3 /*break*/, 2];
-                    return [4 /*yield*/, datasource.listFeatures()];
-                case 1:
-                    entityKeys = _a.sent();
-                    return [3 /*break*/, 8];
-                case 2:
-                    if (!(entityType === "segment")) return [3 /*break*/, 4];
-                    return [4 /*yield*/, datasource.listSegments()];
-                case 3:
-                    entityKeys = _a.sent();
-                    return [3 /*break*/, 8];
-                case 4:
-                    if (!(entityType === "attribute")) return [3 /*break*/, 6];
-                    return [4 /*yield*/, datasource.listAttributes()];
-                case 5:
-                    entityKeys = _a.sent();
-                    return [3 /*break*/, 8];
-                case 6:
-                    if (!(entityType === "test")) return [3 /*break*/, 8];
-                    return [4 /*yield*/, datasource.listTests()];
-                case 7:
-                    entityKeys = _a.sent();
-                    _a.label = 8;
-                case 8:
-                    if (entityKeys.length === 0) {
-                        return [2 /*return*/, result];
-                    }
-                    entitiesWithTests = {
-                        features: [],
-                        segments: [],
-                    };
-                    entitiesWithTestsInitialized = false;
-                    _loop_1 = function (key) {
-                        var entity, parsedFeature_1, archivedStatus, description, regex, disabledInEnvironment, enabledInEnvironment, regex, tags, hasTags, lookForVariables, variablesInFeature_1, hasVariables, lookForVariations, variationsInFeature_1, hasVariations, hasVariables, hasVariations, hasVariables, hasVariations, segment, archivedStatus, description, regex, regex, attribute, archivedStatus, description, regex, regex, test_2, testEntityKey, testEntityType, testAssertions, assertionsAfterApplyingMatrix, aIndex, processedAssertions, assertionsAfterApplyingMatrix, aIndex, processedAssertions, regex, regex_1;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    entity = {};
-                                    if (!(entityType === "feature")) return [3 /*break*/, 2];
-                                    return [4 /*yield*/, datasource.readFeature(key)];
-                                case 1:
-                                    entity = (_b.sent());
-                                    return [3 /*break*/, 8];
-                                case 2:
-                                    if (!(entityType === "segment")) return [3 /*break*/, 4];
-                                    return [4 /*yield*/, datasource.readSegment(key)];
-                                case 3:
-                                    entity = (_b.sent());
-                                    return [3 /*break*/, 8];
-                                case 4:
-                                    if (!(entityType === "attribute")) return [3 /*break*/, 6];
-                                    return [4 /*yield*/, datasource.readAttribute(key)];
-                                case 5:
-                                    entity = (_b.sent());
-                                    return [3 /*break*/, 8];
-                                case 6:
-                                    if (!(entityType === "test")) return [3 /*break*/, 8];
-                                    return [4 /*yield*/, datasource.readTest(key)];
-                                case 7:
-                                    entity = (_b.sent());
-                                    _b.label = 8;
-                                case 8:
-                                    if (!(entityType === "feature")) return [3 /*break*/, 13];
-                                    parsedFeature_1 = entity;
-                                    // --archived=true|false
-                                    if (parsedFeature_1.archived) {
-                                        archivedStatus = options.archived === "false";
-                                        if (parsedFeature_1.archived !== archivedStatus) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --description=<pattern>
-                                    if (options.description) {
-                                        description = parsedFeature_1.description || "";
-                                        regex = new RegExp(options.description, "i");
-                                        if (!regex.test(description)) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --disabledIn=<environment>
-                                    if (options.disabledIn &&
-                                        parsedFeature_1.environments &&
-                                        parsedFeature_1.environments[options.disabledIn]) {
-                                        disabledInEnvironment = parsedFeature_1.environments[options.disabledIn].rules.every(function (rule) {
-                                            return rule.percentage === 0;
-                                        });
-                                        if (!disabledInEnvironment) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --enabledIn=<environment>
-                                    if (options.enabledIn &&
-                                        parsedFeature_1.environments &&
-                                        parsedFeature_1.environments[options.enabledIn]) {
-                                        enabledInEnvironment = parsedFeature_1.environments[options.enabledIn].rules.some(function (rule) {
-                                            return rule.percentage > 0;
-                                        });
-                                        if (!enabledInEnvironment) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --keyPattern=<pattern>
-                                    if (options.keyPattern) {
-                                        regex = new RegExp(options.keyPattern, "i");
-                                        if (!regex.test(key)) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --tag=<tag>
-                                    if (options.tag) {
-                                        tags = Array.isArray(options.tag) ? options.tag : [options.tag];
-                                        hasTags = tags.every(function (tag) { return parsedFeature_1.tags.includes(tag); });
-                                        if (!hasTags) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --variable=<variableKey>
-                                    if (options.variable) {
-                                        lookForVariables = Array.isArray(options.variable)
-                                            ? options.variable
-                                            : [options.variable];
-                                        variablesInFeature_1 = [];
-                                        if (Array.isArray(parsedFeature_1.variablesSchema)) {
-                                            variablesInFeature_1 = parsedFeature_1.variablesSchema.map(function (variable) { return variable.key; });
-                                        }
-                                        else if (parsedFeature_1.variablesSchema) {
-                                            variablesInFeature_1 = Object.keys(parsedFeature_1.variablesSchema);
-                                        }
-                                        hasVariables = lookForVariables.every(function (variable) {
-                                            return variablesInFeature_1.includes(variable);
-                                        });
-                                        if (!hasVariables) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --variation=<variationValue>
-                                    if (options.variation) {
-                                        lookForVariations = Array.isArray(options.variation)
-                                            ? options.variation
-                                            : [options.variation];
-                                        variationsInFeature_1 = parsedFeature_1.variations
-                                            ? parsedFeature_1.variations.map(function (v) { return v.value; })
-                                            : [];
-                                        hasVariations = lookForVariations.every(function (variation) {
-                                            return variationsInFeature_1.includes(variation);
-                                        });
-                                        if (!hasVariations) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    if (!options.withTests) return [3 /*break*/, 10];
-                                    return [4 /*yield*/, initializeEntitiesWithTests()];
-                                case 9:
-                                    _b.sent();
-                                    if (!entitiesWithTests.features.includes(key)) {
-                                        return [2 /*return*/, "continue"];
-                                    }
-                                    _b.label = 10;
-                                case 10:
-                                    // --with-variables
-                                    if (options.withVariables) {
-                                        hasVariables = parsedFeature_1.variablesSchema;
-                                        if (!hasVariables) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --with-variations
-                                    if (options.withVariations) {
-                                        hasVariations = parsedFeature_1.variations;
-                                        if (!hasVariations) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    if (!options.withoutTests) return [3 /*break*/, 12];
-                                    return [4 /*yield*/, initializeEntitiesWithTests()];
-                                case 11:
-                                    _b.sent();
-                                    if (entitiesWithTests.features.includes(key)) {
-                                        return [2 /*return*/, "continue"];
-                                    }
-                                    _b.label = 12;
-                                case 12:
-                                    // --without-variables
-                                    if (options.withoutVariables) {
-                                        hasVariables = parsedFeature_1.variablesSchema;
-                                        if (hasVariables) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --without-variations
-                                    if (options.withoutVariations) {
-                                        hasVariations = parsedFeature_1.variations;
-                                        if (hasVariations) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    return [3 /*break*/, 19];
-                                case 13:
-                                    if (!(entityType === "segment")) return [3 /*break*/, 18];
-                                    segment = entity;
-                                    // --archived=true|false
-                                    if (segment.archived) {
-                                        archivedStatus = options.archived === "false";
-                                        if (segment.archived !== archivedStatus) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --description=<pattern>
-                                    if (options.description) {
-                                        description = segment.description || "";
-                                        regex = new RegExp(options.description, "i");
-                                        if (!regex.test(description)) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    // --keyPattern=<pattern>
-                                    if (options.keyPattern) {
-                                        regex = new RegExp(options.keyPattern, "i");
-                                        if (!regex.test(key)) {
-                                            return [2 /*return*/, "continue"];
-                                        }
-                                    }
-                                    if (!options.withTests) return [3 /*break*/, 15];
-                                    return [4 /*yield*/, initializeEntitiesWithTests()];
-                                case 14:
-                                    _b.sent();
-                                    if (!entitiesWithTests.segments.includes(key)) {
-                                        return [2 /*return*/, "continue"];
-                                    }
-                                    _b.label = 15;
-                                case 15:
-                                    if (!options.withoutTests) return [3 /*break*/, 17];
-                                    return [4 /*yield*/, initializeEntitiesWithTests()];
-                                case 16:
-                                    _b.sent();
-                                    if (entitiesWithTests.segments.includes(key)) {
-                                        return [2 /*return*/, "continue"];
-                                    }
-                                    _b.label = 17;
-                                case 17: return [3 /*break*/, 19];
-                                case 18:
-                                    if (entityType === "attribute") {
-                                        attribute = entity;
-                                        // --archived=true|false
-                                        if (options.archived) {
-                                            archivedStatus = options.archived === "false";
-                                            if (attribute.archived !== archivedStatus) {
-                                                return [2 /*return*/, "continue"];
-                                            }
-                                        }
-                                        // --description=<pattern>
-                                        if (options.description) {
-                                            description = attribute.description || "";
-                                            regex = new RegExp(options.description, "i");
-                                            if (!regex.test(description)) {
-                                                return [2 /*return*/, "continue"];
-                                            }
-                                        }
-                                        // --keyPattern=<pattern>
-                                        if (options.keyPattern) {
-                                            regex = new RegExp(options.keyPattern, "i");
-                                            if (!regex.test(key)) {
-                                                return [2 /*return*/, "continue"];
-                                            }
-                                        }
-                                    }
-                                    else if (entityType === "test") {
-                                        test_2 = entity;
-                                        testEntityKey = test_2.feature || test_2.segment;
-                                        testEntityType = test_2.segment ? "segment" : "feature";
-                                        testAssertions = test_2.assertions;
-                                        // --apply-matrix
-                                        if (options.applyMatrix) {
-                                            if (testEntityType === "feature") {
-                                                assertionsAfterApplyingMatrix = [];
-                                                for (aIndex = 0; aIndex < testAssertions.length; aIndex++) {
-                                                    processedAssertions = (0, tester_1.getFeatureAssertionsFromMatrix)(aIndex, testAssertions[aIndex]);
-                                                    assertionsAfterApplyingMatrix =
-                                                        assertionsAfterApplyingMatrix.concat(processedAssertions);
-                                                }
-                                                testAssertions = assertionsAfterApplyingMatrix;
-                                            }
-                                            else if (testEntityType === "segment") {
-                                                assertionsAfterApplyingMatrix = [];
-                                                for (aIndex = 0; aIndex < testAssertions.length; aIndex++) {
-                                                    processedAssertions = (0, tester_1.getSegmentAssertionsFromMatrix)(aIndex, testAssertions[aIndex]);
-                                                    assertionsAfterApplyingMatrix =
-                                                        assertionsAfterApplyingMatrix.concat(processedAssertions);
-                                                }
-                                                testAssertions = assertionsAfterApplyingMatrix;
-                                            }
-                                        }
-                                        // --keyPattern=<pattern>
-                                        if (options.keyPattern) {
-                                            regex = new RegExp(options.keyPattern, "i");
-                                            if (!regex.test(testEntityKey)) {
-                                                return [2 /*return*/, "continue"];
-                                            }
-                                        }
-                                        // --assertionPattern=<pattern>
-                                        if (options.assertionPattern) {
-                                            regex_1 = new RegExp(options.assertionPattern, "i");
-                                            testAssertions = testAssertions.filter(function (assertion) {
-                                                if (!assertion.description) {
-                                                    return false;
-                                                }
-                                                return regex_1.test(assertion.description);
-                                            });
-                                            if (testAssertions.length === 0) {
-                                                return [2 /*return*/, "continue"];
-                                            }
-                                        }
-                                        entity.assertions = testAssertions;
-                                    }
-                                    _b.label = 19;
-                                case 19:
-                                    result.push(__assign(__assign({}, entity), { key: key }));
-                                    return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _i = 0, entityKeys_1 = entityKeys;
-                    _a.label = 9;
-                case 9:
-                    if (!(_i < entityKeys_1.length)) return [3 /*break*/, 12];
-                    key = entityKeys_1[_i];
-                    return [5 /*yield**/, _loop_1(key)];
-                case 10:
-                    _a.sent();
-                    _a.label = 11;
-                case 11:
-                    _i++;
-                    return [3 /*break*/, 9];
-                case 12: return [2 /*return*/, result];
+                if (testAssertions.length === 0) {
+                    continue;
+                }
             }
+            entity.assertions = testAssertions;
+        }
+        result.push({
+            ...entity,
+            key,
         });
-    });
+    }
+    return result;
 }
 function ucfirst(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function printResult(_a) {
-    var result = _a.result, entityType = _a.entityType, options = _a.options;
+function printResult({ result, entityType, options }) {
     if (options.json) {
         console.log(options.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result));
         return;
     }
     if (result.length === 0) {
-        console.log("No ".concat(entityType, "s found."));
+        console.log(`No ${entityType}s found.`);
         return;
     }
-    console.log("\n".concat(ucfirst(entityType), "s:\n"));
-    for (var _i = 0, result_1 = result; _i < result_1.length; _i++) {
-        var item = result_1[_i];
-        console.log("- ".concat(item.key));
+    console.log(`\n${ucfirst(entityType)}s:\n`);
+    for (const item of result) {
+        console.log(`- ${item.key}`);
     }
-    console.log("\n\nFound ".concat(result.length, " ").concat(entityType, "s."));
+    console.log(`\n\nFound ${result.length} ${entityType}s.`);
 }
-function listProject(deps) {
-    return __awaiter(this, void 0, void 0, function () {
-        var rootDirectoryPath, projectConfig, datasource, options, result, result, result, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    rootDirectoryPath = deps.rootDirectoryPath, projectConfig = deps.projectConfig, datasource = deps.datasource, options = deps.options;
-                    if (!options.features) return [3 /*break*/, 2];
-                    return [4 /*yield*/, listEntities(deps, "feature")];
-                case 1:
-                    result = _a.sent();
-                    return [2 /*return*/, printResult({
-                            result: result,
-                            entityType: "feature",
-                            options: options,
-                        })];
-                case 2:
-                    if (!options.segments) return [3 /*break*/, 4];
-                    return [4 /*yield*/, listEntities(deps, "segment")];
-                case 3:
-                    result = _a.sent();
-                    return [2 /*return*/, printResult({
-                            result: result,
-                            entityType: "segment",
-                            options: options,
-                        })];
-                case 4:
-                    if (!options.attributes) return [3 /*break*/, 6];
-                    return [4 /*yield*/, listEntities(deps, "attribute")];
-                case 5:
-                    result = _a.sent();
-                    return [2 /*return*/, printResult({
-                            result: result,
-                            entityType: "attribute",
-                            options: options,
-                        })];
-                case 6:
-                    if (!options.tests) return [3 /*break*/, 8];
-                    return [4 /*yield*/, listEntities(deps, "test")];
-                case 7:
-                    result = _a.sent();
-                    return [2 /*return*/, printResult({
-                            result: result,
-                            entityType: "test",
-                            options: options,
-                        })];
-                case 8:
-                    console.log("\nNothing to list. \n\nPlease pass `--features`, `--segments`, or `--attributes`.");
-                    return [2 /*return*/];
-            }
+async function listProject(deps) {
+    const { options } = deps;
+    // features
+    if (options.features) {
+        const result = await listEntities(deps, "feature");
+        return printResult({
+            result,
+            entityType: "feature",
+            options,
         });
-    });
+    }
+    // segments
+    if (options.segments) {
+        const result = await listEntities(deps, "segment");
+        return printResult({
+            result,
+            entityType: "segment",
+            options,
+        });
+    }
+    // attributes
+    if (options.attributes) {
+        const result = await listEntities(deps, "attribute");
+        return printResult({
+            result,
+            entityType: "attribute",
+            options,
+        });
+    }
+    // tests
+    if (options.tests) {
+        const result = await listEntities(deps, "test");
+        return printResult({
+            result,
+            entityType: "test",
+            options,
+        });
+    }
+    console.log("\nNothing to list. \n\nPlease pass `--features`, `--segments`, or `--attributes`.");
 }
 exports.listPlugin = {
     command: "list",
-    handler: function (_a) {
-        return __awaiter(this, arguments, 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*/, listProject({
-                            rootDirectoryPath: rootDirectoryPath,
-                            projectConfig: projectConfig,
-                            datasource: datasource,
-                            options: parsed,
-                        })];
-                    case 1:
-                        _c.sent();
-                        return [2 /*return*/];
-                }
-            });
+    handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
+        await listProject({
+            rootDirectoryPath,
+            projectConfig,
+            datasource,
+            options: parsed,
         });
     },
     examples: [