@bitblit/ratchet-node-only 4.0.80-alpha

package/dist/es/ci/apply-ci-env-variables-to-files.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import { ErrorRatchet, Logger, RequireRatchet, StringRatchet } from '@bitblit/ratchet-common';
+import { CiRunInformationUtil } from './ci-run-information-util';
+export class ApplyCiEnvVariablesToFiles {
+    static async process(fileNames, cfg, buildFinder = 'LOCAL-SNAPSHOT', branchFinder = 'LOCAL-BRANCH', hashFinder = 'LOCAL-HASH', tagFinder = 'LOCAL-TAG', timeFinder = 'LOCAL-TIME') {
+        RequireRatchet.notNullOrUndefined(cfg, 'cfg');
+        RequireRatchet.notNullOrUndefined(cfg.buildNumber, 'cfg.buildNumber');
+        RequireRatchet.notNullOrUndefined(cfg.localTime, 'cfg.localTime');
+        if (!fileNames) {
+            throw new Error('fileNames must be defined');
+        }
+        if (fileNames.length === 0) {
+            Logger.warn('Warning - no files supplied to process');
+        }
+        if (!cfg.buildNumber) {
+            ErrorRatchet.throwFormattedErr('%s env var not set - apparently not in a CI environment', cfg.buildNumber);
+        }
+        Logger.info('Processing files %j with run info %j', cfg);
+        let foundCount = 0;
+        fileNames.forEach((f) => {
+            if (!fs.existsSync(f)) {
+                Logger.error('Could not find file %s to process, continuing', f);
+            }
+            else {
+                try {
+                    let contents = fs.readFileSync(f).toString();
+                    contents = contents.split(buildFinder).join(cfg.buildNumber);
+                    contents = contents.split(branchFinder).join(cfg.branch || '');
+                    contents = contents.split(hashFinder).join(cfg.commitHash || '');
+                    contents = contents.split(tagFinder).join(cfg.tag || '');
+                    contents = contents.split(timeFinder).join(cfg.localTime || '');
+                    fs.writeFileSync(f, contents);
+                    foundCount++;
+                }
+                catch (err) {
+                    Logger.error('Error processing %s , continuing: %s', f, err, err);
+                }
+            }
+        });
+        return foundCount;
+    }
+    static extractFileNames() {
+        let rval = [];
+        if (process && process.argv && process.argv.length > 3) {
+            rval = process.argv.slice(3);
+        }
+        return rval;
+    }
+    static extractVariableConfig(inName) {
+        let rval = null;
+        const name = StringRatchet.trimToEmpty(inName).toLowerCase();
+        switch (name) {
+            case 'circleci':
+                rval = CiRunInformationUtil.createDefaultCircleCiRunInformation();
+                break;
+            case 'github':
+                rval = CiRunInformationUtil.createDefaultGithubActionsRunInformation();
+                break;
+            case 'test':
+                rval = CiRunInformationUtil.createTestingCiRunInformation();
+                break;
+            default:
+                ErrorRatchet.throwFormattedErr('Unrecognized env var config type : %s', name);
+        }
+        Logger.info('Using variable config : %j', rval);
+        return rval;
+    }
+    static async runFromCliArgs(args) {
+        if (args.length > 1) {
+            return ApplyCiEnvVariablesToFiles.process(args.slice(1), ApplyCiEnvVariablesToFiles.extractVariableConfig(args[0]));
+        }
+        else {
+            Logger.infoP('Usage : apply-ci-env-variables-to-files {file1} {file2} ...');
+            return -1;
+        }
+    }
+}

package/dist/es/ci/ci-run-information-util.js

@@ -0,0 +1,43 @@
+import { DateTime } from 'luxon';
+import { GlobalRatchet } from '@bitblit/ratchet-common';
+export class CiRunInformationUtil {
+    static createTestingCiRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE) {
+        const now = new Date().toISOString();
+        const rval = {
+            buildNumber: 'Test_buildNumberVar_' + now,
+            localTime: DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+            branch: 'Test_branchVar_' + now,
+            tag: 'Test_tagVar_' + now,
+            commitHash: 'Test_hashVar_' + now,
+            userName: 'Test_userNameVar_' + now,
+            projectName: 'Test_projectNameVar_' + now,
+        };
+        return rval;
+    }
+    static createDefaultCircleCiRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE) {
+        const rval = {
+            buildNumber: GlobalRatchet.fetchGlobalVar('CIRCLE_BUILD_NUM'),
+            branch: GlobalRatchet.fetchGlobalVar('CIRCLE_BRANCH'),
+            tag: GlobalRatchet.fetchGlobalVar('CIRCLE_TAG'),
+            commitHash: GlobalRatchet.fetchGlobalVar('CIRCLE_SHA1'),
+            localTime: DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+            userName: GlobalRatchet.fetchGlobalVar('CIRCLE_USERNAME'),
+            projectName: GlobalRatchet.fetchGlobalVar('CIRCLE_PROJECT_REPONAME'),
+        };
+        return rval;
+    }
+    static createDefaultGithubActionsRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE) {
+        const rval = {
+            buildNumber: GlobalRatchet.fetchGlobalVar('GITHUB_RUN_NUMBER'),
+            branch: GlobalRatchet.fetchGlobalVar('GITHUB_REF_NAME'),
+            tag: GlobalRatchet.fetchGlobalVar('GITHUB_REF_NAME'),
+            commitHash: GlobalRatchet.fetchGlobalVar('GITHUB_SHA'),
+            localTime: DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+            userName: GlobalRatchet.fetchGlobalVar('GITHUB_ACTOR'),
+            projectName: GlobalRatchet.fetchGlobalVar('GITHUB_REPOSITORY'),
+        };
+        return rval;
+    }
+}
+CiRunInformationUtil.DEFAULT_TIME_FORMAT = 'yyyy-MM-dd HH:mm:ss a z';
+CiRunInformationUtil.DEFAULT_TIME_ZONE = 'America/Los_Angeles';

package/dist/es/ci/ci-run-information.js

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

package/dist/es/cli/abstract-ratchet-cli-handler.js

@@ -0,0 +1,28 @@
+import { CliRatchet } from './cli-ratchet';
+export class AbstractRatchetCliHandler {
+    async findAndExecuteHandler() {
+        let handler = null;
+        if (CliRatchet.argsAfterCommand(['version'])) {
+            console.log('Version : ' + JSON.stringify(this.fetchVersionInfo()));
+        }
+        else {
+            const handlerMap = this.fetchHandlerMap();
+            const keys = Object.keys(handlerMap);
+            let remainArgs = null;
+            for (let i = 0; i < keys.length && !handler; i++) {
+                remainArgs = CliRatchet.argsAfterCommand([keys[i], keys[i] + '.js']);
+                if (remainArgs) {
+                    handler = handlerMap[keys[i]];
+                }
+            }
+            if (handler) {
+                console.debug('Running command with args ' + JSON.stringify(remainArgs));
+                await handler(remainArgs);
+            }
+            else {
+                console.log('Unrecognized command : ', process.argv);
+                console.log('Valid commands are : ', Object.keys(handlerMap));
+            }
+        }
+    }
+}

package/dist/es/cli/cli-ratchet.js

@@ -0,0 +1,28 @@
+export class CliRatchet {
+    static isCalledFromCLI(filenames) {
+        let rval = false;
+        for (let i = 0; filenames && i < filenames.length && !rval; i++) {
+            rval = CliRatchet.indexOfCommandArgument(filenames[i]) > -1;
+        }
+        return rval;
+    }
+    static argsAfterCommand(filenames) {
+        let rval = null;
+        if (process?.argv?.length && filenames?.length) {
+            let idx = null;
+            for (let i = 0; i < filenames.length && idx === null; i++) {
+                idx = CliRatchet.indexOfCommandArgument(filenames[i]);
+            }
+            rval = idx !== null ? process.argv.slice(idx + 1, process.argv.length) : null;
+        }
+        return rval;
+    }
+    static isCalledFromCLISingle(filename) {
+        return CliRatchet.isCalledFromCLI([filename]);
+    }
+    static indexOfCommandArgument(filename) {
+        const contFileName = process.argv.map((arg) => arg.indexOf(filename) !== -1);
+        const idx = contFileName.indexOf(true);
+        return idx === -1 ? null : idx;
+    }
+}

package/dist/es/cli/ratchet-cli-handler.js

@@ -0,0 +1,17 @@
+import { RatchetNodeOnlyInfo } from '../build/ratchet-node-only-info';
+import { ApplyCiEnvVariablesToFiles } from '../ci/apply-ci-env-variables-to-files';
+import { FilesToStaticClass } from '../files/files-to-static-class';
+import { PublishCiReleaseToSlack } from '../third-party/slack/publish-ci-release-to-slack';
+import { AbstractRatchetCliHandler } from './abstract-ratchet-cli-handler';
+export class RatchetCliHandler extends AbstractRatchetCliHandler {
+    fetchHandlerMap() {
+        return {
+            'apply-ci-env-variables-to-files': ApplyCiEnvVariablesToFiles.runFromCliArgs,
+            'files-to-static-class': FilesToStaticClass.runFromCliArgs,
+            'publish-ci-release-to-slack': PublishCiReleaseToSlack.runFromCliArgs,
+        };
+    }
+    fetchVersionInfo() {
+        return RatchetNodeOnlyInfo.buildInformation();
+    }
+}

package/dist/es/csv/csv-ratchet.js

@@ -0,0 +1,158 @@
+import fs from 'fs';
+import { parse } from 'csv-parse';
+import { Logger } from '@bitblit/ratchet-common';
+import { stringify } from 'csv-stringify';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { MapRatchet } from '@bitblit/ratchet-common';
+import { Readable } from 'stream';
+export class CsvRatchet {
+    static defaultParseOptions() {
+        const rval = {
+            delimiter: ',',
+            columns: true,
+        };
+        return rval;
+    }
+    static defaultStringifyOptions() {
+        const rval = {
+            header: true,
+        };
+        return rval;
+    }
+    static async stringParse(input, pf, opts = CsvRatchet.defaultParseOptions()) {
+        return CsvRatchet.streamParse(Readable.from(input), pf, opts);
+    }
+    static async streamParse(readStream, pf, opts = CsvRatchet.defaultParseOptions()) {
+        return new Promise((res, rej) => {
+            const rval = [];
+            const p = parse(opts);
+            p.on('readable', () => {
+                let record = p.read();
+                while (record) {
+                    const newVal = pf(record);
+                    if (newVal) {
+                        rval.push(newVal);
+                    }
+                    else {
+                    }
+                    record = p.read();
+                }
+            });
+            p.on('error', (err) => {
+                rej(err);
+            });
+            p.on('end', () => {
+                res(rval);
+            });
+            readStream.pipe(p);
+        });
+    }
+    static async fileParse(filename, pf) {
+        const readStream = fs.createReadStream(filename);
+        return CsvRatchet.streamParse(readStream, pf);
+    }
+    static async generateCsvData(objectsToConvert, opts = CsvRatchet.defaultStringifyOptions()) {
+        Logger.silly('Converting %d items into csv file', objectsToConvert.length);
+        const genProm = new Promise((res, rej) => {
+            stringify(objectsToConvert, opts, function (err, data) {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res(data);
+                }
+            });
+        });
+        return genProm;
+    }
+    static async generateComparison(file1, file2, keyField) {
+        RequireRatchet.notNullOrUndefined(file1, 'file1');
+        RequireRatchet.notNullOrUndefined(file2, 'file2');
+        RequireRatchet.notNullOrUndefined(keyField, 'keyField');
+        Logger.info('Created csv compare with files %s and %s keyed on %s', file1, file2, keyField);
+        let file1Parsed = await this.streamParse(fs.createReadStream(file1), (f) => {
+            f;
+        });
+        file1Parsed = file1Parsed.map((m) => {
+            const next = {};
+            Object.keys(m).forEach((k) => {
+                next[k.trim()] = m[k];
+            });
+            return next;
+        });
+        const file1Mapped = MapRatchet.mapByUniqueProperty(file1Parsed, keyField);
+        let file2Parsed = await this.streamParse(fs.createReadStream(file2), (f) => {
+            f;
+        });
+        file2Parsed = file2Parsed.map((m) => {
+            const next = {};
+            Object.keys(m).forEach((k) => {
+                next[k.trim()] = m[k];
+            });
+            return next;
+        });
+        const file2Mapped = MapRatchet.mapByUniqueProperty(file2Parsed, keyField);
+        const f1Only = [];
+        const f2Only = [];
+        const both = [];
+        Array.from(file1Mapped.keys()).forEach((f1k) => {
+            if (file2Mapped.has(f1k)) {
+                both.push(f1k);
+            }
+            else {
+                f1Only.push(f1k);
+            }
+        });
+        Array.from(file2Mapped.keys()).forEach((f1k) => {
+            if (!file1Mapped.has(f1k)) {
+                f2Only.push(f1k);
+            }
+        });
+        const rval = {
+            file1Data: file1Mapped,
+            file2Data: file2Mapped,
+            file1OnlyKeys: f1Only,
+            file2OnlyKeys: f2Only,
+            bothFilesKeys: both,
+        };
+        return rval;
+    }
+    static async streamObjectsToCsv(srcSubject, output, inOpts) {
+        RequireRatchet.notNullOrUndefined(srcSubject, 'srcSubject');
+        RequireRatchet.notNullOrUndefined(output, 'output');
+        const opts = inOpts || CsvRatchet.defaultStringifyOptions();
+        Logger.silly('Running pipe to csv output : %j', opts);
+        let count = 0;
+        const genProm = new Promise((res, rej) => {
+            const stringifier = stringify(opts);
+            stringifier.on('error', (err) => {
+                if (sub) {
+                    sub.unsubscribe();
+                }
+                rej(err);
+            });
+            stringifier.on('finish', () => {
+                if (sub) {
+                    sub.unsubscribe();
+                }
+                res(count);
+            });
+            stringifier.pipe(output);
+            const sub = srcSubject.subscribe((next) => {
+                Logger.debug('Adding %j to csv', next);
+                count++;
+                stringifier.write(next);
+            }, (err) => {
+                Logger.error('Error generating : %s', err);
+                rej(err);
+            }, () => {
+                Logger.debug('Finished');
+                stringifier.end();
+            });
+        });
+        return genProm;
+    }
+    static defaultParseFunction(row) {
+        return row;
+    }
+}

package/dist/es/files/files-to-static-class.js

@@ -0,0 +1,56 @@
+import { Logger } from '@bitblit/ratchet-common';
+import fs from 'fs';
+import { CliRatchet } from '../cli/cli-ratchet';
+export class FilesToStaticClass {
+    static async process(fileNames, outClassName, outFileName = null) {
+        if (!fileNames) {
+            throw new Error('fileNames must be defined');
+        }
+        if (!outClassName) {
+            throw new Error('outClassName must be defined');
+        }
+        if (fileNames.length === 0) {
+            Logger.warn('Warning - no files supplied to process');
+        }
+        Logger.info('Generating class %s from files %j (output file: %s)', outClassName, fileNames, outFileName);
+        let rval = '/** \n';
+        rval += '* Holder for the constants to be used by consumers \n';
+        rval += '* Moves it into code so that it can survive a trip through WebPack \n';
+        rval += '*/ \n\n';
+        rval += 'export class ' + outClassName + ' { \n';
+        rval += '  public static readonly VALUES:Record<string, string> = { \n';
+        for (let i = 0; i < fileNames.length; i++) {
+            let contents = 'NOT-FOUND';
+            if (fs.existsSync(fileNames[i])) {
+                const trimmed = fileNames[i].substring(fileNames[i].lastIndexOf('/') + 1);
+                contents = fs.readFileSync(fileNames[i]).toString();
+                rval += i > 0 ? ',' : '';
+                rval += '"' + trimmed + '":' + JSON.stringify(contents) + '\n';
+            }
+            else {
+                Logger.warn('Could not find file %s', fileNames[i]);
+            }
+        }
+        rval += '}; \n';
+        rval += '}';
+        if (!!outFileName) {
+            Logger.info('Writing to %s', outFileName);
+            fs.writeFileSync(outFileName, rval);
+        }
+        return rval;
+    }
+    static async runFromCliArgs(args) {
+        if (args.length < 4) {
+            Logger.infoP('Usage: ratchet-files-to-static-class {outFileName} {outClassName} {file0} ... {fileN}');
+            return null;
+        }
+        else {
+            const idx = CliRatchet.indexOfCommandArgument('files-to-static-class');
+            const outFileName = process.argv[idx + 1];
+            const outClassName = process.argv[idx + 2];
+            const files = process.argv.slice(idx + 3);
+            Logger.info('Running FilesToStaticClass from command line arguments Target: %s TargetClass: %s InFiles: %j', outFileName, outClassName, files);
+            return FilesToStaticClass.process(files, outClassName, outFileName);
+        }
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,11 @@
+export * from './build/ratchet-node-only-info';
+export * from './ci/apply-ci-env-variables-to-files';
+export * from './ci/ci-run-information-util';
+export * from './ci/ci-run-information';
+export * from './cli/abstract-ratchet-cli-handler';
+export * from './cli/cli-ratchet';
+export * from './cli/ratchet-cli-handler';
+export * from './csv/csv-ratchet';
+export * from './files/files-to-static-class';
+export * from './third-party/git/git-ratchet';
+export * from './third-party/slack/publish-ci-release-to-slack';

package/dist/es/third-party/git/git-ratchet.js

@@ -0,0 +1,69 @@
+import process from 'child_process';
+import { Logger } from '@bitblit/ratchet-common';
+export class GitRatchet {
+    static async executeCommand(command, options) {
+        let dst = __dirname;
+        if (!!options && !!options.dst) {
+            dst = options.dst;
+        }
+        return new Promise((res, rej) => {
+            process.exec(command, { cwd: dst }, (err, stdout, stderr) => {
+                if (stdout === '') {
+                    rej('this does not look like a git repo');
+                }
+                if (!!stderr) {
+                    rej(stderr);
+                }
+                res(stdout);
+            });
+        });
+    }
+    static getCommandString(splitChar) {
+        return ('git log -1 --pretty=format:"' +
+            GitRatchet.PRETTY_FORMAT.join(splitChar) +
+            '"' +
+            ' && git rev-parse --abbrev-ref HEAD' +
+            ' && git tag --contains HEAD');
+    }
+    static async getLastCommitSwallowException(options = {}) {
+        let rval = null;
+        try {
+            rval = await this.getLastCommit(options);
+        }
+        catch (err) {
+            Logger.warn('Failed to fetch git data : %s', err, err);
+        }
+        return rval;
+    }
+    static async getLastCommit(options = {}) {
+        const command = GitRatchet.getCommandString(GitRatchet.SPLIT_CHARACTER);
+        const res = await GitRatchet.executeCommand(command, options);
+        const a = res.split(GitRatchet.SPLIT_CHARACTER);
+        const branchAndTags = a[a.length - 1].split('\n').filter((n) => n);
+        const branch = branchAndTags[0];
+        const tags = branchAndTags.slice(1);
+        const rval = {
+            shortHash: a[0],
+            hash: a[1],
+            subject: a[2],
+            sanitizedSubject: a[3],
+            body: a[4],
+            authoredOn: a[5],
+            committedOn: a[6],
+            author: {
+                name: a[7],
+                email: a[8],
+            },
+            committer: {
+                name: a[9],
+                email: a[10],
+            },
+            notes: a[11],
+            branch,
+            tags,
+        };
+        return rval;
+    }
+}
+GitRatchet.SPLIT_CHARACTER = '<##>';
+GitRatchet.PRETTY_FORMAT = ['%h', '%H', '%s', '%f', '%b', '%at', '%ct', '%an', '%ae', '%cn', '%ce', '%N', ''];

package/dist/es/third-party/slack/publish-ci-release-to-slack.js

@@ -0,0 +1,59 @@
+import { DateTime } from 'luxon';
+import { GlobalRatchet, Logger } from '@bitblit/ratchet-common';
+import fetch from 'cross-fetch';
+import util from 'util';
+import { GitRatchet } from '../git/git-ratchet';
+export class PublishCiReleaseToSlack {
+    static async process(slackHookUrl, timezone = 'America/Los_Angeles') {
+        if (!slackHookUrl) {
+            throw new Error('slackHookUrl must be defined');
+        }
+        const buildNum = GlobalRatchet.fetchGlobalVar('CIRCLE_BUILD_NUM');
+        const userName = GlobalRatchet.fetchGlobalVar('CIRCLE_USERNAME');
+        const projectName = GlobalRatchet.fetchGlobalVar('CIRCLE_PROJECT_REPONAME');
+        const branch = GlobalRatchet.fetchGlobalVar('CIRCLE_BRANCH') || '';
+        const tag = GlobalRatchet.fetchGlobalVar('CIRCLE_TAG') || '';
+        const sha1 = GlobalRatchet.fetchGlobalVar('CIRCLE_SHA1') || '';
+        const localTime = DateTime.local().setZone(timezone).toFormat('MMMM Do yyyy, h:mm:ss a z');
+        const gitData = await GitRatchet.getLastCommitSwallowException();
+        if (!buildNum || !userName || !projectName) {
+            throw new Error('CIRCLE_BUILD_NUM, CIRCLE_USERNAME, CIRCLE_PROJECT_REPONAME env vars not set - apparently not in a CircleCI environment');
+        }
+        Logger.info('Sending slack notification %j with build %s, branch %s, tag %s, sha %s, time: %s', buildNum, branch, tag, sha1, localTime);
+        let message = util.format('%s performed release %s on %s at %s', userName, tag + ' ' + branch, projectName, localTime);
+        if (!!gitData && !!gitData.subject) {
+            message += '\n\n' + gitData.subject;
+        }
+        const response = await fetch(slackHookUrl, {
+            method: 'POST',
+            mode: 'cors',
+            cache: 'no-cache',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            redirect: 'follow',
+            body: JSON.stringify({ text: message }),
+        });
+        const bodyOut = await response.text();
+        Logger.info('Slack returned : %s', bodyOut);
+        return bodyOut;
+    }
+    static extractHookUrl() {
+        let rval = null;
+        if (process && process.argv && process.argv.length > 2) {
+            rval = process.argv[2];
+        }
+        return rval;
+    }
+    static async runFromCliArgs(args) {
+        Logger.info('Running PublishCiReleaseToSlack from command line arguments');
+        const hook = PublishCiReleaseToSlack.extractHookUrl();
+        if (!!hook) {
+            return PublishCiReleaseToSlack.process(hook);
+        }
+        else {
+            Logger.infoP('Usage : ratchet-publish-circle-ci-release-to-slack {hookUrl} ...');
+            return null;
+        }
+    }
+}