@salesforce/core/lib/config/configAggregator.js

"use strict";
/*
 * Copyright (c) 2020, salesforce.com, inc.
 * All rights reserved.
 * Licensed under the BSD 3-Clause license.
 * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.SfdxConfigAggregator = exports.ConfigAggregator = void 0;
const kit_1 = require("@salesforce/kit");
const ts_types_1 = require("@salesforce/ts-types");
const messages_1 = require("../messages");
const envVars_1 = require("./envVars");
const config_1 = require("./config");
messages_1.Messages.importMessagesDirectory(__dirname);
const messages = messages_1.Messages.load('@salesforce/core', 'config', ['unknownConfigKey', 'deprecatedConfigKey']);
/**
 * Aggregate global and local project config files, as well as environment variables for
 * `config.json`. The resolution happens in the following bottom-up order:
 *
 * 1. Environment variables  (`SF_LOG_LEVEL`)
 * 1. Workspace settings  (`<workspace-root>/.sf/config.json`)
 * 1. Global settings  (`$HOME/.sf/config.json`)
 *
 * Use {@link ConfigAggregator.create} to instantiate the aggregator.
 *
 * ```
 * const aggregator = await ConfigAggregator.create();
 * console.log(aggregator.getPropertyValue('target-org'));
 * ```
 */
class ConfigAggregator extends kit_1.AsyncOptionalCreatable {
    /**
     * **Do not directly construct instances of this class -- use {@link ConfigAggregator.create} instead.**
     *
     * @ignore
     */
    constructor(options) {
        super(options ?? {});
        this.envVars = {};
        // Don't throw an project error with the aggregator, since it should resolve to global if
        // there is no project.
        try {
            this.localConfig = new config_1.Config(config_1.Config.getDefaultOptions(false));
        }
        catch (err) {
            if (err.name !== 'InvalidProjectWorkspaceError') {
                throw err;
            }
        }
        this.globalConfig = new config_1.Config(config_1.Config.getDefaultOptions(true));
        this.setAllowedProperties(config_1.Config.getAllowedProperties());
    }
    get config() {
        return this.resolveProperties(this.globalConfig.getContents(), this.localConfig?.getContents());
    }
    // Use typing from AsyncOptionalCreatable to support extending ConfigAggregator.
    // We really don't want ConfigAggregator extended but typescript doesn't support a final.
    static async create(options) {
        let config = ConfigAggregator.instance;
        if (!config) {
            config = ConfigAggregator.instance = new this(options);
            await config.init();
        }
        if (ConfigAggregator.encrypted) {
            await config.loadProperties();
        }
        if (options?.customConfigMeta) {
            config_1.Config.addAllowedProperties(options.customConfigMeta);
        }
        return ConfigAggregator.instance;
    }
    /**
     * Get the info for a given key. If the ConfigAggregator was not asynchronously created OR
     * the {@link ConfigAggregator.reload} was not called, the config value may be encrypted.
     *
     * @param key The config key.
     */
    static getValue(key) {
        return this.getInstance().getInfo(key);
    }
    /**
     * Get the static ConfigAggregator instance. If one doesn't exist, one will be created with
     * the **encrypted** config values. Encrypted config values need to be resolved
     * asynchronously by calling {@link ConfigAggregator.reload}
     */
    // Use typing from AsyncOptionalCreatable to support extending ConfigAggregator.
    // We really don't want ConfigAggregator extended but typescript doesn't support a final.
    static getInstance() {
        if (!ConfigAggregator.instance) {
            ConfigAggregator.instance = new this();
            ConfigAggregator.instance.loadPropertiesSync();
        }
        return ConfigAggregator.instance;
    }
    /**
     * Initialize this instances async dependencies.
     */
    async init() {
        await this.loadProperties();
    }
    /**
     * Get a resolved config property.
     *
     * **Throws** *{@link SfError}{ name: 'UnknownConfigKeyError' }* An attempt to get a property that's not supported.
     *
     * @param key The key of the property.
     */
    getPropertyValue(key) {
        if (this.getAllowedProperties().some((element) => key === element.key)) {
            return this.getConfig()[key];
        }
        else {
            throw messages.createError('unknownConfigKey', [key]);
        }
    }
    /**
     * Get a resolved config property meta.
     *
     * **Throws** *{@link SfError}{ name: 'UnknownConfigKeyError' }* An attempt to get a property that's not supported.
     *
     * @param key The key of the property.
     */
    getPropertyMeta(key) {
        const match = this.getAllowedProperties().find((element) => key === element.key);
        if (match) {
            return match;
        }
        else {
            throw messages.createError('unknownConfigKey', [key]);
        }
    }
    /**
     * Get a resolved config property.
     *
     * @param key The key of the property.
     * @param throwOnDeprecation True, if you want an error throw when reading a deprecated config
     */
    getInfo(key, throwOnDeprecation = false) {
        const meta = this.getPropertyMeta(key);
        if (throwOnDeprecation && meta.deprecated && meta.newKey) {
            throw messages.createError('deprecatedConfigKey', [key, meta.newKey]);
        }
        const location = this.getLocation(key);
        return {
            key,
            location,
            value: this.getPropertyValue(key),
            path: this.getPath(key),
            isLocal: () => location === "Local" /* ConfigAggregator.Location.LOCAL */,
            isGlobal: () => location === "Global" /* ConfigAggregator.Location.GLOBAL */,
            isEnvVar: () => location === "Environment" /* ConfigAggregator.Location.ENVIRONMENT */,
            deprecated: meta.deprecated ?? false,
        };
    }
    /**
     * Gets a resolved config property location.
     *
     * For example, `getLocation('logLevel')` will return:
     * 1. `Location.GLOBAL` if resolved to an environment variable.
     * 1. `Location.LOCAL` if resolved to local project config.
     * 1. `Location.ENVIRONMENT` if resolved to the global config.
     *
     * @param key The key of the property.
     */
    getLocation(key) {
        if (this.envVars[key] != null) {
            return "Environment" /* ConfigAggregator.Location.ENVIRONMENT */;
        }
        if (this.localConfig?.get(key)) {
            return "Local" /* ConfigAggregator.Location.LOCAL */;
        }
        if (this.globalConfig?.get(key)) {
            return "Global" /* ConfigAggregator.Location.GLOBAL */;
        }
    }
    /**
     * Get a resolved file path or environment variable name of the property.
     *
     * For example, `getPath('logLevel')` will return:
     * 1. `$SF_LOG_LEVEL` if resolved to an environment variable.
     * 1. `./.sf/config.json` if resolved to the local config.
     * 1. `~/.sf/config.json` if resolved to the global config.
     * 1. `undefined`, if not resolved.
     *
     * **Note:** that the path returned may be the absolute path instead of
     * relative paths such as `./` and `~/`.
     *
     * @param key The key of the property.
     */
    getPath(key) {
        if (this.envVars[key] != null) {
            return `$${envVars_1.EnvVars.propertyToEnvName(key)}`;
        }
        if (this.localConfig?.getContents()[key] != null) {
            return this.localConfig.getPath();
        }
        if (this.globalConfig.getContents()[key] != null) {
            return this.globalConfig.getPath();
        }
    }
    /**
     * Get all resolved config property keys, values, locations, and paths.
     *
     * ```
     * > console.log(aggregator.getConfigInfo());
     * [
     *     { key: 'logLevel', val: 'INFO', location: 'Environment', path: '$SF_LOG_LEVEL'}
     *     { key: 'target-org', val: '<username>', location: 'Local', path: './.sf/config.json'}
     * ]
     * ```
     */
    getConfigInfo() {
        const infos = Object.keys(this.getConfig())
            .filter((key) => this.getAllowedProperties().some((element) => key === element.key))
            .map((key) => this.getInfo(key))
            .filter((info) => !!info);
        return (0, kit_1.sortBy)(infos, 'key');
    }
    /**
     * Get the local project config instance.
     */
    getLocalConfig() {
        return this.localConfig;
    }
    /**
     * Get the global config instance.
     */
    getGlobalConfig() {
        return this.globalConfig;
    }
    /**
     * Get the resolved config object from the local, global and environment config instances.
     */
    getConfig() {
        return this.config;
    }
    /**
     * Get the config properties that are environment variables.
     */
    getEnvVars() {
        return this.envVars;
    }
    /**
     * Re-read all property configurations from disk.
     */
    async reload() {
        await this.loadProperties();
        return this;
    }
    /**
     * Add an allowed config property.
     */
    addAllowedProperties(configMetas) {
        if ((0, ts_types_1.isArray)(configMetas)) {
            this.allowedProperties.push(...configMetas);
        }
        else {
            this.allowedProperties.push(configMetas);
        }
    }
    /**
     * Set the allowed properties.
     *
     * @param properties The properties to set.
     */
    setAllowedProperties(properties) {
        this.allowedProperties = properties;
    }
    /**
     * Get the allowed properties.
     */
    getAllowedProperties() {
        return this.allowedProperties;
    }
    /**
     * Loads all the properties and aggregates them according to location.
     */
    async loadProperties() {
        this.resolveProperties(await this.globalConfig.read(), this.localConfig && (await this.localConfig.read()));
        ConfigAggregator.encrypted = false;
    }
    /**
     * Loads all the properties and aggregates them according to location.
     */
    loadPropertiesSync() {
        this.resolveProperties(this.globalConfig.readSync(), this.localConfig?.readSync());
    }
    resolveProperties(globalConfig, localConfig) {
        const envVars = new envVars_1.EnvVars();
        for (const property of this.getAllowedProperties()) {
            const key = property.newKey ? property.newKey : property.key;
            const value = envVars.getPropertyFromEnv(property.key);
            if (value)
                this.envVars[key] = value;
        }
        // Global config must be read first so it is on the left hand of the
        // object assign and is overwritten by the local config.
        const configs = [globalConfig];
        // We might not be in a project workspace
        if (localConfig) {
            configs.push(localConfig);
        }
        configs.push(this.envVars);
        const json = {};
        const reduced = configs.filter(ts_types_1.isJsonMap).reduce((acc, el) => (0, kit_1.merge)(acc, el), json);
        return reduced;
    }
}
exports.ConfigAggregator = ConfigAggregator;
ConfigAggregator.encrypted = true;
/**
 * A ConfigAggregator that will work with deprecated config vars (e.g. defaultusername, apiVersion).
 * We do NOT recommend using this class unless you absolutely have to.
 *
 * @deprecated
 */
class SfdxConfigAggregator extends ConfigAggregator {
    static async create(options = {}) {
        const customConfigMeta = options.customConfigMeta ?? [];
        // org-metadata-rest-deploy has been moved to plugin-deploy-retrieve but we need to have a placeholder
        // for it here since sfdx needs to know how to set the deprecated restDeploy config var.
        const restDeploy = config_1.SFDX_ALLOWED_PROPERTIES.find((p) => p.key === config_1.SfdxPropertyKeys.REST_DEPLOY);
        const orgRestDeploy = Object.assign({}, restDeploy, { key: 'org-metadata-rest-deploy', deprecated: false });
        options.customConfigMeta = [...customConfigMeta, orgRestDeploy];
        let config = SfdxConfigAggregator.instance;
        if (!config) {
            config = SfdxConfigAggregator.instance = new this(options);
            await config.init();
        }
        if (SfdxConfigAggregator.encrypted) {
            await config.loadProperties();
        }
        if (options?.customConfigMeta) {
            config_1.Config.addAllowedProperties(options.customConfigMeta);
        }
        return SfdxConfigAggregator.instance;
    }
    getPropertyMeta(key) {
        const match = this.getAllowedProperties().find((element) => key === element.key);
        if (match?.deprecated && match?.newKey) {
            return this.getPropertyMeta(match.newKey);
        }
        else if (match) {
            return match;
        }
        else {
            throw messages.createError('unknownConfigKey', [key]);
        }
    }
    getPropertyValue(key) {
        return super.getPropertyValue(this.translate(key));
    }
    getInfo(key) {
        const info = super.getInfo(this.translate(key));
        info.key = this.translate(info.key, 'toOld');
        return info;
    }
    getLocation(key) {
        return super.getLocation(this.translate(key));
    }
    getPath(key) {
        return super.getPath(this.translate(key));
    }
    getConfigInfo() {
        return super.getConfigInfo().map((c) => {
            c.key = this.translate(c.key, 'toOld');
            return c;
        });
    }
    translate(key, direction = 'toNew') {
        const propConfig = direction === 'toNew'
            ? this.getPropertyMeta(key)
            : config_1.Config.getAllowedProperties().find((c) => c.newKey === key) ?? {};
        return propConfig.key || key;
    }
}
exports.SfdxConfigAggregator = SfdxConfigAggregator;
SfdxConfigAggregator.encrypted = true;
//# sourceMappingURL=configAggregator.js.map