@anycli/config/lib/config.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs-extra");
const readJSON = require("load-json-file");
const _ = require("lodash");
const os = require("os");
const path = require("path");
const readPkg = require("read-pkg");
const util_1 = require("util");
const _pjson = require('../package.json');
const _base = `${_pjson.name}@${_pjson.version}`;
const debug = require('debug')('@anycli/config');
class Config {
    constructor() {
        /**
         * registers ts-node for reading typescript source (./src) instead of compiled js files (./lib)
         * there are likely issues doing this any the tsconfig.json files are not compatible with others
         */
        this._base = _base;
        this.debug = 0;
        this.legacy = false;
        this.arch = (os.arch() === 'ia32' ? 'x86' : os.arch());
        this.platform = os.platform();
        this.windows = this.platform === 'win32';
    }
    async load(root, pjson, baseConfig) {
        const base = baseConfig || {};
        this.root = root;
        this.pjson = pjson;
        this.name = this.pjson.name;
        this.version = this.pjson.version;
        if (!this.pjson.anycli) {
            this.legacy = true;
            this.pjson.anycli = this.pjson['cli-engine'] || {};
        }
        this.bin = this.pjson.anycli.bin || base.bin || this.name;
        this.dirname = this.pjson.anycli.dirname || base.dirname || this.name;
        this.userAgent = `${this.name}/${this.version} (${this.platform}-${this.arch}) node-${process.version}`;
        this.shell = this._shell();
        this.debug = this._debug();
        this.home = process.env.HOME || (this.windows && this.windowsHome()) || os.homedir() || os.tmpdir();
        this.cacheDir = this.scopedEnvVar('CACHE_DIR') || this.macosCacheDir() || this.dir('cache');
        this.configDir = this.scopedEnvVar('CONFIG_DIR') || this.dir('config');
        this.dataDir = this.scopedEnvVar('DATA_DIR') || this.dir('data');
        this.errlog = path.join(this.cacheDir, 'error.log');
        this.tsconfig = await this._tsConfig();
        if (this.pjson.anycli.commands) {
            this.commandsDir = path.join(this.root, this.pjson.anycli.commands);
            this.commandsDirTS = await this._tsPath(this.pjson.anycli.commands);
        }
        this.hooks = _.mapValues(this.pjson.anycli.hooks || {}, h => _.castArray(h).map(h => path.join(this.root, h)));
        this.hooksTS = await this._hooks();
        if (typeof this.pjson.anycli.plugins === 'string') {
            this.pluginsModule = path.join(this.root, this.pjson.anycli.plugins);
            this.pluginsModuleTS = await this._tsPath(this.pjson.anycli.plugins);
        }
        this.npmRegistry = this.scopedEnvVar('NPM_REGISTRY') || this.pjson.anycli.npmRegistry || 'https://registry.yarnpkg.com';
        this.topics = topicsToArray(this.pjson.anycli.topics || {});
        return this;
    }
    scopedEnvVar(k) {
        return process.env[this.scopedEnvVarKey(k)];
    }
    scopedEnvVarTrue(k) {
        let v = process.env[this.scopedEnvVarKey(k)];
        return v === '1' || v === 'true';
    }
    scopedEnvVarKey(k) {
        return [this.bin, k]
            .map(p => p.replace(/-/g, '_'))
            .join('_')
            .toUpperCase();
    }
    _topics() {
    }
    dir(category) {
        const base = process.env[`XDG_${category.toUpperCase()}_HOME`]
            || (this.windows && process.env.LOCALAPPDATA)
            || path.join(this.home, category === 'data' ? '.local/share' : '.' + category);
        return path.join(base, this.dirname);
    }
    windowsHome() { return this.windowsHomedriveHome() || this.windowsUserprofileHome(); }
    windowsHomedriveHome() { return (process.env.HOMEDRIVE && process.env.HOMEPATH && path.join(process.env.HOMEDRIVE, process.env.HOMEPATH)); }
    windowsUserprofileHome() { return process.env.USERPROFILE; }
    macosCacheDir() { return this.platform === 'darwin' && path.join(this.home, 'Library', 'Caches', this.dirname) || undefined; }
    async _tsConfig() {
        try {
            // ignore if no .git as it's likely not in dev mode
            if (!await fs.pathExists(path.join(this.root, '.git')))
                return;
            const tsconfigPath = path.join(this.root, 'tsconfig.json');
            const tsconfig = await readJSON(tsconfigPath);
            if (!tsconfig || !tsconfig.compilerOptions)
                return;
            return tsconfig;
        }
        catch (err) {
            if (err.code !== 'ENOENT')
                throw err;
        }
    }
    /**
     * convert a path from the compiled ./lib files to the ./src typescript source
     * this is for developing typescript plugins/CLIs
     * if there is a tsconfig and the original sources exist, it attempts to require ts-
     */
    async _tsPath(orig) {
        if (!orig || !this.tsconfig)
            return;
        orig = path.join(this.root, orig);
        let { rootDirs, outDir } = this.tsconfig.compilerOptions;
        if (!rootDirs || !rootDirs.length || !outDir)
            return;
        let rootDir = rootDirs[0];
        try {
            // rewrite path from ./lib/foo to ./src/foo
            const lib = path.join(this.root, outDir); // ./lib
            const src = path.join(this.root, rootDir); // ./src
            const relative = path.relative(lib, orig); // ./commands
            const out = path.join(src, relative); // ./src/commands
            // this can be a directory of commands or point to a hook file
            // if it's a directory, we check if the path exists. If so, return the path to the directory.
            // For hooks, it might point to a module, not a file. Something like "./hooks/myhook"
            // That file doesn't exist, and the real file is "./hooks/myhook.ts"
            // In that case we attempt to resolve to the filename. If it fails it will revert back to the lib path
            if (await fs.pathExists(out) || await fs.pathExists(out + '.ts'))
                return out;
            return out;
        }
        catch (err) {
            debug(err);
            return;
        }
    }
    async _hooks() {
        const hooks = {};
        if (_.isEmpty(this.pjson.anycli.hooks))
            return;
        for (let [k, h] of Object.entries(this.pjson.anycli.hooks)) {
            hooks[k] = [];
            for (let m of _.castArray(h)) {
                const ts = await this._tsPath(m);
                if (!ts)
                    return;
                hooks[k].push(ts);
            }
        }
        return hooks;
    }
    _shell() {
        let shellPath;
        const { SHELL, COMSPEC } = process.env;
        if (SHELL) {
            shellPath = SHELL.split('/');
        }
        else if (this.windows && COMSPEC) {
            shellPath = COMSPEC.split(/\\|\//);
        }
        else {
            shellPath = ['unknown'];
        }
        return shellPath[shellPath.length - 1];
    }
    _debug() {
        try {
            const { enabled } = require('debug')(this.bin);
            if (enabled)
                return 1;
            if (this.scopedEnvVarTrue('DEBUG'))
                return 1;
            return 0;
            // tslint:disable-next-line
        }
        catch (err) {
            return 0;
        }
    }
}
exports.Config = Config;
/**
 * 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
 */
async function findPkg(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 (await fs.pathExists(cur))
            return cur;
    }
}
/**
 * returns true if config is instantiated and not ConfigOptions
 */
function isIConfig(o) {
    return !!o._base;
}
exports.isIConfig = isIConfig;
/**
 * reads a plugin/CLI's config
 */
async function read(opts = {}) {
    let root = opts.root || (module.parent && module.parent.parent && module.parent.parent.filename) || __dirname;
    const pkgPath = await findPkg(opts.name, root);
    if (!pkgPath)
        throw new Error(`could not find package.json with ${util_1.inspect(opts)}`);
    debug('reading plugin %s', path.dirname(pkgPath));
    const pkg = await readPkg(pkgPath);
    const config = new Config();
    await config.load(path.dirname(pkgPath), pkg, opts.baseConfig);
    return config;
}
exports.read = read;
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}`));
    });
}