trm-client 6.1.1 → 7.0.0

package/dist/command/implementations/View.js

@@ -0,0 +1,237 @@
+"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 = void 0;
+const trm_commons_1 = require("trm-commons");
+const trm_core_1 = require("trm-core");
+const AbstractCommand_1 = require("../AbstractCommand");
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("../../utils");
+const semver_1 = require("semver");
+const registryAlias_1 = require("../../registryAlias");
+class View extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresConnection = true;
+        this.registerOpts.addNoConnection = true;
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.ignoreRegistryUnreachable = true;
+        this.command.description(`View package.`);
+        this.command.addHelpText(`before`, `Shows package details.
+If the package is not found on the system, it will automatically fall back to the data provided by the registry, granted it exists.`);
+        this.command.argument(`<package>`, `Name of the package.`);
+    }
+    printHeaderSection() {
+        trm_commons_1.Logger.info(`Package name: ${chalk_1.default.bold(this.args.package)}`);
+        trm_commons_1.Logger.info(`Registry: ${this.getRegistry().name}`);
+    }
+    printVersionSection(systemPackage, registryView) {
+        if (!systemPackage && !registryView) {
+            return;
+        }
+        var oSystemManifest;
+        if (!(trm_core_1.SystemConnector.systemConnector instanceof utils_1.DummyConnector)) {
+            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) {
+            if (registryView.dist_tags['latest']) {
+                console.log(`Latest version available: ${registryView.dist_tags['latest']}`);
+                if (oSystemManifest) {
+                    if ((0, semver_1.eq)(oSystemManifest.version, registryView.dist_tags['latest'])) {
+                        trm_commons_1.Logger.success(`Latest version installed: Yes`);
+                    }
+                    else {
+                        trm_commons_1.Logger.error(`Latest version installed: No`);
+                    }
+                }
+            }
+            else {
+                console.log(`Latest version available: unknown`);
+            }
+        }
+    }
+    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: ${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}`);
+        }
+    }
+    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);
+        }
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const packageName = this.args.package;
+            const dest = trm_core_1.SystemConnector.getDest();
+            const aSystemPackages = yield this.getSystemPackages();
+            trm_commons_1.Logger.loading(`Searching package ${packageName}...`);
+            const oSystemView = aSystemPackages.find(o => o.compareName(packageName) && o.compareRegistry(this.getRegistry()));
+            const oRegistryView = yield this.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.manifest.private,
+                    description: oRegistryView.manifest.shortDescription,
+                    git: oRegistryView.manifest.git,
+                    website: oRegistryView.manifest.website,
+                    license: oRegistryView.manifest.license
+                };
+            }
+            else {
+                throw new Error(`Package "${packageName}" does not exist or insufficient view permissions.`);
+            }
+            this.printHeaderSection();
+            this.printVersionSection(oSystemView, oRegistryView);
+            this.printManifestSection(printManifest);
+            this.printDependenciesSection(dependencies);
+        });
+    }
+}
+exports.View = View;

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

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

package/dist/command/implementations/WhoAmI.js

@@ -0,0 +1,36 @@
+"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.WhoAmI = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const trm_registry_types_1 = require("trm-registry-types");
+class WhoAmI extends AbstractCommand_1.AbstractCommand {
+    init() {
+        this.registerOpts.requiresRegistry = true;
+        this.registerOpts.onlyRegistryAlias = true;
+        this.registerOpts.registryAuthBlacklist = [trm_registry_types_1.AuthenticationType.NO_AUTH];
+        this.command.description(`Get data about a current registry logged user.`);
+        this.command.addHelpText(`before`, `This command has no effect when trying to login into a registry that doesn't require authentication.`);
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasRegistryAuthData()) {
+                yield this.registryWhoAmI();
+            }
+            else {
+                trm_commons_1.Logger.error(`You are not logged in`);
+                trm_commons_1.Logger.error(`Run command "trm login" and follow instructions.`);
+            }
+        });
+    }
+}
+exports.WhoAmI = WhoAmI;

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

@@ -0,0 +1,19 @@
+export * from "./Ping";
+export * from "./Info";
+export * from "./Registry";
+export * from "./Login";
+export * from "./WhoAmI";
+export * from "./Logout";
+export * from "./Alias";
+export * from "./Publish";
+export * from "./DistTag";
+export * from "./Lock";
+export * from "./Unpublish";
+export * from "./Deprecate";
+export * from "./Install";
+export * from "./List";
+export * from "./Content";
+export * from "./View";
+export * from "./Compare";
+export * from "./FindDependencies";
+export * from "./Settings";

package/dist/command/implementations/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Ping"), exports);
+__exportStar(require("./Info"), exports);
+__exportStar(require("./Registry"), exports);
+__exportStar(require("./Login"), exports);
+__exportStar(require("./WhoAmI"), exports);
+__exportStar(require("./Logout"), exports);
+__exportStar(require("./Alias"), exports);
+__exportStar(require("./Publish"), exports);
+__exportStar(require("./DistTag"), exports);
+__exportStar(require("./Lock"), exports);
+__exportStar(require("./Unpublish"), exports);
+__exportStar(require("./Deprecate"), exports);
+__exportStar(require("./Install"), exports);
+__exportStar(require("./List"), exports);
+__exportStar(require("./Content"), exports);
+__exportStar(require("./View"), exports);
+__exportStar(require("./Compare"), exports);
+__exportStar(require("./FindDependencies"), exports);
+__exportStar(require("./Settings"), exports);

package/dist/command/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./AbstractCommand";
+export * from "./InquirerType";
+export * from "./LoggerType";
+export * from "./RegisterCommandOpts";

package/dist/{commands/commons → command}/index.js

@@ -14,5 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./viewRegistryPackage"), exports);
-__exportStar(require("./CommandContext"), exports);
+__exportStar(require("./AbstractCommand"), exports);
+__exportStar(require("./InquirerType"), exports);
+__exportStar(require("./LoggerType"), exports);
+__exportStar(require("./RegisterCommandOpts"), exports);

package/dist/{commands/arguments/ConnectArguments.d.ts → command/prompts/connect.d.ts}

@@ -1,3 +1,4 @@
+import { IConnect } from "trm-commons";
 import { ISystemConnector } from "trm-core";
 export type ConnectArguments = {
     type?: string;
@@ -15,3 +16,4 @@ export type ConnectArguments = {
     forwardRfcDest?: string;
     connection?: ISystemConnector;
 };
+export declare function connect(commandArgs: ConnectArguments, createAliasIfNotExist?: boolean, addNoConnection?: boolean): Promise<IConnect>;

package/dist/{commands → command}/prompts/connect.js

@@ -121,7 +121,7 @@ function connect(commandArgs_1) {
                     };
                 })
             })).alias;
-            const connection = utils_1.Context.getInstance().getConnections().find(o => o.name === inq2.type);
+            const connection = utils_1.GlobalContext.getInstance().getConnections().find(o => o.name === inq2.type);
             if (!connection) {
                 throw new Error(`Unknown connection type "${inq2.type}" in alias "${inq2.name}"`);
             }
@@ -158,7 +158,7 @@ function connect(commandArgs_1) {
                     type: `list`,
                     name: `type`,
                     message: `Connection type`,
-                    choices: utils_1.Context.getInstance().getConnections().map(o => {
+                    choices: utils_1.GlobalContext.getInstance().getConnections().map(o => {
                         return {
                             name: o.description,
                             value: o.name
@@ -166,7 +166,7 @@ function connect(commandArgs_1) {
                     })
                 })).type;
             }
-            const connectionType = utils_1.Context.getInstance().getConnections().find(o => o.name === type);
+            const connectionType = utils_1.GlobalContext.getInstance().getConnections().find(o => o.name === type);
             if (!connectionType) {
                 throw new Error(`Invalid connection type "${type}"`);
             }

package/dist/command/prompts/createAlias.d.ts

@@ -0,0 +1 @@
+export declare function createAlias(alias: string): Promise<void>;

package/dist/{commands → command/prompts}/createAlias.js

@@ -10,17 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAlias = createAlias;
-const systemAlias_1 = require("../systemAlias");
-const prompts_1 = require("./prompts");
 const trm_commons_1 = require("trm-commons");
-function createAlias(commandArgs) {
+const systemAlias_1 = require("../../systemAlias");
+const connect_1 = require("./connect");
+function createAlias(alias) {
     return __awaiter(this, void 0, void 0, function* () {
-        const connection = yield (0, prompts_1.connect)({
+        const connection = yield (0, connect_1.connect)({
             noSystemAlias: true,
             force: true
         }, false, false);
-        systemAlias_1.SystemAlias.create(commandArgs.alias, connection.name, connection.getData());
-        trm_commons_1.Logger.loading(`Connecting to "${commandArgs.alias}"...`);
+        systemAlias_1.SystemAlias.create(alias, connection.name, connection.getData());
+        trm_commons_1.Logger.loading(`Connecting to "${alias}"...`);
         var connectionSuccess = true;
         try {
             yield connection.getSystemConnector().connect();
@@ -31,10 +31,10 @@ function createAlias(commandArgs) {
         }
         finally {
             if (connectionSuccess) {
-                trm_commons_1.Logger.success(`Alias "${commandArgs.alias}" created.`);
+                trm_commons_1.Logger.success(`Alias "${alias}" has been created.`);
             }
             else {
-                systemAlias_1.SystemAlias.delete(commandArgs.alias);
+                systemAlias_1.SystemAlias.delete(alias);
             }
         }
     });

package/dist/command/prompts/deleteAlias.d.ts

@@ -0,0 +1 @@
+export declare function deleteAlias(alias: string): Promise<void>;

package/dist/{commands → command/prompts}/deleteAlias.js

@@ -11,12 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteAlias = deleteAlias;
 const trm_commons_1 = require("trm-commons");
-const systemAlias_1 = require("../systemAlias");
-function deleteAlias(commandArgs) {
+const systemAlias_1 = require("../../systemAlias");
+function deleteAlias(alias) {
     return __awaiter(this, void 0, void 0, function* () {
-        const alias = commandArgs.alias;
         systemAlias_1.SystemAlias.get(alias);
         systemAlias_1.SystemAlias.delete(alias);
-        trm_commons_1.Logger.success(`Alias "${alias}" deleted.`);
+        trm_commons_1.Logger.success(`Alias "${alias}" has been deleted.`);
     });
 }

package/dist/command/prompts/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./connect";
+export * from "./pickRegistry";
+export * from "./createAlias";
+export * from "./deleteAlias";

package/dist/{commands → command}/prompts/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./connect"), exports);
 __exportStar(require("./pickRegistry"), exports);
+__exportStar(require("./createAlias"), exports);
+__exportStar(require("./deleteAlias"), exports);