rman 0.0.1 → 0.1.0

package/README.md

@@ -1,4 +1,4 @@
-## postgresql-client
+## rman
   
 [![NPM Version][npm-image]][npm-url]
 [![NPM Downloads][downloads-image]][downloads-url]
@@ -6,96 +6,28 @@
 [![Test Coverage][coveralls-image]][coveralls-url]
 
 
-Professional PostgreSQL client written in TypeScript.
-
-## Features
-
-- Pure JavaScript library completely written in TypeScript
-- Supports both single connection and pooling
-- Named Prepared Statements
-- Extended cursor support with fast double-link cache
-- Extensible data-types and type mapping
-- Extended bind parameters
-- Multidimensional arrays with fast binary encoding/decoding
-- Low memory utilization and boosted performance with Shared Buffers
-- Full binary and text wire protocol support for all data types
-- Supports Clear text, MD5 and SASL password algorithms
-- Can return both array and object rows
-- Asynchronous Promise based api
-- Strictly typed
-
-## Installation
-
-```bash
-$ npm install postgresql-client --save
-```
-
-## Documentation
-Documentation for detailed usage is [here](DOCUMENTATION.md)
-
-```ts
-import {Connection} from 'postgresql-client';
-
-const connection = new Connection('postgres://localhost');
-await connection.connect();
-const result = await connection.query(
-    'select * from cities where name like $1',
-    {params: ['%york%']});
-const rows = result.rows;
-await connection.close(); // Disconnect
-```
-
-```ts
-import {Pool} from 'postgresql-client';
-
-const db = new Pool({
-    host: 'postgres://localhost',
-    pool: {
-       min: 1,
-       max: 10,
-       idleTimeoutMillis: 5000
-    }
-});
-
-const result = await db.query(
-    'select * from cities where name like $1',
-    {params: ['%york%'], cursor: true});
-const cursor = result.cursor;
-let row;
-while ((row = cursor.next())) {
-  console.log(row);
-}
-
-await db.close(); // Disconnect all connections and shutdown pool
-```
-
-
-## Support
-You can report bugs and discuss features on the [GitHub issues](https://github.com/panates/postgresql-client/issues) page
-When you open an issue please provide version of NodeJS and PostgreSQL server.
-
+Monorepo repository manager
 
 ## Node Compatibility
 
-- node >= 10.x
- 
-  
-### License
-postgresql-client is available under [MIT](LICENSE) license.
+- node >= 14.x
 
-[npm-image]: https://img.shields.io/npm/v/postgresql-client.svg
-[npm-url]: https://npmjs.org/package/postgresql-client
-[travis-image]: https://img.shields.io/travis/panates/postgresql-client/master.svg
-[travis-url]: https://travis-ci.com/panates/postgresql-client
-[coveralls-image]: https://img.shields.io/coveralls/panates/postgresql-client/master.svg
-[coveralls-url]: https://coveralls.io/r/panates/postgresql-client
-[downloads-image]: https://img.shields.io/npm/dm/postgresql-client.svg
-[downloads-url]: https://npmjs.org/package/postgresql-client
-[gitter-image]: https://badges.gitter.im/panates/postgresql-client.svg
-[gitter-url]: https://gitter.im/panates/postgresql-client?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-[dependencies-image]: https://david-dm.org/panates/postgresql-client/status.svg
-[dependencies-url]:https://david-dm.org/panates/postgresql-client
-[devdependencies-image]: https://david-dm.org/panates/postgresql-client/dev-status.svg
-[devdependencies-url]:https://david-dm.org/panates/postgresql-client?type=dev
-[quality-image]: http://npm.packagequality.com/shield/postgresql-client.png
-[quality-url]: http://packagequality.com/#?package=postgresql-client
+### License
+rman is available under [MIT](LICENSE) license.
+
+[npm-image]: https://img.shields.io/npm/v/rman.svg
+[npm-url]: https://npmjs.org/package/rman
+[travis-image]: https://img.shields.io/travis/panates/rman/master.svg
+[travis-url]: https://travis-ci.com/panates/rman
+[coveralls-image]: https://img.shields.io/coveralls/panates/rman/master.svg
+[coveralls-url]: https://coveralls.io/r/panates/rman
+[downloads-image]: https://img.shields.io/npm/dm/rman.svg
+[downloads-url]: https://npmjs.org/package/rman
+[gitter-image]: https://badges.gitter.im/panates/rman.svg
+[gitter-url]: https://gitter.im/panates/rman?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[dependencies-image]: https://david-dm.org/panates/rman/status.svg
+[dependencies-url]:https://david-dm.org/panates/rman
+[devdependencies-image]: https://david-dm.org/panates/rman/dev-status.svg
+[devdependencies-url]:https://david-dm.org/panates/rman?type=dev
+[quality-image]: http://npm.packagequality.com/shield/rman.png
+[quality-url]: http://packagequality.com/#?package=rman

package/bin/debug.ts

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import {run} from '../src/cli.js';
+import {run} from '../src/cli';
 
 run().catch(e => console.error(e));

package/bin/rman.js

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

package/cjs/cli.js

@@ -0,0 +1,67 @@
+"use strict";
+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 path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+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);
+    }
+}

package/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./workspace/workspace"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/workspace/executor.js

@@ -0,0 +1,114 @@
+"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 child_process_1 = require("child_process");
+const npm_run_path_1 = __importDefault(require("npm-run-path"));
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
+const runningChildren = new Map();
+async function executeCommand(command, options) {
+    const opts = {
+        ...options
+    };
+    opts.env = {
+        ...npm_run_path_1.default.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 = (0, child_process_1.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_1.default.red(text) : text) + '\n  ' +
+                        opts.color ? chalk_1.default.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_1.default.red(text) : text));
+            }
+            return resolve(result);
+        });
+    });
+}
+exports.executeCommand = executeCommand;
+(0, utils_1.onProcessExit)(() => {
+    runningChildren.forEach((child) => {
+        child.kill();
+    });
+});

package/cjs/workspace/package.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Package = void 0;
+const parse_npm_script_1 = __importDefault(require("@netlify/parse-npm-script"));
+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 = (0, parse_npm_script_1.default)(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;
+    }
+}
+exports.Package = Package;

package/cjs/workspace/providers/npm-provider.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmProvider = void 0;
+const utils_1 = require("../utils");
+class NpmProvider {
+    parse(root) {
+        const pkg = (0, utils_1.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 };
+        }
+    }
+}
+exports.NpmProvider = NpmProvider;

package/cjs/workspace/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/workspace/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFind = exports.onProcessExit = exports.getPackageJson = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function getPackageJson(dirname) {
+    const f = path_1.default.resolve(dirname, 'package.json');
+    if (!fs_1.default.existsSync(f))
+        return;
+    return JSON.parse(fs_1.default.readFileSync(f, 'utf-8'));
+}
+exports.getPackageJson = getPackageJson;
+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"));
+}
+exports.onProcessExit = onProcessExit;
+function setFind(set, cb) {
+    for (const e of set) {
+        if (cb(e))
+            return e;
+    }
+}
+exports.setFind = setFind;

package/cjs/workspace/workspace.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspace = void 0;
+const fs_1 = __importDefault(require("fs"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const cli_progress_1 = require("cli-progress");
+const utils_1 = require("./utils");
+const executor_1 = require("./executor");
+const package_1 = require("./package");
+const npm_provider_1 = require("./providers/npm-provider");
+const providers = [
+    new npm_provider_1.NpmProvider()
+];
+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 cli_progress_1.MultiBar({
+            format: '[' + chalk_1.default.cyan('{bar}') + '] {percentage}% | {value}/{total} | ' +
+                chalk_1.default.yellowBright('{package}') + ' | ' + chalk_1.default.yellow('{command}'),
+            barsize: 30,
+            hideCursor: true,
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+        }, cli_progress_1.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 => (0, utils_1.setFind)(remaining, p => p === dep))) {
+                                cmd.status = '';
+                                if (progress)
+                                    progress.update({ command: chalk_1.default.bgYellow.white('Waiting dependencies') });
+                                break;
+                            }
+                            cmd.status = 'running';
+                            if (progress)
+                                progress.update({ command: cmd.name });
+                            else
+                                console.log('[' + chalk_1.default.whiteBright(pkg.name) + ']  ' +
+                                    chalk_1.default.yellow(cmd.command), (chalk_1.default.cyanBright(' +' + (Date.now() - t))));
+                            void (0, executor_1.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_1.default.yellow(cmd.name) + chalk_1.default.red(' Filed!') });
+                                        else
+                                            progress.update({ command: chalk_1.default.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_1.default.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 = (0, utils_1.getPackageJson)(inf.root);
+                if (!pkgJson)
+                    continue;
+                const packages = [];
+                for (const pattern of inf.packages) {
+                    const dirs = fast_glob_1.default.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_1.default.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;
+    }
+}
+exports.Workspace = Workspace;
+function detectPackage(dirname) {
+    const pkgJson = (0, utils_1.getPackageJson)(dirname);
+    if (pkgJson && pkgJson.name) {
+        return new package_1.Package(dirname, pkgJson);
+    }
+}

package/{dist/cli.js → esm/cli.mjs}

@@ -1,10 +1,14 @@
+import path from 'path';
 import fs from 'fs/promises';
-import { URL } from 'url';
 import chalk from 'chalk';
 import { program } from "commander";
-import { Workspace } from './workspace/workspace.js';
+import { Workspace } from './workspace/workspace.mjs';
+import { URL } from 'url';
 export async function run(argv = process.argv) {
-    const pkgJson = JSON.parse(await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
+    const pkgJson = JSON.parse(global.__dirname
+        ? await fs.readFile(path.resolve(__dirname, '../package.json'), 'utf-8')
+        // @ts-ignore
+        : await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
     program.version(pkgJson.version || '');
     program
         .command('run <script>')
@@ -29,10 +33,15 @@ export async function run(argv = process.argv) {
     program.parse(argv);
 }
 async function runScript(script) {
-    const workspace = await Workspace.resolve();
+    const workspace = Workspace.create();
     const result = await workspace.runScript(script, {
         gauge: true
     });
+    if (!result.commands.length) {
+        console.warn(chalk.cyanBright('There is nothing to do for "') +
+            chalk.yellowBright(script) + chalk.cyanBright('" script.'));
+        return;
+    }
     if (result.errorCount) {
         console.error('\n' + chalk.yellow(result.errorCount) + chalk.white(' error(s)'));
         let s = '';

package/esm/index.mjs

@@ -0,0 +1 @@
+export * from './workspace/workspace.mjs';

package/{dist/workspace/executor.js → esm/workspace/executor.mjs}

@@ -1,7 +1,7 @@
 import { spawn } from 'child_process';
 import npmRubPath from 'npm-run-path';
 import chalk from 'chalk';
-import { onProcessExit } from './utils.js';
+import { onProcessExit } from './utils.mjs';
 const runningChildren = new Map();
 export async function executeCommand(command, options) {
     const opts = {

package/{dist → esm}/workspace/providers/npm-provider.d.ts

@@ -1,4 +1,4 @@
 import { IParsedWorkspaceInfo, IWorkspaceProvider } from '../types';
 export declare class NpmProvider implements IWorkspaceProvider {
-    parse(root: string): Promise<IParsedWorkspaceInfo | undefined>;
+    parse(root: string): IParsedWorkspaceInfo | undefined;
 }

package/{dist/workspace/providers/npm-provider.js → esm/workspace/providers/npm-provider.mjs}

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

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

@@ -1,9 +1,8 @@
 export interface IWorkspaceOptions {
     packageOrder?: string[];
-    scripts?: Record<string, {}>;
 }
 export interface IWorkspaceProvider {
-    parse: (root: string) => Promise<IParsedWorkspaceInfo | undefined>;
+    parse: (root: string) => IParsedWorkspaceInfo | undefined;
 }
 export interface IParsedWorkspaceInfo {
     root: string;

package/esm/workspace/workspace.d.ts

@@ -0,0 +1,17 @@
+import { IRunScriptOptions } from './executor';
+import { Package, RunScriptResult } from './package';
+import { IWorkspaceOptions } from './types';
+export declare class Workspace {
+    readonly root: string;
+    private _options;
+    private _packages;
+    protected constructor(root: string, packages: Package[], options?: IWorkspaceOptions);
+    get packages(): Package[];
+    getPackage(name: string): Package | undefined;
+    runScript(script: string, options?: IRunScriptOptions): Promise<RunScriptResult>;
+    static create(root?: string, options?: {
+        deep?: number;
+    }): Workspace;
+    private _determineDependencies;
+    private _sortPackages;
+}

package/{dist/workspace/workspace.js → esm/workspace/workspace.mjs}

@@ -3,19 +3,23 @@ import glob from 'fast-glob';
 import path from 'path';
 import chalk from 'chalk';
 import { MultiBar, Presets } from 'cli-progress';
-import { getPackageJson, setFind } from './utils.js';
-import { executeCommand } from './executor.js';
-import { Package } from './package.js';
-import { NpmProvider } from './providers/npm-provider.js';
+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.packages = packages;
         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);
@@ -28,31 +32,38 @@ export class Workspace {
             commands: []
         };
         options.gauge = options.gauge == null ? true : options.gauge;
-        const progressBars = options.gauge && new MultiBar({
-            format: '[' + chalk.cyan('{bar}') + '] {percentage}% | {value}/{total} | ' +
-                chalk.yellowBright('{package}') + ' | ' + chalk.yellow('{command}'),
-            barsize: 30,
-            hideCursor: true
-        }, Presets.rect);
-        const overallProgress = progressBars && progressBars.create(0, 0);
         let totalCommands = 0;
-        for (const p of this._getSortedPackages()) {
+        for (const p of this.packages) {
             const commands = p.getScriptCommands(script);
-            const progress = progressBars && progressBars.create(commands.length, 0);
+            totalCommands += commands.length;
             packages[p.name] = {
                 package: p,
-                commands: [...commands],
-                progress
+                commands: [...commands]
             };
-            totalCommands += commands.length;
-            if (progress)
-                progress.start(commands.length, 0, {
-                    package: p.name,
-                    command: 'Waiting'
-                });
         }
-        if (overallProgress) {
-            overallProgress.start(totalCommands, 0, { package: 'Overall', command: '' });
+        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) => {
@@ -129,6 +140,38 @@ export class Workspace {
             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) {
@@ -167,7 +210,7 @@ export class Workspace {
             deepFindDependencies(pkg, pkg.dependencies);
         }
     }
-    _getSortedPackages() {
+    _sortPackages() {
         const packages = [...this.packages];
         const packageOrder = this._options.packageOrder;
         packages.sort((a, b) => {
@@ -184,42 +227,10 @@ export class Workspace {
                 return 1;
             return 0;
         });
-        return packages;
-    }
-    static async resolve(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 = await provider.parse(root);
-                if (!inf)
-                    continue;
-                const pkgJson = getPackageJson(inf.root);
-                if (!pkgJson)
-                    continue;
-                const packages = [];
-                for (const pattern of inf.packages) {
-                    const dirs = await glob(pattern, {
-                        cwd: inf.root,
-                        absolute: true,
-                        deep: 0,
-                        onlyDirectories: true
-                    });
-                    for (const dir of dirs) {
-                        const p = await 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');
+        this._packages = packages;
     }
 }
-async function detectPackage(dirname) {
+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.1",
+  "version": "0.1.0",
   "author": "Panates",
   "license": "MIT",
   "contributors": [
@@ -23,23 +23,29 @@
     "rman": "bin/rman.js"
   },
   "type": "module",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "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",
@@ -48,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"
   ],
@@ -63,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/index.js

@@ -1 +0,0 @@
-export * from './workspace/workspace';

package/dist/workspace/workspace.d.ts

@@ -1,16 +0,0 @@
-import { IRunScriptOptions } from './executor.js';
-import { Package, RunScriptResult } from './package.js';
-import { IWorkspaceOptions } from './types.js';
-export declare class Workspace {
-    readonly root: string;
-    readonly packages: Package[];
-    private _options;
-    constructor(root: string, packages: Package[], options?: IWorkspaceOptions);
-    getPackage(name: string): Package | undefined;
-    runScript(script: string, options?: IRunScriptOptions): Promise<RunScriptResult>;
-    private _determineDependencies;
-    private _getSortedPackages;
-    static resolve(root?: string, options?: {
-        deep?: number;
-    }): Promise<Workspace>;
-}