@cto.ai/ops/lib/commands/run.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const sdk_1 = require("@cto.ai/sdk");
const fuzzy_1 = tslib_1.__importDefault(require("fuzzy"));
const fs = tslib_1.__importStar(require("fs-extra"));
const path = tslib_1.__importStar(require("path"));
const base_1 = tslib_1.__importStar(require("../base"));
const CustomErrors_1 = require("../errors/CustomErrors");
const opConfig_1 = require("../constants/opConfig");
const env_1 = require("../constants/env");
const utils_1 = require("../utils");
const validate_1 = require("../utils/validate");
const { multiBlue, multiOrange, green, dim, reset, bold } = sdk_1.ux.colors;
class Run extends base_1.default {
    constructor() {
        super(...arguments);
        this.opsAndWorkflows = [];
        this.customParse = (options, argv) => {
            const { args, flags } = require('@oclif/parser').parse(argv, Object.assign({}, options, { context: this }));
            if (!args.nameOrPath && !flags.help) {
                throw new CustomErrors_1.MissingRequiredArgument('ops run');
            }
            if (!args.nameOrPath)
                this._help();
            return { args, flags, opParams: argv.slice(1) };
        };
        this.checkPathOpsYmlExists = (nameOrPath) => {
            const pathToOpsYml = path.join(path.resolve(nameOrPath), opConfig_1.OP_FILE);
            return fs.existsSync(pathToOpsYml);
        };
        this.parseYamlFile = async (relativePathToOpsYml) => {
            const opsYmlExists = this.checkPathOpsYmlExists(relativePathToOpsYml);
            if (!opsYmlExists) {
                return null;
            }
            const opsYml = await fs.readFile(path.join(path.resolve(relativePathToOpsYml), opConfig_1.OP_FILE), 'utf8');
            const { ops = [], workflows = [], version = '1' } = (await utils_1.parseYaml(opsYml));
            return { ops, workflows, version };
        };
        this.logResolvedLocalMessage = (inputs) => {
            const { parsedArgs: { args: { nameOrPath }, }, } = inputs;
            this.log(`❗️ ${this.ux.colors.callOutCyan(nameOrPath)} ${this.ux.colors.white('resolved to a local path and is running local Op.')} `);
            return inputs;
        };
        /* get all the commands and workflows in an ops.yml that match the nameOrPath */
        this.getOpsAndWorkflowsFromFileSystem = (relativePathToOpsYml) => async (inputs) => {
            const yamlContents = await this.parseYamlFile(relativePathToOpsYml);
            if (!yamlContents) {
                return Object.assign({}, inputs, { opsAndWorkflows: [] });
            }
            const { ops, workflows, version } = yamlContents;
            return Object.assign({}, inputs, { opsAndWorkflows: [...ops, ...workflows], version });
        };
        this.addMissingApiFieldsToLocalOps = async (inputs) => {
            const { opsAndWorkflows, config } = inputs;
            const updatedOpsAndWorkflows = opsAndWorkflows.map((opOrWorkflow) => {
                let newOpOrWorkflow = Object.assign({}, opOrWorkflow);
                newOpOrWorkflow.teamName = config.team.name;
                newOpOrWorkflow.type =
                    'steps' in newOpOrWorkflow ? opConfig_1.WORKFLOW_TYPE : opConfig_1.COMMAND_TYPE;
                return newOpOrWorkflow;
            });
            return Object.assign({}, inputs, { opsAndWorkflows: updatedOpsAndWorkflows });
        };
        this.filterLocalOps = (inputs) => {
            const { opsAndWorkflows } = inputs;
            if (!opsAndWorkflows) {
                return Object.assign({}, inputs);
            }
            const { parsedArgs: { args: { nameOrPath }, }, } = inputs;
            const keepOnlyMatchingNames = ({ name }) => {
                return name.indexOf(nameOrPath) >= 0;
            };
            return Object.assign({}, inputs, { opsAndWorkflows: opsAndWorkflows.filter(keepOnlyMatchingNames) });
        };
        this.formatOpOrWorkflowEmoji = (opOrWorkflow) => {
            if (!opOrWorkflow.isPublished) {
                return '🖥  ';
            }
            else if (opOrWorkflow.isPublic) {
                return '🌎 ';
            }
            else {
                return '🔑 ';
            }
        };
        this.formatOpOrWorkflowName = (opOrWorkflow) => {
            const name = reset.white(opOrWorkflow.name);
            if ((!opOrWorkflow.isPublished && 'steps' in opOrWorkflow) ||
                (opOrWorkflow.isPublished && opOrWorkflow.type === opConfig_1.WORKFLOW_TYPE)) {
                return `${reset(multiOrange('\u2022'))} ${this.formatOpOrWorkflowEmoji(opOrWorkflow)} ${name}`;
            }
            else {
                return `${reset(multiBlue('\u2022'))} ${this.formatOpOrWorkflowEmoji(opOrWorkflow)} ${name}`;
            }
        };
        this.fuzzyFilterParams = () => {
            const list = this.opsAndWorkflows.map(opOrWorkflow => {
                const name = this.formatOpOrWorkflowName(opOrWorkflow);
                return {
                    name: `${name} - ${opOrWorkflow.description}`,
                    value: opOrWorkflow,
                };
            });
            const options = { extract: el => el.name };
            return { list, options };
        };
        this.autocompleteSearch = async (_, input = '') => {
            try {
                const { list, options } = this.fuzzyFilterParams();
                const fuzzyResult = fuzzy_1.default.filter(input, list, options);
                return fuzzyResult.map(result => result.original);
            }
            catch (err) {
                this.debug('%O', err);
                throw err;
            }
        };
        this.selectOpOrWorkflowToRun = async (inputs) => {
            try {
                const { opsAndWorkflows } = inputs;
                if (!opsAndWorkflows || !opsAndWorkflows.length)
                    throw new CustomErrors_1.InvalidOpName();
                if (opsAndWorkflows.length === 1) {
                    return Object.assign({}, inputs, { opOrWorkflow: opsAndWorkflows[0] });
                }
                this.opsAndWorkflows = opsAndWorkflows;
                const { opOrWorkflow } = await sdk_1.ux.prompt({
                    type: 'autocomplete',
                    name: 'opOrWorkflow',
                    pageSize: 5,
                    message: `\nSelect a ${multiBlue('\u2022Command')} or ${multiOrange('\u2022Workflow')} to run ${reset(green('→'))}\n${reset(dim('🌎 = Public 🔑 = Private 🖥  = Local  🔍 Search:'))} `,
                    source: this.autocompleteSearch.bind(this),
                });
                return Object.assign({}, inputs, { opOrWorkflow });
            }
            catch (err) {
                this.debug('%O', err);
                throw err;
            }
        };
        this.printCustomHelp = (op) => {
            try {
                if (!op.help) {
                    throw new Error('Custom help message can be defined in the ops.yml\n');
                }
                switch (true) {
                    case Boolean(op.description):
                        this.log(`\n${op.description}`);
                    case Boolean(op.help.usage):
                        this.log(`\n${bold('USAGE')}`);
                        this.log(`  ${op.help.usage}`);
                    case Boolean(op.help.arguments):
                        this.log(`\n${bold('ARGUMENTS')}`);
                        Object.keys(op.help.arguments).forEach(a => {
                            this.log(`  ${a} ${dim(op.help.arguments[a])}`);
                        });
                    case Boolean(op.help.options):
                        this.log(`\n${bold('OPTIONS')}`);
                        Object.keys(op.help.options).forEach(o => {
                            this.log(`  -${o.substring(0, 1)}, --${o} ${dim(op.help.options[o])}`);
                        });
                }
            }
            catch (err) {
                this.debug('%O', err);
                throw err;
            }
        };
        this.checkForHelpMessage = (inputs) => {
            try {
                const { parsedArgs: { flags: { help }, }, opOrWorkflow, } = inputs;
                // TODO add support for workflows help
                if (help && 'run' in opOrWorkflow) {
                    this.printCustomHelp(opOrWorkflow);
                    process.exit();
                }
                return inputs;
            }
            catch (err) {
                this.debug('%O', err);
                throw err;
            }
        };
        this.executeOpOrWorkflowService = async (inputs) => {
            try {
                let { opOrWorkflow, config, parsedArgs, parsedArgs: { opParams }, teamName, version, } = inputs;
                if (opOrWorkflow.type === opConfig_1.WORKFLOW_TYPE) {
                    await this.services.workflowService.run(opOrWorkflow, opParams, config);
                }
                else {
                    if (!opOrWorkflow.isPublished) {
                        opOrWorkflow = Object.assign({}, opOrWorkflow, { isPublished: false, teamName: opOrWorkflow.teamName || teamName });
                    }
                    await this.services.opService.run(opOrWorkflow, parsedArgs, config, version);
                }
                return Object.assign({}, inputs, { opOrWorkflow });
            }
            catch (err) {
                this.debug('%O', err);
                throw err;
            }
        };
        /**
         * Extracts the Op Team and Name from the input argument
         * @cto.ai/github -> { teamName: cto.ai, opname: github }
         * cto.ai/github -> { teamName: cto.ai, opname: github }
         * github -> { teamName: '', opname: github }
         * cto.ai/extra/blah -> InvalidOpName
         * null -> InvalidOpName
         */
        this.parseTeamAndOpName = (inputs) => {
            const { parsedArgs: { args: { nameOrPath }, }, config: { team: { name: configTeamName }, }, } = inputs;
            const splits = nameOrPath.split('/');
            if (splits.length === 0 || splits.length > 2)
                throw new CustomErrors_1.InvalidOpName();
            if (splits.length === 1) {
                let [opName] = splits;
                opName = validate_1.isValidOpName(splits[0]) ? splits[0] : '';
                return Object.assign({}, inputs, { teamName: configTeamName, opName });
            }
            let [teamName, opName] = splits;
            teamName = teamName.startsWith('@')
                ? teamName.substring(1, teamName.length)
                : teamName;
            teamName = validate_1.isValidTeamName(teamName) ? teamName : '';
            opName = validate_1.isValidOpName(opName) ? opName : '';
            return Object.assign({}, inputs, { teamName, opName });
        };
        this.getApiOps = async (inputs) => {
            let { config, teamName, opName, opsAndWorkflows: previousOpsAndWorkflows = [], } = inputs;
            let apiOp;
            try {
                if (!opName)
                    return Object.assign({}, inputs);
                teamName = teamName ? teamName : config.team.name;
                ({ data: apiOp } = await this.services.api.find(`teams/${teamName}/ops/${opName}`, {
                    headers: {
                        Authorization: this.accessToken,
                    },
                }));
            }
            catch (err) {
                this.debug('%O', err);
                if (err.error[0].code === 4011) {
                    throw new CustomErrors_1.UnauthorizedtoAccessOp(err);
                }
                throw new CustomErrors_1.APIError(err);
            }
            if (!apiOp) {
                throw new CustomErrors_1.NoOpsFound(opName);
            }
            apiOp.isPublished = true;
            return Object.assign({}, inputs, { opsAndWorkflows: [...previousOpsAndWorkflows, apiOp] });
        };
        this.sendAnalytics = (inputs) => {
            const { opOrWorkflow: { id, name, description }, parsedArgs: { opParams }, } = inputs;
            this.services.analytics.track({
                userId: this.user.email,
                event: 'Ops CLI Run',
                properties: {
                    email: this.user.email,
                    username: this.user.username,
                    id,
                    name,
                    description,
                    argments: opParams.length,
                    image: `${env_1.OPS_REGISTRY_HOST}/${name}`,
                },
            }, this.accessToken);
            return inputs;
        };
    }
    async run() {
        try {
            await this.isLoggedIn();
            const { config } = this.state;
            const parsedArgs = this.customParse(Run, this.argv);
            const { args: { nameOrPath }, } = parsedArgs;
            if (this.checkPathOpsYmlExists(nameOrPath)) {
                /* The nameOrPath argument is a directory containing an ops.yml */
                const runFsPipeline = utils_1.asyncPipe(this.logResolvedLocalMessage, this.getOpsAndWorkflowsFromFileSystem(nameOrPath), this.addMissingApiFieldsToLocalOps, this.selectOpOrWorkflowToRun, this.checkForHelpMessage, this.sendAnalytics, this.executeOpOrWorkflowService);
                await runFsPipeline({ parsedArgs, config });
            }
            else {
                /*
                 * nameOrPath is either the name of an op and not a directory, or a
                 * directory which does not contain an ops.yml.
                 */
                const runApiPipeline = utils_1.asyncPipe(this.getOpsAndWorkflowsFromFileSystem(process.cwd()), this.addMissingApiFieldsToLocalOps, this.filterLocalOps, this.parseTeamAndOpName, this.getApiOps, this.selectOpOrWorkflowToRun, this.checkForHelpMessage, this.sendAnalytics, this.executeOpOrWorkflowService);
                await runApiPipeline({ parsedArgs, config });
            }
        }
        catch (err) {
            this.debug('%O', err);
            this.config.runHook('error', { err, accessToken: this.accessToken });
        }
    }
}
Run.description = 'Run an op from the registry.';
Run.flags = {
    help: base_1.flags.boolean({
        char: 'h',
        description: 'show CLI help',
    }),
    build: base_1.flags.boolean({
        char: 'b',
        description: 'Builds the op before running. Must provide a path to the op.',
        default: false,
    }),
};
// Used to specify variable length arguments
Run.strict = false;
Run.args = [
    {
        name: 'nameOrPath',
        description: 'Name or path of the command or workflow you want to run.',
    },
];
exports.default = Run;