foy/lib/task-manager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getGlobalTaskManager = exports.TaskManager = exports.TaskContext = exports.TaskState = void 0;
const tslib_1 = require("tslib");
const cli_loading_1 = require("./cli-loading");
const chalk_1 = tslib_1.__importDefault(require("chalk"));
const utils_1 = require("./utils");
const fs_1 = require("./fs");
const exec_1 = require("./exec");
const logger_1 = require("./logger");
const figures_1 = tslib_1.__importDefault(require("figures"));
var TaskState;
(function (TaskState) {
    TaskState["waiting"] = "waiting";
    TaskState["pending"] = "pending";
    TaskState["skipped"] = "skipped";
    TaskState["loading"] = "loading";
    TaskState["succeeded"] = "succeeded";
    TaskState["failed"] = "failed";
})(TaskState = exports.TaskState || (exports.TaskState = {}));
class TaskContext extends exec_1.ShellContext {
    constructor(task, global) {
        super();
        this.task = task;
        this.global = global;
        this.fs = fs_1.fs;
        this.logCommand = utils_1.defaults(task.logger && task.logCommand, global.logCommand, true);
        this._logger = new logger_1.Logger(global.logger);
    }
    get debug() { return this._logger.debug; }
    get info() { return this._logger.info; }
    get log() { return this._logger.log; }
    get warn() { return this._logger.warn; }
    get error() { return this._logger.error; }
    /**
     * get task options
     */
    get options() {
        return this.task.options || {};
    }
    /**
     * run a task manually
     * @param task
     * @param options
     */
    run(task, options) {
        return getGlobalTaskManager().run(task, Object.assign({ force: true, loading: false }, options));
    }
}
exports.TaskContext = TaskContext;
class TaskManager {
    constructor() {
        this._tasks = {};
        this._didMap = new Map();
        this.namespaces = [];
        this.listeners = {
            before: [],
            after: [],
            onerror: [],
        };
        this.globalOptions = {
            loading: true,
            options: {},
            indent: 3,
            logCommand: true,
            logger: {}
        };
    }
    getTasks() {
        return Object.keys(this._tasks).map(k => this._tasks[k]);
    }
    addTask(task) {
        if (this._tasks[task.name]) {
            throw new TypeError(`Task name [${task.name}] already exists, please choose another task name!`);
        }
        this._tasks[task.name] = task;
        return task;
    }
    resolveDependencyTree(t, depth = 0) {
        let asyncDeps = [];
        let syncDeps = [];
        let asyncDepsMap = {};
        if (t.async === true) {
            t.async = 0;
        }
        if (t.dependencies) {
            t.dependencies.forEach(taskDep => {
                let fullTask = this._tasks[taskDep.name];
                if (!fullTask) {
                    throw new TypeError(`Cannot find task with name [${taskDep.name}]`);
                }
                const t = Object.assign(Object.assign(Object.assign({}, fullTask), taskDep), { options: Object.assign(Object.assign({}, fullTask.options), taskDep.options) });
                let depTask = this.resolveDependencyTree(t, depth + 1);
                if (t.async === false || !utils_1.Is.defed(t.async)) { // sync tasks
                    syncDeps.push(depTask);
                }
                else {
                    let idx = t.async === true ? 0 : t.async;
                    let deps = asyncDepsMap[idx] = asyncDepsMap[idx] || [];
                    deps.push(depTask);
                }
            });
            asyncDeps = [];
            Object.keys(asyncDepsMap) // Sort async deps via priority, bigger is former
                .map(Number)
                .sort((a, b) => b - a)
                .map(k => (asyncDeps.push(asyncDepsMap[k])));
        }
        return {
            uid: Date.now().toString(36) +
                Math.random()
                    .toString(36)
                    .slice(2),
            task: t,
            asyncDeps,
            syncDeps,
            state: TaskState.waiting,
            depth,
            priority: utils_1.Is.num(t.async) ? t.async : 0,
        };
    }
    isLoading(t, props) {
        return utils_1.defaults(props.loading, t.loading, this.globalOptions.loading, true);
    }
    runDepsTree(depsTree, props) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            let t = depsTree.task;
            let taskHash = utils_1.hashAny(t);
            let loading = this.isLoading(t, props);
            let didResolved = null;
            if (this._didMap.has(taskHash) && !t.force) {
                depsTree.state = TaskState.skipped;
                yield this._didMap.get(taskHash);
                if (!loading) {
                    console.log(chalk_1.default.yellow(`Skip task: `) + t.name);
                }
                return;
            }
            this._didMap.set(taskHash, new Promise(res => (didResolved = res)));
            t.rawArgs = props.rawArgs || [];
            const ctx = new TaskContext(t, this.globalOptions);
            const depProps = {
                rawArgs: props.rawArgs,
                indent: props.indent,
                loading: props.loading,
                parentCtx: ctx,
            };
            depsTree.state = TaskState.pending;
            yield Promise.all([
                (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
                    for (const t of depsTree.syncDeps) {
                        yield this.runDepsTree(t, Object.assign(Object.assign({}, depProps), { parentCtx: ctx }));
                    }
                }))(),
                (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
                    for (const deps of depsTree.asyncDeps) {
                        yield Promise.all(deps.map(t => this.runDepsTree(t, Object.assign(Object.assign({}, depProps), { parentCtx: ctx }))));
                    }
                }))(),
            ]);
            depsTree.state = TaskState.loading;
            if (t.resolveOptions && props.parentCtx) {
                let lazyOptions = yield t.resolveOptions(props.parentCtx);
                t.options = Object.assign(Object.assign({}, t.options), lazyOptions);
            }
            if (!loading) {
                console.log(chalk_1.default.yellow('Task: ') + t.name);
                let retPromise = t.fn && t.fn(ctx);
                didResolved && didResolved();
                return retPromise;
            }
            try {
                let ret = t.fn && (yield t.fn(ctx));
                depsTree.state = TaskState.succeeded;
                didResolved && didResolved();
                return ret;
            }
            catch (error) {
                depsTree.state = TaskState.failed;
                throw error;
            }
        });
    }
    runListner(name, ns, args = []) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const listeners = this.listeners[name].slice();
            if (name === 'before') {
                listeners.sort((a, b) => a.namespaces.length - b.namespaces.length);
            }
            else {
                listeners.sort((a, b) => b.namespaces.length - a.namespaces.length);
            }
            for (const fn of listeners) {
                if (ns.join(':').startsWith(fn.namespaces.join(':'))) {
                    try {
                        yield fn.fn(...args);
                    }
                    catch (error) {
                        logger_1.logger.error(error);
                    }
                }
            }
        });
    }
    run(name = 'default', props) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            logger_1.logger._props = Object.assign(Object.assign({}, logger_1.logger._props), this.globalOptions.logger);
            props = Object.assign({ options: null, parentCtx: null, rawArgs: [], force: false }, props);
            this._tasks.all =
                this._tasks.all || (yield Promise.resolve().then(() => tslib_1.__importStar(require('./task'))).then(e => e.task('all', Object.keys(this._tasks))));
            this._tasks.default = this._tasks.default || this._tasks.all;
            if (!this._tasks[utils_1.Is.str(name) ? name : name.name]) {
                throw new TypeError(`Cannot find task with name [${name}]`);
            }
            const t = Object.assign(Object.assign({}, (utils_1.Is.str(name) ? this._tasks[name] : name)), { force: props.force });
            t.options = Object.assign(Object.assign({}, (t.options || null)), (props.options || null));
            let depsTree = this.resolveDependencyTree(t);
            let loading = this.isLoading(t, props);
            let cliLoading = new cli_loading_1.CliLoading({
                depsTree,
                indent: utils_1.defaults(props.indent, this.globalOptions.indent),
            });
            if (loading) {
                cliLoading.start();
            }
            else {
                cliLoading.props.symbolMap = { [TaskState.waiting]: figures_1.default.line };
                cliLoading.props.grayState = [];
                console.log(chalk_1.default.yellow(`DependencyGraph for task [${t.name}]:`));
                console.log(cliLoading.renderDepsTree(depsTree).join('\n') + '\n');
            }
            yield this.runListner('before', t.namespaces, [t]);
            try {
                let ret = yield this.runDepsTree(depsTree, props);
                return ret;
            }
            catch (e) {
                logger_1.logger.error(e);
                yield this.runListner('onerror', t.namespaces, [e, t]);
            }
            finally {
                yield this.runListner('after', t.namespaces, [t]);
                if (loading) {
                    cliLoading.stop();
                }
            }
        });
    }
}
exports.TaskManager = TaskManager;
const TMKey = `@foy${require('../package.json').version}/taskManager`;
/** @internal */
function getGlobalTaskManager() {
    let taskManager = (global[TMKey] = global[TMKey] || new TaskManager());
    return taskManager;
}
exports.getGlobalTaskManager = getGlobalTaskManager;
//# sourceMappingURL=task-manager.js.map