foy/lib/task-manager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const cli_loading_1 = require("./cli-loading");
const chalk_1 = require("chalk");
const utils_1 = require("./utils");
const stream_1 = require("stream");
const fs_1 = require("./fs");
const exec_1 = require("./exec");
const logger_1 = require("./logger");
const stripAnsi = require("strip-ansi");
const figures = 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.debug = logger_1.logger.debug;
        this.info = logger_1.logger.info;
        this.log = logger_1.logger.log;
        this.warn = logger_1.logger.warn;
        this.error = logger_1.logger.error;
        this.logCommand = utils_1.defaults(task.logCommand, global.logCommand, true);
        this.redirectLog = utils_1.defaults(task.redirectLog, global.redirectLog, false);
    }
    get options() {
        return this.task.options || {};
    }
    run(task, options) {
        return getGlobalTaskManager().run(task, Object.assign({ force: true, loading: false }, options));
    }
}
exports.TaskContext = TaskContext;
class TaskManager {
    constructor() {
        this._tasks = {};
        this._didSet = new Set();
        this.globalOptions = {
            logLevel: 'debug',
            loading: true,
            options: {},
            logCommand: true,
            indent: 3,
        };
    }
    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 = [];
        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({}, fullTask, taskDep, { options: Object.assign({}, fullTask.options, taskDep.options) });
                (t.async ? asyncDeps : syncDeps).push(this.resolveDependencyTree(t, depth + 1));
            });
        }
        return {
            uid: Date.now().toString(36) +
                Math.random()
                    .toString(36)
                    .slice(2),
            task: t,
            asyncDeps,
            syncDeps,
            state: TaskState.waiting,
            depth,
        };
    }
    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;
            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({}, depProps, { parentCtx: ctx }));
                    }
                }))(),
                Promise.all(depsTree.asyncDeps.map(t => this.runDepsTree(t, 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({}, t.options, lazyOptions);
            }
            let loading = this.isLoading(t, props);
            let taskHash = utils_1.hashAny(t);
            if (this._didSet.has(taskHash) && !t.force) {
                depsTree.state = TaskState.skipped;
                if (!loading) {
                    console.log(chalk_1.default.yellow(`Skip task: `) + t.name);
                }
                return;
            }
            if (!loading) {
                console.log(chalk_1.default.yellow('Task: ') + t.name);
                let ret = t.fn && (yield t.fn(ctx));
                this._didSet.add(taskHash);
                return ret;
            }
            try {
                let ret = t.fn && (yield t.fn(ctx));
                depsTree.state = TaskState.succeeded;
                this._didSet.add(taskHash);
                return ret;
            }
            catch (error) {
                depsTree.state = TaskState.failed;
                throw error;
            }
        });
    }
    run(name = 'default', props) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            let { redirectLog } = this.globalOptions;
            let redirectStream = undefined;
            if (redirectLog) {
                if (redirectLog instanceof stream_1.Stream) {
                    redirectStream = redirectLog;
                }
                else {
                    redirectLog = utils_1.Is.str(redirectLog) ? redirectLog : utils_1.DefaultLogFile;
                    redirectStream = fs_1.fs.createWriteStream(redirectLog, { mode: fs_1.fs.constants.O_APPEND });
                }
                process.stdout.write = (buf, encoding, ...args) => {
                    if (buf instanceof Buffer) {
                        buf = buf.toString(utils_1.Is.str(encoding) ? encoding : 'utf-8');
                    }
                    buf = stripAnsi(buf);
                    return redirectStream.write(buf, encoding, ...args);
                };
            }
            props = Object.assign({ options: null, parentCtx: null, rawArgs: [], force: false }, props);
            this._tasks.all =
                this._tasks.all || (yield Promise.resolve().then(() => 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({}, (utils_1.Is.str(name) ? this._tasks[name] : name), { force: props.force });
            t.options = 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.line };
                cliLoading.props.grayState = [];
                console.log(chalk_1.default.yellow(`DependencyGraph for task [${t.name}]:`));
                console.log(cliLoading.renderDepsTree(depsTree).join('\n') + '\n');
            }
            try {
                let ret = yield this.runDepsTree(depsTree, props);
                return ret;
            }
            finally {
                if (loading) {
                    cliLoading.stop();
                }
                if (redirectStream) {
                    redirectStream.end();
                }
            }
        });
    }
}
exports.TaskManager = TaskManager;
const TMKey = '@foyjs/taskManager';
/** @internal */
function getGlobalTaskManager() {
    let taskManager = (global[TMKey] = global[TMKey] || new TaskManager());
    return taskManager;
}
exports.getGlobalTaskManager = getGlobalTaskManager;
//# sourceMappingURL=task-manager.js.map