trm-client 6.1.1 → 7.0.0

package/dist/command/implementations/Compare.js

@@ -0,0 +1,133 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Compare = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+const systemAlias_1 = require("../../systemAlias");
+const prompts_1 = require("../prompts");
+class Compare extends AbstractCommand_1.AbstractCommand {
+    constructor() {
+        super(...arguments);
+        this.connections = [];
+    }
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.ignoreRegistryUnreachable = true;
+        this.command.description(`Compare a package between different systems.`);
+        this.command.argument(`<package>`, `Name of the package.`);
+        this.command.option(`-c, --connections <json>`, `Array of system connection aliases (JSON or path to JSON file).`);
+    }
+    promptConnections() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.connections.length > 0) {
+                trm_commons_1.Logger.info(`Compare systems: ${this.connections.map(o => o.getDest()).join(', ')}`);
+            }
+            var askConnection = true;
+            const inq1 = yield trm_commons_1.Inquirer.prompt([{
+                    message: "Add another connection?",
+                    name: "continue",
+                    type: "confirm",
+                    default: true,
+                    when: this.connections.length > 0
+                }]);
+            askConnection = inq1.continue !== undefined ? inq1.continue : askConnection;
+            if (askConnection) {
+                const connectArgs = yield (0, prompts_1.connect)({}, false, false);
+                const systemConnector = connectArgs.getSystemConnector();
+                yield systemConnector.connect();
+                this.connections.push(systemConnector);
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packageName = this.args.package;
+            const registry = this.getRegistry();
+            var inputConnections = this.parseJsonArg('connections');
+            if (Array.isArray(inputConnections)) {
+                for (const sAlias of inputConnections) {
+                    if (typeof (sAlias) === 'string') {
+                        const oAlias = systemAlias_1.SystemAlias.get(sAlias);
+                        const oConnection = oAlias.getConnection();
+                        this.connections.push(oConnection);
+                    }
+                }
+            }
+            else {
+                var keepPrompt = true;
+                while (keepPrompt) {
+                    keepPrompt = yield this.promptConnections();
+                }
+            }
+            trm_commons_1.Logger.info(`Compare systems: ${this.connections.map(o => o.getDest()).join(', ')}`);
+            const tableHead = [`System`, `Installed`, `Version`, `Devclass`, `Import transport`];
+            var tableData = [];
+            trm_commons_1.Logger.loading(`Reading registry data...`);
+            var oRegistryView;
+            try {
+                oRegistryView = yield this.viewRegistryPackage(packageName, true);
+            }
+            catch (e) { }
+            trm_commons_1.Logger.loading(`Reading system data...`);
+            for (const oConnection of this.connections) {
+                trm_core_1.SystemConnector.systemConnector = oConnection;
+                const system = trm_core_1.SystemConnector.getDest() || '';
+                var installed;
+                var version;
+                var devclass;
+                var importTransport;
+                const aSystemPackages = yield trm_core_1.SystemConnector.getInstalledPackages(true);
+                const oSystemView = aSystemPackages.find(o => o.compareName(packageName) && o.compareRegistry(registry));
+                if (oSystemView && oSystemView.manifest) {
+                    installed = 'Yes';
+                    version = oSystemView.manifest.get().version || 'Unknown';
+                    devclass = oSystemView.getDevclass() || 'Unknown';
+                    if (oSystemView.manifest.getLinkedTransport()) {
+                        importTransport = oSystemView.manifest.getLinkedTransport().trkorr;
+                    }
+                    else {
+                        importTransport = 'Unknown';
+                    }
+                }
+                else {
+                    installed = 'No';
+                    version = '';
+                    devclass = '';
+                    importTransport = '';
+                }
+                tableData.push([
+                    system,
+                    installed,
+                    version,
+                    devclass,
+                    importTransport
+                ]);
+            }
+            trm_commons_1.Logger.info(`Package name: ${packageName}`);
+            trm_commons_1.Logger.info(`Registry: ${registry.name}`);
+            try {
+                trm_commons_1.Logger.info(`Latest version: ${oRegistryView.dist_tags['latest'] || 'unknown'}`);
+            }
+            catch (e) {
+                trm_commons_1.Logger.warning(`Latest version: Unknown`);
+            }
+            trm_commons_1.Logger.log(`\n`);
+            trm_commons_1.Logger.table(tableHead, tableData);
+        });
+    }
+}
+exports.Compare = Compare;

package/dist/command/implementations/Content.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Content extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Content.js

@@ -0,0 +1,195 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Content = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const utils_1 = require("../../utils");
+const chalk_1 = __importDefault(require("chalk"));
+class Content extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.requiresR3trans = true;
+        this.command.description(`Extract and list content of a package.`);
+        this.command.addHelpText(`before`, `This command has no effect when trying to login into a registry that doesn't require authentication.`);
+        this.command.argument(`<package>`, `Name of the package.`);
+        this.command.argument(`[version]`, `Version or tag of the package`, 'latest');
+        this.command.option(`--full`, `Show all transport entries of the package`, false);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var transports = {};
+            var aNodes = [];
+            var iOtherEntries = 0;
+            const registry = this.getRegistry();
+            trm_commons_1.Logger.loading(`Searching package "${this.args.package}"...`);
+            const data = yield registry.getPackage(this.args.package, this.args.version);
+            const artifact = yield registry.downloadArtifact(this.args.package, this.args.version);
+            trm_commons_1.Logger.loading(`Reading content...`);
+            const packageContent = yield artifact.getContent({
+                tempDirPath: (0, utils_1.getTempFolder)(),
+                r3transDirPath: this.args.r3transPath,
+                useDocker: utils_1.GlobalContext.getInstance().getSettings().r3transDocker,
+                dockerOptions: {
+                    name: utils_1.GlobalContext.getInstance().getSettings().r3transDockerName
+                }
+            });
+            if (this.args.tadirOnly) {
+                transports.TADIR = packageContent.TADIR.trkorr;
+                aNodes.push({
+                    tableName: 'TADIR',
+                    content: packageContent.TADIR.content.TADIR
+                });
+                Object.keys(packageContent).forEach(type => {
+                    if (type === 'TADIR') {
+                        return;
+                    }
+                    Object.keys(packageContent[type].content).forEach(tableName => {
+                        iOtherEntries += packageContent[type].content[tableName].length;
+                    });
+                });
+            }
+            else {
+                Object.keys(packageContent).forEach(type => {
+                    transports[type] = packageContent[type].trkorr;
+                    Object.keys(packageContent[type].content).forEach(tableName => {
+                        var nodeIndex = aNodes.findIndex(o => o.tableName === tableName);
+                        if (nodeIndex < 0) {
+                            nodeIndex = (aNodes.push({
+                                tableName,
+                                content: []
+                            })) - 1;
+                        }
+                        aNodes[nodeIndex].content = aNodes[nodeIndex].content.concat(packageContent[type].content[tableName].map(o => {
+                            o.__isDevc = type === 'DEVC';
+                            o.__isLang = type === 'LANG';
+                            o.__isCust = type === 'CUST';
+                            return o;
+                        }));
+                    });
+                });
+            }
+            var tree = {
+                text: `${chalk_1.default.bold(this.args.package)} v${data.manifest.version} content`,
+                children: []
+            };
+            aNodes.forEach(node => {
+                if (node.content.length > 0) {
+                    var tableNode = {
+                        text: `${chalk_1.default.bold(node.tableName)} (${node.content.length} record${node.content.length > 1 ? 's' : ''})`,
+                        children: []
+                    };
+                    node.content.forEach(record => {
+                        var sRecord = [];
+                        Object.keys(record).filter(k => !k.startsWith('__')).forEach(field => {
+                            var fieldValue = record[field];
+                            if (field && fieldValue) {
+                                if (node.tableName === 'TADIR') {
+                                    if (field === 'SRCSYSTEM') {
+                                        fieldValue = chalk_1.default.strikethrough(fieldValue);
+                                    }
+                                    else if (field === 'DEVCLASS') {
+                                        fieldValue = chalk_1.default.italic(fieldValue);
+                                    }
+                                }
+                                sRecord.push(`${chalk_1.default.bold(field)}: ${fieldValue}`);
+                            }
+                        });
+                        if (sRecord.length > 0) {
+                            if (record.__isDevc) {
+                                tableNode.children.push({
+                                    text: chalk_1.default.bgGrey(sRecord.join(', ')),
+                                    children: []
+                                });
+                            }
+                            else if (record.__isLang) {
+                                tableNode.children.push({
+                                    text: chalk_1.default.bgGreen(sRecord.join(', ')),
+                                    children: []
+                                });
+                            }
+                            else if (record.__isCust) {
+                                tableNode.children.push({
+                                    text: chalk_1.default.bgYellow(sRecord.join(', ')),
+                                    children: []
+                                });
+                            }
+                            else {
+                                tableNode.children.push({
+                                    text: sRecord.join(', '),
+                                    children: []
+                                });
+                            }
+                        }
+                    });
+                    tree.children.push(tableNode);
+                }
+            });
+            trm_commons_1.Logger.tree(tree);
+            var header = ['', 'Namespace', 'ABAP Package', 'TRM Transport', 'Customizing', 'Translations'];
+            var row1 = [''];
+            var row2 = ['Highlight color'];
+            if (data.manifest.namespace) {
+                row1.push(`${data.manifest.namespace.ns || 'Yes'} ${data.manifest.namespace.replicense}`);
+                row2.push(``);
+            }
+            else {
+                row1.push(`No`);
+                row2.push(``);
+            }
+            if (Object.keys(packageContent).includes('DEVC')) {
+                row1.push(packageContent['DEVC'].trkorr);
+                row2.push(`${chalk_1.default.bgGrey('Grey')}`);
+            }
+            else {
+                row1.push(`No`);
+                row2.push(``);
+            }
+            if (Object.keys(packageContent).includes('TADIR')) {
+                row1.push(packageContent['TADIR'].trkorr);
+                row2.push(``);
+            }
+            else {
+                row1.push(`No`);
+                row2.push(``);
+            }
+            if (Object.keys(packageContent).includes('CUST')) {
+                row1.push(packageContent['CUST'].trkorr);
+                row2.push(`${chalk_1.default.bgYellow('Yellow')}`);
+            }
+            else {
+                row1.push(`No`);
+                row2.push(``);
+            }
+            if (Object.keys(packageContent).includes('LANG')) {
+                row1.push(packageContent['LANG'].trkorr);
+                row2.push(`${chalk_1.default.bgGreen('Green')}`);
+            }
+            else {
+                row1.push(`No`);
+                row2.push(``);
+            }
+            if (row2.filter(s => s.length > 0).length > 0) {
+                trm_commons_1.Logger.table(header, [row1, row2]);
+            }
+            else {
+                trm_commons_1.Logger.table(header, [row1]);
+            }
+            if (iOtherEntries > 0) {
+                trm_commons_1.Logger.warning(`There are ${iOtherEntries} other entries to show. Run with option "--full" in order to see them.`);
+            }
+        });
+    }
+}
+exports.Content = Content;

package/dist/command/implementations/Deprecate.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Deprecate extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Deprecate.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deprecate = void 0;
+const AbstractCommand_1 = require("../AbstractCommand");
+class Deprecate extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.command.description(`Deprecate a package release from registry.`);
+        this.command.argument(`<package>`, `Name of the package.`);
+        this.command.argument(`<version>`, `Version of the release.`);
+        this.command.option(`--note <note>`, `Deprecation note`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.args.note) {
+                throw new Error(`Provide a message with option "--note".`);
+            }
+            yield this.getRegistry().deprecate(this.args.package, this.args.version, {
+                deprecate_note: this.args.note
+            });
+        });
+    }
+}
+exports.Deprecate = Deprecate;

package/dist/command/implementations/DistTag.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class DistTag extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/DistTag.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistTag = void 0;
+const AbstractCommand_1 = require("../AbstractCommand");
+class DistTag extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        if (this.name.includes('add')) {
+            this.command.description(`Tag a release.`);
+            this.command.argument(`<package>`, `Name of the package.`);
+            this.command.argument(`<version>`, `Release version of the package.`);
+            this.command.argument(`<tag>`, `Tag to assign to release.`);
+        }
+        else if (this.name.includes('rm')) {
+            this.command.description(`Remove tag from a release.`);
+            this.command.argument(`<package>`, `Name of the package.`);
+            this.command.argument(`<tag>`, `Tag to remove.`);
+        }
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.args.add && this.args.add.trim().toLowerCase() === 'add') {
+                yield this.getRegistry().addDistTag(this.args.package, {
+                    version: this.args.version,
+                    tag: this.args.tag
+                });
+            }
+            else if (this.args.rm && this.args.rm.trim().toLowerCase() === 'rm') {
+                yield this.getRegistry().rmDistTag(this.args.package, {
+                    tag: this.args.tag
+                });
+            }
+            else {
+                throw new Error(`Unknown command.`);
+            }
+        });
+    }
+}
+exports.DistTag = DistTag;

package/dist/command/implementations/FindDependencies.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class FindDependencies extends AbstractCommand {
+    protected init(): void;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/FindDependencies.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindDependencies = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+class FindDependencies extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.command.description(`Find SAP package dependencies with custom packages/trm packages/SAP entries/objects.`);
+        this.command.argument(`<sap package>`, `Name of the SAP package to check.`);
+        this.command.option(`--sap-entries`, `Show list of required SAP entries/objects.`, false);
+        this.command.option(`--no-prompts`, `No prompts (will force some decisions).`, false);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            trm_commons_1.Logger.loading(`Searching for dependencies in package "${this.args.sapPackage}"...`);
+            yield (0, trm_core_1.findDependencies)({
+                contextData: {
+                    noInquirer: this.args.noPrompts
+                },
+                packageData: {
+                    package: this.args.sapPackage
+                },
+                printOptions: {
+                    trmDependencies: true,
+                    sapObjectDependencies: this.args.sapEntries
+                }
+            });
+        });
+    }
+}
+exports.FindDependencies = FindDependencies;

package/dist/command/implementations/Info.d.ts

@@ -0,0 +1,11 @@
+import { TrmPackage } from "trm-core";
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Info extends AbstractCommand {
+    protected init(): void;
+    protected onTrmDepMissing(dependency: string): boolean;
+    protected onTrmDepVersionNotSatisfied(trmPackage: TrmPackage): boolean;
+    private getDependencyVersion;
+    private getNodeRfcVersion;
+    private getNpmLatestForText;
+    protected handler(): Promise<void>;
+}