trm-client/dist/commands/view.js

TRM (Transport Request Manager) Client

"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.view = view;
const trm_core_1 = require("trm-core");
const commons_1 = require("./commons");
const semver_1 = require("semver");
const registryAlias_1 = require("../registryAlias");
const utils_1 = require("../utils");
const chalk_1 = __importDefault(require("chalk"));
const trm_commons_1 = require("trm-commons");
const _printHeaderSection = (packageName) => {
    trm_commons_1.Logger.info(`Package name: ${chalk_1.default.bold(packageName)}`);
    trm_commons_1.Logger.info(`Registry: ${commons_1.CommandContext.getRegistry().name}`);
};
const _printVersionSection = (systemPackage, registryView) => {
    if (!systemPackage && !registryView) {
        return;
    }
    var oSystemManifest;
    if (!(trm_core_1.SystemConnector.systemConnector instanceof utils_1.NoConnection)) {
        console.log('');
        if (systemPackage) {
            oSystemManifest = systemPackage.manifest.get();
            trm_commons_1.Logger.success(`Installed on ${trm_core_1.SystemConnector.getDest()}: Yes`);
            console.log(`Installed version: ${oSystemManifest.version}`);
        }
        else {
            trm_commons_1.Logger.error(`Installed on ${trm_core_1.SystemConnector.getDest()}: No`);
        }
    }
    if (registryView && registryView.release) {
        console.log(`Latest version available: ${registryView.release.version}`);
        if (oSystemManifest) {
            if ((0, semver_1.eq)(oSystemManifest.version, registryView.release.version)) {
                trm_commons_1.Logger.success(`Latest version installed: Yes`);
            }
            else {
                trm_commons_1.Logger.error(`Latest version installed: No`);
            }
        }
    }
};
const _printManifestSection = (manifest) => {
    console.log('');
    if (manifest.devclass !== undefined) {
        console.log(`SAP Package: ${manifest.devclass}`);
    }
    if (manifest.importTransport !== undefined) {
        console.log(`TRM transport: ${manifest.importTransport}`);
    }
    if (manifest.workbenchTransport !== undefined) {
        console.log(`Landscape transport (Use this to transport in landscape): ${manifest.workbenchTransport}`);
    }
    if (manifest.private !== undefined) {
        if (manifest.private) {
            console.log(`Private: Yes`);
        }
        else {
            console.log(`Private: No`);
        }
    }
    if (manifest.description !== undefined) {
        console.log(`Short description: ${manifest.description}`);
    }
    if (manifest.backwardsCompatible !== undefined) {
        if (manifest.backwardsCompatible) {
            console.log(`Backwards compatible: Yes`);
        }
        else {
            console.log(`Backwards compatible: No`);
        }
    }
    if (manifest.website !== undefined) {
        console.log(`Website: ${manifest.website}`);
    }
    if (manifest.git !== undefined) {
        console.log(`Git: ${manifest.git}`);
    }
    if (manifest.authors !== undefined) {
        console.log(`Authors: ${manifest.authors}`);
    }
    if (manifest.license !== undefined) {
        console.log(`License: ${manifest.license}`);
    }
};
const _printDependenciesSection = (dependencies) => {
    if (dependencies.length > 0) {
        console.log('');
        trm_commons_1.Logger.info(`This package has a total of ${dependencies.length} dependencies.`);
        const registryAliases = registryAlias_1.RegistryAlias.getAll();
        const tableHead = [`Name`, `Version`, `Registry`];
        var tableData = [];
        dependencies.forEach(o => {
            const dependencyName = o.name;
            const dependencyVersion = o.version;
            var dependencyRegistry;
            if (!o.registry || o.registry.trim().toLowerCase() === trm_core_1.PUBLIC_RESERVED_KEYWORD) {
                dependencyRegistry = trm_core_1.PUBLIC_RESERVED_KEYWORD;
            }
            else {
                const oRegistryAlias = registryAliases.find(k => k.endpointUrl === o.registry);
                if (oRegistryAlias) {
                    dependencyRegistry = oRegistryAlias.alias;
                }
                else {
                    dependencyRegistry = o.registry;
                }
            }
            tableData.push([
                dependencyName,
                dependencyVersion,
                dependencyRegistry
            ]);
        });
        trm_commons_1.Logger.table(tableHead, tableData);
    }
};
function view(commandArgs) {
    return __awaiter(this, void 0, void 0, function* () {
        const packageName = commandArgs.package;
        const dest = trm_core_1.SystemConnector.getDest();
        trm_commons_1.Logger.loading(`Searching package ${packageName}...`);
        const aSystemPackages = yield commons_1.CommandContext.getSystemPackages();
        const oSystemView = aSystemPackages.find(o => o.compareName(packageName) && o.compareRegistry(commons_1.CommandContext.getRegistry()));
        const oRegistryView = yield (0, commons_1.viewRegistryPackage)(packageName, true);
        var authors;
        var keywords;
        var printManifest;
        var dependencies;
        if (oSystemView) {
            if (!oSystemView.manifest) {
                throw new Error(`Package "${packageName}" found, but manifest is missing on ${dest}!`);
            }
            const oSystemManifest = oSystemView.manifest.get();
            if (Array.isArray(oSystemManifest.authors)) {
                authors = oSystemManifest.authors.map(o => {
                    var sAuthor;
                    if (o.email) {
                        if (o.name) {
                            sAuthor = `${o.name} <${o.email}>`;
                        }
                        else {
                            sAuthor = o.email;
                        }
                    }
                    else if (o.name) {
                        sAuthor = o.name;
                    }
                    else {
                        return undefined;
                    }
                    return sAuthor;
                }).join(', ');
            }
            else {
                authors = oSystemManifest.authors;
            }
            if (Array.isArray(oSystemManifest.keywords)) {
                keywords = oSystemManifest.keywords.join(', ');
            }
            else {
                keywords = oSystemManifest.keywords;
            }
            var importTransport;
            var workbenchTransport;
            try {
                importTransport = oSystemView.manifest.getLinkedTransport().trkorr;
            }
            catch (e) { }
            try {
                workbenchTransport = (yield oSystemView.getWbTransport()).trkorr;
            }
            catch (e) { }
            dependencies = oSystemManifest.dependencies || [];
            printManifest = {
                devclass: oSystemView.getDevclass(),
                private: oSystemManifest.private,
                description: oSystemManifest.description,
                git: oSystemManifest.git,
                website: oSystemManifest.website,
                backwardsCompatible: oSystemManifest.backwardsCompatible,
                license: oSystemManifest.license,
                authors,
                keywords,
                importTransport,
                workbenchTransport
            };
        }
        else if (oRegistryView) {
            dependencies = [];
            printManifest = {
                private: oRegistryView.private,
                description: oRegistryView.shortDescription,
                git: oRegistryView.git,
                website: oRegistryView.website,
                license: oRegistryView.license
            };
        }
        else {
            throw new Error(`Package "${packageName}" does not exist or insufficient view permissions.`);
        }
        _printHeaderSection(packageName);
        _printVersionSection(oSystemView, oRegistryView);
        _printManifestSection(printManifest);
        _printDependenciesSection(dependencies);
    });
}