trm-client 3.1.6 → 4.0.1

package/dist/commands/info.js

@@ -8,21 +8,69 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.info = void 0;
 const trm_core_1 = require("trm-core");
 const utils_1 = require("../utils");
+const commons_1 = require("./commons");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const get_root_path_1 = require("get-root-path");
+const chalk_1 = __importDefault(require("chalk"));
+const _getDependencyVersion = (moduleName) => {
+    var file;
+    try {
+        file = (0, fs_1.readFileSync)(path_1.default.join(get_root_path_1.rootPath, `/node_modules/trm-client/node_modules/${moduleName}/package.json`));
+    }
+    catch (e) {
+        file = (0, fs_1.readFileSync)(path_1.default.join(get_root_path_1.rootPath, `/node_modules/${moduleName}/package.json`));
+    }
+    if (!file) {
+        trm_core_1.Logger.warning(`Library ${moduleName} was not found!`, true);
+    }
+    else {
+        return JSON.parse(file.toString()).version;
+    }
+};
+const _getNodeRfcVersion = (npmGlobal) => {
+    var file;
+    try {
+        file = (0, fs_1.readFileSync)(path_1.default.join(npmGlobal, `/node-rfc/package.json`));
+    }
+    catch (e) {
+    }
+    if (!file) {
+        trm_core_1.Logger.warning(`Library node-rfc was not found!`, true);
+    }
+    else {
+        return JSON.parse(file.toString()).version;
+    }
+};
 function info(commandArgs) {
     return __awaiter(this, void 0, void 0, function* () {
+        const npmGlobal = yield (0, trm_core_1.getNpmGlobalPath)();
         const clientVersion = (0, utils_1.getClientVersion)();
         const clientDependencies = (0, utils_1.getClientDependencies)() || {};
         const trmDependencies = (0, utils_1.getTrmDependencies)() || {};
-        const trmDependenciesInstances = utils_1.TrmDependencies.getInstance().getAll();
+        const trmDependenciesInstances = commons_1.CommandContext.trmDependencies;
+        const trmMissingDependencies = commons_1.CommandContext.missingTrmDependencies;
+        const nodeRfcVersion = _getNodeRfcVersion(npmGlobal);
+        const trmRest = commons_1.CommandContext.systemPackages.find(o => o.compareName("trm-rest") && o.compareRegistry(new trm_core_1.Registry(trm_core_1.PUBLIC_RESERVED_KEYWORD)));
         var clientDependenciesTree = [];
         if (clientDependencies) {
             Object.keys(clientDependencies).filter(d => d.startsWith('trm')).forEach(d => {
+                var installedVersion = _getDependencyVersion(d);
+                if (installedVersion) {
+                    installedVersion = ` -> ${installedVersion}`;
+                }
+                else {
+                    installedVersion = ``;
+                }
                 clientDependenciesTree.push({
-                    text: `${d} ${clientDependencies[d]}`,
+                    text: `${d} ${clientDependencies[d]}${installedVersion}`,
                     children: []
                 });
             });
@@ -30,15 +78,37 @@ function info(commandArgs) {
         var serverDependenciesTree = [];
         if (trmDependencies) {
             Object.keys(trmDependencies).forEach(d => {
+                var installedVersion = ``;
                 const oTrmPackage = trmDependenciesInstances.find(o => o.compareName(d));
-                var installedVersion;
-                try {
-                    installedVersion = oTrmPackage.manifest.get().version;
+                if (oTrmPackage) {
+                    try {
+                        installedVersion = ` -> ${oTrmPackage.manifest.get().version}`;
+                    }
+                    catch (e) {
+                        installedVersion = ` -> ${e.message}`;
+                    }
                 }
-                catch (e) {
-                }
-                if (installedVersion) {
-                    installedVersion = ` -> ${trm_core_1.SystemConnector.getDest()} ${installedVersion}`;
+                else {
+                    const missingDependency = trmMissingDependencies.find(o => {
+                        if (typeof (o) === 'string') {
+                            if (o === d) {
+                                return o;
+                            }
+                        }
+                        else {
+                            if (o.compareName(d)) {
+                                return o;
+                            }
+                        }
+                    });
+                    if (missingDependency) {
+                        try {
+                            installedVersion = ` -> ${chalk_1.default.bgRed(missingDependency.manifest.get().version)}`;
+                        }
+                        catch (e) {
+                            installedVersion = ` -> ${chalk_1.default.bgRed('Not found')}`;
+                        }
+                    }
                 }
                 serverDependenciesTree.push({
                     text: `${d} ${trmDependencies[d]}${installedVersion}`,
@@ -46,16 +116,29 @@ function info(commandArgs) {
                 });
             });
         }
+        if (trmRest && trmRest.manifest) {
+            serverDependenciesTree.push({
+                text: `trm-rest -> ${trmRest.manifest.get().version}`,
+                children: []
+            });
+        }
+        var clientChildrenTree = [{
+                text: `trm-client ${clientVersion}`,
+                children: clientDependenciesTree
+            }];
+        if (nodeRfcVersion) {
+            clientChildrenTree.push({
+                text: `node-rfc ${nodeRfcVersion}`,
+                children: []
+            });
+        }
         const clientTree = {
-            text: `Client`,
-            children: [{
-                    text: `trm-client ${clientVersion}`,
-                    children: clientDependenciesTree
-                }]
+            text: chalk_1.default.bold(`Client`),
+            children: clientChildrenTree
         };
         trm_core_1.Logger.tree(clientTree);
         const serverTree = {
-            text: `Server`,
+            text: chalk_1.default.bold(`Server (${trm_core_1.SystemConnector.getDest()})`),
             children: serverDependenciesTree
         };
         trm_core_1.Logger.tree(serverTree);

package/dist/commands/install.js

@@ -1,27 +1,4 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 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) {
@@ -34,28 +11,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.install = void 0;
 const trm_core_1 = require("trm-core");
-const commons_1 = require("./commons");
-const fs = __importStar(require("fs"));
 const utils_1 = require("../utils");
-const _parsePackageReplacementsArgument = (packageReplacements) => {
-    var returnValue = [];
-    if (packageReplacements) {
-        packageReplacements = packageReplacements.trim();
-        var sInput;
-        if (packageReplacements[0] === '[') {
-            sInput = packageReplacements;
-        }
-        else {
-            sInput = fs.readFileSync(packageReplacements);
-        }
+const commons_1 = require("./commons");
+const _parsePackageReplacementsArgument = (arg) => {
+    if (arg) {
         try {
-            returnValue = JSON.parse(sInput);
-        }
-        catch (e) {
-            throw new Error('Input package replacements map: invalid JSON format.');
+            return JSON.parse(arg);
         }
+        catch (e) { }
     }
-    return returnValue;
 };
 const _parseImportTimeoutArg = (arg) => {
     if (arg) {
@@ -67,52 +31,49 @@ const _parseImportTimeoutArg = (arg) => {
 };
 function install(commandArgs) {
     return __awaiter(this, void 0, void 0, function* () {
-        const registry = commons_1.CommandRegistry.get();
-        const packageName = commandArgs.package;
-        const packageVersion = commandArgs.version || 'latest';
-        const transportLayer = commandArgs.transportLayer;
-        const force = commandArgs.force;
-        const keepOriginalDevclass = commandArgs.keepOriginals ? true : false;
-        const importTimeout = _parseImportTimeoutArg(commandArgs.importTimeout);
-        const generateTransport = commandArgs.workbenchGen;
-        const skipSapEntriesCheck = commandArgs.skipSapEntries;
-        const skipObjectTypesCheck = commandArgs.skipObjectsCheck;
-        const skipLangImport = commandArgs.skipLang;
-        const skipCustImport = commandArgs.skipCustomizing;
-        const ignoreDependencies = commandArgs.skipDependencies;
-        const wbTrTargetSystem = commandArgs.workbenchTarget;
-        const silent = commandArgs.silent;
-        const packageReplacements = _parsePackageReplacementsArgument(commandArgs.packageReplacements);
-        const allowReplace = commandArgs.replaceAllowed;
-        const tmpFolder = (0, utils_1.getTempFolder)();
-        const output = yield (0, trm_core_1.install)({
-            packageName: packageName,
-            registry: registry,
-            version: packageVersion,
-            r3transOptions: {
-                tempDirPath: tmpFolder
+        const result = yield (0, trm_core_1.install)({
+            contextData: {
+                r3transOptions: {
+                    tempDirPath: (0, utils_1.getTempFolder)(),
+                    r3transDirPath: commandArgs.r3transPath
+                },
+                noInquirer: commandArgs.noPrompts,
+                systemPackages: commons_1.CommandContext.systemPackages,
+                noR3transInfo: false
             },
-            transportLayer,
-            force,
-            keepOriginalDevclass,
-            importTimeout,
-            generateTransport,
-            skipSapEntriesCheck,
-            skipObjectTypesCheck,
-            skipLangImport,
-            skipCustImport,
-            ignoreDependencies,
-            wbTrTargetSystem,
-            silent,
-            packageReplacements,
-            allowReplace
+            packageData: {
+                name: commandArgs.package,
+                version: commandArgs.version,
+                overwrite: commandArgs.overwrite,
+                integrity: commandArgs.integrity,
+                registry: commons_1.CommandContext.getRegistry()
+            },
+            installData: {
+                checks: {
+                    safe: commandArgs.safe,
+                    noDependencies: commandArgs.noDependencies,
+                    noObjectTypes: commandArgs.noObjectTypes,
+                    noSapEntries: commandArgs.noSapEntries
+                },
+                import: {
+                    noLang: commandArgs.noLanguageTransport,
+                    noCust: commandArgs.noCustomizingTransport,
+                    timeout: _parseImportTimeoutArg(commandArgs.importTimeout)
+                },
+                installDevclass: {
+                    keepOriginal: commandArgs.keepOriginalPackages,
+                    transportLayer: commandArgs.transportLayer,
+                    replacements: _parsePackageReplacementsArgument(commandArgs.packageReplacements)
+                },
+                installTransport: {
+                    create: commandArgs.createInstallTransport,
+                    targetSystem: commandArgs.installTransportTargetSys
+                }
+            }
         });
-        var sOutput = `${output.trmPackage.packageName} installed`;
-        if (output.wbTransport) {
-            sOutput += `, use ${output.wbTransport.trkorr} transport.`;
-        }
-        else {
-            sOutput += `.`;
+        var sOutput = `${result.trmPackage.packageName} installed`;
+        if (result.installTransport) {
+            sOutput += `, use ${result.installTransport.trkorr} transport in landscape`;
         }
         trm_core_1.Logger.success(sOutput);
     });

package/dist/commands/login.js

@@ -12,14 +12,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.login = void 0;
 const trm_core_1 = require("trm-core");
 const registryAlias_1 = require("../registryAlias");
-const commons_1 = require("./commons");
 const whoami_1 = require("./whoami");
+const commons_1 = require("./commons");
 function login(commandArgs) {
     return __awaiter(this, void 0, void 0, function* () {
         var continueLogin = false;
         if (!commandArgs.force) {
             try {
-                const whoami = yield commons_1.CommandRegistry.get().whoAmI();
+                const whoami = yield commons_1.CommandContext.getRegistry().whoAmI();
                 const inq1 = yield trm_core_1.Inquirer.prompt({
                     type: "confirm",
                     name: "continue",
@@ -49,10 +49,10 @@ function login(commandArgs) {
             else {
                 oAuth = undefined;
             }
-            yield commons_1.CommandRegistry.get().authenticate(oAuth);
-            oAuth = commons_1.CommandRegistry.get().getAuthData();
+            yield commons_1.CommandContext.getRegistry().authenticate(oAuth);
+            oAuth = commons_1.CommandContext.getRegistry().getAuthData();
             trm_core_1.Logger.success('Logged in.');
-            registryAlias_1.RegistryAlias.update(commons_1.CommandRegistry.get().name, oAuth);
+            registryAlias_1.RegistryAlias.update(commons_1.CommandContext.getRegistry().name, oAuth);
             yield (0, whoami_1.whoami)({});
         }
     });

package/dist/commands/logout.js

@@ -16,8 +16,8 @@ const commons_1 = require("./commons");
 function logout(commandArgs) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield commons_1.CommandRegistry.get().whoAmI();
-            registryAlias_1.RegistryAlias.update(commons_1.CommandRegistry.get().name, null);
+            yield commons_1.CommandContext.getRegistry().whoAmI();
+            registryAlias_1.RegistryAlias.update(commons_1.CommandContext.getRegistry().name, null);
             trm_core_1.Logger.info(`Logged out.`);
         }
         catch (e) {

package/dist/commands/prompts/connect.js

@@ -8,11 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.connect = void 0;
 const trm_core_1 = require("trm-core");
 const systemAlias_1 = require("../../systemAlias");
 const utils_1 = require("../../utils");
+const normalize_url_1 = __importDefault(require("@esm2cjs/normalize-url"));
 const languageList = [
     { value: 'AR', name: 'AR (Arabic)' },
     { value: 'BG', name: 'BG (Bulgarian)' },
@@ -54,10 +58,13 @@ const languageList = [
     { value: 'UK', name: 'UK (Ukrainian)' },
     { value: 'VI', name: 'VI (Vietnamese)' }
 ];
+const _createAliasIfNotExists = () => {
+};
 function connect(commandArgs, createAliasIfNotExist = true) {
     return __awaiter(this, void 0, void 0, function* () {
         const noSystemAlias = commandArgs.noSystemAlias ? true : false;
         const force = commandArgs.force ? true : false;
+        var type = commandArgs.type;
         var aInputType = [];
         var aSapLogonConnections;
         const aAlias = systemAlias_1.SystemAlias.getAll();
@@ -72,14 +79,14 @@ function connect(commandArgs, createAliasIfNotExist = true) {
                 value: 'alias', name: 'System Alias'
             });
         }
+        aInputType.push({
+            value: 'input', name: 'Manual input'
+        });
         if (aSapLogonConnections.length > 0) {
             aInputType.push({
-                value: 'logon', name: 'SAP Logon Connection'
+                value: 'logon', name: 'SAP Logon Connection (Uses node-rfc)'
             });
         }
-        aInputType.push({
-            value: 'input', name: 'Manual input'
-        });
         var result;
         var inputType;
         if (!commandArgs.ashost && !commandArgs.dest && !commandArgs.sysnr) {
@@ -107,6 +114,8 @@ function connect(commandArgs, createAliasIfNotExist = true) {
             });
             const alias = aAlias.find(o => o.alias === inq2.aliasName);
             result = Object.assign(Object.assign({}, alias.connection), alias.login);
+            type = alias.type;
+            createAliasIfNotExist = false;
         }
         else {
             if (inputType === 'logon') {
@@ -125,73 +134,167 @@ function connect(commandArgs, createAliasIfNotExist = true) {
                 commandArgs.dest = logonConnection.dest;
                 commandArgs.sysnr = logonConnection.sysnr;
                 commandArgs.saprouter = logonConnection.saprouter;
+                type = utils_1.SystemConnectorType.RFC;
+            }
+            else {
+                type = commandArgs.type;
             }
             result = yield trm_core_1.Inquirer.prompt([{
+                    type: `list`,
+                    name: `type`,
+                    message: `Connection type`,
+                    choices: [{
+                            value: 'REST',
+                            name: 'REST (Requires trm-rest)'
+                        }, {
+                            value: 'RFC',
+                            name: 'RFC (Uses node-rfc)'
+                        }],
+                    when: (type ? false : true) || force
+                },
+                {
+                    type: `input`,
+                    name: `endpoint`,
+                    message: `System endpoint`,
+                    default: commandArgs.endpoint,
+                    when: (hash) => {
+                        return hash.type === 'REST' && ((commandArgs.endpoint ? false : true) || force);
+                    }
+                }, {
+                    type: `input`,
+                    name: `forwardRfcDest`,
+                    message: `Forward RFC Destination`,
+                    default: commandArgs.forwardRfcDest,
+                    when: (hash) => {
+                        return hash.type === 'REST' && (commandArgs.forwardRfcDest || force);
+                    }
+                },
+                {
                     type: `input`,
                     name: `ashost`,
                     message: `Application server`,
                     default: commandArgs.ashost,
-                    when: (commandArgs.ashost ? false : true) || force
+                    when: (hash) => {
+                        return hash.type === 'RFC' && ((commandArgs.ashost ? false : true) || force);
+                    }
                 }, {
                     type: `input`,
                     name: `dest`,
                     message: `System ID`,
                     default: commandArgs.dest,
-                    when: (commandArgs.dest ? false : true) || force
+                    when: (hash) => {
+                        return hash.type === 'RFC' && ((commandArgs.dest ? false : true) || force);
+                    }
                 }, {
                     type: `input`,
                     name: `sysnr`,
                     message: `Instance number`,
                     default: commandArgs.sysnr,
-                    when: (commandArgs.sysnr ? false : true) || force
+                    when: (hash) => {
+                        return hash.type === 'RFC' && ((commandArgs.sysnr ? false : true) || force);
+                    }
                 }, {
                     type: `input`,
                     name: `saprouter`,
                     message: `SAProuter`,
                     default: commandArgs.saprouter,
-                    when: force
+                    when: (hash) => {
+                        return hash.type === 'RFC' && ((commandArgs.saprouter ? false : true) || force);
+                    }
                 }, {
                     type: `input`,
                     name: `client`,
                     message: `Logon Client`,
                     default: commandArgs.client,
-                    when: (commandArgs.client ? false : true) || force
+                    when: (hash) => {
+                        return hash.type === 'RFC' && ((commandArgs.client ? false : true) || force);
+                    }
                 }, {
                     type: `input`,
                     name: `user`,
                     message: `Logon User`,
                     default: commandArgs.user,
-                    when: (commandArgs.user ? false : true) || force
+                    when: (hash) => {
+                        return (commandArgs.user ? false : true) || force;
+                    }
                 }, {
                     type: `password`,
                     name: `passwd`,
                     message: `Logon Password`,
                     default: commandArgs.passwd,
-                    when: (commandArgs.passwd ? false : true) || force
+                    when: (hash) => {
+                        return (commandArgs.passwd ? false : true) || force;
+                    }
                 }, {
                     type: `list`,
                     name: `lang`,
                     message: `Logon Language`,
-                    default: commandArgs.lang,
-                    when: (commandArgs.lang ? false : true) || force,
+                    default: commandArgs.lang || 'EN',
+                    when: (hash) => {
+                        return (commandArgs.lang ? false : true) || force;
+                    },
                     validate: (input) => {
                         return languageList.includes(input.trim().toUpperCase());
                     },
                     choices: languageList
                 }]);
         }
-        result.ashost = result.ashost || commandArgs.ashost;
-        result.dest = result.dest || commandArgs.dest;
-        result.saprouter = result.saprouter || commandArgs.saprouter;
-        result.sysnr = result.sysnr || commandArgs.sysnr;
-        result.client = result.client || commandArgs.client;
+        type = result.type || type;
         result.user = result.user || commandArgs.user;
         result.passwd = result.passwd || commandArgs.passwd;
         result.lang = result.lang || commandArgs.lang;
-        result.noSystemAlias = commandArgs.noSystemAlias;
-        result.dest = result.dest.toUpperCase();
         result.user = result.user.toUpperCase();
         result.lang = result.lang.toUpperCase();
+        if (type === utils_1.SystemConnectorType.RFC) {
+            result.ashost = result.ashost || commandArgs.ashost;
+            result.dest = result.dest || commandArgs.dest;
+            result.saprouter = result.saprouter || commandArgs.saprouter;
+            result.sysnr = result.sysnr || commandArgs.sysnr;
+            result.client = result.client || commandArgs.client;
+            result.noSystemAlias = commandArgs.noSystemAlias;
+            result.dest = result.dest.toUpperCase();
+            result.connection = (0, utils_1.getSystemConnector)(utils_1.SystemConnectorType.RFC, {
+                connection: {
+                    dest: result.dest,
+                    ashost: result.ashost,
+                    sysnr: result.sysnr,
+                    saprouter: result.saprouter
+                },
+                login: {
+                    user: result.user,
+                    passwd: result.passwd,
+                    lang: result.lang,
+                    client: result.client
+                }
+            });
+        }
+        else if (type === utils_1.SystemConnectorType.REST) {
+            result.endpoint = result.endpoint || commandArgs.endpoint;
+            result.forwardRfcDest = result.forwardRfcDest || commandArgs.forwardRfcDest;
+            if (result.forwardRfcDest) {
+                result.forwardRfcDest = result.forwardRfcDest.toUpperCase();
+            }
+            result.endpoint = (0, normalize_url_1.default)(result.endpoint, {
+                removeTrailingSlash: true
+            });
+            result.connection = (0, utils_1.getSystemConnector)(utils_1.SystemConnectorType.REST, {
+                connection: {
+                    endpoint: result.endpoint,
+                    rfcdest: result.forwardRfcDest || 'NONE'
+                },
+                login: {
+                    user: result.user,
+                    passwd: result.passwd,
+                    lang: result.lang
+                }
+            });
+        }
+        else {
+            throw new Error(`Unknown connection type "${type}".`);
+        }
+        if (createAliasIfNotExist) {
+            yield systemAlias_1.SystemAlias.createIfNotExists(result);
+        }
         return result;
     });
 }