rman 0.0.4 → 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/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/{dist → cjs}/workspace/package.js

@@ -23,7 +23,7 @@ class Package {
         try {
             scriptInfo = (0, parse_npm_script_1.default)(this.def, 'npm run ' + script);
         }
-        catch (_a) {
+        catch {
             return result;
         }
         if (scriptInfo && scriptInfo.raw)

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NpmProvider = void 0;
-const utils_js_1 = require("../utils.js");
+const utils_1 = require("../utils");
 class NpmProvider {
     parse(root) {
-        const pkg = (0, utils_js_1.getPackageJson)(root);
+        const pkg = (0, utils_1.getPackageJson)(root);
         if (pkg && typeof pkg.workspaces === 'object') {
             if (Array.isArray(pkg.workspaces))
                 return { root, packages: pkg.workspaces };

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/esm/cli.mjs

@@ -0,0 +1,60 @@
+import path from 'path';
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import { program } from "commander";
+import { Workspace } from './workspace/workspace.mjs';
+import { URL } from 'url';
+export async function run(argv = process.argv) {
+    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>')
+        .description('Executes given script for every package in repository')
+        .action(async (script) => runScript(script))
+        .allowUnknownOption();
+    program
+        .command('build')
+        .description('Executes "build" script for every package in repository')
+        .action(async () => runScript('build'))
+        .allowUnknownOption();
+    program
+        .command('lint')
+        .description('Executes "lint" script for every package in repository')
+        .action(async () => runScript('lint'))
+        .allowUnknownOption();
+    program
+        .command('test')
+        .description('Executes "test" script for every package in repository')
+        .action(async () => runScript('lint'))
+        .allowUnknownOption();
+    program.parse(argv);
+}
+async function runScript(script) {
+    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 = '';
+        for (let i = 0; i < result.commands.length; i++) {
+            const cmd = result.commands[i];
+            if (cmd.error) {
+                s += '\n' + (i + 1) + ') ' +
+                    chalk.cyanBright(cmd.package) + '\n' +
+                    chalk.white(cmd.command) + '\n' +
+                    chalk.red('Error: ' + cmd.error.message) + '\n' +
+                    chalk.red(cmd.stderr) + '\n';
+            }
+        }
+        console.error(s);
+    }
+}

package/esm/index.mjs

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