@adinsure-ops/ops-cli 4.0.0-rc6

package/lib/commands/jira/labels.js

@@ -0,0 +1,70 @@
+"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 command_base_jira_1 = require("../../command.base.jira");
+class JiraLabels extends command_base_jira_1.default {
+    async setLabels(jira, issue, add = [], remove = []) {
+        let labels = [];
+        add.forEach(label => {
+            let add = {
+                add: label
+            };
+            labels.push(add);
+        });
+        remove.forEach(label => {
+            let remove = {
+                remove: label
+            };
+            labels.push(remove);
+        });
+        let edit = {
+            update: {
+                labels
+            }
+        };
+        return jira.updateIssue(issue, edit);
+    }
+    async run() {
+        const { args, flags } = this.parse(JiraLabels);
+        const jira = await this.jiraInit(flags.hostname, flags.username, flags.password);
+        if (flags.remove || flags.add) {
+            cli_ux_1.default.action.start(`adding "${flags.add}" and removing "${flags.remove}" labels to Jira issue ${args.issue}`, undefined, { stdout: true });
+            try {
+                await this.setLabels(jira, args.issue, flags.add, flags.remove);
+                cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            }
+            catch (_a) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red('error')}`);
+            }
+        }
+        else {
+            let issue = await jira.findIssue(args.issue);
+            this.log(JSON.stringify(issue.fields.labels));
+        }
+    }
+}
+exports.default = JiraLabels;
+// static aliases = ['jira:edit:labels'];
+JiraLabels.description = 'list or edit labels on Jira issue';
+JiraLabels.usage = 'jira:labels <issue> -a [label] -r [label]';
+JiraLabels.examples = [
+    `$ ops jira:labels LJADIRD-1337`,
+];
+JiraLabels.args = [
+    {
+        name: 'issue',
+        description: 'Jira issue number',
+        required: true
+    }
+];
+JiraLabels.flags = Object.assign(Object.assign({}, command_base_jira_1.default.flags), { add: command_1.flags.string({
+        char: 'a',
+        description: 'add label',
+        multiple: true
+    }), remove: command_1.flags.string({
+        char: 'r',
+        description: 'remove label',
+        multiple: true
+    }) });

package/lib/commands/log/add.d.ts

@@ -0,0 +1,17 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+export default class Changelog extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+    }[];
+    static flags: {
+        type: flags.IOptionFlag<string | undefined>;
+        component: flags.IOptionFlag<string>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/log/add.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const fs = require("fs-extra");
+const matter = require("gray-matter");
+const inquirer = require("inquirer");
+const path = require("path");
+const command_base_1 = require("../../command.base");
+class Changelog extends command_base_1.default {
+    async run() {
+        const { args, flags } = this.parse(Changelog);
+        // Validation of input parameters
+        let changelogFolderBase = await this.getChangelogsRoot();
+        let possibleComponents = new Array();
+        fs.readdirSync(changelogFolderBase).forEach(file => {
+            if (fs.statSync(path.resolve(changelogFolderBase, file)).isDirectory()) {
+                possibleComponents.push(file);
+            }
+        });
+        // Validate JIRA ticket
+        const issueRegex = /\w+-\d+/;
+        let changelogIssue = args.issue;
+        if (!issueRegex.test(changelogIssue)) {
+            let responses = await inquirer.prompt([{
+                    name: 'issue',
+                    message: 'select a JIRA issue',
+                    type: 'input',
+                    validate(value) {
+                        if (issueRegex.test(value)) {
+                            return true;
+                        }
+                        return 'Please enter a valid JIRA ticket';
+                    }
+                }]);
+            changelogIssue = responses.issue;
+        }
+        // Validate changelog type
+        let changelogType = flags.type;
+        if (!changelogType) {
+            let responses = await inquirer.prompt([{
+                    name: 'type',
+                    message: 'select a changelog type',
+                    type: 'list',
+                    choices: [{ name: 'feature' }, { name: 'fixed' }, { name: 'improve' }, { name: 'breaking' }],
+                }]);
+            changelogType = responses.type;
+        }
+        // Validate changelog component
+        let changelogComponent = flags.component;
+        let changelogFolder = path.resolve(changelogFolderBase, changelogComponent);
+        if ((possibleComponents.length !== 0 && !changelogComponent) || !fs.pathExistsSync(path.resolve(changelogFolderBase, changelogComponent))) {
+            let responses = await inquirer.prompt([{
+                    name: 'component',
+                    message: 'Multiple components found. Select a changelog componet',
+                    type: 'list',
+                    choices: possibleComponents
+                }]);
+            changelogComponent = responses.component;
+            changelogFolder = path.resolve(changelogFolderBase, changelogComponent);
+        }
+        let fileName = `${changelogIssue.toUpperCase()}.md`;
+        let changelogPath = path.resolve(changelogFolder, fileName);
+        if (!(await fs.pathExists(changelogFolder))) {
+            await fs.mkdirp(changelogFolder);
+        }
+        if (await fs.pathExists(changelogPath)) {
+            this.error(`Changelog for '${changelogIssue}' in '${changelogComponent}' already exists`);
+        }
+        let entry = {
+            meta: {
+                issue: changelogIssue,
+                type: changelogType,
+            },
+            content: 'Explain your changes here'
+        };
+        await fs.writeFile(changelogPath, matter.stringify(entry.content, entry.meta));
+        this.log(`Created changelog for ${changelogIssue} in '${changelogPath}'`);
+    }
+}
+exports.default = Changelog;
+Changelog.aliases = ['log', 'log:add'];
+Changelog.description = 'creates a new changelog entry';
+Changelog.usage = 'log <issue> -t [type] -c [options]';
+Changelog.examples = [
+    `$ ops log LJADIRD-1234 -t feature`,
+    `$ ops log LJADIRD-5678 -t fixed`,
+    `$ ops log LJADIRD-8765 -t breaking -c Platform`,
+    `$ ops log LJADIRD-4321 -t improve -c Configuration`
+];
+Changelog.args = [
+    {
+        name: 'issue',
+        description: 'Jira issue number'
+    }
+];
+Changelog.flags = {
+    type: command_1.flags.string({
+        char: 't',
+        description: 'type of changelog',
+        options: ['feature', 'fixed', 'improve', 'breaking'],
+    }),
+    component: command_1.flags.string({
+        char: 'c',
+        description: 'Component for which new changelog should be generated',
+        default: ''
+    })
+};

package/lib/commands/log/generate.d.ts

@@ -0,0 +1,22 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import { ChangelogEntry } from '../../types/changelog.types';
+export default class Generate extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        components: flags.IOptionFlag<string>;
+        file: flags.IOptionFlag<string>;
+        force: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        preview: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        version: flags.IOptionFlag<string | undefined>;
+        'ignore-no-changelogs': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    private readonly _entryTypes;
+    private readonly _mdFileTypeRegex;
+    readChangelogs(dir: string): Promise<ChangelogEntry[]>;
+    generateLog(entries: ChangelogEntry[], components: string[]): Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/log/generate.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const matter = require("gray-matter");
+const _ = require("lodash");
+const moment = require("moment");
+const path = require("path");
+const rimraf = require("rimraf");
+const command_base_1 = require("../../command.base");
+class Generate extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this._entryTypes = [
+            { types: ['BreakingChange', 'breaking'], text: 'Breaking Changes' },
+            { types: ['Feature', 'feature'], text: 'New Features' },
+            { types: ['Improvement', 'improve'], text: 'Improvements' },
+            { types: ['Fixed', 'fixed'], text: 'Fixed' }
+        ];
+        this._mdFileTypeRegex = /\.md$/i;
+    }
+    async readChangelogs(dir) {
+        let result = [];
+        let files = await this.getFilesRecursive(dir, dir, this._mdFileTypeRegex);
+        for (let fileName of files) {
+            let filePath = path.resolve(dir, fileName);
+            let fileComponent = path.basename(path.dirname(filePath));
+            fileComponent = fileComponent === 'unreleased' ? '' : fileComponent;
+            let contents = matter.read(filePath);
+            result.push({
+                type: contents.data.type,
+                issue: contents.data.issue,
+                component: fileComponent,
+                content: contents.content.trim()
+            });
+        }
+        return result;
+    }
+    async generateLog(entries, components) {
+        let content = '';
+        // First group by component, then re-sort the components to get the desired output ordering
+        let componentGroups = _.groupBy(entries, 'component');
+        for (let group of components) {
+            if (group !== '') {
+                content += `## ${_.capitalize(group)}\r\n\r\n`;
+            }
+            // tslint:disable-next-line: strict-type-predicates
+            if (componentGroups[group] === undefined || componentGroups[group].length === 0) {
+                content += `No changes were introduced in this version.\r\n\r\n`;
+                continue;
+            }
+            for (let type of this._entryTypes) {
+                let batch = _.remove(componentGroups[group], e => _.indexOf(type.types, e.type) > -1);
+                if (batch.length === 0) {
+                    continue;
+                }
+                content += `### ${type.text} (${batch.length} changes)\r\n\r\n`;
+                for (let log of batch) {
+                    if (log.content.startsWith('-') || log.content.startsWith('* ')) {
+                        content += `- [${log.issue}](https://jira.adacta-fintech.com/browse/${log.issue}):\r\n`;
+                        content += '    ' + log.content.replace(/\n/g, '\n    ');
+                    }
+                    else {
+                        content += `- [${log.issue}](https://jira.adacta-fintech.com/browse/${log.issue}): `;
+                        content += log.content.replace(/\n/g, '\n    ') + '\r\n';
+                    }
+                    content += '\r\n';
+                }
+                content += '\r\n';
+            }
+        }
+        // We only want 1 new line at the end of this changelog
+        return content.trimRight() + '\r\n\r\n';
+    }
+    async run() {
+        const { flags } = this.parse(Generate);
+        const root = path.resolve(process.cwd());
+        const changelogFolder = await this.getChangelogsRoot();
+        const version = flags.version || await this.getVersion();
+        const components = flags.components.split(',');
+        this.log(`Inspecting ${changelogFolder} ...`);
+        cli_ux_1.default.action.start(`generating for ${version}`, undefined, { stdout: true });
+        let changelogs = await this.readChangelogs(changelogFolder);
+        if (!flags['ignore-no-changelogs'] && !changelogs.length) {
+            cli_ux_1.default.action.stop('done, no changelogs found.');
+            return;
+        }
+        const content = `# ${version} (${moment().format('YYYY-MM-DD')})\r\n\r\n${await this.generateLog(changelogs, components)}`;
+        if (flags.preview) {
+            fs.writeFileSync(path.resolve(root, 'preview.md'), content, 'utf-8');
+            cli_ux_1.default.action.stop('generated preview.md');
+            return;
+        }
+        this.warn(`The following action will update ${flags.file} and remove all unreleased changelogs in '${changelogFolder}'`);
+        const confirm = flags.force || await cli_ux_1.default.confirm(`Do you want to continue? [y/n/yes/no]`);
+        if (confirm) {
+            let changelogFile = path.resolve(root, flags.file);
+            const currentContents = fs.readFileSync(changelogFile, { encoding: 'utf-8', flag: 'a+' });
+            fs.writeFileSync(changelogFile, content + currentContents, { encoding: 'utf-8', flag: 'w' });
+            // delete unreleased changelogs
+            for (let group of components) {
+                let componentChangelogFolder = path.join(changelogFolder, group);
+                this.log(`Removing unreleased changelogs from ${componentChangelogFolder}`);
+                let changelogFiles = await fs.readdir(componentChangelogFolder);
+                for (let file of changelogFiles) {
+                    if (this._mdFileTypeRegex.test(file)) {
+                        rimraf.sync(path.resolve(componentChangelogFolder, file));
+                    }
+                }
+            }
+        }
+        cli_ux_1.default.action.stop('done');
+    }
+}
+exports.default = Generate;
+Generate.aliases = ['log:gen'];
+Generate.description = 'generates final changelog from unreleased notes';
+Generate.usage = 'log:gen [options]';
+Generate.examples = [
+    `$ ops log:gen`,
+    `$ ops log:gen -p`,
+    `$ ops log:gen -c Platform`,
+    `$ ops log:gen -c Platform,Configuration`,
+    `$ ops log:gen -c Implementation -f CHANGELOG.Implementation.md`
+];
+Generate.flags = {
+    components: command_1.flags.string({
+        char: 'c',
+        description: 'components separated by comma (,) to process for final changelog',
+        default: ''
+    }),
+    file: command_1.flags.string({
+        char: 'f',
+        description: 'file to update with new changelogs',
+        default: 'CHANGELOG.md'
+    }),
+    force: command_1.flags.boolean({
+        description: 'update target file without prompting for confirmation',
+        default: false
+    }),
+    preview: command_1.flags.boolean({
+        char: 'p',
+        description: 'generates a preview markdown of current unreleased changelogs',
+        default: false
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version for which you\'re generating changelogs'
+    }),
+    'ignore-no-changelogs': command_1.flags.boolean({
+        description: 'generate final changelog even if no unreleased changelogs exist',
+        default: false
+    })
+};

package/lib/commands/log/validate.d.ts

@@ -0,0 +1,11 @@
+import CommandBase from '../../command.base';
+export default class Validate extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    private readonly _typeRegex;
+    private readonly _issueRegex;
+    getProblems(path: string): Promise<string[]>;
+    run(): Promise<void>;
+}

package/lib/commands/log/validate.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_ux_1 = require("cli-ux");
+const matter = require("gray-matter");
+const path = require("path");
+const command_base_1 = require("../../command.base");
+class Validate extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        // Added capitalized types for compatibility with current scripts until we migrate away
+        this._typeRegex = /^(feature|fixed|improve|breaking|Fixed|BreakingChange|Improvement|Feature)$/;
+        this._issueRegex = /\w+-\d+/;
+    }
+    async getProblems(path) {
+        let problems = [];
+        let contents = matter.read(path);
+        if (contents.data.issue === undefined) {
+            problems.push('Missing \'issue\' in front-matter');
+        }
+        else if (!this._issueRegex.test(contents.data.issue)) {
+            problems.push(`\'issue\' is not a valid Jira issue number (got: ${contents.data.issue})`);
+        }
+        if (contents.data.type === undefined) {
+            problems.push('Missing \'type\' in front-matter');
+        }
+        else if (!this._typeRegex.test(contents.data.type)) {
+            problems.push(`Invalid \'type\' used (got: ${contents.data.type})`);
+        }
+        return problems;
+    }
+    async run() {
+        const directory = await this.getChangelogsRoot();
+        let files = await this.getFilesRecursive(directory, directory, /\.md$/i);
+        cli_ux_1.default.action.start('validating changelogs', undefined, { stdout: true });
+        let problemsFound = 0;
+        for (let fileName of files) {
+            const filePath = path.resolve(directory, fileName);
+            const problems = await this.getProblems(filePath);
+            if (problems.length > 0) {
+                this.log(filePath);
+                problems.forEach(val => this.warn(val));
+                problemsFound += problems.length;
+            }
+        }
+        if (problemsFound > 0) {
+            cli_ux_1.default.action.stop('failed');
+            this.error(`Found ${problemsFound} problem(s), please correct and re-run`, { exit: 1 });
+        }
+        cli_ux_1.default.action.stop('success');
+    }
+}
+exports.default = Validate;
+Validate.aliases = ['log:validate'];
+Validate.description = 'validates formatting of all unreleased changelogs';
+Validate.usage = 'log:validate [options]';
+Validate.examples = [
+    '$ ops log:validate'
+];

package/lib/commands/login.d.ts

@@ -0,0 +1,23 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+export default class Login extends CommandBase {
+    private readonly npmRegistries;
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        deviceFlow: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        clientId: flags.IOptionFlag<string | undefined>;
+        clientSecret: flags.IOptionFlag<string | undefined>;
+        npm: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        skipCI: flags.IOptionFlag<string | undefined>;
+    };
+    static responsePageContent: string;
+    /**
+     * Get NPM token for adinsure npm repositories
+     *
+     * @returns [[Promise<string>]]
+     */
+    setNPM(): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/login.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const http = require("http");
+const open = require("open");
+const url = require("url");
+const command_base_1 = require("../command.base");
+const npmrc_1 = require("../lib/npmrc");
+class Login extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this.npmRegistries = [
+            'https://pkgs.dev.azure.com/adacta-fintech/adinsure/_packaging/feed/npm/registry/',
+            'https://pkgs.dev.azure.com/adinsure-test/_packaging/TestFeed/npm/registry/',
+        ];
+    }
+    /**
+     * Get NPM token for adinsure npm repositories
+     *
+     * @returns [[Promise<string>]]
+     */
+    async setNPM() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let npmRc = new npmrc_1.default();
+                let token;
+                token = await this.security.getNPMToken();
+                this.npmRegistries.forEach(registry => {
+                    const registryUrl = url.parse(registry);
+                    npmRc.set(`//${registryUrl.hostname}${registryUrl.pathname}:_authToken`, token);
+                });
+                npmRc.save();
+                this.log(`${chalk_1.default.green('NPM token generated!')}`);
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async run() {
+        const { flags } = this.parse(Login);
+        if (flags.skipCI && process.env[flags.skipCI]) {
+            this.log(`${chalk_1.default.yellow('Note: skipping login because variables was set for CI')}`);
+            return;
+        }
+        if (flags.npm) {
+            try {
+                await this.setNPM();
+                return;
+            }
+            catch (err) {
+                this.log(`${chalk_1.default.yellow('Note: Login is needed to get NPM token!')}`);
+            }
+        }
+        if (flags.deviceFlow) {
+            try {
+                await this.security.acquireTokenDeviceFlow();
+                this.log(`${chalk_1.default.green('Login Successful!')}`);
+            }
+            catch (err) {
+                this.error(err);
+            }
+        }
+        else {
+            this.log(`${chalk_1.default.yellow('Note: We have launched a browser for you to login.')}`);
+            // await open(this.security.getAuthUrl());
+            let loginUrl = await this.security.getLoginUrl();
+            await open(loginUrl);
+            let server = http.createServer(async (req, res) => {
+                // First let the user know everything was OK
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.write(Login.responsePageContent);
+                res.end();
+                this.log(`${chalk_1.default.yellow('You have logged in successfully. Acquiring your access token...')}`);
+                // Then let's acquire an authentication token from AAD
+                try {
+                    let query = url.parse(req.url, true).query;
+                    let name = await this.security.acquireToken(query);
+                    this.log(`Hello ${name}!`);
+                }
+                catch (err) {
+                    this.error(err, { exit: false });
+                }
+                if (flags.npm) {
+                    try {
+                        await this.setNPM();
+                    }
+                    catch (err) {
+                        this.error(err, { exit: false });
+                    }
+                }
+                server.close();
+            });
+            server.listen(3044);
+        }
+    }
+}
+exports.default = Login;
+Login.description = 'log in to use ops services';
+Login.usage = 'login';
+Login.examples = [
+    `$ ops login`,
+    `$ ops login -c {client id} -s {secret}`
+];
+Login.flags = {
+    deviceFlow: command_1.flags.boolean({
+        description: 'authenticate using device flow',
+        default: false
+    }),
+    clientId: command_1.flags.string({
+        char: 'c',
+        env: 'AZURE_CLIENT_ID',
+        description: '(application) client id'
+    }),
+    clientSecret: command_1.flags.string({
+        char: 's',
+        env: 'AZURE_CLIENT_SECRET',
+        description: 'client secret'
+    }),
+    npm: command_1.flags.boolean({
+        description: 'register also for npm',
+        default: false
+    }),
+    skipCI: command_1.flags.string({
+        description: 'Skip login if environment variables is set'
+    })
+};
+Login.responsePageContent = `
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>ops-cli authenticate</title>
+        <link rel="icon" href="data:;base64,iVBORw0KGgo=">
+    </head>
+    <body>
+        <p><strong>Your login was successful!</strong></p>
+        <p>This page will automatically close after 10 seconds OR you can close it yourself immediately.</p>
+        <script type="text/javascript">
+            setTimeout("self.close()", 10000);
+        </script>
+    </body>
+</html>`;

package/lib/commands/npm/check.publish.d.ts

@@ -0,0 +1,17 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import { AzurePackageArray, NpmPackage } from '../../types/npm.types';
+export default class NpmCheckPublish extends CommandBase {
+    static aliases: string[];
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        package: flags.IOptionFlag<string[]>;
+        exclude: flags.IOptionFlag<string[]>;
+        version: flags.IOptionFlag<string>;
+        pat: flags.IOptionFlag<string | undefined>;
+    };
+    checkPackagesExists(packages: NpmPackage[], allPackages: AzurePackageArray, version: string): Promise<void>;
+    run(): Promise<void>;
+}