Beau/src/config.js

const deepMerge = require('deepmerge');
const { requestRegex, UpperCaseKeys, moduleVersion } = require('./shared');
const Plugins = require('./plugins');

class Config {
    constructor(doc, env = {}) {
        const defaultConfigValues = {
            VERSION: moduleVersion(),
            ENDPOINT: '',
            PLUGINS: [],
            DEFAULTS: {},
            ENVIRONMENT: {},
            HOSTS: [],
            COOKIEJAR: false
        };

        this.configKeys = Object.keys(defaultConfigValues);

        let config = this.loadConfig(doc);
        Object.assign(this, defaultConfigValues, config);

        this.ENVIRONMENT = deepMerge(this.ENVIRONMENT, env);

        this.REQUESTS = [];

        this.loadRequests(doc, {
            DEFAULTS: this.DEFAULTS,
            ENDPOINT: this.ENDPOINT
        });

        this.loadHosts(this.HOSTS, config, defaultConfigValues);

        this.PLUGINS = new Plugins(this.PLUGINS);
    }

    loadHosts(hosts, rootConfig, defaultConfigValues) {
        hosts.forEach(host => {
            if (typeof host.host === 'undefined') {
                throw new Error(`Host doesn't indicate it's host name.`);
            }

            let config = deepMerge(defaultConfigValues, this.loadConfig(host));

            config.DEFAULTS = deepMerge(rootConfig.DEFAULTS, config.DEFAULTS);

            this.loadRequests(host, {
                DEFAULTS: config.DEFAULTS,
                ENDPOINT: config.ENDPOINT,
                NAMESPACE: host.host
            });
        });
    }

    loadRequests(host, settings) {
        Object.entries(host)
            .filter(([key]) => requestRegex.test(key))
            .forEach(([key, rDefinition]) => {
                if (Array.isArray(rDefinition)) {
                    rDefinition.forEach(req =>
                        this.addRequest(key, req, settings)
                    );
                } else {
                    this.addRequest(key, rDefinition, settings);
                }
            });
    }

    addRequest(key, rDefinition, settings) {
        let requestDefinitionIsString = typeof rDefinition === 'string';
        let originalRequest = requestDefinitionIsString
            ? { ALIAS: rDefinition }
            : rDefinition;

        let request = UpperCaseKeys(originalRequest);

        if (settings.NAMESPACE) {
            request.ALIAS = `${settings.NAMESPACE}:${request.ALIAS}`;
        }

        request.REQUEST = key;
        request.COOKIEJAR = this.COOKIEJAR;
        request.ENDPOINT = settings.ENDPOINT;

        let defaults = UpperCaseKeys(settings.DEFAULTS);

        this.REQUESTS.push(deepMerge(defaults, request));
    }

    loadConfig(host) {
        let config = {};

        Object.entries(host)
            .filter(([key]) => this.configKeys.includes(key.toUpperCase()))
            .forEach(([key, value]) => (config[key.toUpperCase()] = value));

        return config;
    }
}

module.exports = Config;