rtolms-cli/lib/base.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const command_1 = require("@oclif/command");
const fs = require("fs-extra");
const fuzzy = require("fuzzaldrin");
const globby = require("globby");
const inquirer = require("inquirer");
const inquirerAutocompletePrompt = require("inquirer-autocomplete-prompt");
const path = require("path");
const PrettyError = require("pretty-error");
const utils_1 = require("./utils");
const prompt = inquirer.createPromptModule();
prompt.registerPrompt('autocomplete', inquirerAutocompletePrompt);
const pe = new PrettyError();
pe.skipNodeFiles();
pe.start();
class BaseCommand extends command_1.default {
    constructor() {
        super(...arguments);
        this.fuzzyMatchCustomDir = async (partialCustomName) => {
            const { customerName } = this.args;
            if (!customerName)
                return;
            const customRepoRegex = new RegExp(this.flags['custom-repo-regex']);
            const repoDirs = await this.getCustomRepos();
            const matches = await Promise.resolve(repoDirs)
                .then(choices => choices.filter(p => customRepoRegex.test(path.basename(p))))
                .then(choices => fuzzy.filter(choices, partialCustomName));
            if (matches.lengh === 0) {
                return;
            }
            return matches[0];
        };
        this.getCorePath = async () => {
            const userConfig = await this.getConfig();
            return path.resolve(path.join(userConfig.reposDir, this.flags['core-repo-name']));
        };
        this.getCoreCustomSubdirPath = async () => {
            const coreRepo = await this.getCorePath();
            return path.resolve(path.join(coreRepo, 'Site', 'LmsSite', 'Custom'));
        };
        this.getCustomRepos = async () => {
            const userConfig = await this.getConfig();
            return globby([userConfig.reposDir + '/*/'], { onlyDirectories: true });
        };
        this.getCurrentlyLinkedCustomDir = async () => {
            const coreSubdir = await this.getCoreCustomSubdirPath();
            return fs.realpath(coreSubdir)
                .catch(_err => {
                return;
            });
        };
        this.promptForCustomerDir = async () => {
            const repoDirs = await this.getCustomRepos();
            const customRepoRegex = new RegExp(this.flags['custom-repo-regex']);
            const customRepoShortnameRegex = new RegExp(this.flags['custom-repo-shortname-regex']);
            //@ts-ignore
            return prompt([
                {
                    type: 'autocomplete',
                    message: 'Which custom repo do you want to link?',
                    name: 'customDir',
                    pageSize: 20,
                    source: (_answers, input) => {
                        return Promise.resolve(repoDirs)
                            .then(choices => choices.filter(p => customRepoRegex.test(path.basename(p))))
                            .then(choices => fuzzy.filter(choices, input))
                            .then(choices => {
                            return choices.map(p => {
                                const bname = path.basename(p);
                                return {
                                    name: bname,
                                    value: p,
                                    short: bname.replace(customRepoShortnameRegex, ''),
                                };
                            });
                        });
                    },
                },
            ])
                .then(({ customDir }) => customDir);
        };
    }
    getConfigPath() {
        return path.join(this.config.configDir, 'config.json');
    }
    getConfig() {
        const cfgPath = this.getConfigPath();
        return fs.readJSON(cfgPath)
            .then(contents => {
            return contents;
        });
    }
    getConfigDefaults() {
        const ret = {
            reposDir: path.join(this.config.home, 'Projects', 'lms'),
            server: '10.0.0.130\\SQL2012',
            database: 'TestLms',
            maildrop: path.join(this.config.home, 'maildrop'),
        };
        return Promise.resolve(ret);
    }
    configExists() {
        return fs.pathExistsSync(this.getConfigPath());
    }
    async requireConfig() {
        if (!this.configExists()) {
            if (!process.stdout.isTTY) {
                throw new Error('Config not found. Run init to create a config.');
            }
            console.error('Config not found. Run init to create a config.');
            await inquirer.prompt([
                {
                    type: 'confirm',
                    message: 'Do you want to run configuration now?',
                    name: 'runconfig',
                },
            ])
                .then(({ runconfig }) => {
                if (runconfig) {
                    return utils_1.promptForConfig.call(this);
                }
                this.log('KBAI.');
                this.exit(-1);
            });
        }
        return this.getConfig();
    }
    async init() {
        const { flags, args } = this.parse();
        this.flags = flags;
        this.args = args;
    }
    async finally() {
        // called after run and catch regardless of whether or not the command errored
    }
}
BaseCommand.flags = {
    help: command_1.flags.help({ char: 'h' }),
    // Hidden/advanced flags
    'core-repo-name': command_1.flags.string({
        hidden: true,
        description: 'name of the lms core repo',
        required: true,
        default: 'lms-core',
    }),
    'custom-repo-regex': command_1.flags.string({
        hidden: true,
        description: 'regex for which repos are considered custom',
        required: true,
        default: '^lms-custom-',
    }),
    'custom-repo-shortname-regex': command_1.flags.string({
        description: 'regex used to shorten customer repo names',
        hidden: true,
        required: true,
        default: '^lms-custom-',
    })
};
exports.default = BaseCommand;