@anycli/engine/lib/engine.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const command_1 = require("@anycli/command");
const config_1 = require("@anycli/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).uniq().value(); }
    get rootTopics() { return this.topics.filter(t => !t.name.includes(':')); }
    get rootCommands() { return this.commands.filter(c => !c.id.includes(':')); }
    async load(config) {
        this.config = config;
        this.config.engine = this;
        this.debug = require('debug')(['@anycli/engine', this.config.name].join(':'));
        this.rootPlugin = await this.loadPlugin({ type: 'core', config, loadDevPlugins: true, useCache: true });
        // await this.runHook('legacy', {engine: this})
        const getAllPluginProps = (plugin) => {
            this.plugins.push(plugin);
            for (let [hook, hooks] of Object.entries(plugin.hooks)) {
                this._hooks[hook] = [...this._hooks[hook] || [], ...hooks];
            }
            this.topics.push(...plugin.topics);
            this.commands.push(...plugin.manifest.commands);
            // // 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})
            //   }
            // }
            for (let p of plugin.plugins || []) {
                getAllPluginProps(p);
            }
        };
        getAllPluginProps(this.rootPlugin);
    }
    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 loadPlugin(opts) {
        const config = opts.config || await config_1.read(opts);
        this.debug('loading plugin', config.name);
        const pjson = config.pjson;
        const name = pjson.name;
        const version = pjson.version;
        const type = opts.type;
        if (config.pluginsModuleTS || config.hooksTS || config.commandsDirTS) {
            typescript_1.registerTSNode(this.debug, config.root);
        }
        let plugins = [];
        if (config.pluginsModule) {
            try {
                let roots;
                let fetch = (d) => util_1.undefault(require(d))(this.config);
                if (config.pluginsModuleTS) {
                    try {
                        roots = await fetch(config.pluginsModuleTS);
                    }
                    catch (err) {
                        cli_ux_1.default.warn(err);
                    }
                }
                if (!roots)
                    roots = await fetch(config.pluginsModule);
                const promises = roots.map((r) => this.loadPlugin(Object.assign({}, r, { useCache: true })).catch(cli_ux_1.default.warn));
                plugins.push(...await Promise.all(promises));
            }
            catch (err) {
                cli_ux_1.default.warn(err);
            }
        }
        else if (_.isArray(pjson.anycli.plugins)) {
            const promises = pjson.anycli.plugins.map(p => this.loadPlugin({ root: config.root, type, name: p, useCache: opts.useCache }).catch(cli_ux_1.default.warn));
            plugins.push(..._(await Promise.all(promises)).compact().flatMap().value());
        }
        if (opts.loadDevPlugins && _.isArray(config.pjson.anycli.devPlugins)) {
            const devPlugins = config.pjson.anycli.devPlugins;
            this.debug('loading dev plugins', devPlugins);
            const promises = devPlugins.map(p => this.loadPlugin({ root: config.root, type: 'dev', name: p, useCache: opts.useCache }).catch(cli_ux_1.default.warn));
            plugins.push(..._(await Promise.all(promises)).compact().flatMap().value());
        }
        return {
            name,
            version,
            root: config.root,
            tag: opts.tag,
            type,
            config,
            hooks: config.hooksTS || config.hooks,
            topics: [],
            plugins,
            manifest: await this.getPluginManifest(config, opts),
        };
    }
    async getPluginManifest(config, opts) {
        const debug = require('debug')(['@anycli/load', config.name].join(':'));
        function findCommand(dir, 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;
        }
        const rehydrate = (dir, commands) => {
            return commands.map((cmd) => (Object.assign({}, cmd, { load: async () => findCommand(dir, cmd.id) })));
        };
        const fetchFromDir = async () => {
            const dir = config.commandsDirTS || config.commandsDir;
            if (!dir)
                return [];
            const fetch = async () => {
                function getCached(c) {
                    const opts = { pluginName: config.name };
                    if (c.convertToCached)
                        return c.convertToCached(opts);
                    return command_1.convertToCached(c, opts);
                }
                const fetchCommandIDs = async () => {
                    function idFromPath(file) {
                        const p = path.parse(file);
                        const topics = p.dir.split('/');
                        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;
                };
                const commands = (await fetchCommandIDs())
                    .map(id => {
                    try {
                        const cmd = findCommand(dir, id);
                        return getCached(cmd);
                    }
                    catch (err) {
                        cli_ux_1.default.warn(err);
                    }
                });
                return _.compact(commands);
            };
            let commands;
            if (opts.useCache) {
                const getLastUpdated = async () => {
                    try {
                        // if (!await fs.pathExists(path.join(plugin.root, '.git'))) return
                        let files = await globby([`${config.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 cacheFile = path.join(this.config.cacheDir, 'commands', opts.type, `${config.name}.json`);
                let cacheKey = [this.config.version, config.version];
                const lastUpdated = await getLastUpdated();
                if (lastUpdated)
                    cacheKey.push(lastUpdated.toISOString());
                const cache = new cache_1.default(cacheFile, cacheKey.join(':'), config.name);
                commands = await cache.fetch('commands', fetch);
            }
            else {
                commands = await fetch();
            }
            return rehydrate(dir, commands);
        };
        const loadFromManifest = async () => {
            try {
                const manifest = await fs.readJSON(path.join(config.root, '.anycli.manifest.json'));
                if (manifest.version !== config.version) {
                    const err = new Error(`Mismatched version in plugin manifest. Expected: ${config.version} Received: ${manifest.version}`);
                    err.code = 'EMISMATCH';
                    throw err;
                }
                return rehydrate(config.commandsDir, manifest.commands);
            }
            catch (err) {
                switch (err.code) {
                    case 'ENOENT': return;
                    case 'EMISMATCH': return debug(err);
                    default: cli_ux_1.default.warn(err);
                }
            }
        };
        return {
            version: config.version,
            commands: (await loadFromManifest()) || (await fetchFromDir()),
        };
    }
}
exports.default = Engine;