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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const sdk_1 = require("@cto.ai/sdk");
const fs = tslib_1.__importStar(require("fs-extra"));
const path = tslib_1.__importStar(require("path"));
const base_1 = tslib_1.__importStar(require("../base"));
const env_1 = require("../constants/env");
const opConfig_1 = require("../constants/opConfig");
const CustomErrors_1 = require("../errors/CustomErrors");
const asyncPipe_1 = require("../utils/asyncPipe");
const get_docker_1 = tslib_1.__importDefault(require("../utils/get-docker"));
const validate_1 = require("../utils/validate");
const utils_1 = require("../utils");
class Publish extends base_1.default {
    constructor() {
        super(...arguments);
        this.resolvePath = async (opPath) => {
            return path.resolve(process.cwd(), opPath);
        };
        this.checkDocker = async (opPath) => {
            const docker = await get_docker_1.default(this, 'publish');
            if (!docker) {
                throw new Error('No docker');
            }
            return { opPath, docker };
        };
        this.determineQuestions = async (inputs) => {
            const { opsAndWorkflows } = await sdk_1.ux.prompt({
                type: 'list',
                name: 'opsAndWorkflows',
                message: `\n Which would you like to publish ${sdk_1.ux.colors.reset.green('→')}`,
                choices: [
                    { name: 'Commands', value: opConfig_1.COMMAND },
                    { name: 'Workflows', value: opConfig_1.WORKFLOW },
                    'Both',
                ],
                afterMessage: `${sdk_1.ux.colors.reset.green('✓')}`,
            });
            return Object.assign({}, inputs, { opsAndWorkflows });
        };
        this.getOpsAndWorkFlows = async ({ opPath, opsAndWorkflows, docker, }) => {
            const manifest = await fs
                .readFile(path.join(opPath, opConfig_1.OP_FILE), 'utf8')
                .catch((err) => {
                this.debug('%O', err);
                throw new CustomErrors_1.FileNotFoundError(err, opPath, opConfig_1.OP_FILE);
            });
            if (!manifest)
                throw new CustomErrors_1.NoLocalOpsFound();
            const { ops, version, workflows } = utils_1.parseYaml(manifest);
            if (!ops && (opsAndWorkflows === opConfig_1.COMMAND || opsAndWorkflows === 'Both')) {
                throw new CustomErrors_1.NoLocalOpsFound();
            }
            if (!workflows &&
                (opsAndWorkflows === opConfig_1.WORKFLOW || opsAndWorkflows === 'Both')) {
                throw new CustomErrors_1.NoWorkflowsFound();
            }
            return { ops, workflows, docker, version, opsAndWorkflows };
        };
        this.selectOpsAndWorkFlows = async ({ ops, workflows, version, docker, opsAndWorkflows, }) => {
            switch (opsAndWorkflows) {
                case opConfig_1.COMMAND:
                    ops = await this.selectOps(ops);
                    break;
                case opConfig_1.WORKFLOW:
                    workflows = await this.selectWorkflows(workflows);
                    break;
                default:
                    ops = await this.selectOps(ops);
                    workflows = await this.selectWorkflows(workflows);
            }
            return { ops, workflows, version, docker, opsAndWorkflows };
        };
        this.selectOps = async (ops) => {
            if (ops.length <= 1) {
                return ops;
            }
            const answers = await sdk_1.ux.prompt({
                type: 'checkbox',
                name: 'ops',
                message: `\n Which ops would you like to publish ${sdk_1.ux.colors.reset.green('→')}`,
                choices: ops.map(op => {
                    return {
                        value: op,
                        name: `${op.name} - ${op.description}`,
                    };
                }),
                validate: input => input.length > 0,
            });
            return answers.ops;
        };
        this.selectWorkflows = async (workflows) => {
            if (workflows.length <= 1) {
                return workflows;
            }
            const answers = await sdk_1.ux.prompt({
                type: 'checkbox',
                name: 'workflows',
                message: `\n Which workflows would you like to publish ${sdk_1.ux.colors.reset.green('→')}`,
                choices: workflows.map(workflow => {
                    return {
                        value: workflow,
                        name: `${workflow.name} - ${workflow.description}`,
                    };
                }),
                validate: input => input.length > 0,
            });
            return answers.workflows;
        };
        this.getRegistryAuth = async (name, version) => {
            try {
                const registryAuth = await this.services.registryAuthService.create(this.accessToken, this.team.name, name, version, false, true);
                return registryAuth;
            }
            catch (err) {
                throw new CustomErrors_1.CouldNotGetRegistryToken(err);
            }
        };
        this.publishOpsAndWorkflows = async (inputs) => {
            switch (inputs.opsAndWorkflows) {
                case opConfig_1.COMMAND:
                    await this.opsPublishLoop(inputs);
                    break;
                case opConfig_1.WORKFLOW:
                    await this.workflowsPublishLoop(inputs);
                    break;
                default:
                    await this.opsPublishLoop(inputs);
                    await this.workflowsPublishLoop(inputs);
            }
        };
        this.opsPublishLoop = async ({ ops, version }) => {
            for (const op of ops) {
                if (!validate_1.isValidOpName(op.name)) {
                    throw new CustomErrors_1.InvalidInputCharacter('Op Name');
                }
                // TODO: Change 'latest' to the user's intended version once it is in place
                const opName = utils_1.getOpImageTag(this.team.name, op.name, 'latest', op.isPublic);
                const localImage = await this.services.imageService.checkLocalImage(`${env_1.OPS_REGISTRY_HOST}/${opName}`);
                if (!localImage) {
                    throw new CustomErrors_1.DockerPublishNoImageFound(op.name, this.team.name);
                }
                const { data: apiOp, } = await this.services.publishService.publishOpToAPI(op, version, this.team.id, this.accessToken, this.services.api);
                // TODO: Setting version as 'platform version' for now
                // but it has to be changed to op.version when versioning is added
                const registryAuth = await this.getRegistryAuth(op.name, version);
                await this.services.publishService.publishOpToRegistry(apiOp, registryAuth, this.team.name, this.accessToken, this.services.registryAuthService, version);
                this.sendAnalytics('op', apiOp);
            }
        };
        this.workflowsPublishLoop = async ({ workflows, version, }) => {
            for (const workflow of workflows) {
                if (workflow.remote) {
                    const newSteps = [];
                    for (const step of workflow.steps) {
                        let newStep = '';
                        if (await this.services.buildStepService.isGlueCode(step)) {
                            const opPath = path.resolve(__dirname, './../templates/workflowsteps/js/');
                            newStep = await this.services.buildStepService.buildAndPublishGlueCode(step, this.team.id, this.team.name, this.accessToken, opPath, this.user, this.services.publishService, this.services.opService, this.services.api, this.services.registryAuthService, this.state.config, workflow.isPublic, version);
                            newSteps.push(newStep);
                        }
                        else {
                            if (!this.services.buildStepService.isOpRun(step)) {
                                this.debug('InvalidStepsFound - Step:', step);
                                throw new CustomErrors_1.InvalidStepsFound(step);
                            }
                            newSteps.push(step);
                        }
                    }
                    workflow.steps = newSteps;
                }
                try {
                    const { data: apiWorkflow, } = await this.services.api.create(opConfig_1.WORKFLOW_ENDPOINT, Object.assign({}, workflow, { version, teamID: this.team.id }), {
                        headers: {
                            Authorization: this.accessToken,
                        },
                    });
                    this.log(`\n🙌 ${sdk_1.ux.colors.callOutCyan(apiWorkflow.name)} has been published! \n`);
                    // this.sendAnalytics('workflow', apiWorkflow)
                }
                catch (err) {
                    this.debug('%O', err);
                    throw new CustomErrors_1.CouldNotCreateWorkflow(err.message);
                }
            }
        };
        this.sendAnalytics = async (publishType, opOrWorkflow) => {
            this.services.analytics.track({
                userId: this.user.email,
                event: 'Ops CLI Publish',
                properties: {
                    email: this.user.email,
                    username: this.user.username,
                    type: publishType,
                    name: opOrWorkflow.name,
                    description: opOrWorkflow.description,
                    image: `${env_1.OPS_REGISTRY_HOST}/${opOrWorkflow.id.toLowerCase()}`,
                    tag: 'latest',
                },
            });
        };
    }
    async run() {
        try {
            await this.isLoggedIn();
            const { args } = this.parse(Publish);
            const publishPipeline = asyncPipe_1.asyncPipe(this.resolvePath, this.checkDocker, this.determineQuestions, this.getOpsAndWorkFlows, this.selectOpsAndWorkFlows, this.publishOpsAndWorkflows);
            await publishPipeline(args.path);
        }
        catch (err) {
            this.debug('%O', err);
            this.config.runHook('error', { err, accessToken: this.accessToken });
        }
    }
}
Publish.description = 'Publish an op to a team.';
Publish.flags = {
    help: base_1.flags.help({ char: 'h' }),
};
Publish.args = [
    {
        name: 'path',
        description: 'Path to the op you want to publish.',
        required: true,
    },
];
exports.default = Publish;