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

package/lib/lib/command.js

@@ -1,71 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const child_process_1 = require("child_process");
-class ChildProcessCommand {
+import { __asyncValues, __awaiter } from "tslib";
+import { spawn } from 'child_process';
+export default class ChildProcessCommand {
     /**
      * Only Windows supported at this point
+     * @param cmd Command to run
+     * @return {void}
      */
-    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;
-                }
+    runCommand(cmd) {
+        var _a, e_1, _b, _c, _d, e_2, _e, _f;
+        var _g;
+        return __awaiter(this, void 0, void 0, function* () {
+            let sh;
+            let args;
+            let cp;
+            // cross platform compatibility
+            if (process.platform === 'win32') {
+                sh = 'cmd';
+                args = ['/c', ...cmd];
             }
-            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; }
+            else {
+                [sh, ...args] = cmd;
             }
-            let error = '';
             try {
-                for (var _e = tslib_1.__asyncValues(cp.stderr), _f; _f = await _e.next(), !_f.done;) {
-                    const chunk = _f.value;
-                    error += chunk;
+                cp = spawn(sh, args, {
+                    // cwd:
+                    //     pkg.path,
+                    env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: (_g = process.env.FORCE_COLOR) !== null && _g !== void 0 ? _g : '1' } : {}),
+                    stdio: 'pipe',
+                    shell: true,
+                });
+                let data = '';
+                try {
+                    for (var _h = true, _j = __asyncValues(cp.stdout), _k; _k = yield _j.next(), _a = _k.done, !_a; _h = true) {
+                        _c = _k.value;
+                        _h = false;
+                        const chunk = _c;
+                        data += chunk;
+                    }
                 }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                let error = '';
                 try {
-                    if (_f && !_f.done && (_b = _e.return)) await _b.call(_e);
+                    for (var _l = true, _m = __asyncValues(cp.stderr), _o; _o = yield _m.next(), _d = _o.done, !_d; _l = true) {
+                        _f = _o.value;
+                        _l = false;
+                        const chunk = _f;
+                        error += chunk;
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_l && !_d && (_e = _m.return)) yield _e.call(_m);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                const exitCode = yield new Promise((resolve, _reject) => {
+                    cp.on('close', resolve);
+                });
+                if (exitCode) {
+                    throw new Error(`subprocess error exit ${exitCode}, ${error}`);
                 }
-                finally { if (e_2) throw e_2.error; }
+                return { data, error };
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
-            const exitCode = await new Promise((resolve, _reject) => {
-                cp.on('close', resolve);
-            });
-            if (exitCode) {
-                throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            catch (error) {
+                throw new Error(error.message);
             }
-            return { data, error };
-        }
-        catch (err) {
-            throw new Error(err.message);
-        }
+        });
     }
 }
-exports.default = ChildProcessCommand;

package/lib/lib/gitlab.d.ts

@@ -1,4 +1,4 @@
-import * as semver from 'semver';
+import semver from 'semver';
 export default class GitLab {
     private readonly pat;
     private readonly host;
@@ -7,11 +7,17 @@ export default class GitLab {
     constructor(host: string, project: string, pat: string);
     /**
      * Try to figure out latest available version already created
+     * @param searchVersion Version to search for
+     * @param prefix Prefix
+     * @returns {semver.SemVer} Version object
      */
     getLatestVersion(searchVersion: string, prefix?: string): Promise<semver.SemVer>;
     /**
      * Try to figure out latest available version already created
+     * @param tagName Tag name
+     * @param ref Reference
+     * @returns {void}
      */
-    createNewTag(tag_name: string, ref: string): Promise<void>;
+    createNewTag(tagName: string, ref: string): Promise<void>;
     getTagPipelineStatus(tag: string): Promise<string>;
 }

package/lib/lib/gitlab.js

@@ -1,8 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = require("axios");
-const semver = require("semver");
-class GitLab {
+import { __awaiter } from "tslib";
+import axios from 'axios';
+import semver from 'semver';
+export default class GitLab {
     constructor(host, project, pat) {
         this.apiBase = '/api/v4/projects';
         this.pat = pat;
@@ -11,89 +10,102 @@ class GitLab {
     }
     /**
      * Try to figure out latest available version already created
+     * @param searchVersion Version to search for
+     * @param prefix Prefix
+     * @returns {semver.SemVer} Version object
      */
-    async getLatestVersion(searchVersion, prefix = '') {
-        let versions = [];
-        try {
-            let page = 1;
-            let totalPages = 1;
-            do {
-                let response = await axios_1.default.get(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
-                    headers: {
-                        Authorization: `Bearer ${this.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];
-                    }
-                    const customOptions = {
-                        includePrerelease: true,
-                    };
-                    let semanticVersion = semver.parse(searchTag, customOptions);
-                    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) {
-            throw new Error(err);
-        }
-        return semver.rsort(versions)[0];
+    getLatestVersion(searchVersion, prefix = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const versions = [];
+            try {
+                let page = 1;
+                let totalPages = 1;
+                do {
+                    const response = yield axios.get(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
+                        headers: {
+                            Authorization: `Bearer ${this.pat}`,
+                        },
+                        params: {
+                            search: `^${prefix}v${searchVersion}`,
+                            // eslint-disable-next-line camelcase
+                            per_page: 100,
+                            page,
+                        },
+                    });
+                    // eslint-disable-next-line unicorn/no-array-for-each, @typescript-eslint/no-explicit-any
+                    response.data.forEach((tag) => {
+                        const regex = new RegExp(`${prefix}(.*)`);
+                        let searchTag = tag;
+                        const match = tag.name.match(regex);
+                        if (match[1]) {
+                            searchTag = match[1];
+                        }
+                        const customOptions = {
+                            includePrerelease: true,
+                        };
+                        const semanticVersion = semver.parse(searchTag, customOptions);
+                        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 && /^\d+$/.test(semanticVersion.prerelease[1].toString())) {
+                            versions.push(semanticVersion);
+                        }
+                    });
+                    totalPages = Number.parseInt(response.headers['x-total-pages'], 10);
+                    page++;
+                } while (page <= totalPages);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                throw new Error(error);
+            }
+            return semver.rsort(versions)[0];
+        });
     }
     /**
      * Try to figure out latest available version already created
+     * @param tagName Tag name
+     * @param ref Reference
+     * @returns {void}
      */
-    async createNewTag(tag_name, ref) {
-        try {
-            await axios_1.default.post(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
-                tag_name,
-                ref
-            }, {
-                headers: {
-                    Authorization: `Bearer ${this.pat}`,
-                }
-            });
-        }
-        catch (err) {
-            throw new Error(err);
-        }
-        return;
+    createNewTag(tagName, ref) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield axios.post(`${this.host}${this.apiBase}/${this.project}/repository/tags`, {
+                    tagName,
+                    ref,
+                }, {
+                    headers: {
+                        Authorization: `Bearer ${this.pat}`,
+                    },
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                throw new Error(error);
+            }
+        });
     }
-    async getTagPipelineStatus(tag) {
-        let pipelines = null;
-        tag = tag.replace(/^v/g, ''); // trim if tag starts with v because already include it in search
-        try {
-            pipelines = await axios_1.default.get(`${this.host}${this.apiBase}/${this.project}/pipelines?ref=v${tag}`, {
-                headers: {
-                    Authorization: `Bearer ${this.pat}`,
-                }
-            });
-        }
-        catch (err) {
-            throw new Error(err);
-        }
-        if (pipelines.data.length > 0) {
-            return pipelines.data[0].status;
-        }
-        else {
+    getTagPipelineStatus(tag) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let pipelines = null;
+            tag = tag.replaceAll(/^v/g, ''); // trim if tag starts with v because already include it in search
+            try {
+                pipelines = yield axios.get(`${this.host}${this.apiBase}/${this.project}/pipelines?ref=v${tag}`, {
+                    headers: {
+                        Authorization: `Bearer ${this.pat}`,
+                    },
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                throw new Error(error);
+            }
+            if (pipelines.data.length > 0) {
+                return pipelines.data[0].status;
+            }
             return 'unknown';
-        }
+        });
     }
 }
-exports.default = GitLab;

package/lib/lib/npm.d.ts

@@ -1,15 +1,19 @@
-import { NpmPackage } from '../types/npm.types';
+import { AxiosResponse } from 'axios';
+import { NpmPackage } from '../types/npm.types.js';
 export default class NpmContext {
     /**
      * Get all workspaces
+     * @returns {Promise<string[]>} String array of all workspaces
      */
     getWorkspaces(): Promise<string[]>;
     /**
      * Get package names
      */
-    packageList(packages: string[] | undefined, excludes: string[] | undefined, context: any): Promise<NpmPackage[]>;
+    packageList(context: any, packages?: string[], excludes?: string[]): Promise<NpmPackage[]>;
     /**
      * Get package all packages
+     * @param patToken Auth token
+     * @returns {Promise<string>} Returns all the NPM packages
      */
-    getAllNpmPackages(patToken?: string): Promise<string>;
+    getAllNpmPackages(patToken?: string): Promise<AxiosResponse<any, any>>;
 }

package/lib/lib/npm.js

@@ -1,79 +1,91 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = require("chalk");
-const fs = require("fs-extra");
-const globby = require("globby");
-const minimatch = require("minimatch");
-const path = require("path");
-const request = require("request-promise");
-class NpmContext {
+import { __awaiter } from "tslib";
+import axios from 'axios';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { globby } from 'globby';
+import { minimatch } from 'minimatch';
+import path from 'path';
+export default class NpmContext {
     /**
      * Get all workspaces
+     * @returns {Promise<string[]>} String array of all workspaces
      */
-    async getWorkspaces() {
-        let workspaces = [];
-        try {
-            let data = await fs.readJSON('./package.json');
-            if (!data.workspaces) {
-                return [];
+    getWorkspaces() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workspaces = [];
+            try {
+                const data = yield fs.readJSON('./package.json');
+                if (!data.workspaces) {
+                    return [];
+                }
+                for (const workspace of data.workspaces.packages) {
+                    workspaces.push(`${workspace}/+(package.json|yarn.json)`);
+                }
+                return workspaces;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
-            for (const workspace of data.workspaces.packages) {
-                workspaces.push(`${workspace}/+(package.json|yarn.json)`);
+            catch (error) {
+                throw new Error(error.message);
             }
-            return workspaces;
-        }
-        catch (err) {
-            throw new Error(err.message);
-        }
+        });
     }
     /**
      * Get package names
      */
-    async packageList(packages = ['**/*'], excludes = [''], context) {
-        try {
-            let workspaces = await this.getWorkspaces();
-            let searchPattern = ['package.json', '**/package.json', '!**/node_modules'];
-            let pkgs = [];
-            if (workspaces.length > 0) {
-                searchPattern = workspaces.concat(['package.json', '!**/node_modules']);
-            }
-            const pkgPaths = await globby(searchPattern);
-            for (const pkgPath of pkgPaths) {
-                try {
-                    let data = await fs.readJSON(pkgPath);
-                    if (!data.version || !data.name || excludes.indexOf(data.name) >= 0 || !packages.some(pkg => minimatch(data.name, pkg))) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    packageList(context, packages = ['**/*'], excludes = ['']) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const workspaces = yield this.getWorkspaces();
+                let searchPattern = ['package.json', '**/package.json', '!**/node_modules'];
+                const pkgs = [];
+                if (workspaces.length > 0) {
+                    searchPattern = [...workspaces, 'package.json', '!**/node_modules'];
+                }
+                const pkgPaths = yield globby(searchPattern);
+                for (const pkgPath of pkgPaths) {
+                    try {
+                        const data = yield fs.readJSON(pkgPath);
+                        if (!data.version || !data.name || excludes.includes(data.name) || !packages.some(pkg => minimatch(data.name, pkg))) {
+                            continue;
+                        }
+                        // create object to simply remove duplicates
+                        pkgs[data.name] = {
+                            name: data.name,
+                            path: path.dirname(pkgPath),
+                            jsonPath: pkgPath,
+                            version: data.version,
+                        };
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    }
+                    catch (error) {
+                        context.warn(`Error reading package.json: ${chalk.yellow(error.message)}.`);
                         continue;
                     }
-                    // create object to simply remove duplicates
-                    pkgs[data.name] = {
-                        name: data.name,
-                        path: path.dirname(pkgPath),
-                        jsonPath: pkgPath,
-                        version: data.version
-                    };
-                }
-                catch (err) {
-                    context.warn(`Error reading package.json: ${chalk_1.default.yellow(err.message)}.`);
-                    continue;
                 }
+                return Object.values(pkgs); // return array of values
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
-            return Object.values(pkgs); // return array of values
-        }
-        catch (err) {
-            throw new Error(`Unknown error: ${chalk_1.default.red(err)}`);
-        }
+            catch (error) {
+                throw new Error(`Unknown error: ${chalk.red(error)}`);
+            }
+        });
     }
     /**
      * Get package all packages
+     * @param patToken Auth token
+     * @returns {Promise<string>} Returns all the NPM packages
      */
-    async getAllNpmPackages(patToken = '') {
-        let options = {
-            uri: `https://feeds.dev.azure.com/adacta-fintech/adinsure/_apis/packaging/Feeds/feed/packages?api-version=6.0-preview.1&includeAllVersions=true&protocolType=Npm`,
-            headers: {
-                Authorization: 'Basic ' + Buffer.from(`:${patToken}`).toString('base64')
-            }
-        };
-        return request.get(options);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getAllNpmPackages(patToken = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uri = `https://feeds.dev.azure.com/adacta-fintech/adinsure/_apis/packaging/Feeds/feed/packages?api-version=6.0-preview.1&includeAllVersions=true&protocolType=Npm`;
+            return axios.get(uri, {
+                headers: {
+                    Authorization: 'Basic ' + Buffer.from(`:${patToken}`).toString('base64'),
+                    'Content-Type': 'application/octet-strem',
+                },
+            });
+        });
     }
 }
-exports.default = NpmContext;

package/lib/lib/npmrc.d.ts

@@ -4,14 +4,19 @@ export default class NpmRc {
     constructor(createIfNotExists?: boolean);
     /**
      * Load config file
+     * @returns {void}
      */
     load(): void;
     /**
      * Add registry to config file
+     * @param key Config key
+     * @param value Config value
+     * @returns {void}
      */
     set(key: string, value: string): Promise<void>;
     /**
      * Set token for Registry
+     * @returns {void}
      */
     save(): Promise<void>;
 }

package/lib/lib/npmrc.js

@@ -1,14 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const fs = require("fs");
-const ini = require("ini");
-const os = require("os");
-class NpmRc {
+import { __awaiter } from "tslib";
+import { execSync } from 'child_process';
+import fs from 'fs';
+import ini from 'ini';
+import os from 'os';
+export default class NpmRc {
     constructor(createIfNotExists = true) {
         this.config = {};
         try {
-            this.filePath = child_process_1.execSync('npm config get userconfig', { stdio: ['pipe', 'pipe', 'ignore'] })
+            this.filePath = execSync('npm config get userconfig', { stdio: ['pipe', 'pipe', 'ignore'] })
                 .toString()
                 .trim();
         }
@@ -24,21 +23,29 @@ class NpmRc {
     }
     /**
      * Load config file
+     * @returns {void}
      */
     load() {
         this.config = ini.parse(fs.readFileSync(this.filePath, 'utf8'));
     }
     /**
      * Add registry to config file
+     * @param key Config key
+     * @param value Config value
+     * @returns {void}
      */
-    async set(key, value) {
-        this.config[key] = value;
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.config[key] = value;
+        });
     }
     /**
      * Set token for Registry
+     * @returns {void}
      */
-    async save() {
-        fs.writeFileSync(this.filePath, ini.encode(this.config));
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            fs.writeFileSync(this.filePath, ini.encode(this.config));
+        });
     }
 }
-exports.default = NpmRc;

package/lib/lib/nuget.d.ts

@@ -1,6 +1,8 @@
 export default class NugetContext {
     /**
      * Get package names
+     * @param exclude List of excluded packages
+     * @returns {Promise<string>} Array of package names
      */
     projectList(exclude?: string[]): Promise<string[]>;
 }