@adinsure-ops/ops-cli 4.1.0 → 4.3.0

package/CHANGELOGS.md

@@ -1,5 +1,17 @@
 # Changelogs
 
+## 4.3.0: 2022-07-27
+
+- added command `npm:dependency-update` to update dependencies on packages in workspace defined by filter
+- added command `nuget:dependency-update` to update dependencies on packages in workspace defined by filter
+- improve error handling in translation fetching
+- improve warning output when npm publish fails
+
+## 4.2.0: 2022-07-15
+
+- added command `gitlab:get-tag-pipeline` to track pipeline status and wait for pipeline to finish
+- added `--outputVersionOnly` to `gitlab:next-nightly-tag` to output only version
+
 ## 4.1.0: 2022-06-15
 
 - `vsix` file is removed after installation when `-i` flag is used

package/README.md

@@ -2,22 +2,11 @@
 
 Operations CLI for supporting AdInsure development processes.
 
-# Latest version
-
-4.0.0
+https://www.npmjs.com/package/@adinsure-ops/ops-cli
 
 ## Install
 
-OPS CLI can be downloaded and installed using installer.
-For versions check [tags](https://git.adacta-fintech.com/ops/ops-cli/-/tags)
-or [download a JSON](https://adinsure.blob.core.windows.net/ops-cli/version) containing version and other information.
-
-| Platform| Link|
-|:---|:---|
-|Windows 64-bit|https://adinsure.blob.core.windows.net/ops-cli/win/ops-v4.0.0-x64.exe|
-|Debian 64-bit |https://adinsure.blob.core.windows.net/ops-cli/deb/ops_4.0.0-1_amd64.deb|
-
-
+`npm install -g @adinsure-ops/ops-cli`
 
 ## CLI development
 
@@ -45,6 +34,7 @@ You can run and debug commands directly from terminal by running `ops [command]`
 * [`ops download:scheduler <flags>`](#ops-download-scheduler-flags)
 * [`ops download:server <flags>`](#ops-download-server-flags)
 * [`ops download:studio <flags>`](#ops-download-studio-flags)
+* [`ops gitlab:get-tag-pipeline`](#ops-gitlab-get-tag-pipeline)
 * [`ops gitlab:next-nightly-tag`](#ops-gitlab-next-nightly-tag)
 * [`ops log <component> <issue> [options]`](#ops-log-component-issue-options)
 * [`ops log:gen [options]`](#ops-loggen-options)
@@ -52,6 +42,8 @@ You can run and debug commands directly from terminal by running `ops [command]`
 * [`ops login`](#ops-login)
 * [`ops npm:check-publish`](#ops-npm-check-publish)
 * [`ops npm:publish`](#ops-npm-publish)
+* [`ops npm:dependency-update`](#ops-npm-dependency-update)
+* [`ops nuget:dependency-update`](#ops-nuget-dependency-update)
 * [`ops prepare-content`](#ops-prepare-content)
 * [`ops sql <type> <module> [flags]`](#ops-sql-type-module-flags)
 * [`ops translate`](#ops-translate)
@@ -210,6 +202,26 @@ EXAMPLES
   $ ops download:studio -v 15.0.0 -i
 ```
 
+## `ops gitlab:get-tag-pipeline`
+
+get pipeline status for tag
+
+```
+USAGE
+  $ ops gitlab:get-tag-pipeline <tag>
+
+ARGUMENTS
+  TAG  Tag
+
+OPTIONS
+  --delay=delay      [default: 5] Delay of check in seconds (defaults to 5 seconds)
+  --host=host        (required) [default: https://git.adacta-fintech.com] Server hostname
+  --pat=pat          (required) Token from user that has permissions to list and create tags
+  --project=project  (required) [default: 413] Project ID
+  --timeout=timeout  [default: 120] Timeout for wait command in seconds (defaults to 120 seconds)
+  --wait             Wait for pipeline to finish
+```
+
 ## `ops gitlab:next-nightly-tag`
 
 creates new gitlab tag
@@ -404,6 +416,43 @@ EXAMPLES
   $ ops npm:publish -p @adinsure-tooling/* -x @adisure-tooling/studio-services -v 6.0.0
 ```
 
+## `ops npm:dependency-update`
+
+update npm dependencies per package filter
+
+```
+USAGE
+  $ ops npm:dependency-update <type> [flags]
+
+ARGUMENTS
+  VERSION  Type of release
+
+OPTIONS
+  --exclude=exclude  exclude directories where to search for package.json
+  --filter=filter    (required) regular expression for which NPM packages to update
+
+EXAMPLE
+  $ ops npm:dependency-update 3.4.3 --filter @adinsure/*
+```
+## `ops nuget:dependency-update`
+
+update nuget dependencies per package filter
+
+```
+USAGE
+  $ ops nuget:dependency-update <type> [flags]
+
+ARGUMENTS
+  VERSION  Type of release
+
+OPTIONS
+  --exclude=exclude  exclude directories where to search for csproj files
+  --filter=filter    (required) regular expression for which NuGet packages to update
+
+EXAMPLE
+  $ ops nuget:dependency-update 3.4.3 --filter Adacta.AdInsure --exclude Scheduler
+```
+
 ## `ops prepare-content -d <destination> -s [source]`
 
 creates a directory/file structure from `/source` to `/destination</source>` as defined in the `.opsprepare` file. Actual

package/lib/commands/docker/update-image-version.d.ts

@@ -0,0 +1,17 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class DockerUpdateImageVersion extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static flags: {
+        services: flags.IOptionFlag<string[]>;
+        'file-path': flags.IOptionFlag<string>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/docker/update-image-version.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const fs = require("fs-extra");
+const yaml_1 = require("yaml");
+const command_base_1 = require("../../command.base");
+class DockerUpdateImageVersion extends command_base_1.default {
+    async run() {
+        const { args, flags } = this.parse(DockerUpdateImageVersion);
+        try {
+            let parsedYaml = yaml_1.parse(fs.readFileSync(flags['file-path'], 'utf8'));
+            for (let service of flags.services) {
+                let image = parsedYaml.services[service].image.split(':');
+                image[1] = args.version;
+                parsedYaml.services[service].image = image.join(':');
+            }
+            fs.writeFileSync(flags['file-path'], yaml_1.stringify(parsedYaml));
+        }
+        catch (err) {
+            this.error(err.message);
+        }
+    }
+}
+exports.default = DockerUpdateImageVersion;
+DockerUpdateImageVersion.description = 'update docker image version docker compose file';
+DockerUpdateImageVersion.usage = 'docker:update-image-version <tag>';
+DockerUpdateImageVersion.examples = [
+    `$ ops docker:update-image-version 17.0.0 --service server client`
+];
+DockerUpdateImageVersion.args = [
+    {
+        name: 'version',
+        description: 'version',
+        required: true
+    }
+];
+DockerUpdateImageVersion.flags = {
+    services: command_1.flags.string({
+        required: true,
+        description: 'list of services to update',
+        multiple: true
+    }),
+    'file-path': command_1.flags.string({
+        default: './docker-compose.yml',
+        description: 'list of services to update'
+    })
+};

package/lib/commands/gitlab/get-tag-pipeline.d.ts

@@ -0,0 +1,23 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import GitLab from '../../lib/gitlab';
+export default class GitlabGetTagPipeline extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static flags: {
+        pat: flags.IOptionFlag<string>;
+        host: flags.IOptionFlag<string>;
+        project: flags.IOptionFlag<string>;
+        wait: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        timeout: flags.IOptionFlag<string>;
+        delay: flags.IOptionFlag<string>;
+    };
+    waitPipelineStatus(gitlab: GitLab, tag: string, timeout: number, delay: number): Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/gitlab/get-tag-pipeline.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const command_base_1 = require("../../command.base");
+const gitlab_1 = require("../../lib/gitlab");
+class GitlabGetTagPipeline extends command_base_1.default {
+    async waitPipelineStatus(gitlab, tag, timeout, delay) {
+        return new Promise(async (resolve, reject) => {
+            let time = 0;
+            try {
+                let status = await gitlab.getTagPipelineStatus(tag);
+                switch (status) {
+                    case 'unknown': {
+                        reject(new Error(`Pipeline or tag does not exist!`));
+                        return;
+                    }
+                    case 'failed': {
+                        reject(new Error(`Pipeline failed!`));
+                        return;
+                    }
+                    case 'canceled': {
+                        reject(new Error(`Pipeline canceled!`));
+                        return;
+                    }
+                    case 'skipped': {
+                        reject(new Error(`Pipeline skipped!`));
+                        return;
+                    }
+                    case 'success': {
+                        resolve(`Pipeline passed successfully!`);
+                        return;
+                    }
+                }
+            }
+            catch (err) {
+                reject(new Error(err.message));
+                return;
+            }
+            const interval = setInterval(async () => {
+                if (time >= timeout) {
+                    reject(new Error('Timeout waiting pipeline'));
+                    clearInterval(interval);
+                }
+                time += delay;
+                try {
+                    let status = await gitlab.getTagPipelineStatus(tag);
+                    switch (status) {
+                        case 'unknown': {
+                            reject(new Error(`Pipeline or tag does not exist!`));
+                            clearInterval(interval);
+                            break;
+                        }
+                        case 'failed': {
+                            reject(new Error(`Pipeline failed!`));
+                            clearInterval(interval);
+                            break;
+                        }
+                        case 'canceled': {
+                            reject(new Error(`Pipeline canceled!`));
+                            clearInterval(interval);
+                            break;
+                        }
+                        case 'skipped': {
+                            reject(new Error(`Pipeline skipped!`));
+                            clearInterval(interval);
+                            break;
+                        }
+                        case 'success': {
+                            resolve(`Pipeline passed successfully!`);
+                            clearInterval(interval);
+                        }
+                    }
+                }
+                catch (err) {
+                    reject(new Error(err.message));
+                    clearInterval(interval);
+                }
+            }, delay * 1000);
+        });
+    }
+    async run() {
+        const { args, flags } = this.parse(GitlabGetTagPipeline);
+        const gitlab = new gitlab_1.default(flags.host, flags.project, flags.pat);
+        if (!flags.wait) {
+            let status = await gitlab.getTagPipelineStatus(args.tag);
+            return this.log(`${chalk_1.default.green(status)}`);
+        }
+        else {
+            try {
+                let status = await this.waitPipelineStatus(gitlab, args.tag, parseInt(flags.timeout, 10), parseInt(flags.delay, 10));
+                this.log(status);
+            }
+            catch (err) {
+                this.error(err.message);
+            }
+        }
+    }
+}
+exports.default = GitlabGetTagPipeline;
+GitlabGetTagPipeline.description = 'get pipeline status for tag';
+GitlabGetTagPipeline.usage = 'gitlab:get-tag-pipeline <tag>';
+GitlabGetTagPipeline.examples = [
+    `$ ops gitlab:get-tag-pipeline 17.0.0`
+];
+GitlabGetTagPipeline.args = [
+    {
+        name: 'tag',
+        description: 'Tag',
+        required: true
+    }
+];
+GitlabGetTagPipeline.flags = {
+    pat: command_1.flags.string({
+        required: true,
+        env: 'PRIVATE_TOKEN',
+        description: 'Token from user that has permissions to list and create tags'
+    }),
+    host: command_1.flags.string({
+        required: true,
+        default: 'https://git.adacta-fintech.com',
+        env: 'CI_SERVER_URL',
+        description: 'Server hostname'
+    }),
+    project: command_1.flags.string({
+        required: true,
+        default: '413',
+        env: 'CI_PROJECT_ID',
+        description: 'Project ID'
+    }),
+    wait: command_1.flags.boolean({
+        description: 'Wait for pipeline to finish',
+        default: false
+    }),
+    timeout: command_1.flags.string({
+        default: '120',
+        description: 'Timeout for wait command in seconds (defaults to 120 seconds)'
+    }),
+    delay: command_1.flags.string({
+        default: '5',
+        description: 'Delay of check in seconds (defaults to 5 seconds)'
+    })
+};

package/lib/commands/gitlab/next-nightly-tag.d.ts

@@ -1,5 +1,4 @@
 import { flags } from '@oclif/command';
-import * as semver from 'semver';
 import CommandBase from '../../command.base';
 export default class GitlabNextNightlyTag extends CommandBase {
     static description: string;
@@ -14,16 +13,8 @@ export default class GitlabNextNightlyTag extends CommandBase {
         host: flags.IOptionFlag<string>;
         project: flags.IOptionFlag<string>;
         reference: flags.IOptionFlag<string>;
+        outputVersionOnly: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
         dryRun: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
     };
-    private readonly apiBase;
-    /**
-     * Try to figure out latest available version already created
-     */
-    createNewTag(url: string, pat: string, tag_name: string, ref: string): Promise<void>;
-    /**
-     * Try to figure out latest available version already created
-     */
-    getLatestVersion(url: string, pat: string, searchVersion: string, prefix?: string): Promise<semver.SemVer>;
     run(): Promise<undefined>;
 }

package/lib/commands/gitlab/next-nightly-tag.js

@@ -1,81 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const command_1 = require("@oclif/command");
-const axios_1 = require("axios");
 const chalk_1 = require("chalk");
 const cli_ux_1 = require("cli-ux");
 const semver = require("semver");
 const command_base_1 = require("../../command.base");
+const gitlab_1 = require("../../lib/gitlab");
 class GitlabNextNightlyTag extends command_base_1.default {
-    constructor() {
-        super(...arguments);
-        this.apiBase = '/api/v4/projects';
-    }
-    /**
-     * Try to figure out latest available version already created
-     */
-    async createNewTag(url, pat, tag_name, ref) {
-        try {
-            await axios_1.default.post(`${url}`, {
-                tag_name,
-                ref
-            }, {
-                headers: {
-                    Authorization: `Bearer ${pat}`,
-                }
-            });
-        }
-        catch (err) {
-            throw new Error(err);
-        }
-        return;
-    }
-    /**
-     * Try to figure out latest available version already created
-     */
-    async getLatestVersion(url, pat, searchVersion, prefix = '') {
-        let versions = [];
-        try {
-            let page = 1;
-            let totalPages = 1;
-            do {
-                let response = await axios_1.default.get(`${url}`, {
-                    headers: {
-                        Authorization: `Bearer ${pat}`,
-                    },
-                    params: {
-                        search: `^${prefix}v${searchVersion}`,
-                        per_page: 100,
-                        page
-                    }
-                });
-                response.data.forEach((tag) => {
-                    const regex = new RegExp(`${prefix}(.*)`);
-                    let searchTag = tag;
-                    let match = tag.name.match(regex);
-                    if (match[1]) {
-                        searchTag = match[1];
-                    }
-                    let semanticVersion = semver.parse(searchTag, { includePrerelease: true });
-                    if (semanticVersion && semanticVersion.prerelease.length === 0) {
-                        versions.push(semanticVersion);
-                        // ignore versions that that doesn't have number for prerelease identifier (skip qa and test prereleases)
-                    }
-                    else if (semanticVersion && semanticVersion.prerelease.length === 2 && /^[0-9]+$/.test(semanticVersion.prerelease[1].toString())) {
-                        versions.push(semanticVersion);
-                    }
-                });
-                totalPages = parseInt(response.headers['x-total-pages'], 10);
-                page++;
-            } while (page <= totalPages);
-        }
-        catch (err) {
-            this.error(err.message);
-        }
-        return semver.rsort(versions)[0];
-    }
     async run() {
         const { args, flags } = this.parse(GitlabNextNightlyTag);
+        const gitlab = new gitlab_1.default(flags.host, flags.project, flags.pat);
         const re = /^release\/(\w+\-)?((\d+)(\.\d+)?)$/;
         let prefix = '';
         let inputVersion = args.version;
@@ -86,12 +20,16 @@ class GitlabNextNightlyTag extends command_base_1.default {
             }
             inputVersion = match[2];
         }
-        const urlPath = `${this.apiBase}/${flags.project}/repository/tags`;
         let version = semver.parse(inputVersion);
         let nextVersion = null;
         // if version is not parsable try to find something that starts with this version
         if (!version) {
-            version = await this.getLatestVersion(`${flags.host}${urlPath}`, flags.pat, inputVersion, prefix);
+            try {
+                version = await gitlab.getLatestVersion(inputVersion, prefix);
+            }
+            catch (err) {
+                this.error(err.message);
+            }
         }
         // still version does not exists we will try to parse it with additional 0 as patch version
         if (!version) {
@@ -105,10 +43,18 @@ class GitlabNextNightlyTag extends command_base_1.default {
         if (!version) {
             return this.error(`${chalk_1.default.red('Version in incorrect format')}`);
         }
-        cli_ux_1.default.action.start('Calculating next prerelease test version', undefined, { stdout: true });
+        if (!flags.outputVersionOnly) {
+            cli_ux_1.default.action.start('Calculating next prerelease test version', undefined, { stdout: true });
+        }
         const date = new Date();
         const prereleaseDate = `${date.getFullYear()}${('0' + (date.getMonth() + 1)).slice(-2)}`;
-        let lastVersion = await this.getLatestVersion(`${flags.host}${urlPath}`, flags.pat, version.version, prefix);
+        let lastVersion = null;
+        try {
+            lastVersion = await gitlab.getLatestVersion(version.version, prefix);
+        }
+        catch (err) {
+            this.error(err.message);
+        }
         if (lastVersion) {
             nextVersion = `v${semver.inc(lastVersion, 'prerelease', prereleaseDate)}`;
         }
@@ -118,9 +64,19 @@ class GitlabNextNightlyTag extends command_base_1.default {
         if (prefix) {
             nextVersion = `${prefix}${nextVersion}`;
         }
-        cli_ux_1.default.action.stop(`${chalk_1.default.green(nextVersion)}`);
+        if (!flags.outputVersionOnly) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.green(nextVersion)}`);
+        }
+        else {
+            this.log(`${nextVersion}`);
+        }
         if (!flags.dryRun) {
-            await this.createNewTag(`${flags.host}${urlPath}`, flags.pat, nextVersion, flags.reference);
+            try {
+                await gitlab.createNewTag(nextVersion, flags.reference);
+            }
+            catch (err) {
+                this.error(err.message);
+            }
         }
         else {
             this.warn(`This is only dry run. no new tag will was created!`);
@@ -162,6 +118,10 @@ GitlabNextNightlyTag.flags = {
         env: 'CI_COMMIT_REF_NAME',
         description: 'Reference to create tag on (branch, commit, tag)'
     }),
+    outputVersionOnly: command_1.flags.boolean({
+        description: `output only version instead of pretty output`,
+        default: false
+    }),
     dryRun: command_1.flags.boolean({
         description: `Only printout version and don't create it`,
         default: false

package/lib/commands/npm/dependency-update.d.ts

@@ -0,0 +1,23 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import { NpmPackage } from '../../types/npm.types';
+export default class NpmDependencyUpdate extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    static flags: {
+        filter: flags.IOptionFlag<string[]>;
+        exclude: flags.IOptionFlag<string[]>;
+        force: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    /**
+     * Update dependencies in package.json files for @adinsure packages
+     */
+    updateDependencies(newVersion: string, filter: string[] | undefined, packages: NpmPackage[], force?: boolean): Promise<void>;
+    run(): Promise<undefined>;
+}

package/lib/commands/npm/dependency-update.js

@@ -0,0 +1,113 @@
+"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 minimatch = require("minimatch");
+const semver = require("semver");
+const command_base_1 = require("../../command.base");
+const command_2 = require("../../lib/command");
+const npm_1 = require("../../lib/npm");
+class NpmDependencyUpdate extends command_base_1.default {
+    /**
+     * Update dependencies in package.json files for @adinsure packages
+     */
+    async updateDependencies(newVersion, filter = ['**/*'], packages, force = false) {
+        // Find all package.json files that are not in node modules
+        for (const path of packages) {
+            try {
+                let data = await fs.readJSON(path.jsonPath);
+                let updatedKeys = [];
+                if (data.hasOwnProperty('dependencies')) {
+                    for (const [key, value] of Object.entries(data.dependencies)) {
+                        let currentVersion = semver.valid(String(value));
+                        if (filter.some(pkg => minimatch(key, pkg))) {
+                            if (currentVersion && semver.gt(currentVersion, newVersion) && !force) {
+                                this.warn(`Lower of same version for dependency ${key} updated in file ${path.jsonPath}: ${newVersion} vs. ${currentVersion} is ${semver.gt(newVersion, currentVersion)}`);
+                            }
+                            else {
+                                data.dependencies[key] = newVersion;
+                                updatedKeys.push(key);
+                            }
+                        }
+                    }
+                    fs.writeFileSync(path.jsonPath, JSON.stringify(data, null, 4));
+                    if (updatedKeys.length > 0) {
+                        this.log(`Dependencies ${updatedKeys} updated in file ${path.jsonPath}`);
+                    }
+                }
+                if (data.hasOwnProperty('devDependencies')) {
+                    for (const [key, value] of Object.entries(data.devDependencies)) {
+                        let currentVersion = semver.valid(String(value));
+                        if (filter.some(pkg => minimatch(key, pkg))) {
+                            if (currentVersion && semver.gt(currentVersion, newVersion) && !force) {
+                                this.warn(`Lower of same version for devDependency ${key} updated in file ${path.jsonPath}: ${newVersion} vs. ${currentVersion} is ${semver.gt(newVersion, currentVersion)}`);
+                            }
+                            else {
+                                data.devDependencies[key] = newVersion;
+                                updatedKeys.push(key);
+                            }
+                        }
+                    }
+                    fs.writeFileSync(path.jsonPath, JSON.stringify(data, null, 4));
+                    if (updatedKeys.length > 0) {
+                        this.log(`devDependencies ${updatedKeys} updated in file ${path.jsonPath}`);
+                    }
+                }
+            }
+            catch (err) {
+                this.warn(err.message);
+                break;
+            }
+        }
+    }
+    async run() {
+        const { args, flags } = this.parse(NpmDependencyUpdate);
+        let newVersion = semver.valid(args.version);
+        let npmContext = new npm_1.default();
+        let command = new command_2.default();
+        // Stop if version invalid
+        if (!newVersion) {
+            return this.error(`${chalk_1.default.red('Version in incorrect format')}`);
+        }
+        const packages = await npmContext.packageList(['**/*'], [''], this);
+        try {
+            await this.updateDependencies(newVersion, flags.filter, packages, flags.force);
+            cli_ux_1.default.action.start(`running 'yarn install'`, undefined, { stdout: true });
+            await command.runCommand(['yarn', 'install']);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        catch (err) {
+            this.error(err.message);
+        }
+    }
+}
+exports.default = NpmDependencyUpdate;
+NpmDependencyUpdate.description = 'update npm dependencies per package filter';
+NpmDependencyUpdate.usage = 'npm:dependency-update <type> [flags]';
+NpmDependencyUpdate.examples = [
+    `$ ops npm:dependency-update 3.4.3 --filter @adinsure/*`
+];
+NpmDependencyUpdate.args = [
+    {
+        name: 'version',
+        required: true,
+        description: 'Type of release'
+    }
+];
+NpmDependencyUpdate.flags = {
+    filter: command_1.flags.string({
+        description: 'regular expression for which NPM packages to update',
+        required: true,
+        multiple: true
+    }),
+    exclude: command_1.flags.string({
+        description: 'exclude directories where to search for package.json',
+        multiple: true
+    }),
+    force: command_1.flags.boolean({
+        description: 'force update of version regardless of lower vs higher version check',
+        default: false
+    })
+};