@adinsure-ops/ops-cli 4.0.0-rc10

package/lib/commands/translate.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const JSZip = require("jszip");
+const path = require("path");
+const request = require("request-promise");
+const command_base_1 = require("../command.base");
+class Translate extends command_base_1.default {
+    getFormat(format) {
+        if (format === 'json') {
+            return 'text/json';
+        }
+        if (format === 'xml') {
+            return 'text/xml';
+        }
+        return this.error(`Format ${format} not supported.`);
+    }
+    /**
+     * Gets resources, checks a response and returns a response stream.
+     * @param languages list of translations to download
+     * @param format format of translations
+     * @param modules list of modules to download
+     * @returns arhive as an byte array response stream
+     */
+    async getTranslations(languages, format, modules) {
+        let requestOptions = {
+            uri: `https://dictionary.adinsure.com/api/Translations?languages=${languages}`,
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken(),
+                'Content-Type': this.getFormat(format),
+            },
+            encoding: null
+        };
+        if (modules) {
+            requestOptions.uri += `&modules=${modules}`;
+        }
+        try {
+            let response = await request.get(requestOptions);
+            return response;
+        }
+        catch (error) {
+            const errorJson = JSON.parse(error.error);
+            const errorMessage = `An error has occurred: ${errorJson.ExceptionMessage}`;
+            this.log(chalk_1.default.red(errorMessage));
+            throw errorJson;
+        }
+    }
+    /**
+     * Read from response stream and extract files into output directory.
+     * @param content zip file or a stream
+     * @param dest final destination to extract files
+     * @returns void
+     * @throws error message
+     */
+    async extractFiles(content, destinationDir, xmlFilename = '') {
+        const zip = await JSZip.loadAsync(content);
+        for (const fileName of Object.keys(zip.files)) {
+            const buffer = await zip.files[fileName].async('nodebuffer');
+            //  Rename from translations..Xml to Translations..xml to respect naming in mono
+            if (fileName.includes('Xml')) {
+                let finalFileName = fileName;
+                if (xmlFilename !== '') {
+                    finalFileName = xmlFilename;
+                }
+                const dest = destinationDir + '/' + finalFileName;
+                await fs.writeFile(dest, buffer);
+            }
+            else {
+                const dest = destinationDir + '/' + zip.files[fileName].name;
+                await fs.writeFile(dest, buffer);
+            }
+        }
+    }
+    async run() {
+        const { args, flags } = this.parse(Translate);
+        let destination = flags.output;
+        if (flags.format === 'json' && flags.module === undefined) {
+            this.error('You need to specify `\'module\' when choosing client `\'json\' format.');
+        }
+        try {
+            // Get translations
+            cli_ux_1.default.action.start('Fetching translations from AdDictionary', undefined, { stdout: true });
+            let response = await this.getTranslations(args.language, flags.format, flags.module);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            if (!await fs.pathExists(destination)) {
+                await fs.mkdirp(destination);
+            }
+            // Extract files
+            cli_ux_1.default.action.start('Extracting translation zip files', undefined, { stdout: true });
+            let finalFileName = 'Translations..xml';
+            if (flags.filename) {
+                finalFileName = flags.filename;
+            }
+            // set finalFileName to empty string to indicate filename needs to be taken from server response
+            if (flags.respectServerFilename) {
+                finalFileName = '';
+            }
+            await this.extractFiles(response, destination, finalFileName);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        catch (error) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('error')}`);
+            this.error(error.message);
+        }
+        this.log(`Translations extracted into ${chalk_1.default.cyan(path.resolve(destination))}`);
+        this.log(`${chalk_1.default.green('Done.')}`);
+    }
+}
+exports.default = Translate;
+Translate.description = 'downloads translate from AdDictionary service';
+Translate.usage = 'translate <language> [flags]';
+Translate.examples = [
+    `$ ops translate "en-US=en-US;ru-Ru=ru-RU" -f json -m "Client business accounting;Client business base;"`,
+    `$ ops translate "en-US=en-US;ru-Ru=ru-RU" -f xml -o translationDestination`
+];
+Translate.args = [
+    {
+        name: 'language',
+        required: true,
+        description: 'language id you want to download. Values must be semi-colon (;) separated.'
+    }
+];
+Translate.flags = {
+    format: command_1.flags.string({
+        char: 'f',
+        description: 'translations format [xml - server translations, json - client translations]',
+        options: ['json', 'xml'],
+        required: true
+    }),
+    module: command_1.flags.string({
+        char: 'm',
+        description: 'module name you want to download. Values must be semi-colon (;) separated.'
+    }),
+    output: command_1.flags.string({
+        char: 'o',
+        default: '.',
+        description: 'absolute or relative destination path to a folder where translations are extracted.'
+    }),
+    filename: command_1.flags.string({
+        description: 'specify filename of output (XML only).'
+    }),
+    respectServerFilename: command_1.flags.boolean({
+        default: false,
+        description: 'respect filename that is returned from AdDictionary server (XML only).'
+    })
+};

package/lib/commands/version.d.ts

@@ -0,0 +1,48 @@
+import { flags } from '@oclif/command';
+import * as semver from 'semver';
+import CommandBase from '../command.base';
+declare type ReleaseType = semver.ReleaseType | 'new';
+export default class Version extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        options: string[];
+    }[];
+    static flags: {
+        independent: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        version: flags.IOptionFlag<string | undefined>;
+        'script-prefix': flags.IOptionFlag<string>;
+        'no-deps': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'no-script': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'only-npm-packages': flags.IOptionFlag<string>;
+        'exclude-dir': flags.IOptionFlag<string[]>;
+    };
+    /**
+     * Update NPM packages with wsrun
+     */
+    bumpNpm(type: ReleaseType, version: string, filter: string, excludeDirs: string[]): Promise<string[]>;
+    /**
+     * Validate args and flags
+     */
+    validateOptions(args: any, flags: any): boolean;
+    /**
+     * Update dependencies in package.json files for @adinsure packages
+     */
+    updateDependencies(version: string, updatedPackages: Array<string>): Promise<void>;
+    insertScriptRequest(token: string, version: string, prefix: string): Promise<string>;
+    insertScript(token: string, version: string, prefix: string, skip?: boolean): Promise<void>;
+    /**
+     * Check if version has valid prerelease as 'rc' or '201910' (year month)
+     */
+    checkPrerelease(version: string, month: string): boolean;
+    /**
+     * Write new version in VERSION file
+     */
+    setVersion(version: string): Promise<void>;
+    run(): Promise<undefined>;
+}
+export {};

package/lib/commands/version.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const globby = require("globby");
+const moment = require("moment");
+const path = require("path");
+const request = require("request-promise");
+const semver = require("semver");
+const replaceInFile = require('replace-in-file');
+const command_base_1 = require("../command.base");
+class Version extends command_base_1.default {
+    /**
+     * Update NPM packages with wsrun
+     */
+    async bumpNpm(type, version, filter, excludeDirs) {
+        const currentPrereleaseDate = moment().format('YYYYMM');
+        let bumpedPackageName = [];
+        // Find all package.json files that are not in node modules
+        let searchPattern = ['**/package.json', '!**/node_modules'];
+        if (excludeDirs) {
+            for (const exclude of excludeDirs) {
+                searchPattern.push(`!${exclude}`);
+            }
+        }
+        const paths = await globby(searchPattern);
+        for (const path of paths) {
+            try {
+                // Read the data from it
+                let data = await fs.readJSON(path);
+                // Check if version exists
+                if (!data.version || !data.name) {
+                    continue;
+                }
+                let regexp = new RegExp(filter);
+                if (!regexp.test(data.name)) {
+                    continue;
+                }
+                // Increment the package version depending on the increment type
+                if (type === 'new') {
+                    data.version = version;
+                }
+                else if (type === 'prerelease' && this.checkPrerelease(data.version, currentPrereleaseDate)) {
+                    data.version = semver.inc(data.version, type, true);
+                }
+                else {
+                    data.version = semver.inc(data.version, type, false, currentPrereleaseDate);
+                }
+                bumpedPackageName.push(data.name);
+                // Save file
+                await fs.writeJSON(path, data, { spaces: 4, EOL: '\r\n' });
+            }
+            catch (err) {
+                if (err instanceof SyntaxError) {
+                    this.warn(`Error reading package.json: ${chalk_1.default.yellow(err.message)}. Consider using '--exclude-dir'.`);
+                }
+                else {
+                    return this.error(`Unknown error: ${chalk_1.default.red(err)}`);
+                }
+            }
+        }
+        return bumpedPackageName;
+    }
+    /**
+     * Validate args and flags
+     */
+    validateOptions(args, flags) {
+        if (args.type !== 'new' && flags.version) {
+            this.error(`${chalk_1.default.red('Version flag can only be used with new type')}`);
+            return false;
+        }
+        else if (args.type === 'new' && !flags.version) {
+            this.error(`${chalk_1.default.red('Version flag is required with new type')}`);
+            return false;
+        }
+        else if (args.type === 'new' && flags.increment) {
+            this.error(`${chalk_1.default.red('Increment flag not supported with new type')}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Update dependencies in package.json files for @adinsure packages
+     */
+    async updateDependencies(version, updatedPackages) {
+        // Find all package.json files that are not in node modules
+        const paths = await globby(['**/package.json', '!**/node_modules']);
+        for (const path of paths) {
+            for (const packageName of updatedPackages) {
+                let re = new RegExp('"' + packageName + '": "\\d+\\.\\d+\\..*"', 'g');
+                await replaceInFile({
+                    files: path,
+                    from: re,
+                    to: `"${packageName}": "${version}"`
+                });
+            }
+        }
+    }
+    async insertScriptRequest(token, version, prefix) {
+        let options = {
+            uri: `https://ops.adinsure.com/api/script`,
+            headers: {
+                Authorization: 'Bearer ' + token
+            },
+            body: {
+                version,
+                prefix
+            },
+            json: true
+        };
+        return request.post(options);
+    }
+    async insertScript(token, version, prefix, skip = false) {
+        cli_ux_1.default.action.start('Inserting new script version', undefined, { stdout: true });
+        if (skip) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.blue('skip')}`);
+        }
+        else if (token) {
+            try {
+                await this.insertScriptRequest(token, version, prefix);
+            }
+            catch (err) {
+                switch (err.statusCode) {
+                    case 401: {
+                        this.error(`${chalk_1.default.red('You don\'t have permissions. If this was intentional command, please contact Operations for permissions, do git reset and rerun command.')}`);
+                        break;
+                    }
+                    default: {
+                        this.error(`${chalk_1.default.red(err)}`);
+                    }
+                }
+            }
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        else {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('error')}`);
+        }
+    }
+    /**
+     * Check if version has valid prerelease as 'rc' or '201910' (year month)
+     */
+    checkPrerelease(version, month) {
+        const prereleaseVersion = semver.prerelease(version, true);
+        if (!prereleaseVersion)
+            return false;
+        if (prereleaseVersion[0].toString() === month)
+            return true;
+        if (prereleaseVersion[0].toString() === 'rc')
+            return true;
+        return false;
+    }
+    /**
+     * Write new version in VERSION file
+     */
+    async setVersion(version) {
+        const versionPath = path.resolve(await this.getGitRoot(), 'VERSION');
+        if (!await fs.pathExists(versionPath)) {
+            throw new Error('VERSION file not found. File will not be updated.');
+        }
+        return fs.writeFileSync(versionPath, version, 'utf-8');
+    }
+    async run() {
+        const { args, flags } = this.parse(Version);
+        const currentPrereleaseDate = moment().format('YYYYMM');
+        // Check if token is correct and save it for later use
+        let token = '';
+        if (!flags['no-script']) {
+            token = await this.security.getToken();
+        }
+        // exit if validation fails
+        if (!this.validateOptions(args, flags)) {
+            return;
+        }
+        let newVersion = null;
+        if (args.type === 'new' && flags.version) {
+            this.log(`Using 'new' command. VERSION file ignored.`);
+            newVersion = semver.valid(flags.version);
+        }
+        else {
+            // Get current version
+            const fullVersion = await this.getVersion();
+            this.log(`Current version is ${chalk_1.default.green(fullVersion)}`);
+            // Calculate new version
+            newVersion = semver.inc(fullVersion, args.type, true, currentPrereleaseDate);
+            // Force prerelease if prerelease is in same month and increment RC correctly
+            if (args.type === 'prerelease' && this.checkPrerelease(fullVersion, currentPrereleaseDate)) {
+                newVersion = semver.inc(fullVersion, args.type, true);
+            }
+            // Allow npm packages to be versioned seperately. Ultimately we want to force npm package to have same verion as VERSION file.
+            if (!flags.independent) {
+                args.type = 'new';
+            }
+        }
+        // Stop if version invalid
+        if (!newVersion) {
+            return this.error(`${chalk_1.default.red('Version in incorrect format')}`);
+        }
+        this.log(`Setting new version to ${chalk_1.default.green(newVersion)}`);
+        try {
+            await this.setVersion(newVersion);
+        }
+        catch (err) {
+            this.warn(`${chalk_1.default.yellow(err.message)}`);
+        }
+        cli_ux_1.default.action.start('Bumping NPM packages', undefined, { stdout: true });
+        let packages = await this.bumpNpm(args.type, newVersion, flags['only-npm-packages'], flags['exclude-dir']);
+        cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        cli_ux_1.default.action.start('Updating NPM dependencies in package.json files', undefined, { stdout: true });
+        if (flags['no-deps']) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.blue('skip')}`);
+        }
+        else {
+            await this.updateDependencies(newVersion, packages);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        await this.insertScript(token, newVersion, flags['script-prefix'], flags['no-script']);
+    }
+}
+exports.default = Version;
+Version.description = 'release new version';
+Version.usage = 'version <type> [flags]';
+Version.examples = [
+    `$ ops version patch`,
+    `$ ops version prerelease -i`,
+    `$ ops version new -v 3.4.3`
+];
+Version.args = [
+    {
+        name: 'type',
+        required: true,
+        description: 'Type of release',
+        options: ['patch', 'minor', 'major', 'prerelease', 'preminor', 'premajor', 'new']
+    },
+];
+Version.flags = {
+    independent: command_1.flags.boolean({
+        char: 'i',
+        description: 'increment npm packages independent of VERSION file',
+        default: false
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'force version'
+    }),
+    'script-prefix': command_1.flags.string({
+        description: 'prefix for db script version creation. (default: 7.10)',
+        default: '7.10'
+    }),
+    'no-deps': command_1.flags.boolean({
+        description: 'skip dependency update',
+        default: false
+    }),
+    'no-script': command_1.flags.boolean({
+        description: 'skip creation of script',
+        default: false
+    }),
+    'only-npm-packages': command_1.flags.string({
+        description: 'regular expression for which NPM packages to include',
+        default: '.*'
+    }),
+    'exclude-dir': command_1.flags.string({
+        description: 'exclude directories where to search for package.json',
+        multiple: true
+    })
+};

package/lib/config.d.ts

@@ -0,0 +1,7 @@
+export interface Config {
+    changelogs: {
+        file: string;
+        unreleasedFolder: string;
+    };
+}
+export declare const DefaultConfig: Config;

package/lib/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultConfig = void 0;
+exports.DefaultConfig = {
+    changelogs: {
+        file: 'CHANGELOG.md',
+        unreleasedFolder: 'changelogs/unreleased'
+    }
+};

package/lib/hooks/init/version-override.d.ts

@@ -0,0 +1,2 @@
+import { Hook } from '@oclif/config';
+export declare const versionOverride: Hook.Init;

package/lib/hooks/init/version-override.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionOverride = void 0;
+const version_1 = require("../../commands/version");
+exports.versionOverride = async function () {
+    if (process.argv[2] === 'version') {
+        try {
+            await version_1.default.run(process.argv.splice(3));
+        }
+        catch (err) {
+            this.error(err);
+        }
+        return process.exit(0);
+    }
+};

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/command';

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var command_1 = require("@oclif/command");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });

package/lib/lib/command.d.ts

@@ -0,0 +1,9 @@
+export default class ChildProcessCommand {
+    /**
+     * Only Windows supported at this point
+     */
+    runCommand(cmd: string[]): Promise<{
+        data: string;
+        error: string;
+    }>;
+}

package/lib/lib/command.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+class ChildProcessCommand {
+    /**
+     * Only Windows supported at this point
+     */
+    async runCommand(cmd) {
+        var e_1, _a, e_2, _b;
+        let sh;
+        let args;
+        let cp;
+        // cross platform compatibility
+        if (process.platform === 'win32') {
+            sh = 'cmd';
+            args = ['/c'].concat(cmd);
+        }
+        else {
+            [sh, ...args] = cmd;
+        }
+        try {
+            cp = child_process_1.spawn(sh, args, {
+                // cwd:
+                //     pkg.path,
+                env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: process.env.FORCE_COLOR || '1' } : {}),
+                stdio: 'pipe',
+                shell: true
+            });
+            let data = '';
+            try {
+                for (var _c = tslib_1.__asyncValues(cp.stdout), _d; _d = await _c.next(), !_d.done;) {
+                    const chunk = _d.value;
+                    data += chunk;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) await _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            let error = '';
+            try {
+                for (var _e = tslib_1.__asyncValues(cp.stderr), _f; _f = await _e.next(), !_f.done;) {
+                    const chunk = _f.value;
+                    error += chunk;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) await _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            const exitCode = await new Promise((resolve, _reject) => {
+                cp.on('close', resolve);
+            });
+            if (exitCode) {
+                throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            }
+            return { data, error };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+}
+exports.default = ChildProcessCommand;

package/lib/lib/npm.d.ts

@@ -0,0 +1,15 @@
+import { NpmPackage } from '../types/npm.types';
+export default class NpmContext {
+    /**
+     * Get all workspaces
+     */
+    getWorkspaces(): Promise<string[]>;
+    /**
+     * Get package names
+     */
+    packageList(packages: string[] | undefined, excludes: string[] | undefined, context: any): Promise<NpmPackage[]>;
+    /**
+     * Get package all packages
+     */
+    getAllNpmPackages(patToken?: string): Promise<string>;
+}