@dxcli/engine/lib/engine.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const command_1 = require("@dxcli/command");
const config_1 = require("@dxcli/config");
const cli_ux_1 = require("cli-ux");
const fs = require("fs-extra");
const globby = require("globby");
const _ = require("lodash");
const path = require("path");
const cache_1 = require("./cache");
const typescript_1 = require("./typescript");
const util_1 = require("./util");
class Engine {
    constructor() {
        this._plugins = [];
        this._commands = [];
        this._topics = [];
        this._hooks = {};
    }
    get plugins() { return this._plugins; }
    get topics() { return this._topics; }
    get commands() { return this._commands; }
    get commandIDs() { return this.commands.map(c => c.id); }
    get rootTopics() { return this.topics.filter(t => !t.name.includes(':')); }
    get rootCommands() { return this.commands.filter(c => !c.id.includes(':')); }
    async load(config, loadOptions = {}) {
        this.config = Object.assign({}, config, { engine: this });
        this.debug = require('debug')(['@dxcli/engine', this.config.name].join(':'));
        const loadPlugin = async (opts) => {
            this.debug('loading plugin', opts.name || opts.root);
            const config = opts.config || await config_1.read(opts);
            const pjson = config.pjson;
            const name = pjson.name;
            const version = pjson.version;
            const type = opts.type || 'core';
            const plugin = {
                name,
                version,
                root: config.root,
                tag: opts.tag,
                type,
                config,
                hooks: config.hooks,
                commands: [],
                topics: [],
                plugins: [],
            };
            if (config.pluginsModuleTS || config.hooksTS || config.commandsDirTS) {
                typescript_1.registerTSNode(this.debug, config.root);
            }
            if (config.pluginsModule) {
                let plugins;
                let fetch = (d) => util_1.undefault(require(d))(config, loadPlugin);
                if (config.pluginsModuleTS) {
                    try {
                        plugins = await fetch(config.pluginsModuleTS);
                    }
                    catch (err) {
                        cli_ux_1.default.warn(err);
                    }
                }
                if (!plugins)
                    plugins = await fetch(config.pluginsModule);
                plugin.plugins = plugins;
            }
            if (_.isArray(pjson.dxcli.plugins)) {
                const promises = pjson.dxcli.plugins.map(p => loadPlugin({ root: config.root, type, name: p }).catch(cli_ux_1.default.warn));
                plugin.plugins = _(await Promise.all(promises)).compact().flatMap().value();
            }
            this.plugins.push(plugin);
            return plugin;
        };
        await loadPlugin({ type: 'core', root: config.root });
        await this.runHook('legacy', { engine: this });
        // add hooks and topics
        for (let p of this._plugins) {
            for (let [hook, hooks] of Object.entries(p.hooks)) {
                this._hooks[hook] = [...this._hooks[hook] || [], ...hooks];
            }
            this._topics.push(...p.topics);
        }
        this._commands.push(..._(await Promise.all(this.plugins.map(p => this.loadCommands(p, loadOptions)))).flatMap().value());
        // add missing topics from commands
        for (let c of this._commands) {
            let name = c.id.split(':').slice(0, -1).join(':');
            if (!this.topics.find(t => t.name === name)) {
                this.topics.push({ name });
            }
        }
    }
    findCommand(id, must) {
        const cmd = this.commands.find(c => c.id === id);
        if (!cmd && must)
            throw new Error(`command ${id} not found`);
        return cmd;
    }
    findTopic(name, must) {
        const topic = this.topics.find(t => t.name === name);
        if (!topic && must)
            throw new Error(`command ${name} not found`);
        return topic;
    }
    async runHook(event, opts) {
        this.debug('starting hook', event);
        await Promise.all((this._hooks[event] || [])
            .map(async (hook) => {
            try {
                this.debug('running hook', event, hook);
                const m = await util_1.undefault(require(hook));
                await m(Object.assign({}, opts || {}, { config: this.config }));
            }
            catch (err) {
                if (err.code === 'EEXIT')
                    throw err;
                cli_ux_1.default.warn(err, { context: { hook: event, module: hook } });
            }
        }));
        this.debug('finished hook', event);
    }
    async loadCommands(plugin, loadOptions) {
        function getCached(c) {
            const opts = { plugin };
            if (c.convertToCached)
                return c.convertToCached(opts);
            return command_1.convertToCached(c, opts);
        }
        const getLastUpdated = async () => {
            try {
                if (loadOptions.resetCache)
                    return new Date();
                if (!await fs.pathExists(path.join(plugin.root, '.git')))
                    return;
                let files = await globby([`${plugin.root}/+(src|lib)/**/*.+(js|ts)`, '!**/*.+(d.ts|test.ts|test.js)']);
                let stats = await Promise.all(files.map(async (f) => {
                    const stat = await fs.stat(f);
                    return [f, stat];
                }));
                const max = _.maxBy(stats, '[1].mtime');
                if (!max)
                    return new Date();
                this.debug('most recently updated file: %s %o', max[0], max[1].mtime);
                return max[1].mtime;
            }
            catch (err) {
                cli_ux_1.default.warn(err);
                return new Date();
            }
        };
        const lastUpdated = await getLastUpdated();
        const debug = require('debug')(['@dxcli/load', plugin.name].join(':'));
        const cacheFile = path.join(plugin.config.cacheDir, 'commands', plugin.type, `${plugin.name}.json`);
        let cacheKey = [plugin.config.version, plugin.version];
        if (lastUpdated)
            cacheKey.push(lastUpdated.toISOString());
        const cache = new cache_1.default(cacheFile, cacheKey.join(':'), plugin.name);
        async function fetchFromDir(dir) {
            async function fetchCommandIDs() {
                function idFromPath(file) {
                    const p = path.parse(file);
                    const topics = p.dir.split(path.sep);
                    let command = p.name !== 'index' && p.name;
                    return _([...topics, command]).compact().join(':');
                }
                debug(`loading IDs from ${dir}`);
                const files = await globby(['**/*.+(js|ts)', '!**/*.+(d.ts|test.ts|test.js)'], { cwd: dir });
                let ids = files.map(idFromPath);
                debug('commandIDs dir: %s ids: %s', dir, ids.join(' '));
                return ids;
            }
            function findCommand(id) {
                function commandPath(id) {
                    return require.resolve(path.join(dir, ...id.split(':')));
                }
                debug('fetching %s from %s', id, dir);
                const p = commandPath(id);
                let c = util_1.undefault(require(p));
                c.id = id;
                return c;
            }
            return (await cache.fetch('commands', async () => {
                const commands = (await fetchCommandIDs())
                    .map(id => {
                    try {
                        const cmd = findCommand(id);
                        return getCached(cmd);
                    }
                    catch (err) {
                        cli_ux_1.default.warn(err);
                    }
                });
                return _.compact(commands);
            }))
                .map((cmd) => (Object.assign({}, cmd, { load: async () => findCommand(cmd.id) })));
        }
        let commands = [];
        if (plugin.config.commandsDirTS) {
            try {
                commands.push(...await fetchFromDir(plugin.config.commandsDirTS));
            }
            catch (err) {
                cli_ux_1.default.warn(err);
                // debug(err)
            }
        }
        if (plugin.config.commandsDir)
            commands.push(...await fetchFromDir(plugin.config.commandsDir));
        return commands;
    }
}
exports.default = Engine;