@cirrusct/cli/dist/Parser.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const mri = require("mri");
const os = require("os");
const parameters_1 = require("./parameters");
const ParserErrors_1 = require("./ParserErrors");
const program_1 = require("./program");
const utils_1 = require("./utils");
class Parser {
    constructor(argv = process.argv, commandPackageDefinition, runHandler, errorHandler, promptHandler, version, internalOptions = [], showPrompts = false) {
        this.argv = argv;
        this.runHandler = runHandler;
        this.errorHandler = errorHandler;
        this.promptHandler = promptHandler;
        this.version = version;
        this.internalOptions = internalOptions;
        this.showPrompts = showPrompts;
        this._definitionsMap = new Map();
        this._argVals = [];
        this._optionVals = {};
        this._passedOptions = [];
        this._parserErrors = new ParserErrors_1.ParserErrors();
        this.findCommandDefinition = (name) => {
            let cmdDef = this._definitionsMap.get(name);
            if (!cmdDef) {
                // if no exact match on command name, try to match on all lower case, or dash-case of command name
                const cmdDefs = Array.from(this._definitionsMap.values());
                cmdDef = cmdDefs.find(d => utils_1.dashCase(d.name).toLowerCase() === name.toLowerCase() || d.name.toLowerCase() === name.toLowerCase());
            }
            return cmdDef;
        };
        this.parseCommandLine = () => {
            let offset = 2;
            // parse using root and internal options
            this._definitionOptions = this.internalOptions.concat(this._commandPackage.options || []);
            let parsedMri = mri(this.argv.slice(offset), utils_1.getOptionsMriOpts(this._definitionOptions));
            // Loop thru possible command(s)
            let tryName;
            let name = '';
            let i = 1;
            const len = parsedMri._.length + 1;
            for (; i < len; i++) {
                tryName = parsedMri._.slice(0, i).join(' ');
                // if (this._definitionsMap.has(tryName)) {
                if (this.findCommandDefinition(tryName)) {
                    name = tryName;
                    offset = i + 2; // argv slicer
                }
            }
            let cmdDef = this.findCommandDefinition(name);
            if (!cmdDef) {
                if (name) {
                    this.pushError('command', `Unknown Command: '${name}'`);
                }
                else if (this._commandPackage.defaultCommandName) {
                    cmdDef = this._definitionsMap.get(this._commandPackage.defaultCommandName);
                }
                else if (this._commandPackage.commands.length > 0) {
                    this.pushError('command', `No Command Specified`);
                }
            }
            // this._passedOptions = passedOptionsToNames(, ;
            const rawPassedOptions = Object.keys(parsedMri).filter(v => v !== '_');
            // if a command definition is identified, re-parse the command line with definition configurations
            if (cmdDef) {
                this._definitionOptions.push(...(cmdDef.options || []));
                parsedMri = mri(this.argv.slice(offset), utils_1.getOptionsMriOpts(this._definitionOptions));
                this._argVals = parsedMri._;
                this._parsedCommand.command = cmdDef;
                this._parsedCommand.parsedCommandName = name;
            }
            this._passedOptions = utils_1.passedOptionsToNames(rawPassedOptions, this._definitionOptions);
            // Collect parsed Options
            this._optionVals = Object.keys(parsedMri)
                .filter(v => v !== '_')
                .reduce((prev, curr) => {
                prev[curr] = parsedMri[curr];
                return prev;
            }, {});
            // Create a hash with all active options for final parsed output
            this._parsedCommand.optionDefinitions = this._definitionOptions.reduce((prev, curr) => {
                prev[curr.name] = curr;
                return prev;
            }, {});
        };
        this.parseArgs = () => {
            const cmd = this.parsedCommand.command;
            const defArgs = cmd ? cmd.arguments || [] : [];
            const requiredDefArgs = defArgs.filter(a => !a.isOptional);
            const isVariadic = defArgs.length > 0 && defArgs[defArgs.length - 1].isVariadic;
            // check for too many args
            if (this._argVals.length > defArgs.length && !isVariadic) {
                this.pushError('argument', `Too many Arguments`);
            }
            // check for too few args
            if (this._argVals.length < requiredDefArgs.length) {
                // don't raise insufficient args if an option with a handler is set (ie help/version);
                if (!this.getParsedOptionCommandName()) {
                    this.pushError('argument', `Insufficient arguments`);
                }
            }
            const parsedArgs = {};
            const validateArg = (val, arg) => {
                const validation = parameters_1.validateCommandDefinitionParameterValue(val, arg);
                if (validation !== true) {
                    const msg = typeof validation === 'string' ? validation : undefined;
                    this.pushError('argument', `Value for argument '${arg.name}' is invalid${msg ? `: ${msg}` : ''}`);
                }
            };
            let argValIndex = 0;
            // Loop through definition arguments, and assign each prop in definition to args value array
            for (const defArg of defArgs) {
                if (defArg.isVariadic) {
                    // variadic arg, must be last arg, assign remainder of command line
                    const vals = this._argVals.slice(argValIndex).map(a => parameters_1.getCommandDefinitionParameterValue(a, defArg));
                    // validate each value
                    vals.forEach(v => validateArg(v, defArg));
                    parsedArgs[defArg.name] = Object.assign(Object.assign({}, defArg), { wasPassed: true, value: vals });
                    argValIndex = this._argVals.length;
                }
                else if (this._argVals.length > argValIndex) {
                    // still arguments from command line, assign next arg to args arry
                    // assign value from command line to args array
                    const val = parameters_1.getCommandDefinitionParameterValue(this._argVals[argValIndex], defArg);
                    // validate
                    validateArg(val, defArg);
                    parsedArgs[defArg.name] = Object.assign(Object.assign({}, defArg), { wasPassed: true, value: val });
                    argValIndex++;
                }
                else {
                    // no more arguments on command line, assign default
                    parsedArgs[defArg.name] = Object.assign(Object.assign({}, defArg), { wasPassed: false, value: parameters_1.getCommandDefinitionParameterValue(undefined, defArg, false) });
                    argValIndex++;
                }
            }
            // create args hash with just values
            const args = Object.keys(parsedArgs).reduce((prev, curr) => {
                prev[curr] = parsedArgs[curr].value;
                return prev;
            }, {});
            const transformedArgs = utils_1.isFunction(cmd.transformArguments) ? cmd.transformArguments(args) : args;
            // re-assign parsed arg value from transformed args (transform could add or remove entries, so not necessarily 1:1)
            Object.keys(transformedArgs).forEach(ta => {
                if (parsedArgs[ta]) {
                    parsedArgs[ta].value = transformedArgs[ta];
                }
            });
            this.parsedCommand.parsedArguments = parsedArgs;
            this.parsedCommand.arguments = transformedArgs;
        };
        this.parseOptions = () => {
            const cmd = this._parsedCommand.command;
            const dynamicOptions = {};
            Object.keys(this._optionVals).forEach(o => {
                if (!this._definitionOptions.find(co => co.name === o || co.flag === o || utils_1.dashCase(co.name) === o)) {
                    // if option not defined, add as dynamic if allowed, otherwise add as error
                    if (cmd && cmd.allowDynamicOptions) {
                        dynamicOptions[utils_1.camelCase(o)] = this._optionVals[o];
                    }
                    else {
                        this.pushError('option', `Invalid Option: ${o}`);
                    }
                }
            });
            const parsedOptions = {};
            this._definitionOptions.forEach(o => {
                const wasPassed = this._passedOptions.indexOf(o.name) >= 0;
                parsedOptions[o.name] = Object.assign(Object.assign({}, o), { wasPassed, value: parameters_1.getCommandDefinitionParameterValue(this._optionVals[o.name], o, wasPassed) });
                if (wasPassed) {
                    // if option set on command line, and not a boolean option, make sure there is a value
                    if (o.valueType && o.valueType !== 'boolean' && !parsedOptions[o.name].value) {
                        this.pushError('option', `Value for option '${o.name}' not specified`);
                    }
                    else {
                        const validation = parameters_1.validateCommandDefinitionParameterValue(parsedOptions[o.name].value, o);
                        if (validation !== true) {
                            const msg = typeof validation === 'string' ? validation : undefined;
                            this.pushError('option', `Value for option '${o.name}' is invalid${msg ? `: ${msg}` : ''}`);
                        }
                    }
                }
            });
            // add any dynamic options to parsedOptions
            if (cmd && cmd.allowDynamicOptions) {
                Object.keys(dynamicOptions).forEach(dyo => {
                    parsedOptions[dyo] = {
                        name: dyo,
                        wasPassed: true,
                        value: dynamicOptions[dyo],
                    };
                });
            }
            // create options hash with just values
            const options = Object.keys(parsedOptions).reduce((prev, curr) => {
                prev[curr] = parsedOptions[curr].value;
                return prev;
            }, {});
            const transformedOptions = cmd
                ? utils_1.isFunction(cmd.transformOptions)
                    ? cmd.transformOptions(options)
                    : options
                : options;
            // re-assign parsed option value from transformed options (transform could add or remove entries, so not necessarily 1:1)
            Object.keys(transformedOptions).forEach(to => {
                if (parsedOptions[to]) {
                    parsedOptions[to].value = transformedOptions[to];
                }
            });
            this._parsedCommand.parsedOptions = parsedOptions;
            this._parsedCommand.options = transformedOptions;
            this._parsedCommand.dynamicOptions = dynamicOptions;
        };
        this.pushError = (type, message) => {
            this._parserErrors.push(type, message);
        };
        this.getEnv = () => {
            const cmd = this.parsedCommand.command;
            const env = {};
            if (cmd && cmd.env) {
                return cmd.env;
            }
            return env;
        };
        this.parseArgsAndOptions = () => {
            this.parseOptions();
            if (this._parsedCommand.command) {
                this.parseArgs();
            }
        };
        this.getParsedOptionCommandName = () => {
            const parsed = this._parsedCommand;
            return Object.keys(parsed.options)
                .filter(o => typeof parsed.options[o] !== 'undefined')
                .find(o => !!(parsed.optionDefinitions[o] && parsed.optionDefinitions[o].commandHandler));
        };
        this.setProcessEnvFromParsedCommand = () => {
            Object.keys(this.parsedCommand.env).forEach(k => {
                process.env[k] = this.parsedCommand.env[k];
            });
        };
        this.promptArgsToArgVals = (promptArgs) => {
            const cmd = this.parsedCommand.command;
            const defArgs = cmd ? cmd.arguments || [] : [];
            const argVals = [];
            // Loop through definition arguments, and assign value from promptArgs Hash
            for (const defArg of defArgs) {
                const promptArgVal = promptArgs[defArg.name];
                if (defArg.isVariadic) {
                    const promptArgValAry = Array.isArray(promptArgVal) ? promptArgVal : [promptArgVal];
                    argVals.push(...promptArgValAry);
                }
                else {
                    argVals.push(promptArgVal);
                }
            }
            return argVals;
        };
        this.runAndParsePrompt = () => __awaiter(this, void 0, void 0, function* () {
            if (this.showPrompts) {
                const parsedCommand = this._parsedCommand;
                // call out to prompt handler to get args and options
                const promptResult = yield this.promptHandler(parsedCommand);
                // reset arg/option errors
                this._parserErrors.clearErrors('argument');
                this._parserErrors.clearErrors('option');
                // convert prompt arg values to command line array to re-parse them
                this._argVals = this.promptArgsToArgVals(promptResult.arguments);
                // assign prompt options to _optionVals to re-parse them
                this._optionVals = promptResult.options;
                // re-parse args and options from prompt values
                this.parseArgsAndOptions();
            }
        });
        this.runner = () => __awaiter(this, void 0, void 0, function* () {
            const parsedCommand = this._parsedCommand;
            // determine if an option is set to call a handler (in to over-ride the command def handler)
            const commandOption = this.getParsedOptionCommandName();
            let exitCode;
            if (commandOption) {
                // a selected option has it's own handler, set it up and run the option's handler (in lieu of the command's handler)
                const commandOptionHandler = parsedCommand.optionDefinitions[commandOption].commandHandler;
                exitCode = yield Promise.resolve(commandOptionHandler(parsedCommand));
            }
            else {
                // delete options that are commands themselves (i.e. '--help', '--version')
                Object.keys(parsedCommand.options)
                    .filter(o => !!(parsedCommand.optionDefinitions[o] && parsedCommand.optionDefinitions[o].commandHandler))
                    .forEach(o => {
                    delete parsedCommand.options[o];
                });
                yield this.runAndParsePrompt();
                if (parsedCommand.errors.hasErrors) {
                    // parsed errors, call the errorHandler
                    exitCode = (yield Promise.resolve(this.errorHandler(parsedCommand))) || 1;
                }
                else {
                    // set process env from command env settings
                    this.setProcessEnvFromParsedCommand();
                    // call the handler with parsed command
                    exitCode = yield this.runHandler(parsedCommand);
                }
            }
            return {
                parsedCommand,
                exitCode: typeof exitCode === 'number' ? exitCode : 0,
            };
        });
        this._commandPackage = program_1.CliProgram.create(commandPackageDefinition, internalOptions);
        if (this._commandPackage.validationErrors.length > 0) {
            throw new Error(`Invalid Command Definition: ${this._commandPackage.validationErrors.join(os.EOL)}`);
        }
        this._definitionsMap = this._commandPackage.commandsMap;
    }
    get parsedCommand() {
        if (!this._parsedCommand) {
            this._parsedCommand = {};
            this._parsedCommand.errors = this._parserErrors;
            this._parsedCommand.program = this._commandPackage;
            this._parsedCommand.run = this.runner;
            this._parsedCommand.version = this.version;
            this.parseCommandLine();
            this.parseArgsAndOptions();
            this._parsedCommand.env = this.getEnv();
        }
        return this._parsedCommand;
    }
}
exports.Parser = Parser;
//# sourceMappingURL=Parser.js.map