@codiac.io/codiac-cli 1.2.219 → 1.2.222

package/dist/uilogic/config-ui-utils.js

@@ -0,0 +1,676 @@
+"use strict";
+var ConfigUiUtils_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findScopeTarget = exports.ConfigUiUtils = exports.InteractionModes = exports.SpecialConfigTypes = void 0;
+const tslib_1 = require("tslib");
+const path = require("path");
+const inversify_1 = require("inversify");
+const _ = require("lodash");
+const YAML = require("yaml");
+const minimatch_1 = require("minimatch");
+const codiac_common_1 = require("@codiac.io/codiac-common");
+const codiac_ops_common_1 = require("@codiac.io/codiac-ops-common");
+const codiac_api_1 = require("../apis/codiac-api");
+const contracts_1 = require("../apis/codiac-api/contracts");
+const CodiacConstants = require("../codiac-constants");
+const render = require("./render-methods");
+var SpecialConfigTypes;
+(function (SpecialConfigTypes) {
+    SpecialConfigTypes["env"] = "env";
+    SpecialConfigTypes["footprint"] = "footprint";
+    SpecialConfigTypes["helm"] = "helm";
+})(SpecialConfigTypes = exports.SpecialConfigTypes || (exports.SpecialConfigTypes = {}));
+var InteractionModes;
+(function (InteractionModes) {
+    InteractionModes["echo"] = "echo";
+    InteractionModes["toscript"] = "toscript";
+    InteractionModes["silent"] = "silent";
+})(InteractionModes = exports.InteractionModes || (exports.InteractionModes = {}));
+let ConfigUiUtils = ConfigUiUtils_1 = class ConfigUiUtils {
+    /** Converts the source properties of a ScopedSetting into a parseable string so that it can be rendered as a string value.
+     *
+     * eg: converts this:
+     * ```
+     * {
+     *  "type": "awsKeyVault",
+     *  "name": "our-aws-east-dev-secrets",
+     *  "key": "mongo-db-user-dev"
+     * }
+     * ```
+     * into this: `#REF|awsKeyVault|our-aws-east-dev-secrets|mongo-db-user-dev`
+     *
+      */
+    serializeSourcedValue(source) {
+        return `${ConfigUiUtils_1.SOURCED_VALUE_PREFIX}|${source.type}|${source.name}|${source.key}`;
+    }
+    /** Determines if the given setting value is a serialized representation of a sourced setting. */
+    isSourced(value) {
+        if ((value != undefined) && (typeof value === 'string') && value.startsWith(ConfigUiUtils_1.SOURCED_VALUE_PREFIX.concat("|"))) {
+            if (value.split("|").length === 4) {
+                return true;
+            }
+            else {
+                return true; // <--- It probably IS a sourced setting, just incorrectly formatted.  We are returning true, so that parsing will fail with more descriptive errors. 
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    /** Mutates the setting object to convert a value that is a serialized source reference into the explicit source property  */
+    deserializeSourcedValue(setting) {
+        var _a, _b;
+        try {
+            if (this.isSourced(setting.value)) {
+                let parts = setting.value.split("|");
+                if (parts.length != 4)
+                    throw new Error("Invalid source value syntax; Must be '#REF|<type>|<name>|<key>'.");
+                if (Object.keys(contracts_1.KvpStoreTypesEnum).includes(parts[1]) != true)
+                    throw new Error("Unrecognized source type.");
+                // MUTATE THE GIVEN SETTING OBJECT
+                setting.source = {
+                    type: contracts_1.KvpStoreTypesEnum[parts[1]],
+                    name: parts[2],
+                    key: parts[3]
+                };
+                delete setting.value;
+            }
+        }
+        catch (err) {
+            throw new Error(`Error parsing sourced value: ${(_a = err.name) !== null && _a !== void 0 ? _a : ""} ${(_b = err.message) !== null && _b !== void 0 ? _b : ""}`);
+        }
+    }
+    buildConfigTree(settings) {
+        let tree = [];
+        for (let setting of settings) {
+            let branch = { text: `${this._styler.dim(setting.setting)}:  ${setting.value}`, value: "" };
+            // TODO: unflatten dotpaths and recurse...
+            tree.push(branch);
+        }
+        return tree;
+    }
+    constructor(_ui, _styler, _codiacApi) {
+        this._ui = _ui;
+        this._styler = _styler;
+        this._codiacApi = _codiacApi;
+    }
+    /** Validates the candidate's current value,
+     * prompts the user if necessary,
+     * mutates the candidate as needed,
+     * and returns the applicable enterprise obj from the RootMap.
+     *
+     * Throws when unable to assign one,
+     * so otherwise, candidate SHALL ALWAYS end up with an enterprise assigned.*/
+    promptForEnterprise(candidate, rootMap) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let ent;
+                if (candidate.enterprise != undefined) {
+                    // validate the given enterprise
+                    if (rootMap.enterprises.length === 0) {
+                        throw new Error("No enterprises found. You must create an enterprise to run this command.");
+                    }
+                    let found = rootMap.enterprises.find(x => x.name === candidate.enterprise);
+                    if (found == undefined)
+                        candidate.enterprise = undefined;
+                }
+                if (candidate.enterprise != undefined) {
+                    ent = rootMap.enterprises.find(x => x.name === candidate.enterprise); // this assertion operator is ok bc we just validated that its in the list
+                }
+                else {
+                    if (rootMap.enterprises.length === 1) {
+                        ent = rootMap.enterprises[0];
+                        candidate.enterprise = ent.name; // Auto-select the one-and-only
+                    }
+                    else {
+                        // PROMPT FOR IT
+                        let choices = rootMap.enterprises.map(e => e.name);
+                        candidate.enterprise = (yield this._ui.promptSelect("enterprise", "Enterprise: ", choices));
+                        ent = (rootMap.enterprises.find(x => x.name === candidate.enterprise)); // this assertion operator is ok bc we know its in this list
+                    }
+                }
+                return ent;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    /** Returns the ultiamate asset name and the flag telling whether the original user input was changed. */
+    promptForAsset(assets, current) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let selected = current;
+            let changed = false;
+            if (assets.length === 0) {
+                throw new Error("This enterprise has no assets. You must create an asset to run this command.");
+            }
+            if (selected != undefined) {
+                // Drop the current value if its invalid
+                let found = assets.find(x => x.name === selected);
+                if (found == undefined) {
+                    selected = undefined;
+                }
+            }
+            if (selected == undefined) {
+                if (assets.length === 1) {
+                    selected = assets[0].name; // Auto-select the one-and-only
+                }
+                else {
+                    // PROMPT FOR IT
+                    let choices = assets.map(a => { return { name: a.name, value: a.name }; });
+                    selected = (yield this._ui.promptSelect("asset", "Asset: ", choices)); // TODO: This needs to be a fuzzy-select
+                }
+                changed = Boolean(current != undefined);
+            }
+            return [selected, changed];
+        });
+    }
+    promptForTypeAndFile(enterprise, asset, configType, targetFile, existingConfigDefs, allowAddNew = false, takeDefaults = false) {
+        var _a, _b, _c;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let typeFileChanged = false; // true when original input is invalid
+            let partial = {
+                configType: configType,
+                targetFile: targetFile
+            };
+            let configDefs;
+            if (existingConfigDefs) {
+                // Use the given list
+                configDefs = existingConfigDefs;
+            }
+            else {
+                // Query the api for the list of existing configDefs for this asset
+                let crit = {
+                    asset: asset,
+                    enterprise: enterprise
+                };
+                let cfgResult = yield this._codiacApi.Call.getConfigDefs(crit, { projection: { pathsExcluded: [], pathsIncluded: ["type", "targetFile", "settings"] } });
+                if (cfgResult.error)
+                    throw cfgResult.error;
+                configDefs = (_a = cfgResult.output) !== null && _a !== void 0 ? _a : [];
+                if (configDefs.length == 0)
+                    throw new Error("This asset has no configs defined."); // REVISIT THIS THROW - Dont we just want to return empty results instead?  
+            }
+            // Validate Type/File
+            if (partial.targetFile != undefined) {
+                const found = configDefs.find(x => x.targetFile == partial.targetFile);
+                if (found) {
+                    partial.targetFile = found.targetFile;
+                    partial.existingSettings = found.settings;
+                }
+                else {
+                    partial.targetFile = undefined;
+                    typeFileChanged = true;
+                }
+            }
+            else if (partial.configType != undefined) {
+                const found = configDefs.find(x => { var _a; return (x.type != undefined) && (x.type.toString() == ((_a = partial.configType) === null || _a === void 0 ? void 0 : _a.toString())); });
+                if (found) {
+                    partial.configType = SpecialConfigTypes[found.type];
+                    partial.existingSettings = found.settings;
+                }
+                else {
+                    partial.configType = undefined;
+                    typeFileChanged = true;
+                }
+            }
+            if (partial.targetFile == undefined && partial.configType == undefined) {
+                let choices = configDefs.map(x => {
+                    var _a, _b;
+                    return {
+                        name: (x.type == contracts_1.ConfigDefTypesEnum.file && x.targetFile != undefined) ? x.targetFile : x.type,
+                        value: `${(_a = x.type) !== null && _a !== void 0 ? _a : ""}|${(_b = x.targetFile) !== null && _b !== void 0 ? _b : ""}`
+                    };
+                });
+                let selected;
+                if (allowAddNew === true) {
+                    // ----------------------------------------------------------------------
+                    // WRITE MODE (so user can declare a new file or choose an un-used type)
+                    // ----------------------------------------------------------------------
+                    choices.push({ name: CodiacConstants.CliConstants.CHOICE_VALUE_FOR_NEW, value: CodiacConstants.CliConstants.CHOICE_VALUE_FOR_NEW });
+                    if (choices.length > 0) {
+                        selected = (yield this._ui.promptSelect("existingCfgTarget", "Config: ", choices));
+                    }
+                    if ((selected === undefined) || (selected === CodiacConstants.CliConstants.CHOICE_VALUE_FOR_NEW)) {
+                        // 1. Select a config type first
+                        let newCfgTypeChoices = [contracts_1.ConfigDefTypesEnum.file, ...Object.keys(SpecialConfigTypes)];
+                        selected = (yield this._ui.promptSelect("cfgType", "Target: ", newCfgTypeChoices));
+                        // 2. Target file declaration
+                        if (selected == contracts_1.ConfigDefTypesEnum.file) {
+                            selected = (yield this._ui.prompt("filefreehand", "Path from image root: ('?' to browse): "));
+                            if (selected === "?") {
+                                let localPath = (yield this._ui.promptSelectFile("filebrowse", "Select file: ", { asRelative: true }));
+                                // settingsInLocalFile = await this.extractSettingsFromFile(localPath);
+                                let filename = path.basename(localPath);
+                                let pathInImage = path.dirname(localPath);
+                                this._ui.userMessage(`Target file: ${this._styler.hilite(filename)}`);
+                                pathInImage = (yield this._ui.prompt("pathinimage", "Path from image root: ", true, pathInImage));
+                                selected = path.posix.join(pathInImage, filename);
+                            }
+                            else {
+                                // the user free-handed the targetFile field
+                                // this._ui.userMessage(`Target file: ${this._styler.hilite(selected)}`);
+                            }
+                            selected = "|".concat(selected); // to conform with the format we're using below
+                        }
+                        else {
+                            selected = selected.concat("|"); // to conform with the format we're using below
+                        }
+                    }
+                }
+                else {
+                    // ----------------------------------------------------------------------
+                    // Readonly mode - Limit choices to existing files/types
+                    // ----------------------------------------------------------------------
+                    if (choices.length === 1) {
+                        selected = choices[0].value; // Auto-select the one-and-only
+                        if (typeFileChanged) {
+                            // if we changed their value, then we need their confirmation
+                            let keep = yield this._ui.promptConfirm("type-file-changed", `Only 1 config found; Continue?  ${this._styler.hilite(choices[0].name)} `);
+                            if (!keep)
+                                throw new Error("You declined the only available config definition.");
+                        }
+                        else {
+                            if (takeDefaults != true) {
+                                this._ui.userMessage(`Only 1 config found: ${this._styler.hilite(choices[0].name)}`);
+                            }
+                        }
+                    }
+                    else {
+                        selected = (yield this._ui.promptSelect("cfgType", "Config: ", choices));
+                    }
+                }
+                partial.configType = SpecialConfigTypes[selected.split("|")[0]];
+                if (_.isEmpty(partial.configType))
+                    partial.configType = undefined;
+                partial.targetFile = selected.split("|")[1];
+                if (_.isEmpty(partial.targetFile))
+                    partial.targetFile = undefined;
+                if (partial.configType)
+                    partial.existingSettings = (_b = configDefs.find(x => { var _a; return x.type.toString() == ((_a = partial.configType) === null || _a === void 0 ? void 0 : _a.toString()); })) === null || _b === void 0 ? void 0 : _b.settings;
+                else if (partial.targetFile)
+                    partial.existingSettings = (_c = configDefs.find(x => x.targetFile == partial.targetFile)) === null || _c === void 0 ? void 0 : _c.settings;
+            }
+            return [partial.configType, partial.targetFile, partial.existingSettings, typeFileChanged];
+        });
+    }
+    /** Prompts for a single setting name.
+   *
+   * TODO: Add ability to select branches of settings (globbed dot-paths)
+   * so user can delete entire sections at a time (eg: database-settings.*).
+   *
+   *
+   * Use this inquirer plugin for navigating the object structure:
+   *    https://github.com/insightfuls/inquirer-tree-prompt
+   *
+   * See if this file tree selector could be fashioned to do the same:
+   *    https://github.com/anc95/inquirer-file-tree-selection
+   *
+   * @param existing The list of existing settings to choose from.
+   * @param mode Set this to `write` only if you want the user to be able to add new settings.  Indicates whether "Add New" (mode: `write`) or "All" (mode: `read`) options will be provided.
+   * @param given A prompt gets invoked in `read` mode only if none match any existing settings, and in `write` mode only if none are given at all.
+   */
+    promptForOneSetting(existing, mode = "read", given) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (mode == "read") {
+                let [selectedMany, instances, changedGivens] = yield this.promptForManySettings(existing, given, false); // TODO: prevent multi
+                if (selectedMany.length == 0)
+                    throw new Error("User canceled setting selection");
+                return [selectedMany[0], instances, changedGivens];
+            }
+            else {
+                // mode == "write"
+                let selected;
+                if ((given != undefined) && !_.isEmpty(given)) {
+                    selected = given; // NOTE:  blindly accepting the given without a prompt.  Because in write mode, misspellings arent our problem.
+                }
+                else {
+                    if (existing.length > 0) {
+                        // let choices = existing.map(s => { return { name: s.setting, value: s.setting }; });
+                        let choices = _.uniq(existing.map(s => s.setting));
+                        choices.sort();
+                        choices = _.uniq(choices);
+                        choices.push(CodiacConstants.CliConstants.CHOICE_VALUE_FOR_NEW);
+                        selected = (yield this._ui.promptSelect("settingSelect", "Setting: ", choices));
+                    }
+                    if (selected == undefined || selected === CodiacConstants.CliConstants.CHOICE_VALUE_FOR_NEW) {
+                        selected = (yield this._ui.prompt("settingFreehand", "Setting (use '.' for hierarchy): "));
+                    }
+                }
+                let instances = existing.filter(s => s.setting == selected);
+                let settingChanged = ConfigUiUtils_1.areDifferent(selected, given);
+                return [selected, instances, settingChanged];
+            }
+        });
+    }
+    /** Prompts for one or many setting names.  Includes an `ALL` but NOT an `ADDNEW` option.
+     *
+     * TODO: Add ability to select branches of settings (globbed dot-paths)
+     * so user can delete entire sections at a time (eg: database-settings.*).
+     *
+     *
+     * Use this inquirer plugin for navigating the object structure:
+     *    https://github.com/insightfuls/inquirer-tree-prompt
+     *
+     * See if this file tree selector could be fashioned to do the same:
+     *    https://github.com/anc95/inquirer-file-tree-selection
+     *
+     * @param existing
+     * @param given A prompt gets invoked only if no givens match any existing settings.
+     */
+    promptForManySettings(existing, given, multi = true) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let selected = ((given != undefined) && (typeof given == 'string')) ? [given] : given;
+                let settingChanged = false;
+                let instances;
+                if (existing.length == 0) {
+                    throw new Error("No existing settings were found");
+                }
+                // TODO: Check for glob magic  - globs should pass through
+                instances = (selected != undefined) ? ConfigUiUtils_1.matchMultipleWithGlobbing(existing, selected) : [];
+                if (instances.length > 0) {
+                    // (at least one or more of) the given setting(s) are valid.  
+                }
+                else {
+                    if (given != undefined && !_.isEmpty(given)) {
+                        this._ui.userMessage(`None of your requested settings were found.`);
+                    }
+                    // TODO: render a tree of settings choices 
+                    // so they can select either branches (glob) or leaf nodes (distinct)
+                    // let choices = existing.map(s => { return { name: s.setting, value: s.setting }; });
+                    let choices = existing.map(s => { return { name: s.setting, value: s.setting }; });
+                    choices = _.orderBy(choices, x => x.name);
+                    choices = _.uniqBy(choices, x => x.name);
+                    choices.unshift({ name: CodiacConstants.CliConstants.CHOICE_VALUE_FOR_ALL, value: CodiacConstants.CliConstants.GLOB_FOR_ALL });
+                    selected = [(yield this._ui.promptSelect("settingSelect", "Setting: ", choices))]; // stuffing it into an Array here!!!
+                    instances = ConfigUiUtils_1.matchMultipleWithGlobbing(existing, selected);
+                }
+                settingChanged = ConfigUiUtils_1.areDifferent(selected, given);
+                // ----------------------------------------------------------------------------------------------
+                // // Try to implement un-selectable options...
+                // let settings = ["bill", "sam", "tom", "harry"];
+                // let choices: any[] = settings.map(s => { return { name: s, value: s }; });
+                // // choices.push({ name: "some branch", value: new inquirer.Separator("--I am a branch") });
+                // choices.push(new inquirer.Separator("--I am a branch"));
+                // choices.push({ name: "sally", value: "sally" });
+                // choices.push({ name: "Sue", value: "Sue" });
+                // choices.push({ name: "Suzy", value: "Suzy" });
+                // let nada = await this._ui.promptSelect("test", "try this", choices);
+                // ----------------------------------------------------------------------------------------------
+                return [selected, instances, settingChanged];
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+    }
+    /** Searches out availables that match ANY of the given specs.
+     * @param availables: setting objects to search for.
+     * @param matchSpecs: each can be either a distinct setting name (eg `shoe-size`) or a glob (eg `api-settings.*`).
+     */
+    static matchMultipleWithGlobbing(availables, matchSpecs) {
+        let patterns = matchSpecs.filter(x => (new minimatch_1.Minimatch(x, {})).hasMagic());
+        let names = _.difference(matchSpecs, patterns);
+        let globs = patterns.map(g => new minimatch_1.Minimatch(g));
+        let instances = [];
+        if (names) {
+            instances = instances.concat(availables.filter(s => names.includes(s.setting)));
+        }
+        if (globs) {
+            for (let glob of globs) {
+                instances = instances.concat(availables.filter(s => glob.match(s.setting)));
+            }
+        }
+        return instances;
+    }
+    /** Determines if the two collections have ANY different concrete values,
+     * regardless of order or string/array/undefined/empty)
+     *
+     * ```
+     * DIFFERENT IF:
+     * any of A not in B
+     * AND
+     * any of B not in A
+     * ```
+     * */
+    static areDifferent(thingA, thingB) {
+        if (thingA == undefined || _.isEmpty(thingA)) {
+            return !Boolean(thingB == undefined || _.isEmpty(thingB));
+        }
+        else if (thingB == undefined || _.isEmpty(thingB)) {
+            return true; // because A is not empty
+        }
+        else {
+            let areDiff = (Boolean(_.difference((typeof thingA == 'string') ? [thingA] : thingA, thingB).length > 0)
+                || Boolean(_.difference((typeof thingB == 'string') ? [thingB] : thingB, thingA).length > 0));
+            return areDiff;
+        }
+    }
+    validateAndPromptForScope(rootMap, enterprise, scope, target, existings, allowEverywhere = true) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let targetChanged = false;
+            let partial = {
+                scope: scope,
+                target: target
+            };
+            if (partial.scope != undefined || partial.target != undefined) {
+                // Validate
+                partial.scope = (partial.scope == undefined) ? undefined : contracts_1.ScopeLevel[partial.scope];
+                if (partial.scope == undefined)
+                    partial.target = undefined; // NOTE:  Instead of dropping the target, you could deduce the scope by searching around the map for a single target with this name...
+                if (partial.scope != undefined && partial.target != undefined) {
+                    let found = findScopeTarget(rootMap, partial.scope, partial.target);
+                    partial.target = found === null || found === void 0 ? void 0 : found.name;
+                    targetChanged = Boolean(partial.target == undefined);
+                }
+            }
+            if (partial.scope == undefined || (partial.target == undefined && partial.scope != contracts_1.ScopeLevel.enterprise)) {
+                let scope = yield this.promptForScope(enterprise, rootMap, existings, allowEverywhere, undefined);
+                if (scope) {
+                    partial.scope = scope.scope;
+                    partial.target = scope.target;
+                }
+            }
+            return [partial.scope, partial.target, targetChanged];
+        });
+    }
+    /** NOTE: /target output can be undefined ONLY if allowEverywhere is set to true.  If false, you can safely apply an assertion operator (!) to scope and target. */
+    promptForScope(enterprise, rootMap, existings, allowEverywhere = true, prompt) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let output;
+                // render cab tree with all lines selectable
+                let cabTree = this.buildCabinetTree(rootMap, existings);
+                let choices = this.buildSelectChoicesFrom(cabTree);
+                if (allowEverywhere)
+                    choices.unshift({ name: "** Everywhere **", value: CodiacConstants.CliConstants.GLOB_FOR_ALL });
+                let delimited = (yield this._ui.promptSelect("scope", prompt !== null && prompt !== void 0 ? prompt : "Scope: ", choices, undefined, false));
+                if (delimited == CodiacConstants.CliConstants.GLOB_FOR_ALL) {
+                    output = undefined;
+                }
+                else {
+                    let parts = delimited.split("|");
+                    output = { scope: parts[0], target: parts[1] };
+                }
+                return output;
+            }
+            catch (err) {
+                throw (err);
+            }
+        });
+    }
+    /** sets each value to "scope|target".
+   * */
+    buildCabinetTree(rootMap, existings) {
+        var _a, _b, _c, _d;
+        let tree = [];
+        // If there's more than a single setting name in the list, then we're gonna show counts>0 at each scope, otherwise we'll show ellipsised values.
+        let showCounts = false;
+        if (existings != undefined && _.uniq(existings.map(x => x.setting).sort()).length > 1) {
+            showCounts = true;
+        }
+        for (let ent of rootMap.enterprises) {
+            let entBranch = { text: `${ent.name} enterprise:`, value: `${contracts_1.ScopeLevel.enterprise}|${ent.name}` };
+            let entSettings = existings === null || existings === void 0 ? void 0 : existings.filter(s => s.scope === contracts_1.ScopeLevel.enterprise && s.target === ent.name);
+            if (entSettings !== undefined && entSettings.length > 0) {
+                let valueSuffix = showCounts ? `${entSettings.length} found` : (this.ellipsis(35, (_a = entSettings[0].value) !== null && _a !== void 0 ? _a : "[set to undefined]"));
+                valueSuffix = `(${valueSuffix})`;
+                entBranch.text = entBranch.text.concat(" ", this._styler.dim(valueSuffix));
+            }
+            for (let env of _.sortBy(ent.environments, e => e.sequence, e => e.name)) {
+                let envBranch = { text: `${env.name}`, value: `${contracts_1.ScopeLevel.environment}|${env.name}` };
+                let envSettings = existings === null || existings === void 0 ? void 0 : existings.filter(s => s.scope === contracts_1.ScopeLevel.environment && s.target === env.name);
+                if (envSettings !== undefined && envSettings.length > 0) {
+                    let valueSuffix = showCounts ? `${envSettings.length} found` : (this.ellipsis(35, (_b = envSettings[0].value) !== null && _b !== void 0 ? _b : "[set to undefined]"));
+                    valueSuffix = `(${valueSuffix})`;
+                    envBranch.text = envBranch.text.concat(" ", this._styler.dim(valueSuffix));
+                }
+                for (let cab of env.cabinets) {
+                    // let cwg = rootMap.clusters.find(c => c.name === cab.cluster);
+                    // let clusterDesc = cwg ? ` (${cab.cluster}, ${cwg.provider} ${cwg.locationName})` : "";
+                    let cabBranch = {
+                        text: `${cab.name}`,
+                        value: `${contracts_1.ScopeLevel.cabinet}|${cab.name}`
+                    };
+                    let cabSettings = existings === null || existings === void 0 ? void 0 : existings.filter(s => s.scope === contracts_1.ScopeLevel.cabinet && s.target === cab.name);
+                    if (cabSettings !== undefined && cabSettings.length > 0) {
+                        let valueSuffix = showCounts ? `${cabSettings.length} found` : this.ellipsis(35, (_c = cabSettings[0].value) !== null && _c !== void 0 ? _c : "[set to undefined]");
+                        valueSuffix = `(${valueSuffix})`;
+                        cabBranch.text = cabBranch.text.concat(" ", this._styler.dim(valueSuffix));
+                    }
+                    if (envBranch.children === undefined)
+                        envBranch.children = [];
+                    (_d = envBranch.children) === null || _d === void 0 ? void 0 : _d.push(cabBranch);
+                }
+                if (entBranch.children === undefined)
+                    entBranch.children = [];
+                entBranch.children.push(envBranch);
+            }
+            tree.push(entBranch);
+        }
+        return tree;
+    }
+    /** Truncates the string to the given length with an ellipses as suffix */
+    ellipsis(maxLength, value) {
+        let output = value;
+        if (output.length > maxLength) {
+            let ellipsis = "..."; // Rather use the ellipsis character but String.fromCharCode(133) is returning a problematic character.
+            output = output.slice(0, maxLength - 1 - ellipsis.length).concat(ellipsis);
+        }
+        return output;
+    }
+    buildSelectChoicesFrom(tree) {
+        try {
+            let choices = [];
+            // the value is no good here - need scope and target both available
+            render.renderStringTree(tree, (txt, item) => choices.push({ name: txt, value: item.value }));
+            // // This is one way to do it
+            // for (let item of tree) {
+            // 
+            //   let thisChoice: PromptChoice = { name: item.text, value: item.text };
+            //   choices.push(thisChoice);
+            // 
+            //   if (item.children && item.children.length > 0) {
+            //     let children = this.buildSelectChoicesFrom(item.children);
+            //     choices.push(...children);
+            //   }
+            // }
+            return choices;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    /** Determines the format of the string that was piped in,
+   * and parses it into an object in memory.
+   *
+   * Supports formats:  json, yaml
+   */
+    parseInputString(input) {
+        var _a, _b;
+        let output;
+        try {
+            // Determine format
+            let format; // | "csv" | "tsv";
+            // if (input.startsWith("setting,value\n")) {
+            //   format = "csv";
+            // } else if (input.startsWith("setting\tvalue\n")) {
+            //   format = "tsv";
+            /* } else */ if (input.startsWith("{") || input.startsWith("[")) {
+                format = "json";
+                // } else if (input.startsWith("- setting\n")) {
+                //   format = "yaml";
+            }
+            else {
+                // throw new Error("Invalid stdin data; data format not recognized.");
+                format = "yaml";
+            }
+            // Parse
+            switch (format) {
+                case "json":
+                    let jsonDoc = JSON.parse(input);
+                    output = codiac_common_1.ObjectFlattener.flatten(jsonDoc).map(x => { return { setting: x.key, value: x.value }; });
+                    break;
+                case "yaml":
+                    let yamlDoc = YAML.parse(input);
+                    output = codiac_common_1.ObjectFlattener.flatten(yamlDoc).map(x => { return { setting: x.key, value: x.value }; });
+                    break;
+                // case "csv":
+                //   output = this.parseTable(input, ",");
+                //   break;
+                // case "tsv":
+                //   output = this.parseTable(input, "\t");
+                //   break;
+            }
+            return output;
+        }
+        catch (err) {
+            throw new Error(`Error parsing stdin: ${(_a = err.name) !== null && _a !== void 0 ? _a : ""} ${(_b = err.message) !== null && _b !== void 0 ? _b : ""}`);
+        }
+    }
+};
+/** The prefix on a setting value indicating that the setting value is actually sourced from a key-value store (such as an Azure key vault or AWS secret store). */
+ConfigUiUtils.SOURCED_VALUE_PREFIX = "#REF";
+ConfigUiUtils = ConfigUiUtils_1 = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.inject)(codiac_ops_common_1.INTERFACES_OPS.IUserInputProvider)),
+    tslib_1.__param(1, (0, inversify_1.inject)(codiac_ops_common_1.INTERFACES_OPS.IOutputStyler)),
+    tslib_1.__param(2, (0, inversify_1.inject)(codiac_api_1.CodiacClient)),
+    tslib_1.__metadata("design:paramtypes", [Object, Object, codiac_api_1.CodiacClient])
+], ConfigUiUtils);
+exports.ConfigUiUtils = ConfigUiUtils;
+/** Finds the object in the rootmap (ent, env, or cab) specified by the given scope.
+*
+* Returns undefined if the scope/target combination does not exist.
+*/
+function findScopeTarget(rootMap, scope, target) {
+    switch (scope) {
+        case contracts_1.ScopeLevel.enterprise:
+            return rootMap.enterprises.find(e => e.name == target);
+        case contracts_1.ScopeLevel.environment:
+            let env;
+            for (let ent of rootMap.enterprises) {
+                env = ent.environments.find(v => v.name == target);
+                if (env)
+                    break;
+            }
+            return env;
+        case contracts_1.ScopeLevel.cabinet:
+            let cab;
+            for (let ent of rootMap.enterprises) {
+                for (let env of ent.environments) {
+                    cab = env.cabinets.find(v => v.name == target);
+                    if (cab)
+                        break;
+                }
+                if (cab)
+                    break;
+            }
+            return cab;
+        default:
+            return undefined;
+    }
+}
+exports.findScopeTarget = findScopeTarget;
+//# sourceMappingURL=config-ui-utils.js.map