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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
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 asyncPipe_1 = require("../utils/asyncPipe");
const CustomErrors_1 = require("../errors/CustomErrors");
const opConfig_1 = require("../constants/opConfig");
const utils_1 = require("../utils");
class Search extends base_1.default {
    constructor() {
        super(...arguments);
        this.opsAndWorkflows = [];
        this.showSearchMessage = (inputs) => {
            const { filter } = inputs;
            this.log(`\n🔍 Searching ${this.ux.colors.callOutCyan(filter || `all ${utils_1.pluralize(opConfig_1.COMMAND)} and ${utils_1.pluralize(opConfig_1.WORKFLOW)}`)}.`);
            return inputs;
        };
        this.getApiOps = async (inputs) => {
            try {
                const findResponse = await this.services.api.find(`/ops`, {
                    headers: {
                        Authorization: this.accessToken,
                    },
                });
                let { data: apiOps } = findResponse;
                apiOps = apiOps.filter(op => op.type !== opConfig_1.GLUECODE_TYPE);
                return Object.assign({ apiOps }, inputs);
            }
            catch (err) {
                this.debug('error: %O', err);
                throw new CustomErrors_1.APIError(err);
            }
        };
        this.getLocalWorkflows = async (inputs) => {
            const localWorkflows = [];
            try {
                const manifest = await fs.readFile(path.join(process.cwd(), opConfig_1.OP_FILE), 'utf8');
                if (!manifest)
                    return inputs;
                const { workflows = [] } = utils_1.parseYaml(manifest);
                workflows.forEach(workflow => (workflow.local = true));
                return Object.assign({}, inputs, { localWorkflows: workflows });
            }
            catch (_a) {
                return Object.assign({}, inputs, { localWorkflows });
            }
        };
        this._removeIfNameOrDescriptionDontContainQuery = (filter) => (workflow) => {
            return (workflow.name.includes(filter) || workflow.description.includes(filter));
        };
        this.filterLocalWorkflows = (inputs) => {
            let { localWorkflows, filter } = inputs;
            if (!localWorkflows.length)
                return inputs;
            localWorkflows = localWorkflows.filter(this._removeIfNameOrDescriptionDontContainQuery(filter));
            return Object.assign({}, inputs, { localWorkflows });
        };
        this._removeIfLocalExists = (workflows) => (apiOp) => {
            const match = workflows.find(workflow => workflow.name === apiOp.name);
            return !match;
        };
        this.resolveLocalAndApi = (inputs) => {
            const { apiOps, localWorkflows } = inputs;
            const ops = apiOps.filter(this._removeIfLocalExists(localWorkflows));
            this.opsAndWorkflows = [...ops, ...localWorkflows].sort((a, b) => {
                if (a.name < b.name)
                    return -1;
                if (b.name < a.name)
                    return 1;
                return 0;
            });
            return inputs;
        };
        this.checkData = async (inputs) => {
            if (!this.opsAndWorkflows.length) {
                this.log(`\n 😞 No ops found in your team, public or local workspaces. Try again or run ${this.ux.colors.callOutCyan('ops publish')} to create an op. \n`);
            }
            return inputs;
        };
        this.selectOpOrWorkflowPrompt = async (inputs) => {
            const { selectedOpOrWorkflow } = await this.ux.prompt({
                type: 'autocomplete',
                name: 'selectedOpOrWorkflow',
                pageSize: 5,
                message: `\nSelect a public ${this.ux.colors.multiBlue('\u2022Command')} or ${this.ux.colors.multiOrange('\u2022Workflow')} to run ${this.ux.colors.reset.green('→')}\n${this.ux.colors.reset.dim('🔍 Search:')} `,
                source: this._autocompleteSearch.bind(this),
                bottomContent: `\n \n${this.ux.colors.white(`Or, run ${this.ux.colors.callOutCyan('ops help')} for usage information.`)}`,
            });
            return Object.assign({}, inputs, { selectedOpOrWorkflow });
        };
        this.showRunMessage = (inputs) => {
            const { selectedOpOrWorkflow: { name, teamName }, } = inputs;
            this.log(`\n💻 Run ${this.ux.colors.green('$')} ${this.ux.colors.italic.dim('ops run @' + teamName + '/' + name)} to test your op. \n`);
            return inputs;
        };
        this.sendAnalytics = (filter) => (inputs) => {
            const { selectedOpOrWorkflow, selectedOpOrWorkflow: { id: opId, teamID }, } = inputs;
            const teamOp = teamID === this.team.id;
            const remote = 'remote' in selectedOpOrWorkflow ? selectedOpOrWorkflow.remote : false;
            try {
                this.services.analytics.track({
                    userId: this.user.email,
                    teamId: this.team.id,
                    event: 'Ops CLI Search',
                    properties: {
                        email: this.user.email,
                        username: this.user.username,
                        selectedOp: opId,
                        teamOp,
                        remote,
                        results: this.opsAndWorkflows.length,
                        filter,
                    },
                }, this.accessToken);
            }
            catch (err) {
                this.debug('%O', err);
                throw new CustomErrors_1.AnalyticsError(err);
            }
        };
        this._autocompleteSearch = async (_, input = '') => {
            const { list, options } = this.fuzzyFilterParams();
            const fuzzyResult = fuzzy_1.default.filter(input, list, options);
            return fuzzyResult.map(result => result.original);
        };
        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._formatOpOrWorkflowName = (opOrWorkflow) => {
            const name = this.ux.colors.reset.white(opOrWorkflow.name);
            const teamName = opOrWorkflow.teamName
                ? `@${this.ux.colors.reset.white(opOrWorkflow.teamName)}/`
                : '';
            if (opOrWorkflow.type === opConfig_1.WORKFLOW_TYPE) {
                return `${this.ux.colors.reset(this.ux.colors.multiOrange('\u2022'))} ${teamName}${name}`;
            }
            else {
                return `${this.ux.colors.reset(this.ux.colors.multiBlue('\u2022'))} ${teamName}${name}`;
            }
        };
    }
    async run() {
        const { args: { filter = '' }, } = this.parse(Search);
        try {
            await this.isLoggedIn();
            const searchPipeline = asyncPipe_1.asyncPipe(this.showSearchMessage, this.getApiOps, this.getLocalWorkflows, this.filterLocalWorkflows, this.resolveLocalAndApi, this.checkData, this.selectOpOrWorkflowPrompt, this.showRunMessage, this.sendAnalytics(filter));
            await searchPipeline(filter);
        }
        catch (err) {
            this.debug('%O', err);
            this.config.runHook('error', { err, accessToken: this.accessToken });
        }
    }
}
Search.description = 'Search for ops in your workspaces.';
Search.args = [
    {
        name: 'filter',
        description: 'Filters op results which include filter text in op name or description.',
    },
];
Search.flags = {
    help: base_1.flags.help({ char: 'h' }),
};
exports.default = Search;