rman 0.0.3 → 0.2.0

package/esm/core/command.mjs

@@ -0,0 +1,103 @@
+import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
+import npmlog from 'npmlog';
+import isCi from 'is-ci';
+import merge from 'putil-merge';
+import './logger.mjs';
+import { isTTY } from './../utils/constants.mjs';
+const noOp = () => void (0);
+export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
+    constructor(options) {
+        super();
+        this._started = false;
+        this._finished = false;
+        this.logger = npmlog;
+        this._options = options || {};
+        if (isCi)
+            this.options.ci = true;
+    }
+    get options() {
+        return this._options;
+    }
+    get commandName() {
+        return Object.getPrototypeOf(this).constructor.commandName;
+    }
+    async execute() {
+        if (this._finished) {
+            this._finished = false;
+            this._started = false;
+        }
+        if (!this._started) {
+            this._started = true;
+            await this.emitAsync('start');
+        }
+        this._started = true;
+        try {
+            this.logger.level = this.options.logLevel ||
+                (this.options.ci ? 'error' : 'info');
+            if (this.options.ci || !isTTY) {
+                this.logger.disableColor();
+                this.logger.disableUnicode();
+            }
+            else {
+                this.logger.enableColor();
+                this.logger.enableUnicode();
+            }
+            if (this._preExecute)
+                await this._preExecute();
+            const v = await this._execute();
+            if (this._postExecute)
+                await this._postExecute();
+            await this.emitAsync('finish', undefined, v).catch(noOp);
+            this.disableProgress();
+            this.logger.resume();
+            this.logger.success('', 'Command completed');
+            return v;
+        }
+        catch (e) {
+            this.disableProgress();
+            await this.emitAsync('finish', e).catch(noOp);
+            if (this.listenerCount('error'))
+                await this.emitAsync('error', e).catch(noOp);
+            this.logger.resume();
+            throw e;
+        }
+        finally {
+            this._finished = true;
+        }
+    }
+    async enableProgress() {
+        if (this.options.ci || !isTTY || (this._screen && this._screen.visible))
+            return;
+    }
+    disableProgress() {
+    }
+}
+(function (Command) {
+    Command.globalOptions = {
+        'log-level': {
+            defaultDescription: "info",
+            describe: "Set log level",
+            choices: ['silly', 'verbose', 'info', 'output', 'notice', 'success', 'warn', 'error', 'silent'],
+            requiresArg: true
+        },
+        'json': {
+            alias: 'j',
+            describe: '# Stream log as json',
+            type: 'boolean'
+        },
+        'ci': {
+            hidden: true,
+            type: "boolean"
+        }
+    };
+    function composeOptions(commandName, yargArgs, config) {
+        const result = merge({}, yargArgs);
+        merge(result, config, { filter: (_, key) => key !== 'command' });
+        const cfgCmd = config.commans && typeof config.command === 'object' ?
+            config.command : undefined;
+        if (cfgCmd && typeof cfgCmd === 'object')
+            merge(result, cfgCmd);
+        return result;
+    }
+    Command.composeOptions = composeOptions;
+})(Command || (Command = {}));

package/esm/core/config.d.ts

@@ -0,0 +1,9 @@
+export declare class Config {
+    data: any;
+    constructor(data: any);
+    getObject(key: string, def?: any): any | undefined;
+    getString(key: string, def?: string): string | undefined;
+    getNumber(key: string, def?: number): number | undefined;
+    get(key: string): any;
+    static resolve(dirname: string): Config;
+}

package/esm/core/config.mjs

@@ -0,0 +1,66 @@
+import path from 'path';
+import fs from 'fs';
+import yaml from 'js-yaml';
+import merge from 'putil-merge';
+import { getPackageJson } from './../utils.mjs';
+export class Config {
+    constructor(data) {
+        this.data = data;
+    }
+    getObject(key, def) {
+        const v = this.get(key);
+        if (v != null && typeof v === 'object')
+            return v;
+        return def;
+    }
+    getString(key, def) {
+        const v = this.get(key);
+        if (v != null && typeof v !== 'object')
+            return '' + v;
+        return def;
+    }
+    getNumber(key, def) {
+        const v = this.get(key);
+        if (v != null && typeof v !== 'object') {
+            const n = parseFloat(v);
+            if (!isNaN(n))
+                return n;
+        }
+        return def;
+    }
+    get(key) {
+        const keys = key.split('.');
+        let o = this.data;
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            if (o.hasOwnProperty(k)) {
+                if (i === keys.length - 1)
+                    return o[k];
+                if (o[k] && typeof o[k] === 'object') {
+                    o = o[k];
+                }
+                else
+                    return;
+            }
+        }
+    }
+    static resolve(dirname) {
+        const data = {};
+        const pkgJson = getPackageJson(dirname);
+        if (pkgJson && typeof pkgJson.rman === 'object')
+            merge(data, pkgJson.rman, { deep: true });
+        let filename = path.resolve(dirname, '.rman.yml');
+        if (fs.existsSync(filename)) {
+            const obj = yaml.load(fs.readFileSync(filename, 'utf-8'));
+            if (obj && typeof obj === 'object')
+                merge(data, obj, { deep: true });
+        }
+        filename = path.resolve(dirname, '.rmanrc');
+        if (fs.existsSync(filename)) {
+            const obj = JSON.parse(fs.readFileSync(filename, 'utf-8'));
+            if (obj && typeof obj === 'object')
+                merge(data, obj, { deep: true });
+        }
+        return new Config(data);
+    }
+}

package/esm/core/logger.d.ts

@@ -0,0 +1,10 @@
+declare module 'npmlog' {
+    interface Logger {
+        output(prefix: string, message: string, ...args: any[]): void;
+        success(prefix: string, message: string, ...args: any[]): void;
+        disp: Record<string, string>;
+        showProgress(): any;
+        hideProgress(): any;
+    }
+}
+export {};

package/esm/core/logger.mjs

@@ -0,0 +1,3 @@
+import logger from 'npmlog';
+logger.addLevel("success", 1500, { fg: "green", bold: true });
+logger.addLevel('output', 3300, {}, '');

package/esm/core/package.d.ts

@@ -0,0 +1,11 @@
+export declare class Package {
+    readonly dirname: string;
+    private _json;
+    dependencies: string[];
+    constructor(dirname: string);
+    get name(): string;
+    get version(): string;
+    get json(): any;
+    get isPrivate(): boolean;
+    reloadJson(): any;
+}

package/esm/core/package.mjs

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import path from 'path';
+export class Package {
+    constructor(dirname) {
+        this.dirname = dirname;
+        this.dependencies = [];
+        this.reloadJson();
+    }
+    get name() {
+        return this._json.name;
+    }
+    get version() {
+        return this._json.version;
+    }
+    get json() {
+        return this._json;
+    }
+    get isPrivate() {
+        return !!this._json.private;
+    }
+    reloadJson() {
+        const f = path.join(this.dirname, 'package.json');
+        this._json = JSON.parse(fs.readFileSync(f, 'utf-8'));
+        return this._json;
+    }
+}

package/esm/core/repository.d.ts

@@ -0,0 +1,18 @@
+import { Package } from './package';
+export declare class Repository extends Package {
+    readonly dirname: string;
+    readonly config: any;
+    readonly packages: Package[];
+    protected constructor(dirname: string, config: any, packages: Package[]);
+    getPackages(options?: {
+        scope?: string | string[];
+        toposort?: boolean;
+    }): Package[];
+    getPackage(name: string): Package | undefined;
+    protected _updateDependencies(): void;
+    static create(root?: string, options?: {
+        deep?: number;
+    }): Repository;
+    protected static _resolvePackages(dirname: string, patterns: string[]): Package[];
+    protected static _readConfig(dirname: string): any;
+}

package/esm/core/repository.mjs

@@ -0,0 +1,126 @@
+import fs from 'fs';
+import path from 'path';
+import glob from 'fast-glob';
+import merge from 'putil-merge';
+import yaml from 'js-yaml';
+import { Package } from './package.mjs';
+import { getPackageJson } from './../utils.mjs';
+export class Repository extends Package {
+    constructor(dirname, config, packages) {
+        super(dirname);
+        this.dirname = dirname;
+        this.config = config;
+        this.packages = packages;
+    }
+    getPackages(options) {
+        const result = [...this.packages];
+        if (options?.toposort)
+            topoSortPackages(result);
+        return result;
+    }
+    getPackage(name) {
+        return this.packages.find(p => p.name === name);
+    }
+    _updateDependencies() {
+        const deps = {};
+        for (const pkg of this.packages) {
+            const o = {
+                ...pkg.json.dependencies,
+                ...pkg.json.devDependencies,
+                ...pkg.json.peerDependencies,
+                ...pkg.json.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);
+        }
+    }
+    static create(root, options) {
+        let dirname = root || process.cwd();
+        let deep = options?.deep ?? 10;
+        while (deep-- >= 0 && fs.existsSync(dirname)) {
+            const f = path.join(dirname, 'package.json');
+            if (fs.existsSync(f)) {
+                const pkgJson = JSON.parse(fs.readFileSync(f, 'utf-8'));
+                if (Array.isArray(pkgJson.workspaces)) {
+                    const packages = this._resolvePackages(dirname, pkgJson.workspaces);
+                    const config = this._readConfig(dirname);
+                    const repo = new Repository(dirname, config, packages);
+                    repo._updateDependencies();
+                    return repo;
+                }
+            }
+            dirname = path.resolve(dirname, '..');
+        }
+        throw new Error('No monorepo project detected');
+    }
+    static _resolvePackages(dirname, patterns) {
+        const packages = [];
+        for (const pattern of patterns) {
+            const dirs = glob.sync(pattern, {
+                cwd: dirname,
+                absolute: true,
+                deep: 0,
+                onlyDirectories: true
+            });
+            for (const dir of dirs) {
+                const f = path.join(dir, 'package.json');
+                if (fs.existsSync(f))
+                    packages.push(new Package(dir));
+            }
+        }
+        return packages;
+    }
+    static _readConfig(dirname) {
+        const result = {};
+        const pkgJson = getPackageJson(dirname);
+        if (pkgJson && typeof pkgJson.rman === 'object')
+            merge(result, pkgJson.rman, { deep: true });
+        let filename = path.resolve(dirname, '.rman.yml');
+        if (fs.existsSync(filename)) {
+            const obj = yaml.load(fs.readFileSync(filename, 'utf-8'));
+            if (obj && typeof obj === 'object')
+                merge(result, obj, { deep: true });
+        }
+        filename = path.resolve(dirname, '.rmanrc');
+        if (fs.existsSync(filename)) {
+            const obj = JSON.parse(fs.readFileSync(filename, 'utf-8'));
+            if (obj && typeof obj === 'object')
+                merge(result, obj, { deep: true });
+        }
+        return result;
+    }
+}
+function topoSortPackages(packages) {
+    packages.sort((a, b) => {
+        if (b.dependencies.includes(a.name))
+            return -1;
+        if (a.dependencies.includes(b.name))
+            return 1;
+        return 0;
+    });
+}

package/esm/core/types.d.ts

@@ -0,0 +1,14 @@
+export interface IWorkspaceProvider {
+    parse: (root: string) => IWorkspaceInfo | undefined;
+}
+export interface IWorkspaceInfo {
+    dirname: string;
+    pkgJson: any;
+    packages: string[];
+}
+export interface Logger {
+    info: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+    log: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+}

package/esm/core/types.mjs

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

package/esm/debug.d.ts

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

package/esm/debug.mjs

@@ -0,0 +1,3 @@
+import { runCli } from './cli.mjs';
+runCli({ cwd: '/Users/ehanoglu/Yazilim/js/sqb' })
+    .catch(() => 0);

package/esm/index.d.ts

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

package/esm/index.mjs

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

package/esm/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DOTS: string[];
+export declare const isTTY: boolean;

package/esm/utils/constants.mjs

@@ -0,0 +1,2 @@
+export const DOTS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export const isTTY = process.stdout.isTTY && process.env.TERM !== 'dumb';

package/{dist/workspace/executor.d.ts → esm/utils/exec.d.ts}

@@ -6,18 +6,15 @@ export interface IExecutorOptions {
     argv?: string[];
     env?: Record<string, string | undefined>;
     shell?: boolean;
-    color?: boolean;
     onSpawn?: (childProcess: ChildProcess) => void;
     onLine?: (line: string, stdio: 'stderr' | 'stdout') => void;
     onData?: (data: string, stdio: 'stderr' | 'stdout') => void;
-}
-export interface IRunScriptOptions {
-    gauge?: boolean;
+    throwOnError?: boolean;
 }
 export interface ExecuteCommandResult {
     code?: number;
-    error?: any;
-    stderr: string;
-    stdout: string;
+    error?: Error;
+    stderr?: string;
+    stdout?: string;
 }
-export declare function executeCommand(command: string, options?: IExecutorOptions): Promise<ExecuteCommandResult>;
+export declare function exec(command: string, options?: IExecutorOptions): Promise<ExecuteCommandResult>;

package/esm/utils/exec.mjs

@@ -0,0 +1,108 @@
+import { spawn } from 'child_process';
+import onExit from 'signal-exit';
+import { npmRunPathEnv } from './npm-run-path.mjs';
+const runningChildren = new Map();
+export async function exec(command, options) {
+    const opts = {
+        shell: true,
+        throwOnError: true,
+        ...options,
+    };
+    opts.env = {
+        ...npmRunPathEnv({ cwd: opts.cwd }),
+        ...opts.env
+    };
+    opts.cwd = opts.cwd || process.cwd();
+    const spawnOptions = {
+        stdio: opts.stdio || 'pipe',
+        env: opts.env,
+        cwd: opts.cwd,
+        shell: opts.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, reject) => {
+        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;
+            if (!err) {
+                const text = `Command failed (${result.code})`;
+                err = new Error(text);
+            }
+            if (typeof err === 'string')
+                err = new Error(err);
+            result.error = err;
+            resolved = true;
+            if (opts.throwOnError)
+                return reject(result.error);
+            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(text);
+            }
+            return resolve(result);
+        });
+    });
+}
+onExit(() => {
+    runningChildren.forEach((child) => {
+        child.kill();
+    });
+});

package/esm/utils/git-utils.d.ts

@@ -0,0 +1,25 @@
+export declare namespace GitHelper {
+    interface FileStatus {
+        filename: string;
+        status: string;
+    }
+}
+export interface GitOptions {
+    cwd?: string;
+}
+export declare class GitHelper {
+    cwd: string;
+    constructor(options?: GitOptions);
+    listDirtyFileStatus(options?: {
+        absolute?: boolean;
+    }): Promise<GitHelper.FileStatus[]>;
+    listDirtyFiles(options?: {
+        absolute?: boolean;
+    }): Promise<string[]>;
+    listCommitSha(): Promise<string[]>;
+    listCommittedFiles(options?: {
+        absolute?: boolean;
+        commits?: string | string[];
+    }): Promise<string[]>;
+    readFileLastPublished(filePath: string, commitSha?: string): Promise<string>;
+}

package/esm/utils/git-utils.mjs

@@ -0,0 +1,63 @@
+import { exec } from './exec.mjs';
+import path from 'path';
+export class GitHelper {
+    constructor(options) {
+        this.cwd = options?.cwd || process.cwd();
+    }
+    async listDirtyFileStatus(options) {
+        const x = await exec('git', {
+            cwd: this.cwd,
+            argv: ['status', '--porcelain']
+        });
+        const result = [];
+        const files = x.stdout ? x.stdout.trim().split(/\s*\n\s*/) : [];
+        for (const f of files) {
+            const m = f.match(/^(\w+) (.+)$/);
+            if (m) {
+                result.push({
+                    filename: options?.absolute ? path.join(this.cwd, m[2]) : m[2],
+                    status: m[1]
+                });
+            }
+        }
+        return result;
+    }
+    async listDirtyFiles(options) {
+        return (await this.listDirtyFileStatus(options)).map(x => x.filename);
+    }
+    async listCommitSha() {
+        const x = await exec('git', {
+            cwd: this.cwd,
+            argv: ['cherry']
+        });
+        const matches = x.stdout ? x.stdout.matchAll(/([a-f0-9]+)/gi) : [];
+        const result = [];
+        for (const m of matches) {
+            result.push(m[1]);
+        }
+        return result;
+    }
+    async listCommittedFiles(options) {
+        const shaArr = options?.commits
+            ? (Array.isArray(options?.commits) ? options?.commits : [options?.commits])
+            : await this.listCommitSha();
+        let result = [];
+        for (const s of shaArr) {
+            const x = await exec('git', {
+                cwd: this.cwd,
+                argv: ['show', s, '--name-only', '--pretty="format:"']
+            });
+            result.push(...(x.stdout ? x.stdout.trim().split(/\s*\n\s*/) : []));
+        }
+        if (options?.absolute)
+            result = result.map(f => path.join(this.cwd, f));
+        return result;
+    }
+    async readFileLastPublished(filePath, commitSha) {
+        const x = await exec('git', {
+            cwd: this.cwd,
+            argv: ['show', (commitSha || 'HEAD') + ':"' + filePath + '"']
+        });
+        return x.stdout || '';
+    }
+}