rman 0.0.4 → 0.1.0

package/esm/workspace/executor.mjs

@@ -0,0 +1,107 @@
+import { spawn } from 'child_process';
+import npmRubPath from 'npm-run-path';
+import chalk from 'chalk';
+import { onProcessExit } from './utils.mjs';
+const runningChildren = new Map();
+export async function executeCommand(command, options) {
+    const opts = {
+        ...options
+    };
+    opts.env = {
+        ...npmRubPath.env({ cwd: options?.cwd }),
+        //        FORCE_COLOR: `${chalk.level}`,
+        ...opts.env
+    };
+    opts.cwd = opts.cwd || process.cwd();
+    opts.color = opts.color == null ? true : opts.color;
+    const spawnOptions = {
+        stdio: opts.stdio || 'pipe',
+        env: opts.env,
+        cwd: opts.cwd,
+        shell: options?.shell,
+        windowsHide: true
+    };
+    const result = {
+        code: undefined,
+        stderr: '',
+        stdout: ''
+    };
+    const buffer = {
+        stdout: '',
+        stderr: ''
+    };
+    const processData = (data, stdio) => {
+        buffer[stdio] += data;
+        result[stdio] += data;
+        if (opts.onData)
+            opts.onData(data, stdio);
+    };
+    const processLines = (stdio, flush) => {
+        let chunk = buffer[stdio];
+        let i;
+        if (flush && !chunk.endsWith('\n'))
+            chunk += '\n';
+        while ((i = chunk.indexOf('\n')) >= 0) {
+            const line = chunk.substring(0, i);
+            chunk = chunk.substring(i + 1);
+            if (opts.onLine)
+                opts.onLine(line, stdio);
+        }
+        buffer[stdio] = chunk;
+    };
+    const child = spawn(command, opts.argv || [], spawnOptions);
+    if (child.pid) {
+        runningChildren.set(child.pid, child);
+        if (opts.onSpawn)
+            opts.onSpawn(child);
+    }
+    child.stdout?.on('data', (data) => {
+        processData(data, 'stdout');
+        processLines('stdout');
+    });
+    child.stderr?.on('data', (data) => {
+        processData(data, 'stderr');
+        processLines('stderr');
+    });
+    return new Promise(resolve => {
+        let resolved;
+        child.on('error', (err) => {
+            if (child.pid)
+                runningChildren.delete(child.pid);
+            processLines('stdout', true);
+            processLines('stderr', true);
+            if (resolved)
+                return;
+            result.code = err.code || 1;
+            result.error = err;
+            if (!result.error) {
+                const text = `Command failed (${result.code})`;
+                result.error =
+                    new Error((opts.color ? chalk.red(text) : text) + '\n  ' +
+                        opts.color ? chalk.white(err.message) : err.message);
+            }
+            resolved = true;
+            resolve(result);
+        });
+        child.on('close', (code) => {
+            if (child.pid)
+                runningChildren.delete(child.pid);
+            processLines('stdout', true);
+            processLines('stderr', true);
+            if (resolved)
+                return;
+            result.code = code;
+            resolved = true;
+            if (code) {
+                const text = `Command failed (${result.code})`;
+                result.error = new Error((opts.color ? chalk.red(text) : text));
+            }
+            return resolve(result);
+        });
+    });
+}
+onProcessExit(() => {
+    runningChildren.forEach((child) => {
+        child.kill();
+    });
+});

package/esm/workspace/package.mjs

@@ -0,0 +1,36 @@
+import parseNpmScript from '@netlify/parse-npm-script';
+export class Package {
+    constructor(dirname, def) {
+        this.dirname = dirname;
+        this.dependencies = [];
+        Object.defineProperty(this, 'def', {
+            enumerable: false,
+            value: def,
+        });
+    }
+    get name() {
+        return this.def.name;
+    }
+    getScriptCommands(script) {
+        const result = [];
+        let scriptInfo;
+        try {
+            scriptInfo = parseNpmScript(this.def, 'npm run ' + script);
+        }
+        catch {
+            return result;
+        }
+        if (scriptInfo && scriptInfo.raw)
+            for (const step of scriptInfo.steps) {
+                const parsed = Array.isArray(step.parsed) ? step.parsed : [step.parsed];
+                for (const cmd of parsed) {
+                    result.push({
+                        name: cmd.split(' ')[0],
+                        command: cmd,
+                        step: step.name
+                    });
+                }
+            }
+        return result;
+    }
+}

package/esm/workspace/providers/npm-provider.mjs

@@ -0,0 +1,12 @@
+import { getPackageJson } from './../utils.mjs';
+export class NpmProvider {
+    parse(root) {
+        const pkg = getPackageJson(root);
+        if (pkg && typeof pkg.workspaces === 'object') {
+            if (Array.isArray(pkg.workspaces))
+                return { root, packages: pkg.workspaces };
+            if (Array.isArray(pkg.workspaces.packages))
+                return { root, packages: pkg.workspaces.packages };
+        }
+    }
+}

package/esm/workspace/types.mjs

@@ -0,0 +1 @@
+export {};

package/esm/workspace/utils.mjs

@@ -0,0 +1,22 @@
+import path from 'path';
+import fs from 'fs';
+export function getPackageJson(dirname) {
+    const f = path.resolve(dirname, 'package.json');
+    if (!fs.existsSync(f))
+        return;
+    return JSON.parse(fs.readFileSync(f, 'utf-8'));
+}
+export function onProcessExit(listener, forceExit = true) {
+    ["SIGTERM", "SIGINT"].forEach((event) => process.once(event, (signal) => {
+        listener(signal);
+        if (forceExit)
+            process.exit(1);
+    }));
+    process.once("exit", () => listener("exit"));
+}
+export function setFind(set, cb) {
+    for (const e of set) {
+        if (cb(e))
+            return e;
+    }
+}

package/{dist → esm}/workspace/workspace.d.ts

@@ -1,6 +1,6 @@
-import { IRunScriptOptions } from './executor.js';
-import { Package, RunScriptResult } from './package.js';
-import { IWorkspaceOptions } from './types.js';
+import { IRunScriptOptions } from './executor';
+import { Package, RunScriptResult } from './package';
+import { IWorkspaceOptions } from './types';
 export declare class Workspace {
     readonly root: string;
     private _options;

package/esm/workspace/workspace.mjs

@@ -0,0 +1,238 @@
+import fs from 'fs';
+import glob from 'fast-glob';
+import path from 'path';
+import chalk from 'chalk';
+import { MultiBar, Presets } from 'cli-progress';
+import { getPackageJson, setFind } from './utils.mjs';
+import { executeCommand } from './executor.mjs';
+import { Package } from './package.mjs';
+import { NpmProvider } from './providers/npm-provider.mjs';
+const providers = [
+    new NpmProvider()
+];
+export class Workspace {
+    constructor(root, packages, options) {
+        this.root = root;
+        this._options = { ...options };
+        this._packages = packages;
+        this._determineDependencies();
+        this._sortPackages();
+    }
+    get packages() {
+        return this._packages;
+    }
+    getPackage(name) {
+        return this.packages.find(p => p.name === name);
+    }
+    async runScript(script, options = {}) {
+        const packages = {};
+        const result = {
+            script,
+            errorCount: 0,
+            commands: []
+        };
+        options.gauge = options.gauge == null ? true : options.gauge;
+        let totalCommands = 0;
+        for (const p of this.packages) {
+            const commands = p.getScriptCommands(script);
+            totalCommands += commands.length;
+            packages[p.name] = {
+                package: p,
+                commands: [...commands]
+            };
+        }
+        if (!totalCommands)
+            return result;
+        let overallProgress;
+        const progressBars = options.gauge && new MultiBar({
+            format: '[' + chalk.cyan('{bar}') + '] {percentage}% | {value}/{total} | ' +
+                chalk.yellowBright('{package}') + ' | ' + chalk.yellow('{command}'),
+            barsize: 30,
+            hideCursor: true,
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+        }, Presets.rect);
+        if (progressBars) {
+            overallProgress = progressBars.create(totalCommands, 0);
+            overallProgress.start(totalCommands, 0, { package: '=== OVERALL ===', command: '' });
+            for (const p of Object.values(packages)) {
+                if (p.commands.length) {
+                    p.progress = progressBars.create(p.commands.length, 0);
+                    p.progress.start(p.commands.length, 0, {
+                        package: p.name,
+                        command: 'Waiting'
+                    });
+                }
+            }
+        }
+        const t = Date.now();
+        return new Promise((resolve) => {
+            const remaining = new Set(Object.keys(packages));
+            const runScripts = () => {
+                for (const pkgName of remaining) {
+                    const pkgInfo = packages[pkgName];
+                    const pkg = pkgInfo.package;
+                    const progress = pkgInfo.progress;
+                    for (let k = 0; k < pkgInfo.commands.length; k++) {
+                        const cmd = pkgInfo.commands[k];
+                        if (cmd.status === 'running')
+                            break;
+                        if (!cmd.status) {
+                            const concurrent = cmd.step.startsWith('pre');
+                            if (!concurrent &&
+                                pkg.dependencies.find(dep => setFind(remaining, p => p === dep))) {
+                                cmd.status = '';
+                                if (progress)
+                                    progress.update({ command: chalk.bgYellow.white('Waiting dependencies') });
+                                break;
+                            }
+                            cmd.status = 'running';
+                            if (progress)
+                                progress.update({ command: cmd.name });
+                            else
+                                console.log('[' + chalk.whiteBright(pkg.name) + ']  ' +
+                                    chalk.yellow(cmd.command), (chalk.cyanBright(' +' + (Date.now() - t))));
+                            void executeCommand(cmd.command, {
+                                ...options,
+                                cwd: pkg.dirname,
+                                shell: true
+                            }).then(r => {
+                                if (overallProgress)
+                                    overallProgress.increment(1);
+                                if (progress)
+                                    progress.increment(1);
+                                const cr = {
+                                    package: pkg.name,
+                                    command: cmd,
+                                    code: r.code || 1,
+                                    error: r.error,
+                                    stdout: r.stdout,
+                                    stderr: r.stderr
+                                };
+                                result.code = result.code || r.code;
+                                if (r.error)
+                                    result.errorCount++;
+                                result.commands.push(cr);
+                                cmd.status = 'done';
+                                if (r.error || k === pkgInfo.commands.length - 1) {
+                                    if (progress) {
+                                        if (r.error)
+                                            progress.update({ command: chalk.yellow(cmd.name) + chalk.red(' Filed!') });
+                                        else
+                                            progress.update({ command: chalk.green(' Completed!') });
+                                    }
+                                    remaining.delete(pkg.name);
+                                }
+                                if (!remaining.size) {
+                                    if (progressBars)
+                                        progressBars.stop();
+                                    return resolve(result);
+                                }
+                                if (!result.errorCount)
+                                    setTimeout(runScripts, 1);
+                            });
+                            if (!concurrent)
+                                break;
+                        }
+                    }
+                }
+            };
+            runScripts();
+        });
+    }
+    static create(root, options) {
+        root = root || process.cwd();
+        let deep = options?.deep || 0;
+        while (deep-- >= 0 && fs.existsSync(root)) {
+            for (let i = providers.length - 1; i >= 0; i--) {
+                const provider = providers[i];
+                const inf = provider.parse(root);
+                if (!inf)
+                    continue;
+                const pkgJson = getPackageJson(inf.root);
+                if (!pkgJson)
+                    continue;
+                const packages = [];
+                for (const pattern of inf.packages) {
+                    const dirs = glob.sync(pattern, {
+                        cwd: inf.root,
+                        absolute: true,
+                        deep: 0,
+                        onlyDirectories: true
+                    });
+                    for (const dir of dirs) {
+                        const p = detectPackage(dir);
+                        if (p && !packages.find(x => x.name === p.name))
+                            packages.push(p);
+                    }
+                }
+                return new Workspace(inf.root, packages, pkgJson.rman);
+            }
+            root = path.resolve(root, '..');
+        }
+        throw new Error('No project workspace detected');
+    }
+    _determineDependencies() {
+        const deps = {};
+        for (const pkg of this.packages) {
+            const o = {
+                ...pkg.def.dependencies,
+                ...pkg.def.devDependencies,
+                ...pkg.def.peerDependencies,
+                ...pkg.def.optionalDependencies
+            };
+            const dependencies = [];
+            for (const k of Object.keys(o)) {
+                const p = this.getPackage(k);
+                if (p)
+                    dependencies.push(k);
+            }
+            deps[pkg.name] = dependencies;
+            pkg.dependencies = dependencies;
+        }
+        let circularCheck;
+        const deepFindDependencies = (pkg, target) => {
+            if (circularCheck.includes(pkg.name))
+                return;
+            circularCheck.push(pkg.name);
+            for (const s of pkg.dependencies) {
+                if (!target.includes(s)) {
+                    target.push(s);
+                    const p = this.getPackage(s);
+                    if (p) {
+                        deepFindDependencies(p, target);
+                    }
+                }
+            }
+        };
+        for (const pkg of this.packages) {
+            circularCheck = [];
+            deepFindDependencies(pkg, pkg.dependencies);
+        }
+    }
+    _sortPackages() {
+        const packages = [...this.packages];
+        const packageOrder = this._options.packageOrder;
+        packages.sort((a, b) => {
+            if (packageOrder) {
+                const a1 = packageOrder.indexOf(a.name);
+                const b1 = packageOrder.indexOf(b.name);
+                const i = (a1 >= 0 ? a1 : Number.MAX_SAFE_INTEGER) - (b1 >= 0 ? b1 : Number.MAX_SAFE_INTEGER);
+                if (i !== 0)
+                    return i;
+            }
+            if (b.dependencies.includes(a.name))
+                return -1;
+            if (a.dependencies.includes(b.name))
+                return 1;
+            return 0;
+        });
+        this._packages = packages;
+    }
+}
+function detectPackage(dirname) {
+    const pkgJson = getPackageJson(dirname);
+    if (pkgJson && pkgJson.name) {
+        return new Package(dirname, pkgJson);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Monorepo repository manager",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "author": "Panates",
   "license": "MIT",
   "contributors": [
@@ -22,23 +22,30 @@
   "bin": {
     "rman": "bin/rman.js"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.mjs",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": "./cjs/index.js",
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.mjs"
+  },
   "dependencies": {
+    "@netlify/parse-npm-script": "^0.1.2",
     "chalk": "^4.1.2",
+    "cli-progress": "^3.9.1",
     "commander": "^8.3.0",
     "fast-glob": "^3.2.7",
-    "npm-run-path": "^4.0.1",
-    "@netlify/parse-npm-script": "^0.1.2",
-    "cli-progress": "^3.9.1"
+    "npm-run-path": "^4.0.1"
   },
   "devDependencies": {
+    "@babel/eslint-parser": "^7.16.3",
+    "@types/cli-progress": "^3.9.2",
     "@types/mocha": "^9.0.0",
     "@types/node": "^16.4.8",
-    "@types/cli-progress": "^3.9.2",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
-    "@babel/eslint-parser": "^7.16.3",
     "eslint": "^8.0.0",
     "eslint-config-google": "^0.14.0",
     "mocha": "^9.0.1",
@@ -47,14 +54,17 @@
     "ts-loader": "^9.0.0",
     "ts-node": "^10.0.0",
     "tsconfig-paths": "^3.9.0",
-    "typescript": "^4.5.2"
+    "typescript": "^4.5.2",
+    "typescript-esm": "^2.0.0"
   },
   "engines": {
-    "node": ">= 14.0"
+    "node": ">=14.0",
+    "npm": ">=7.0.0"
   },
   "files": [
-    "dist/",
     "bin/",
+    "cjs/",
+    "esm/",
     "LICENSE",
     "README.md"
   ],
@@ -62,10 +72,13 @@
     "test": "TS_NODE_PROJECT='./test/tsconfig.json' mocha -r ts-node/register --reporter spec test/**/*.spec.ts",
     "cover": "nyc --reporter=cobertura --reporter html --reporter text npm run test",
     "clean": "npm run clean:src && npm run clean:dist",
-    "clean:dist": "ts-cleanup -d dist --remove-dirs --all",
+    "clean:dist": "rimraf cjs esm",
     "clean:src": "ts-cleanup -s src --all | ts-cleanup -s test",
-    "prebuild": "npm run clean && npm run lint",
-    "build": "tsc -b tsconfig.build.json",
+    "prebuild": "npm run clean:dist && npm run lint",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig.build-cjs.json",
+    "build:esm": "tsc -b tsconfig.build-esm.json && tsc-esm -p tsconfig.build-esm.json",
+    "postbuild": "cp ./src/package.cjs.json ./cjs/package.json",
     "compile": "tsc -b tsconfig.json",
     "lint": "eslint src/** --no-error-on-unmatched-pattern",
     "travis-cover": "nyc --reporter lcovonly npm run test"

package/dist/cli.js

@@ -1,71 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-const promises_1 = __importDefault(require("fs/promises"));
-const url_1 = require("url");
-const chalk_1 = __importDefault(require("chalk"));
-const commander_1 = require("commander");
-const workspace_js_1 = require("./workspace/workspace.js");
-function run(argv = process.argv) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const pkgJson = JSON.parse(yield promises_1.default.readFile(new url_1.URL('../package.json', __dirname), 'utf-8'));
-        commander_1.program.version(pkgJson.version || '');
-        commander_1.program
-            .command('run <script>')
-            .description('Executes given script for every package in repository')
-            .action((script) => __awaiter(this, void 0, void 0, function* () { return runScript(script); }))
-            .allowUnknownOption();
-        commander_1.program
-            .command('build')
-            .description('Executes "build" script for every package in repository')
-            .action(() => __awaiter(this, void 0, void 0, function* () { return runScript('build'); }))
-            .allowUnknownOption();
-        commander_1.program
-            .command('lint')
-            .description('Executes "lint" script for every package in repository')
-            .action(() => __awaiter(this, void 0, void 0, function* () { return runScript('lint'); }))
-            .allowUnknownOption();
-        commander_1.program
-            .command('test')
-            .description('Executes "test" script for every package in repository')
-            .action(() => __awaiter(this, void 0, void 0, function* () { return runScript('lint'); }))
-            .allowUnknownOption();
-        commander_1.program.parse(argv);
-    });
-}
-exports.run = run;
-function runScript(script) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const workspace = workspace_js_1.Workspace.create();
-        const result = yield workspace.runScript(script, {
-            gauge: true
-        });
-        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);
-        }
-    });
-}