@bearer/cli/lib/commands/new.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const authentications_1 = require("@bearer/types/lib/authentications");
const command_1 = require("@oclif/command");
const fs = require("fs-extra");
const Listr = require("listr");
const path = require("path");
const Case = require("case");
const os = require("os");
const globby = require("globby");
const cli_ux_1 = require("cli-ux");
const child_process_1 = require("child_process");
const util = require("util");
const base_command_1 = require("../base-command");
const install_dependencies_1 = require("../tasks/install-dependencies");
const init_views_1 = require("../tasks/init-views");
const helpers_1 = require("../utils/helpers");
const component_1 = require("./generate/component");
const spec_1 = require("./generate/spec");
const inquirer = require("inquirer");
const prompts_1 = require("../utils/prompts");
const locator_1 = require("../utils/locator");
exports.authTypes = {
    [authentications_1.Authentications.OAuth1]: { name: 'OAuth1', value: authentications_1.Authentications.OAuth1 },
    [authentications_1.Authentications.OAuth2]: { name: 'OAuth2', value: authentications_1.Authentications.OAuth2 },
    [authentications_1.Authentications.Basic]: { name: 'Basic Auth', value: authentications_1.Authentications.Basic },
    [authentications_1.Authentications.ApiKey]: { name: 'API Key', value: authentications_1.Authentications.ApiKey },
    [authentications_1.Authentications.NoAuth]: { name: 'NoAuth', value: authentications_1.Authentications.NoAuth },
    [authentications_1.Authentications.Custom]: { name: 'Custom', value: authentications_1.Authentications.Custom }
};
class New extends base_command_1.default {
    constructor() {
        super(...arguments);
        this.createIntegrationStructure = (authType) => async (ctx) => {
            ctx.files = await helpers_1.copyFiles(this, path.join('init', 'structure'), this.copyDestinationFolder, this.getVars(authType), true);
        };
        this.createAuthFiles = (authType) => async (ctx) => {
            const files = await helpers_1.copyFiles(this, path.join('init', authType), this.copyDestinationFolder, this.getVars(authType), true);
            ctx.files = [...ctx.files, ...files];
        };
        this.createViewsStructure = (authType) => async (_ctx, _task) => {
            return new Listr([
                init_views_1.default({
                    cmd: this,
                    vars: Object.assign({}, this.getVars(authType), initViewsVars(authType))
                }),
                {
                    title: 'Create integration specification file',
                    task: async (_ctx, _task) => spec_1.default.run(['--path', this.copyDestinationFolder, '--silent'])
                },
                {
                    title: 'Create intial components',
                    task: async (_ctx, _task) => component_1.default.run(['feature', '--type', 'root', '--path', this.copyDestinationFolder, '--silent'])
                }
            ]);
        };
        this.getVars = (authType) => ({
            integrationTitle: this.name,
            componentName: Case.pascal(this.name),
            componentTagName: Case.kebab(this.name),
            bearerTagVersion: process.env.BEARER_PACKAGE_VERSION || 'latest',
            bearerRestClient: bearerRestClient(authType)
        });
    }
    async run() {
        const { args, flags } = this.parse(New);
        this.debug('url: %j', flags);
        const { template, directory } = flags;
        this.path = flags.path;
        try {
            this.name = args.IntegrationName || (await prompts_1.askForString('Integration name'));
            this.copyDestinationFolder = await defineLocationPath(this, {
                name: this.name,
                cwd: this.path || process.cwd(),
                force: flags.force
            });
            this.debug('target path: %s', this.copyDestinationFolder);
            const skipInstall = flags.skipInstall;
            let files = [];
            if (template) {
                const tmp = path.join(os.tmpdir(), Date.now().toString());
                await cloneRepository(template, tmp, this);
                const { selected } = await selectFolder(tmp, { selectedPath: directory });
                const source = path.join(tmp, selected);
                fs.copySync(source, this.copyDestinationFolder);
                this.debug('copied from %s to %s', source, this.copyDestinationFolder);
                files = await globby(['**/*'], { cwd: this.copyDestinationFolder });
            }
            else {
                const authType = flags.authType || (await askForAuthType());
                const tasks = [
                    {
                        title: 'Generating integration structure',
                        task: this.createIntegrationStructure(authType)
                    },
                    {
                        title: 'Create auth files',
                        task: this.createAuthFiles(authType)
                    },
                    {
                        title: 'Create views related files',
                        enabled: () => flags.withViews,
                        task: this.createViewsStructure(authType)
                    }
                ];
                const { files: created } = await new Listr(tasks, { nonTTYRenderer: 'silent' }).run();
                files = created;
                if (authType) {
                    this.success(`Integration initialized, name: ${this.name}, authentication type: ${exports.authTypes[authType].name}`);
                }
            }
            if (!skipInstall) {
                await new Listr([install_dependencies_1.default({ cwd: this.copyDestinationFolder })]).run();
            }
            helpers_1.printFiles(this, files);
            const finalLocation = this.copyDestinationFolder.replace(path.resolve(args.path || process.cwd()), '.');
            this.log("\nWhat's next?\n");
            this.log('* read the bearer documentation at https://docs.bearer.sh\n');
            this.log(`* start your local development environment by running:\n`);
            this.log(this.colors.bold(`   cd ${finalLocation}`));
        }
        catch (e) {
            this.debug('error: %j', e);
            if (e instanceof NoIntegrationFoundError) {
                this.error(this.colors.red('No valid integrations found within the cloned git repository'));
            }
            else {
                this.error(e);
            }
        }
    }
}
New.description = 'generate integration boilerplate';
New.flags = Object.assign({}, base_command_1.default.flags, { help: command_1.flags.help({ char: 'h' }), template: command_1.flags.string({
        char: 't',
        description: 'Generate an integration from a template (git url)'
    }), directory: command_1.flags.string({
        char: 'd',
        dependsOn: ['template'],
        description: 'Select a directory as source of the integration'
    }), skipInstall: command_1.flags.boolean({ hidden: true, description: 'Do not install dependencies' }), withViews: command_1.flags.boolean({ description: 'Experimental - generate views' }), force: command_1.flags.boolean({ description: 'Force copying files', char: 'f' }), authType: command_1.flags.string({
        char: 'a',
        description: 'Authorization type',
        // only allow the value to be from a discrete set
        options: Object.keys(exports.authTypes).map(auth => exports.authTypes[auth].value)
    }) });
New.args = [{ name: 'IntegrationName' }];
exports.default = New;
async function askForAuthType() {
    const { authenticationType } = await inquirer.prompt([
        {
            message: 'Select an authentication method for the API you want to consume:',
            type: 'list',
            name: 'authenticationType',
            choices: Object.values(exports.authTypes)
        }
    ]);
    return authenticationType;
}
exports.askForAuthType = askForAuthType;
function bearerRestClient(authType) {
    switch (authType) {
        case authentications_1.Authentications.OAuth1:
            return '"oauth": "^0.9.15"';
        case authentications_1.Authentications.ApiKey:
        case authentications_1.Authentications.Basic:
        case authentications_1.Authentications.NoAuth:
        case authentications_1.Authentications.OAuth2:
        case authentications_1.Authentications.Custom:
            return '"axios": "^0.18.0"';
    }
    throw new Error(`Authentication not found: ${authType}`);
}
exports.bearerRestClient = bearerRestClient;
// @ts-ignore
async function cloneRepository(url, destination, logger) {
    const asyncExec = util.promisify(child_process_1.exec);
    cli_ux_1.default.action.start('cloning');
    try {
        const { stdout, stderr } = await asyncExec('git --version');
        // @ts-ignore
        logger.debug('out: %j\n, err: %j', stdout, stderr);
    }
    catch (e) {
        // @ts-ignore
        logger.debug('error: %j', e);
        cli_ux_1.default.action.stop();
        throw new GitNotAvailable();
    }
    await new Promise(async (resolve, reject) => {
        try {
            const command = `git clone ${url} --depth=1 ${destination}`;
            // @ts-ignore
            logger.debug(`Running ${command}`);
            await asyncExec(command);
            resolve();
        }
        catch (e) {
            cli_ux_1.default.action.stop();
            // @ts-ignore
            logger.debug(`%j`, e);
            reject(new CloningError());
        }
    });
    cli_ux_1.default.action.stop();
}
exports.cloneRepository = cloneRepository;
async function selectFolder(location, { selectedPath, integrationRootProof = locator_1.INTEGRATION_PROOF }) {
    const list = await globby([`**/${integrationRootProof}`], { cwd: location });
    const choices = list
        .sort()
        .map(path => {
        return {
            name: path.split(`/${integrationRootProof}`)[0],
            value: path.split(integrationRootProof)[0].replace(/\/$/, '')
        };
    })
        .filter(choice => {
        return !Boolean(selectedPath) || choice.value === selectedPath;
    });
    switch (choices.length) {
        case 0: {
            throw new NoIntegrationFoundError(selectedPath);
        }
        case 1: {
            return { selected: choices[0].value };
        }
        default: {
            return await inquirer.prompt([
                {
                    choices,
                    name: 'selected',
                    message: 'Select a template',
                    type: 'list'
                }
            ]);
        }
    }
}
exports.selectFolder = selectFolder;
async function defineLocationPath(logger, { name, cwd, force }) {
    let location = path.join(cwd, name);
    let shouldForce = force;
    while (fs.existsSync(location) && shouldForce !== true) {
        if (shouldForce === false) {
            logger.warn(`${location.replace(cwd, '')} already exists\n please provide a different folder name`);
            const folderName = await prompts_1.askForString('Folder name to use');
            location = path.join(cwd, folderName);
        }
        else {
            const { override } = await inquirer.prompt([
                {
                    type: 'confirm',
                    name: 'override',
                    default: false,
                    message: `${location} is not empty, copy files anyway?`
                }
            ]);
            shouldForce = override;
        }
    }
    return location;
}
exports.defineLocationPath = defineLocationPath;
function initViewsVars(authType) {
    const setup = authType === authentications_1.Authentications.NoAuth
        ? ''
        : `
  {
    classname: 'SetupAction',
    isRoot: true,
    initialTagName: 'setup-action',
    name: 'setup-action',
    label: 'Setup Action Component'
  },
  {
    classname: 'SetupView',
    isRoot: true,
    initialTagName: 'setup-view',
    name: 'setup-view',
    label: 'Setup Display Component'
  },`;
    return { setup };
}
exports.initViewsVars = initViewsVars;
/**
 * Custom errors
 */
class NoIntegrationFoundError extends Error {
    constructor(selectedFolder) {
        super(`No valid integrations found ${selectedFolder ? `under ${selectedFolder}` : ''}`);
    }
}
class GitNotAvailable extends Error {
    constructor() {
        super('git command not found in your path, please install it');
    }
}
class CloningError extends Error {
    constructor() {
        super('Error while cloning the repository');
    }
}