@adinsure-ops/ops-cli 4.8.3 → 5.0.0-rc4

package/lib/commands/version.js

@@ -1,145 +1,164 @@
-"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 {
+import { __awaiter } from "tslib";
+import { Flags, Args, ux } from '@oclif/core';
+import axios from 'axios';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { globby } from 'globby';
+import moment from 'moment';
+import path from 'path';
+import semver from 'semver';
+import replaceInFile from 'replace-in-file';
+import CommandBase from '../command.base.js';
+class Version extends CommandBase {
     /**
      * Update NPM packages with wsrun
+     * @param type Release type of NPM package
+     * @param version Version
+     * @param filter Regular Expression filter for packages
+     * @param excludeDirs Excluded directories
+     * @returns {Promise<void>} Void
      */
-    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);
+    bumpNpm(type, version, filter, excludeDirs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentPrereleaseDate = moment().format('YYYYMM');
+            const bumpedPackageName = [];
+            // Find all package.json files that are not in node modules
+            const searchPattern = ['**/package.json', '!**/node_modules'];
+            if (excludeDirs) {
+                for (const exclude of excludeDirs) {
+                    searchPattern.push(`!${exclude}`);
                 }
-                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'.`);
+            const paths = yield globby(searchPattern);
+            for (const path of paths) {
+                try {
+                    // Read the data from it
+                    const data = yield fs.readJSON(path);
+                    // Check if version exists
+                    if (!data.version || !data.name) {
+                        continue;
+                    }
+                    const 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
+                    yield fs.writeJSON(path, data, { spaces: 4, EOL: '\r\n' });
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 }
-                else {
-                    return this.error(`Unknown error: ${chalk_1.default.red(err)}`);
+                catch (error) {
+                    if (error instanceof SyntaxError) {
+                        this.warn(`Error reading package.json: ${chalk.yellow(error.message)}. Consider using '--exclude-dir'.`);
+                    }
+                    else {
+                        return this.error(`Unknown error: ${chalk.red(error)}`);
+                    }
                 }
             }
-        }
-        return bumpedPackageName;
+            return bumpedPackageName;
+        });
     }
     /**
      * Validate args and flags
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     validateOptions(args, flags) {
         if (args.type !== 'new' && flags.version) {
-            this.error(`${chalk_1.default.red('Version flag can only be used with new type')}`);
+            this.error(`${chalk.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')}`);
+        if (args.type === 'new' && !flags.version) {
+            this.error(`${chalk.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')}`);
+        if (args.type === 'new' && flags.increment) {
+            this.error(`${chalk.red('Increment flag not supported with new type')}`);
             return false;
         }
         return true;
     }
     /**
      * Update dependencies in package.json files for @adinsure packages
+     * @param version Version
+     * @param updatedPackages Array of updated packages
+     * @returns {void}
      */
-    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}"`
-                });
+    updateDependencies(version, updatedPackages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Find all package.json files that are not in node modules
+            const paths = yield globby(['**/package.json', '!**/node_modules']);
+            for (const path of paths) {
+                for (const packageName of updatedPackages) {
+                    const re = new RegExp('"' + packageName + '": "\\d+\\.\\d+\\..*"', 'g');
+                    yield 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);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    insertScriptRequest(token, version, prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return axios.post(`https://ops.adinsure.com/api/script`, {
+                headers: {
+                    Authorization: 'Bearer ' + token,
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    version,
+                    prefix,
+                },
+            });
+        });
     }
-    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);
+    insertScript(token, version, prefix, skip = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ux.action.start('Inserting new script version', undefined, { stdout: true });
+            if (skip) {
+                ux.action.stop(`${chalk.blue('skip')}`);
             }
-            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)}`);
+            else if (token) {
+                try {
+                    yield this.insertScriptRequest(token, version, prefix);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    switch (error.statusCode) {
+                        case 401: {
+                            this.error(`${chalk.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.red(error)}`);
+                        }
                     }
                 }
+                ux.action.stop(`${chalk.green('done')}`);
             }
-            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
-        }
-        else {
-            cli_ux_1.default.action.stop(`${chalk_1.default.red('error')}`);
-        }
+            else {
+                ux.action.stop(`${chalk.red('error')}`);
+            }
+        });
     }
     /**
      * Check if version has valid prerelease as 'rc' or '201910' (year month)
+     * @param version Version
+     * @param month Month of release
+     * @returns {boolean} True or false
      */
     checkPrerelease(version, month) {
         const prereleaseVersion = semver.prerelease(version, true);
@@ -153,115 +172,121 @@ class Version extends command_base_1.default {
     }
     /**
      * Write new version in VERSION file
+     * @param version The new version
+     * @returns {void}
      */
-    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');
+    setVersion(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const versionPath = path.resolve(yield this.getGitRoot(), 'VERSION');
+            if (!(yield fs.pathExists(versionPath))) {
+                throw new Error('VERSION file not found. File will not be updated.');
+            }
+            return fs.writeFileSync(versionPath, version, 'utf8');
+        });
     }
-    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);
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield 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 = yield this.security.getToken();
             }
-            // 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';
+            // exit if validation fails
+            if (!this.validateOptions(args, flags)) {
+                return;
             }
-        }
-        // 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']);
+            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 = yield this.getVersion();
+                this.log(`Current version is ${chalk.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.red('Version in incorrect format')}`);
+            }
+            this.log(`Setting new version to ${chalk.green(newVersion)}`);
+            try {
+                yield this.setVersion(newVersion);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                this.warn(`${chalk.yellow(error.message)}`);
+            }
+            ux.action.start('Bumping NPM packages', undefined, { stdout: true });
+            const packages = yield this.bumpNpm(args.type, newVersion, flags['only-npm-packages'], flags['exclude-dir']);
+            ux.action.stop(`${chalk.green('done')}`);
+            ux.action.start('Updating NPM dependencies in package.json files', undefined, { stdout: true });
+            if (flags['no-deps']) {
+                ux.action.stop(`${chalk.blue('skip')}`);
+            }
+            else {
+                yield this.updateDependencies(newVersion, packages);
+                ux.action.stop(`${chalk.green('done')}`);
+            }
+            yield 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`
+    `$ ops version new -v 3.4.3`,
 ];
-Version.args = [
-    {
-        name: 'type',
-        required: true,
+Version.args = {
+    type: Args.string({
         description: 'Type of release',
-        options: ['patch', 'minor', 'major', 'prerelease', 'preminor', 'premajor', 'new']
-    },
-];
+        options: ['patch', 'minor', 'major', 'prerelease', 'preminor', 'premajor', 'new'],
+        required: true,
+    }),
+};
 Version.flags = {
-    independent: command_1.flags.boolean({
+    independent: Flags.boolean({
         char: 'i',
         description: 'increment npm packages independent of VERSION file',
-        default: false
+        default: false,
     }),
-    version: command_1.flags.string({
+    version: Flags.string({
         char: 'v',
-        description: 'force version'
+        description: 'force version',
     }),
-    'script-prefix': command_1.flags.string({
+    'script-prefix': Flags.string({
         description: 'prefix for db script version creation. (default: 7.10)',
-        default: '7.10'
+        default: '7.10',
     }),
-    'no-deps': command_1.flags.boolean({
+    'no-deps': Flags.boolean({
         description: 'skip dependency update',
-        default: false
+        default: false,
     }),
-    'no-script': command_1.flags.boolean({
+    'no-script': Flags.boolean({
         description: 'skip creation of script',
-        default: false
+        default: false,
     }),
-    'only-npm-packages': command_1.flags.string({
+    'only-npm-packages': Flags.string({
         description: 'regular expression for which NPM packages to include',
-        default: '.*'
+        default: '.*',
     }),
-    'exclude-dir': command_1.flags.string({
+    'exclude-dir': Flags.string({
         description: 'exclude directories where to search for package.json',
-        multiple: true
-    })
+        multiple: true,
+    }),
 };
+export default Version;

package/lib/config.js

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

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

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

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

@@ -1,15 +1,17 @@
-"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));
+import { __awaiter } from "tslib";
+import Version from '../../commands/version.js';
+export const versionOverride = function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (process.argv[2] === 'version') {
+            try {
+                yield Version.run(process.argv.splice(3));
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                this.error(error);
+            }
+            // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
+            return process.exit(0);
         }
-        catch (err) {
-            this.error(err);
-        }
-        return process.exit(0);
-    }
+    });
 };

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,4 +1 @@
-"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; } });
+export { run } from '@oclif/core';

package/lib/lib/command.d.ts

@@ -1,6 +1,8 @@
 export default class ChildProcessCommand {
     /**
      * Only Windows supported at this point
+     * @param cmd Command to run
+     * @return {void}
      */
     runCommand(cmd: string[]): Promise<{
         data: string;