@anycli/config/lib/plugin.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const cli_ux_1 = require("cli-ux");
const fs = require("fs-extra");
const loadJSON = require("load-json-file");
const _ = require("lodash");
const path = require("path");
const readPkg = require("read-pkg");
const util_1 = require("util");
const Config = require(".");
const ts_node_1 = require("./ts_node");
const util_2 = require("./util");
const debug = require('debug')('@anycli/config');
const _pjson = require('../package.json');
const loadedPlugins = {};
class Plugin {
    constructor(opts) {
        this._base = `${_pjson.name}@${_pjson.version}`;
        this.plugins = [];
        this.ignoreManifest = !!opts.ignoreManifest;
        this.type = opts.type || 'core';
        const root = findRoot(opts.name, opts.root);
        if (!root)
            throw new Error(`could not find package.json with ${util_1.inspect(opts)}`);
        if (loadedPlugins[root])
            return loadedPlugins[root];
        loadedPlugins[root] = this;
        this.root = root;
        debug('reading plugin %s', root);
        this.pjson = readPkg.sync(path.join(root, 'package.json'));
        this.name = this.pjson.name;
        this.version = this.pjson.version;
        if (!this.pjson.anycli) {
            this.pjson.anycli = this.pjson['cli-engine'] || {};
        }
        this.valid = this.pjson.anycli.schema === 1;
        this._topics = topicsToArray(this.pjson.anycli.topics || {});
        this.hooks = _.mapValues(this.pjson.anycli.hooks || {}, _.castArray);
        this.manifest = this._manifest();
        this.loadPlugins(...this.pjson.anycli.plugins || []);
    }
    get commandsDir() {
        return ts_node_1.tsPath(this.root, this.pjson.anycli.commands);
    }
    get topics() {
        let topics = [...this._topics];
        for (let plugin of this.plugins) {
            topics = [...topics, ...plugin.topics];
        }
        return topics;
    }
    get commands() {
        let commands = Object.entries(this.manifest.commands)
            .map(([id, c]) => (Object.assign({}, c, { load: () => this._findCommand(id) })));
        for (let plugin of this.plugins) {
            commands = [...commands, ...plugin.commands];
        }
        return commands;
    }
    get commandIDs() {
        let commands = Object.keys(this.manifest.commands);
        for (let plugin of this.plugins) {
            commands = [...commands, ...plugin.commandIDs];
        }
        return commands;
    }
    findCommand(id, opts = {}) {
        let command = this.manifest.commands[id];
        if (command)
            return Object.assign({}, command, { load: () => this._findCommand(id) });
        for (let plugin of this.plugins) {
            let command = plugin.findCommand(id);
            if (command)
                return command;
        }
        if (opts.must)
            throw new Error(`command ${id} not found`);
    }
    _findCommand(id) {
        const search = (cmd) => {
            if (_.isFunction(cmd.run))
                return cmd;
            return Object.values(cmd).find((cmd) => _.isFunction(cmd.run));
        };
        const p = require.resolve(path.join(this.commandsDir, ...id.split(':')));
        debug('require', p);
        const cmd = search(require(p));
        cmd.id = id;
        return cmd;
    }
    findTopic(name, opts = {}) {
        let topic = this.topics.find(t => t.name === name);
        if (topic)
            return topic;
        for (let plugin of this.plugins) {
            let topic = plugin.findTopic(name);
            if (topic)
                return topic;
        }
        if (opts.must)
            throw new Error(`topic ${name} not found`);
    }
    async runHook(event, opts) {
        const promises = (this.hooks[event] || [])
            .map(async (hook) => {
            try {
                const p = ts_node_1.tsPath(this.root, hook);
                debug('hook', event, p);
                await util_2.undefault(require(p))(opts);
            }
            catch (err) {
                if (err.code === 'EEXIT')
                    throw err;
                cli_ux_1.default.warn(err);
            }
        });
        promises.push(...this.plugins.map(p => p.runHook(event, opts)));
        await Promise.all(promises);
    }
    // findCommand(id: string, opts?: {must: boolean}): ICommand | undefined
    // findManifestCommand(id: string, opts: {must: true}): IManifestCommand
    // findManifestCommand(id: string, opts?: {must: boolean}): IManifestCommand | undefined
    // findTopic(id: string, opts: {must: true}): ITopic
    // findTopic(id: string, opts?: {must: boolean}): ITopic | undefined
    _manifest() {
        const readManifest = () => {
            try {
                const p = path.join(this.root, '.anycli.manifest.json');
                const manifest = loadJSON.sync(p);
                if (manifest.version !== this.version) {
                    cli_ux_1.default.warn(`Mismatched version in ${this.name} plugin manifest. Expected: ${this.version} Received: ${manifest.version}`);
                }
                else {
                    debug('using manifest from', p);
                    return manifest;
                }
            }
            catch (err) {
                if (err.code !== 'ENOENT')
                    cli_ux_1.default.warn(err);
            }
        };
        if (!this.ignoreManifest) {
            let manifest = readManifest();
            if (manifest)
                return manifest;
        }
        if (this.commandsDir)
            return Config.Manifest.build(this.version, this.commandsDir, id => this._findCommand(id));
        return { version: this.version, commands: {} };
    }
    loadPlugins(...plugins) {
        if (!plugins.length)
            return;
        if (!plugins || !plugins.length)
            return;
        debug('loading plugins', plugins);
        for (let plugin of plugins || []) {
            try {
                let opts = { type: this.type, root: this.root };
                if (typeof plugin === 'string')
                    opts.name = plugin;
                else
                    opts = Object.assign({}, opts, plugin);
                this.plugins.push(new Plugin(opts));
            }
            catch (err) {
                cli_ux_1.default.warn(err);
            }
        }
        return plugins;
    }
}
exports.Plugin = Plugin;
function topicsToArray(input, base) {
    if (!input)
        return [];
    base = base ? `${base}:` : '';
    if (Array.isArray(input)) {
        return input.concat(_.flatMap(input, t => topicsToArray(t.subtopics, `${base}${t.name}`)));
    }
    return _.flatMap(Object.keys(input), k => {
        return [Object.assign({}, input[k], { name: `${base}${k}` })].concat(topicsToArray(input[k].subtopics, `${base}${input[k].name}`));
    });
}
/**
 * find package root
 * for packages installed into node_modules this will go up directories until
 * it finds a node_modules directory with the plugin installed into it
 *
 * This is needed because of the deduping npm does
 */
function findRoot(name, root) {
    // essentially just "cd .."
    function* up(from) {
        while (path.dirname(from) !== from) {
            yield from;
            from = path.dirname(from);
        }
        yield from;
    }
    for (let next of up(root)) {
        let cur;
        if (name) {
            cur = path.join(next, 'node_modules', name, 'package.json');
        }
        else {
            cur = path.join(next, 'package.json');
        }
        if (fs.pathExistsSync(cur))
            return path.dirname(cur);
    }
}