tree-gateway/dist/configuration.js

'use strict';
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs-extra-promise");
const _ = require("lodash");
const path = require("path");
const YAML = require("yamljs");
const uuid = require("uuid");
const events_1 = require("events");
const gateway_1 = require("./config/gateway");
const typescript_ioc_1 = require("typescript-ioc");
const env_1 = require("./utils/env");
const users_1 = require("./service/users");
const middleware_1 = require("./service/middleware");
const api_1 = require("./service/api");
const config_1 = require("./service/config");
const gateway_2 = require("./service/gateway");
const plugin_data_1 = require("./service/plugin-data");
const config_2 = require("./utils/config");
const inquirer = require("inquirer");
const chalk_1 = require("chalk");
_.mixin(require('lodash-deep'));
let Configuration = Configuration_1 = class Configuration extends events_1.EventEmitter {
    constructor() {
        super();
        this.isLoaded = false;
        this.load();
    }
    async load() {
        if (!this.isLoaded) {
            try {
                await this.loadGatewayConfig(Configuration_1.gatewayConfigFile || path.join(process.cwd(), 'tree-gateway.json'));
                this.isLoaded = true;
                this.emit('load', this);
            }
            catch (err) {
                this.isLoaded = false;
                this.emit('error', err);
            }
        }
    }
    async reload() {
        this.config = null;
        await this.loadGatewayConfig(Configuration_1.gatewayConfigFile || path.join(process.cwd(), 'tree-gateway.json'));
        this.emit('gateway-update', this.gateway);
        return;
    }
    get gateway() {
        this.ensureLoaded();
        return this.config.gateway;
    }
    get rootPath() {
        return this.config.rootPath;
    }
    get middlewarePath() {
        return this.config.middlewarePath;
    }
    get database() {
        return this.config.database;
    }
    get loaded() {
        return this.isLoaded;
    }
    async loadGatewayConfig(serverConfigFile) {
        let configFileName = serverConfigFile;
        configFileName = this.removeExtension(_.trim(configFileName));
        if (_.startsWith(configFileName, '.')) {
            configFileName = path.join(process.cwd(), configFileName);
        }
        const config = await this.loadServerConfig(configFileName);
        let serverConfig = await gateway_1.validateServerConfig(config);
        serverConfig = _.defaults(serverConfig, {
            rootPath: path.dirname(configFileName),
        });
        if (_.startsWith(serverConfig.rootPath, '.')) {
            serverConfig.rootPath = path.join(path.dirname(configFileName), serverConfig.rootPath);
        }
        serverConfig = _.defaults(serverConfig, {
            middlewarePath: path.join(serverConfig.rootPath, 'middleware')
        });
        if (_.startsWith(serverConfig.middlewarePath, '.')) {
            serverConfig.middlewarePath = path.join(serverConfig.rootPath, serverConfig.middlewarePath);
        }
        serverConfig = this.config = _.deepMapValues(serverConfig, (value) => {
            return env_1.checkEnvVariable(value);
        });
        this.config = serverConfig;
        this.castArrays(this.config);
        this.loadContainerConfigurations();
        await this.loadDatabaseConfig();
        if (this.config.gateway && this.config.gateway.protocol) {
            if (this.config.gateway.protocol.https) {
                if (_.startsWith(this.config.gateway.protocol.https.privateKey, '.')) {
                    this.config.gateway.protocol.https.privateKey =
                        path.join(this.config.rootPath, this.config.gateway.protocol.https.privateKey);
                }
                if (_.startsWith(this.config.gateway.protocol.https.certificate, '.')) {
                    this.config.gateway.protocol.https.certificate =
                        path.join(this.config.rootPath, this.config.gateway.protocol.https.certificate);
                }
            }
        }
        return;
    }
    ensureLoaded() {
        if (!this.isLoaded) {
            throw new Error('Configuration not loaded. Only access configurations after the Configuration \'load\' event is fired.');
        }
    }
    loadContainerConfigurations() {
        const RedisApiService = require('./service/redis/api').RedisApiService;
        const RedisConfigService = require('./service/redis/config').RedisConfigService;
        const RedisUserService = require('./service/redis/users').RedisUserService;
        const RedisMiddlewareService = require('./service/redis/middleware').RedisMiddlewareService;
        const RedisGatewayService = require('./service/redis/gateway').RedisGatewayService;
        const RedisPluginsDataService = require('./service/redis/plugin-data').RedisPluginsDataService;
        typescript_ioc_1.Container.bind(gateway_2.GatewayService).to(RedisGatewayService);
        typescript_ioc_1.Container.bind(middleware_1.MiddlewareService).to(RedisMiddlewareService);
        typescript_ioc_1.Container.bind(api_1.ApiService).to(RedisApiService);
        typescript_ioc_1.Container.bind(config_1.ConfigService).to(RedisConfigService);
        typescript_ioc_1.Container.bind(users_1.UserService).to(RedisUserService);
        typescript_ioc_1.Container.bind(plugin_data_1.PluginsDataService).to(RedisPluginsDataService);
    }
    loadDatabaseConfig() {
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                if (Configuration_1.resetBeforeStart) {
                    console.info('reseting database');
                    const Database = require('./database').Database;
                    const database = typescript_ioc_1.Container.get(Database);
                    database.redisClient.flushdb()
                        .then(() => this.getConfigFromDB())
                        .then(resolve)
                        .catch(reject);
                }
                else {
                    this.getConfigFromDB()
                        .then(resolve)
                        .catch(reject);
                }
            }, 1);
        });
    }
    async getConfigFromDB() {
        const gatewayService = typescript_ioc_1.Container.get(gateway_2.GatewayService);
        const gatewayConfig = await gatewayService.get();
        if (gatewayConfig) {
            this.config.gateway = _.defaultsDeep(gatewayConfig, this.config.gateway);
            await gateway_1.validateGatewayConfig(this.config.gateway);
            if (!this.config.gateway.protocol) {
                throw new Error('GatewayConfig protocol is required.');
            }
        }
        else if (!this.config.gateway) {
            this.config.gateway = this.loadDefaultGatewayConfig();
            await gatewayService.save(this.config.gateway);
            await gatewayService.registerGatewayVersion();
        }
        return;
    }
    loadConfigObject(fileName) {
        if (fs.existsSync(`${fileName}.yml`)) {
            return YAML.load(`${fileName}.yml`);
        }
        else if (fs.existsSync(`${fileName}.yaml`)) {
            return YAML.load(`${fileName}.yaml`);
        }
        else if (fs.existsSync(`${fileName}.json`)) {
            return fs.readJSONSync(`${fileName}.json`);
        }
        else {
            return null;
        }
    }
    removeExtension(fileName) {
        const lowerFileName = fileName.toLowerCase();
        if (lowerFileName.endsWith('.yaml') || lowerFileName.endsWith('.yml') || lowerFileName.endsWith('.json')) {
            return fileName.substring(0, fileName.lastIndexOf('.'));
        }
        return fileName;
    }
    async loadServerConfig(configFileName) {
        let config = this.loadConfigObject(configFileName);
        if (process.env.NODE_ENV) {
            const envConfigFileName = (`${configFileName}-${process.env.NODE_ENV}`);
            const envConfig = this.loadConfigObject(envConfigFileName);
            if (envConfig) {
                config = _.defaultsDeep(envConfig, config);
            }
        }
        if (!config) {
            config = await this.loadDefaultServerConfig();
        }
        return config;
    }
    async loadDefaultServerConfig() {
        const filePath = path.join(process.cwd(), 'tree-gateway.yaml');
        console.info(chalk_1.default.yellowBright(`No server configuration file was found. Creating a configuration file and saving it on '${filePath}'`));
        const config = YAML.load(require.resolve('./tree-gateway-server-default.yaml'));
        const answers = await this.askRedisOptions();
        this.createRedisConfiguration(config, answers);
        await fs.writeFile(filePath, YAML.stringify(config, 15));
        return config;
    }
    askRedisOptions() {
        return inquirer.prompt([
            {
                choices: ['Cluster', 'Standalone'],
                default: 'Standalone',
                filter: function (val) {
                    return val.toLowerCase();
                },
                message: 'Choose the redis topology:',
                name: 'connectionType',
                type: 'list'
            },
            {
                default: 'localhost',
                message: 'Redis host:',
                name: 'host',
                type: 'input'
            },
            {
                default: '6379',
                message: 'Redis port:',
                name: 'port',
                type: 'input',
                validate: function (val) {
                    const valid = val === '' || val.match(/^[0-9]+$/) !== null;
                    return valid || 'Please enter a number';
                }
            },
            {
                message: 'Redis DB number (Optional):',
                name: 'db',
                type: 'input',
                validate: function (val) {
                    const valid = val === '' || val.match(/^[0-9]+$/) !== null;
                    return valid || 'Please enter a number';
                }
            },
            {
                message: 'Redis Password (Optional):',
                name: 'password',
                type: 'password'
            }
        ]);
    }
    createRedisConfiguration(config, answers) {
        if (answers['connectionType'] === 'standalone') {
            config.database.redis = {
                standalone: {
                    host: answers['host'],
                    port: parseInt(answers['port'], 10)
                }
            };
        }
        else {
            config.database.redis = {
                cluster: [{
                        host: answers['host'],
                        port: parseInt(answers['port'], 10)
                    }]
            };
        }
        if (answers['db'] || answers['password']) {
            config.database.redis.options = {};
            if (answers['db']) {
                config.database.redis.options.db = parseInt(answers['db'], 10);
            }
            if (answers['password']) {
                config.database.redis.options.password = answers['password'];
            }
        }
    }
    loadDefaultGatewayConfig() {
        const gateway = YAML.load(require.resolve('./tree-gateway-default.yaml'));
        console.info(`No configuration for gateway was found. Using default configuration and saving it on database.`);
        gateway.admin.userService.jwtSecret = uuid();
        return gateway;
    }
    /**
     * This function cast all array properties inside server configuration to array.
     * It is used to allow user to configure array properties as a single item too.
     * @param server Server configuration
     */
    castArrays(server) {
        config_2.castArray(server, 'database.redis.cluster');
        config_2.castArray(server, 'database.redis.sentinel.nodes');
        config_2.castArray(server, 'gateway.filter');
        config_2.castArray(server, 'gateway.admin.filter');
        config_2.castArray(server, 'gateway.serviceDiscovery.provider');
        config_2.castArray(server, 'gateway.logger.console.stderrLevels');
        config_2.castArray(server, 'gateway.accessLogger.console.stderrLevels');
        if (_.has(server, 'gateway.config.cache')) {
            _.keys(server.gateway.config.cache).forEach(cacheKey => {
                config_2.castArray(server.gateway.config.cache[cacheKey], 'server.preserveHeaders');
            });
        }
        if (_.has(server, 'gateway.config.cors')) {
            _.keys(server.gateway.config.cors).forEach(corsKey => {
                config_2.castArray(server.gateway.config.cors[corsKey], 'allowedHeaders');
                config_2.castArray(server.gateway.config.cors[corsKey], 'exposedHeaders');
                config_2.castArray(server.gateway.config.cors[corsKey], 'method');
            });
        }
    }
};
Configuration = Configuration_1 = __decorate([
    typescript_ioc_1.Singleton,
    typescript_ioc_1.AutoWired,
    __metadata("design:paramtypes", [])
], Configuration);
exports.Configuration = Configuration;
var Configuration_1;
//# sourceMappingURL=configuration.js.map