@lerna-lite/run/dist/run-command.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RunCommand = exports.factory = void 0;
const core_1 = require("@lerna-lite/core");
const exec_run_common_1 = require("@lerna-lite/exec-run-common");
const p_map_1 = __importDefault(require("p-map"));
const lib_1 = require("./lib");
function factory(argv) {
    return new RunCommand(argv);
}
exports.factory = factory;
class RunCommand extends core_1.Command {
    constructor(argv) {
        super(argv);
        /** command name */
        this.name = 'run';
        this.args = [];
        this.bail = false;
        this.prefix = false;
        this.npmClient = 'npm';
        this.packagesWithScript = [];
        this.script = '';
    }
    get requiresGit() {
        return false;
    }
    initialize() {
        const { script, npmClient = 'npm' } = this.options;
        this.script = script;
        this.args = this.options['--'] || [];
        this.npmClient = npmClient;
        if (!script) {
            throw new core_1.ValidationError('ENOSCRIPT', 'You must specify a lifecycle script to run');
        }
        // inverted boolean options
        this.bail = this.options.bail !== false;
        this.prefix = this.options.prefix !== false;
        let chain = Promise.resolve();
        if (!this.options.log) {
            this.options.log = this.logger;
        }
        chain = chain.then(() => (0, exec_run_common_1.getFilteredPackages)(this.packageGraph, this.execOpts, this.options));
        chain = chain.then((filteredPackages) => {
            this.packagesWithScript =
                script === 'env'
                    ? filteredPackages
                    : filteredPackages.filter((pkg) => pkg.scripts && pkg.scripts[script]);
        });
        return chain.then(() => {
            this.count = this.packagesWithScript.length;
            this.packagePlural = this.count === 1 ? 'package' : 'packages';
            this.joinedCommand = [this.npmClient, 'run', this.script].concat(this.args).join(' ');
            if (!this.count) {
                this.logger.info('run', `No packages found with the lifecycle script "${script}"`);
                // still exits zero, aka 'ok'
                return false;
            }
        });
    }
    execute() {
        this.logger.info('', 'Executing command in %d %s: %j', this.count, this.packagePlural, this.joinedCommand);
        let chain = Promise.resolve();
        const getElapsed = (0, lib_1.timer)();
        if (this.options.parallel) {
            this.logger.verbose('Parallel', this.joinedCommand);
            chain = chain.then(() => this.runScriptInPackagesParallel());
        }
        else if (this.toposort) {
            this.logger.verbose('Topological', this.joinedCommand);
            chain = chain.then(() => this.runScriptInPackagesTopological());
        }
        else {
            this.logger.verbose('Lexical', this.joinedCommand);
            chain = chain.then(() => this.runScriptInPackagesLexical());
        }
        if (this.bail) {
            // only the first error is caught
            chain = chain.catch((err) => {
                process.exitCode = err.exitCode;
                // rethrow to halt chain and log properly
                throw err;
            });
        }
        else {
            // detect error (if any) from collected results
            chain = chain.then((results) => {
                /* istanbul ignore else */
                if (results.some((result) => result === null || result === void 0 ? void 0 : result.failed)) {
                    // propagate 'highest' error code, it's probably the most useful
                    const codes = results.filter((result) => result === null || result === void 0 ? void 0 : result.failed).map((result) => result.exitCode);
                    const exitCode = Math.max(...codes, 1);
                    this.logger.error('', 'Received non-zero exit code %d during execution', exitCode);
                    if (!this.options.stream) {
                        results
                            .filter((result) => result === null || result === void 0 ? void 0 : result.failed)
                            .forEach((result) => {
                            this.logger.error('', result.pkg.name, result.stderr);
                        });
                    }
                    process.exitCode = exitCode;
                }
                return results;
            });
        }
        return chain.then((results) => {
            const someFailed = results.some((result) => result === null || result === void 0 ? void 0 : result.failed);
            const logType = someFailed ? 'error' : 'success';
            this.logger[logType]('run', `Ran npm script '%s' in %d %s in %ss:`, this.script, this.count, this.packagePlural, (getElapsed() / 1000).toFixed(1));
            if (!this.bail) {
                results.forEach((result) => {
                    if (result === null || result === void 0 ? void 0 : result.failed) {
                        this.logger.error('', `- ${result.pkg.name}`);
                    }
                    else {
                        this.logger.success('', ` - ${result.pkg.name}`);
                    }
                });
            }
            else {
                this.logger.success('', this.packagesWithScript.map((pkg) => `- ${pkg.name}`).join('\n'));
            }
        });
    }
    getOpts(pkg) {
        // these options are NOT passed directly to execa, they are composed in npm-run-script
        return {
            args: this.args,
            npmClient: this.npmClient,
            prefix: this.prefix,
            reject: this.bail,
            pkg,
        };
    }
    getRunner() {
        return this.options.stream
            ? (pkg) => this.runScriptInPackageStreaming(pkg)
            : (pkg) => this.runScriptInPackageCapturing(pkg);
    }
    runScriptInPackagesTopological() {
        let profiler;
        let runner;
        if (this.options.profile) {
            profiler = new exec_run_common_1.Profiler({
                concurrency: this.concurrency,
                log: this.logger,
                outputDirectory: this.options.profileLocation,
            });
            const callback = this.getRunner();
            runner = (pkg) => profiler.run(() => callback(pkg), pkg.name);
        }
        else {
            runner = this.getRunner();
        }
        let chain = (0, core_1.runTopologically)(this.packagesWithScript, runner, {
            concurrency: this.concurrency,
            rejectCycles: this.options.rejectCycles,
        });
        if (profiler) {
            chain = chain.then((results) => profiler.output().then(() => results));
        }
        return chain;
    }
    runScriptInPackagesParallel() {
        return (0, p_map_1.default)(this.packagesWithScript, (pkg) => this.runScriptInPackageStreaming(pkg));
    }
    runScriptInPackagesLexical() {
        return (0, p_map_1.default)(this.packagesWithScript, this.getRunner(), { concurrency: this.concurrency });
    }
    runScriptInPackageStreaming(pkg) {
        if (this.options.cmdDryRun) {
            return this.dryRunScript(this.script, pkg.name);
        }
        const chain = (0, lib_1.npmRunScriptStreaming)(this.script, this.getOpts(pkg));
        if (!this.bail) {
            chain.then((result) => {
                return { ...result, pkg };
            });
        }
        return chain;
    }
    runScriptInPackageCapturing(pkg) {
        const getElapsed = (0, lib_1.timer)();
        if (this.options.cmdDryRun) {
            return this.dryRunScript(this.script, pkg.name);
        }
        return (0, lib_1.npmRunScript)(this.script, this.getOpts(pkg)).then((result) => {
            this.logger.info('run', `Ran npm script '%s' in '%s' in %ss:`, this.script, pkg.name, (getElapsed() / 1000).toFixed(1));
            (0, core_1.logOutput)(result.stdout);
            if (!this.bail) {
                return { ...result, pkg };
            }
            return result;
        });
    }
    dryRunScript(scriptName, pkgName) {
        this.logger.info('dry-run>', `Run npm script '%s' in '%s'`, scriptName, pkgName);
        (0, core_1.logOutput)(`dry-run> ${pkgName}`);
        return Promise.resolve();
    }
}
exports.RunCommand = RunCommand;
//# sourceMappingURL=run-command.js.map