stix/dist/Library/Cli/CliService.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const yargs_parser_1 = __importDefault(require("yargs-parser"));
const Output_1 = require("../Output");
class CliService {
    constructor(commandManager, config = {}) {
        this.programs = {};
        /**
         * Lookup index linking to commands in programs.
         */
        this.commands = {};
        this.config = config;
        this.commandManager = commandManager;
        if (config.commands) {
            this.registerPrograms(config.commands);
        }
    }
    resolveToken(args) {
        if (args.help) {
            return this.config.fallbackToken;
        }
        return args._.shift() || this.config.fallbackToken;
    }
    async execute(argv) {
        const output = await this.resolve(argv);
        output.send();
    }
    async resolve(argv) {
        const parsed = yargs_parser_1.default(argv, { alias: { h: 'help' } });
        const token = this.resolveToken(parsed);
        const command = this.commands[token];
        const output = new Output_1.Output();
        // Remove the token so we're left with the arguments.
        if (token === argv[0]) {
            argv.splice(0, 1);
        }
        if (!command) {
            return output.error(`Unknown command "${token}".`);
        }
        const commandInstance = this.commandManager.getCommand(command.Command);
        try {
            await commandInstance[command.action](output, this.validate(argv, command));
        }
        catch (error) {
            output.error(error);
        }
        return output;
    }
    validate(argv, command) {
        const alias = this.collectAliases(command);
        const parsed = yargs_parser_1.default(argv, { alias });
        const args = {};
        if (Array.isArray(command.args)) {
            command.args.forEach(({ required, name }, index) => {
                if (required && !parsed._[index]) {
                    throw `Missing required argument "${name}".`;
                }
                if (parsed._[index]) {
                    args[name] = parsed._[index];
                }
            });
        }
        if (!command.config || !command.config.options) {
            return args;
        }
        Object.keys(command.config.options).forEach(option => {
            if (command.config.options[option].required && !parsed[option]) {
                throw `Missing required option "${option}".`;
            }
            args[option] = parsed[option];
        });
        return args;
    }
    collectAliases({ config }) {
        if (!config || !config.options) {
            return {};
        }
        return Object.keys(config.options).reduce((aliases, name) => {
            if (config.options[name].alias) {
                aliases[name] = config.options[name].alias;
            }
            return aliases;
        }, {});
    }
    getPrograms() {
        return this.programs;
    }
    getCommands() {
        return this.commands;
    }
    getCommand(command) {
        return this.commands[command];
    }
    getConfig() {
        return this.config;
    }
    registerPrograms(programs) {
        programs.forEach((programEntry) => {
            const programName = programEntry.program || this.config.defaultProgramName;
            const programConfig = (programEntry.config || { commands: [programEntry] });
            this.registerProgram(programName, programConfig);
        });
    }
    registerProgram(program, { commands, examples }) {
        if (!this.programs[program]) {
            this.programs[program] = { program, examples, commands: {} };
        }
        commands.forEach((command) => {
            const { token, args } = this.queParser(command.commandLine);
            command.args = args;
            command.token = token;
            this.programs[program].commands[token] = command;
            this.commands[token] = command;
        });
    }
    queParser(commandLine) {
        return commandLine.split(' ').reduce((parsed, value) => {
            if (value[0] === '<' && value[value.length - 1] === '>') {
                parsed.args.push({ required: true, name: value.slice(1, -1) });
            }
            else if (value[0] === '[' && value[value.length - 1] === ']') {
                parsed.args.push({ required: false, name: value.slice(1, -1) });
            }
            else {
                parsed.token = value;
            }
            return parsed;
        }, { args: [] });
    }
}
exports.CliService = CliService;
//# sourceMappingURL=CliService.js.map