rman 0.1.0 → 0.2.2

package/bin/rman.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import {run} from '../esm/cli.mjs';
+import {runCli} from '../esm/cli.mjs';
 
 // eslint-disable-next-line
-run().catch(e => console.error(e));
+runCli().catch();

package/cjs/cli.js

@@ -3,65 +3,55 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
+exports.runCli = void 0;
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
+const yargs_1 = __importDefault(require("yargs"));
 const chalk_1 = __importDefault(require("chalk"));
-const commander_1 = require("commander");
-const workspace_1 = require("./workspace/workspace");
-const url_1 = require("url");
-async function run(argv = process.argv) {
-    const pkgJson = JSON.parse(global.__dirname
-        ? await promises_1.default.readFile(path_1.default.resolve(__dirname, '../package.json'), 'utf-8')
-        // @ts-ignore
-        : await promises_1.default.readFile(new url_1.URL('../package.json', import.meta.url), 'utf-8'));
-    commander_1.program.version(pkgJson.version || '');
-    commander_1.program
-        .command('run <script>')
-        .description('Executes given script for every package in repository')
-        .action(async (script) => runScript(script))
-        .allowUnknownOption();
-    commander_1.program
-        .command('build')
-        .description('Executes "build" script for every package in repository')
-        .action(async () => runScript('build'))
-        .allowUnknownOption();
-    commander_1.program
-        .command('lint')
-        .description('Executes "lint" script for every package in repository')
-        .action(async () => runScript('lint'))
-        .allowUnknownOption();
-    commander_1.program
-        .command('test')
-        .description('Executes "test" script for every package in repository')
-        .action(async () => runScript('lint'))
-        .allowUnknownOption();
-    commander_1.program.parse(argv);
-}
-exports.run = run;
-async function runScript(script) {
-    const workspace = workspace_1.Workspace.create();
-    const result = await workspace.runScript(script, {
-        gauge: true
-    });
-    if (!result.commands.length) {
-        console.warn(chalk_1.default.cyanBright('There is nothing to do for "') +
-            chalk_1.default.yellowBright(script) + chalk_1.default.cyanBright('" script.'));
-        return;
-    }
-    if (result.errorCount) {
-        console.error('\n' + chalk_1.default.yellow(result.errorCount) + chalk_1.default.white(' error(s)'));
-        let s = '';
-        for (let i = 0; i < result.commands.length; i++) {
-            const cmd = result.commands[i];
-            if (cmd.error) {
-                s += '\n' + (i + 1) + ') ' +
-                    chalk_1.default.cyanBright(cmd.package) + '\n' +
-                    chalk_1.default.white(cmd.command) + '\n' +
-                    chalk_1.default.red('Error: ' + cmd.error.message) + '\n' +
-                    chalk_1.default.red(cmd.stderr) + '\n';
-            }
-        }
-        console.error(s);
-    }
+const utils_1 = require("./utils");
+const repository_1 = require("./core/repository");
+const info_command_1 = require("./commands/info-command");
+const command_1 = require("./core/command");
+const list_command_1 = require("./commands/list-command");
+const changed_command_1 = require("./commands/changed-command");
+const execute_command_1 = require("./commands/execute-command");
+const run_command_1 = require("./commands/run-command");
+const version_command_1 = require("./commands/version-command");
+const publish_command_1 = require("./commands/publish-command");
+async function runCli(options) {
+    const s = path_1.default.resolve((0, utils_1.getDirname)(), '../package.json');
+    const pkgJson = JSON.parse(await promises_1.default.readFile(s, 'utf-8'));
+    const repository = repository_1.Repository.create(options?.cwd);
+    const _argv = options?.argv || process.argv.slice(2);
+    const globalKeys = Object.keys(command_1.Command.globalOptions).concat(["help", "version"]);
+    const program = (0, yargs_1.default)(_argv)
+        // .scriptName('rman')
+        .strict()
+        .version(pkgJson.version || '').alias('version', 'v')
+        .usage('$0 <cmd> [options...]')
+        .help('help').alias('help', 'h')
+        .showHelpOnFail(false, 'Run with --help for available options')
+        .fail((msg, err) => {
+        const text = (msg
+            ? msg + '\n\n' + chalk_1.default.whiteBright('Run with --help for available options')
+            : (err ? err.message : ''));
+        console.log('\n' + chalk_1.default.red(text));
+        throw msg;
+    })
+        // group options under "Global Options:" header
+        .options(command_1.Command.globalOptions)
+        .group(globalKeys, "Global Options:");
+    info_command_1.InfoCommand.initCli(repository, program);
+    list_command_1.ListCommand.initCli(repository, program);
+    changed_command_1.ChangedCommand.initCli(repository, program);
+    execute_command_1.ExecuteCommand.initCli(repository, program);
+    run_command_1.RunCommand.initCli(repository, program);
+    version_command_1.VersionCommand.initCli(repository, program);
+    publish_command_1.PublishCommand.initCli(repository, program);
+    if (!_argv.length)
+        program.showHelp();
+    else
+        await program.parseAsync()
+            .catch(() => false);
 }
+exports.runCli = runCli;

package/cjs/commands/changed-command.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangedCommand = void 0;
+const list_command_1 = require("./list-command");
+const command_1 = require("../core/command");
+class ChangedCommand extends list_command_1.ListCommand {
+    constructor(repository, options) {
+        super(repository, options);
+        this.repository = repository;
+    }
+    _filter(pkg, inf) {
+        if (!super._filter(pkg, inf))
+            return false;
+        return !!(inf.isDirty || inf.isCommitted);
+    }
+}
+exports.ChangedCommand = ChangedCommand;
+ChangedCommand.commandName = 'changed';
+(function (ChangedCommand) {
+    function initCli(repository, program) {
+        program.command({
+            command: 'changed [options...]',
+            describe: 'List local packages that have changed since the last tagged release',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 changed", "# List changed packages")
+                    .example('$0 changed --json', '# List changed packages in JSON format')
+                    .option(list_command_1.ListCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const options = command_1.Command.composeOptions(ChangedCommand.commandName, args, repository.config);
+                await new ChangedCommand(repository, options)
+                    .execute();
+            }
+        });
+    }
+    ChangedCommand.initCli = initCli;
+})(ChangedCommand = exports.ChangedCommand || (exports.ChangedCommand = {}));

package/cjs/commands/execute-command.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecuteCommand = void 0;
+const npmlog_1 = __importDefault(require("npmlog"));
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const multi_task_command_1 = require("./multi-task-command");
+const power_tasks_1 = require("power-tasks");
+const exec_1 = require("../utils/exec");
+const command_1 = require("../core/command");
+class ExecuteCommand extends multi_task_command_1.MultiTaskCommand {
+    constructor(repository, cmd, argv, options) {
+        super(repository, options);
+        this.repository = repository;
+        this.cmd = cmd;
+        this.argv = argv;
+    }
+    _prepareTasks() {
+        const packages = this.repository.getPackages({ toposort: !this.options.parallel });
+        const tasks = [];
+        for (const p of packages) {
+            const task = new power_tasks_1.Task(async () => {
+                const t = Date.now();
+                npmlog_1.default.verbose(this.commandName, p.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), chalk_1.default.cyanBright.bold('executing'), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), this.cmd + ' ' + (this.argv?.join(' ') || ''));
+                const r = await (0, exec_1.exec)(this.cmd, {
+                    cwd: p.dirname,
+                    argv: this.argv
+                });
+                npmlog_1.default.log((r.error ? 'error' : 'verbose'), this.commandName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), p.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), (r.error ? chalk_1.default.red.bold('failed') : chalk_1.default.green.bold('success')), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), 'Completed in ' + chalk_1.default.yellow('' + (Date.now() - t) + ' ms'));
+            }, {
+                name: p.name,
+                dependencies: this.options.parallel ? undefined : p.dependencies,
+                bail: this.options.bail,
+                concurrency: this.options.concurrency
+            });
+            tasks.push(task);
+        }
+        return tasks;
+    }
+}
+exports.ExecuteCommand = ExecuteCommand;
+ExecuteCommand.commandName = 'exec';
+(function (ExecuteCommand) {
+    ExecuteCommand.cliCommandOptions = {
+        ...multi_task_command_1.MultiTaskCommand.cliCommandOptions
+    };
+    function initCli(repository, program) {
+        program.command({
+            command: 'exec [cmd] [args..]',
+            describe: 'Execute an arbitrary command in each package',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 exec -- ls", '')
+                    .example('$0 exec -- rm -rf ./node_modules', '')
+                    .parserConfiguration({
+                    "populate--": true,
+                })
+                    .positional("cmd", {
+                    describe: "The command to execute. Any command flags must be passed after --",
+                    type: "string",
+                })
+                    .positional("args", {
+                    describe: "Positional arguments to send to command",
+                    type: "string",
+                })
+                    .option(ExecuteCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const argv = args['--'] || [];
+                const options = command_1.Command.composeOptions(ExecuteCommand.commandName, args, repository.config);
+                await new ExecuteCommand(repository, '' + argv.shift(), argv, options).execute();
+            }
+        });
+    }
+    ExecuteCommand.initCli = initCli;
+})(ExecuteCommand = exports.ExecuteCommand || (exports.ExecuteCommand = {}));

package/cjs/commands/info-command.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfoCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const envinfo_1 = __importDefault(require("envinfo"));
+const semver_1 = __importDefault(require("semver"));
+const command_1 = require("../core/command");
+class InfoCommand extends command_1.Command {
+    async _execute() {
+        const systemInfo = JSON.parse(await envinfo_1.default.run({
+            System: ['OS', 'CPU', 'Memory', 'Shell'],
+            Binaries: ['Node', 'Yarn', 'npm'],
+            Utilities: ['Git'],
+            npmPackages: ['rman', 'typescript'],
+            npmGlobalPackages: ['typescript']
+        }, { json: true }));
+        if (this.options.json) {
+            this.logger.output('', '%j', systemInfo);
+            return;
+        }
+        const maxName = Object.keys(systemInfo).reduce((l, p) => Object.keys(systemInfo[p]).reduce((i, x) => l = Math.max(i, x.length), l), 0);
+        for (const [categoryName, category] of Object.entries(systemInfo)) {
+            this.logger.output('', '', chalk_1.default.whiteBright(categoryName) + ':');
+            for (const [n, v] of Object.entries(category)) {
+                const label = '    ' + chalk_1.default.reset(n) +
+                    ' '.repeat(maxName - n.length) + ' :';
+                if (typeof v === 'string') {
+                    this.logger.output('', label, chalk_1.default.yellowBright(v));
+                    continue;
+                }
+                if (v.version)
+                    this.logger.output('', label, chalk_1.default.yellowBright(v.version), (v.path ? ' ' + chalk_1.default.yellow(v.path) : ''));
+                if (v.installed) {
+                    if (v.wanted === 'latest' || semver_1.default.intersects(v.installed, v.wanted))
+                        this.logger.output('', label, chalk_1.default.yellowBright(v.installed));
+                    else
+                        this.logger.output('', label, chalk_1.default.red(v.installed), ' => ', chalk_1.default.yellowBright(v.wanted));
+                }
+            }
+        }
+    }
+}
+exports.InfoCommand = InfoCommand;
+InfoCommand.commandName = 'info';
+(function (InfoCommand) {
+    function initCli(repository, program) {
+        program.command({
+            command: 'info [options...]',
+            describe: 'Prints local environment information',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 info", "# Prints information")
+                    .example('$0 info --json', '# Prints information in JSON format');
+            },
+            handler: async (args) => {
+                const options = command_1.Command.composeOptions(InfoCommand.commandName, args, repository.config);
+                await new InfoCommand(options)
+                    .execute();
+            }
+        });
+    }
+    InfoCommand.initCli = initCli;
+})(InfoCommand = exports.InfoCommand || (exports.InfoCommand = {}));

package/cjs/commands/list-command.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCommand = void 0;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const easy_table_1 = __importDefault(require("easy-table"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const command_1 = require("../core/command");
+const git_utils_1 = require("../utils/git-utils");
+class ListCommand extends command_1.Command {
+    constructor(repository, options) {
+        super(options);
+        this.repository = repository;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _filter(pkg, inf) {
+        return true;
+    }
+    async _execute() {
+        const { repository } = this;
+        const packages = repository.getPackages({ toposort: this.options.toposort });
+        const git = new git_utils_1.GitHelper({ cwd: repository.dirname });
+        const dirtyFiles = await git.listDirtyFiles({ absolute: true });
+        const committedFiles = await git.listCommittedFiles({ absolute: true });
+        const table = new easy_table_1.default();
+        const arr = [];
+        const obj = {};
+        let count = 0;
+        for (const p of packages) {
+            const isDirty = !!dirtyFiles.find(f => !path_1.default.relative(p.dirname, f).startsWith('..'));
+            const isCommitted = !!committedFiles.find(f => !path_1.default.relative(p.dirname, f).startsWith('..'));
+            if (!this._filter(p, { isDirty, isCommitted }))
+                continue;
+            if (this.options.graph) {
+                count++;
+                obj[p.name] = [...p.dependencies];
+                continue;
+            }
+            const location = path_1.default.relative(repository.dirname, p.dirname);
+            let o = {
+                name: p.name,
+                version: p.version,
+                location,
+                private: p.isPrivate,
+                isDirty,
+                isCommitted
+            };
+            o = this.onPrepare ? this.onPrepare(p, o) : o;
+            if (!o)
+                continue;
+            arr.push(o);
+            count++;
+            if (!this.options.json) {
+                if (this.options.parseable) {
+                    const a = [location, p.name, p.version,
+                        (p.isPrivate ? 'PRIVATE' : ''),
+                        (isDirty ? 'DIRTY' : (isCommitted ? ':COMMITTED' : ''))
+                    ];
+                    npmlog_1.default.output('', a.join('::'));
+                }
+                else if (this.options.short) {
+                    npmlog_1.default.output('', p.name);
+                }
+                else {
+                    if (this.onPrintTable)
+                        this.onPrintTable(p, o, table);
+                    else {
+                        table.cell('Package', chalk_1.default.yellowBright(p.name));
+                        table.cell('Version', chalk_1.default.yellow(p.version));
+                        table.cell('Private', p.isPrivate ? chalk_1.default.magentaBright('yes') : '');
+                        table.cell('Changed', isDirty ? chalk_1.default.magenta('dirty') :
+                            (isCommitted ? chalk_1.default.yellow('committed') : ''));
+                        table.cell('Path', path_1.default.relative(repository.dirname, p.dirname));
+                        table.newRow();
+                    }
+                }
+            }
+        }
+        if (this.options.graph) {
+            npmlog_1.default.output('', '%j', obj);
+            return obj;
+        }
+        else if (this.options.json) {
+            npmlog_1.default.output('', '%j', arr);
+            return arr;
+        }
+        else if (table.rows.length) {
+            npmlog_1.default.output('', '%s', table.toString().trim());
+            console.log('');
+            npmlog_1.default.info('list', '%i Package(s) found', count);
+            return arr;
+        }
+        return arr;
+    }
+}
+exports.ListCommand = ListCommand;
+ListCommand.commandName = 'list';
+(function (ListCommand) {
+    ListCommand.cliCommandOptions = {
+        'short': {
+            alias: 's',
+            describe: '# Do not show extended information'
+        },
+        'parseable': {
+            alias: 'p',
+            describe: '# Show parseable output'
+        },
+        'toposort': {
+            alias: 't',
+            describe: '# Sort packages in topological order (dependencies before dependents) instead of lexical by directory'
+        },
+        'graph': {
+            alias: 'g',
+            describe: '# Show dependency graph as a JSON-formatted adjacency list'
+        }
+    };
+    function initCli(repository, program) {
+        program.command({
+            command: 'list [options...]',
+            describe: 'Lists packages in repository',
+            aliases: ['ls'],
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 list", "# List all packages")
+                    .example('$0 list --json', '# List all packages in JSON format')
+                    .conflicts('graph', ['parseable', 'json'])
+                    .conflicts('short', ['parseable', 'json'])
+                    .option(ListCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const options = command_1.Command.composeOptions(ListCommand.commandName, args, repository.config);
+                await new ListCommand(repository, options)
+                    .execute();
+            }
+        });
+    }
+    ListCommand.initCli = initCli;
+})(ListCommand = exports.ListCommand || (exports.ListCommand = {}));

package/cjs/commands/multi-task-command.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTaskCommand = void 0;
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const figures_1 = __importDefault(require("figures"));
+const power_tasks_1 = require("power-tasks");
+const command_1 = require("../core/command");
+const constants_1 = require("../utils/constants");
+const logSeparator = chalk_1.default.gray(figures_1.default.lineVerticalDashed0);
+class MultiTaskCommand extends command_1.Command {
+    constructor(repository, options) {
+        super(options);
+        this.repository = repository;
+        if (this.options.ci || !constants_1.isTTY)
+            this.options.progress = false;
+        // noinspection SuspiciousTypeOfGuard
+        this.options.concurrency = typeof options?.concurrency === 'string' ?
+            parseInt(options.concurrency, 10) : undefined;
+        if (this.options.bail == null)
+            this.options.bail = true;
+    }
+    async _execute() {
+        const childTasks = await this._prepareTasks();
+        if (!(childTasks && childTasks.length)) {
+            npmlog_1.default.info(this.commandName, logSeparator, 'There is no task to process');
+            return;
+        }
+        // this.enableProgress();
+        this._task = new power_tasks_1.Task(childTasks, {
+            concurrency: this.options.concurrency || os_1.default.cpus().length,
+            bail: this.options.bail,
+        });
+        await this._task;
+    }
+}
+exports.MultiTaskCommand = MultiTaskCommand;
+(function (MultiTaskCommand) {
+    MultiTaskCommand.cliCommandOptions = {
+        'concurrency': {
+            describe: '# Set processes count to parallelize tasks. (CPU count if not defined)',
+            type: 'number'
+        },
+        'parallel': {
+            describe: '# Disregards dependency checking and runs the command for every package at same time.',
+            type: 'boolean'
+        },
+        'no-bail': {
+            describe: '# Continue execution even one fails.',
+            type: 'boolean'
+        },
+        'bail': {
+            hidden: true,
+            type: 'boolean'
+        },
+        'no-progress': {
+            describe: "Disable progress bars",
+            type: 'boolean',
+        },
+        'progress': {
+            hidden: true,
+            type: 'boolean',
+            default: true
+        }
+    };
+})(MultiTaskCommand = exports.MultiTaskCommand || (exports.MultiTaskCommand = {}));

package/cjs/commands/publish-command.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const package_json_1 = __importDefault(require("package-json"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const figures_1 = __importDefault(require("figures"));
+const command_1 = require("../core/command");
+const run_command_1 = require("./run-command");
+class PublishCommand extends run_command_1.RunCommand {
+    constructor(repository, options) {
+        super(repository, 'publish', options);
+        this.repository = repository;
+    }
+    async _prepareTasks() {
+        const { repository } = this;
+        const packages = repository.getPackages({ toposort: true });
+        const newVersions = {};
+        const selectedPackages = [];
+        for (const p of packages) {
+            const logPkgName = chalk_1.default.yellow(p.name);
+            const r = await (0, package_json_1.default)(p.json.name);
+            if (r.version === p.version) {
+                npmlog_1.default.info(this.commandName, logPkgName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), `Ignored. Same version (${p.version}) in repository`);
+                continue;
+            }
+            selectedPackages.push(p);
+        }
+        const tasks = [];
+        for (const p of selectedPackages) {
+            const json = { ...p.json };
+            json.scripts = json.scripts || {};
+            json.scripts.publish = json.scripts.publish || 'npm publish';
+            const _p = { json };
+            Object.setPrototypeOf(_p, p);
+            const childTask = this._preparePackageTask(_p, { newVersions });
+            if (childTask) {
+                tasks.push(childTask);
+            }
+        }
+        return tasks;
+    }
+}
+exports.PublishCommand = PublishCommand;
+PublishCommand.commandName = 'publish';
+(function (PublishCommand) {
+    PublishCommand.cliCommandOptions = {
+        ...run_command_1.RunCommand.cliCommandOptions,
+        'contents': {
+            describe: '# Subdirectory to publish',
+            type: 'string'
+        }
+    };
+    function initCli(repository, program) {
+        program.command({
+            command: 'publish [...options]',
+            describe: 'Publish packages in the current project',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 publish", '')
+                    .example("$0 publish --contents dist", '# publish package from built directory')
+                    .option(PublishCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const options = command_1.Command.composeOptions(PublishCommand.commandName, args, repository.config);
+                await new PublishCommand(repository, options).execute();
+            }
+        });
+    }
+    PublishCommand.initCli = initCli;
+})(PublishCommand = exports.PublishCommand || (exports.PublishCommand = {}));