trm-client 4.10.0 → 5.0.0

package/dist/commands/prompts/connect.js

@@ -8,14 +8,10 @@ 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 = connect;
 const systemAlias_1 = require("../../systemAlias");
 const utils_1 = require("../../utils");
-const normalize_url_1 = __importDefault(require("@esm2cjs/normalize-url"));
 const trm_commons_1 = require("trm-commons");
 const languageList = [
     { value: 'AR', name: 'AR (Arabic)' },
@@ -58,8 +54,6 @@ const languageList = [
     { value: 'UK', name: 'UK (Ukrainian)' },
     { value: 'VI', name: 'VI (Vietnamese)' }
 ];
-const _createAliasIfNotExists = () => {
-};
 function connect(commandArgs_1) {
     return __awaiter(this, arguments, void 0, function* (commandArgs, createAliasIfNotExist = true, addNoConnection) {
         const noSystemAlias = commandArgs.noSystemAlias ? true : false;
@@ -85,16 +79,15 @@ function connect(commandArgs_1) {
             });
         }
         aInputType.push({
-            value: 'input', name: 'Manual input'
+            value: null, name: 'Manual input'
         });
         if (aSapLogonConnections.length > 0) {
             aInputType.push({
                 value: 'logon', name: 'SAP Logon Connection (Uses node-rfc)'
             });
         }
-        var result;
         var inputType;
-        if (!commandArgs.ashost && !commandArgs.dest && !commandArgs.sysnr) {
+        if (!commandArgs.type) {
             const inq1 = yield trm_commons_1.Inquirer.prompt({
                 type: `list`,
                 name: `inputType`,
@@ -103,29 +96,26 @@ function connect(commandArgs_1) {
             });
             inputType = inq1.inputType;
         }
-        else {
-            inputType = 'input';
-        }
         if (inputType === 'none') {
-            return {
-                connection: new utils_1.NoConnection()
-            };
+            return null;
         }
         else if (inputType === 'alias') {
-            const inq2 = yield trm_commons_1.Inquirer.prompt({
+            const inq2 = (yield trm_commons_1.Inquirer.prompt({
                 type: `list`,
-                name: `aliasName`,
+                name: `alias`,
                 message: `Select alias`,
                 choices: aAlias.map(o => {
                     return {
-                        value: o.alias, name: o.alias
+                        value: o, name: o.alias
                     };
                 })
-            });
-            const alias = aAlias.find(o => o.alias === inq2.aliasName);
-            result = Object.assign(Object.assign({}, alias.connection), alias.login);
-            type = alias.type;
-            createAliasIfNotExist = false;
+            })).alias;
+            const connection = utils_1.Context.getInstance().connections.find(o => o.name === inq2.type);
+            if (!connection) {
+                throw new Error(`Unknown connection type "${inq2.type}" in alias "${inq2.name}"`);
+            }
+            connection.setData(inq2.data);
+            return connection;
         }
         else {
             if (inputType === 'logon') {
@@ -144,193 +134,84 @@ function connect(commandArgs_1) {
                 commandArgs.dest = logonConnection.dest;
                 commandArgs.sysnr = logonConnection.sysnr;
                 commandArgs.saprouter = logonConnection.saprouter;
-                type = utils_1.SystemConnectorType.RFC;
-            }
-            else {
-                type = commandArgs.type;
+                type = 'RFC';
             }
-            result = yield trm_commons_1.Inquirer.prompt([{
+            if (!type || force) {
+                type = (yield trm_commons_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 || 'NONE',
-                    when: (hash) => {
-                        return hash.type === 'REST' && (commandArgs.forwardRfcDest || force);
-                    }
-                },
-                {
-                    type: `input`,
-                    name: `ashost`,
-                    message: `Application server`,
-                    default: commandArgs.ashost,
-                    when: (hash) => {
-                        return hash.type === 'RFC' && ((commandArgs.ashost ? false : true) || force);
-                    }
-                }, {
-                    type: `input`,
-                    name: `dest`,
-                    message: `System ID`,
-                    default: commandArgs.dest,
-                    when: (hash) => {
-                        return hash.type === 'RFC' && ((commandArgs.dest ? false : true) || force);
-                    },
-                    validate: (val) => {
-                        if (val && /^\w{3}$/.test(val)) {
-                            return true;
-                        }
-                        else {
-                            return `Invalid input: expected length 3, only letters allowed`;
-                        }
-                    }
-                }, {
-                    type: `input`,
-                    name: `sysnr`,
-                    message: `Instance number`,
-                    default: commandArgs.sysnr,
-                    when: (hash) => {
-                        return hash.type === 'RFC' && ((commandArgs.sysnr ? false : true) || force);
-                    },
-                    validate: (val) => {
-                        if (val && /^\d{2}$/.test(val)) {
-                            return true;
-                        }
-                        else {
-                            return `Invalid input: expected length 2, only numbers allowed`;
+                    choices: utils_1.Context.getInstance().connections.map(o => {
+                        return {
+                            name: o.description,
+                            value: o.name
+                        };
+                    })
+                })).type;
+            }
+            const connectionType = utils_1.Context.getInstance().connections.find(o => o.name === type);
+            if (!connectionType) {
+                throw new Error(`Invalid connection type "${type}"`);
+            }
+            if (connectionType.onConnectionData) {
+                yield connectionType.onConnectionData(force, commandArgs);
+            }
+            if (connectionType.loginData) {
+                commandArgs = Object.assign(Object.assign({}, commandArgs), (yield trm_commons_1.Inquirer.prompt([
+                    {
+                        type: `input`,
+                        name: `client`,
+                        message: `Logon Client`,
+                        default: commandArgs.client,
+                        when: (hash) => {
+                            return (commandArgs.client ? false : true) || force;
+                        },
+                        validate: (val) => {
+                            if (val && /^\d{3}$/.test(val)) {
+                                return true;
+                            }
+                            else {
+                                return `Invalid input: expected length 3, only numbers allowed`;
+                            }
                         }
-                    }
-                }, {
-                    type: `input`,
-                    name: `saprouter`,
-                    message: `SAProuter`,
-                    default: commandArgs.saprouter,
-                    when: (hash) => {
-                        return hash.type === 'RFC' && ((commandArgs.saprouter ? false : true) || force);
-                    }
-                }, {
-                    type: `input`,
-                    name: `client`,
-                    message: `Logon Client`,
-                    default: commandArgs.client,
-                    when: (hash) => {
-                        return (commandArgs.client ? false : true) || force;
-                    },
-                    validate: (val) => {
-                        if (val && /^\d{3}$/.test(val)) {
-                            return true;
+                    }, {
+                        type: `input`,
+                        name: `user`,
+                        message: `Logon User`,
+                        default: commandArgs.user,
+                        when: (hash) => {
+                            return (commandArgs.user ? false : true) || force;
                         }
-                        else {
-                            return `Invalid input: expected length 3, only numbers allowed`;
+                    }, {
+                        type: `password`,
+                        name: `passwd`,
+                        message: `Logon Password`,
+                        default: commandArgs.passwd,
+                        when: (hash) => {
+                            return (commandArgs.passwd ? false : true) || force;
                         }
+                    }, {
+                        type: `list`,
+                        name: `lang`,
+                        message: `Logon Language`,
+                        default: commandArgs.lang || 'EN',
+                        when: (hash) => {
+                            return (commandArgs.lang ? false : true) || force;
+                        },
+                        validate: (input) => {
+                            return languageList.includes(input.trim().toUpperCase());
+                        },
+                        choices: languageList
                     }
-                }, {
-                    type: `input`,
-                    name: `user`,
-                    message: `Logon User`,
-                    default: commandArgs.user,
-                    when: (hash) => {
-                        return (commandArgs.user ? false : true) || force;
-                    }
-                }, {
-                    type: `password`,
-                    name: `passwd`,
-                    message: `Logon Password`,
-                    default: commandArgs.passwd,
-                    when: (hash) => {
-                        return (commandArgs.passwd ? false : true) || force;
-                    }
-                }, {
-                    type: `list`,
-                    name: `lang`,
-                    message: `Logon Language`,
-                    default: commandArgs.lang || 'EN',
-                    when: (hash) => {
-                        return (commandArgs.lang ? false : true) || force;
-                    },
-                    validate: (input) => {
-                        return languageList.includes(input.trim().toUpperCase());
-                    },
-                    choices: languageList
-                }]);
-        }
-        result.type = result.type || type;
-        result.user = result.user || commandArgs.user;
-        result.passwd = result.passwd || commandArgs.passwd;
-        result.lang = result.lang || commandArgs.lang;
-        result.user = result.user.toUpperCase();
-        result.lang = result.lang.toUpperCase();
-        if (result.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 (result.type === utils_1.SystemConnectorType.REST) {
-            result.endpoint = result.endpoint || commandArgs.endpoint;
-            result.forwardRfcDest = result.forwardRfcDest || commandArgs.forwardRfcDest;
-            result.client = result.client || commandArgs.client;
-            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,
-                    client: result.client
-                }
-            });
-        }
-        else {
-            throw new Error(`Unknown connection type "${result.type}".`);
-        }
-        if (createAliasIfNotExist) {
-            yield systemAlias_1.SystemAlias.createIfNotExists(result);
+            if (connectionType.onAfterLoginData) {
+                yield connectionType.onAfterLoginData(force, commandArgs);
+            }
+            if (createAliasIfNotExist) {
+                yield systemAlias_1.SystemAlias.createIfNotExists(connectionType);
+            }
+            return connectionType;
         }
-        return result;
     });
 }

package/dist/commands/settings.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.settings = settings;
-const settings_1 = require("../settings");
+const utils_1 = require("../utils");
 const trm_commons_1 = require("trm-commons");
 function settings(commandArgs) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -22,9 +22,9 @@ function settings(commandArgs) {
             }
             const key = aSplit[0];
             const value = aSplit[1];
-            settings_1.Settings.getInstance().set(key, value);
+            utils_1.Context.getInstance().setSetting(key, value);
         }
-        const settingsData = settings_1.Settings.getInstance().data;
+        const settingsData = utils_1.Context.getInstance().settings;
         Object.keys(settingsData).forEach(k => {
             trm_commons_1.Logger.log(`${k}: ${settingsData[k]}`);
         });

package/dist/systemAlias/SystemAlias.d.ts

@@ -1,18 +1,18 @@
-import { SystemConnectorType } from "../utils";
 import { SystemAliasData } from "./SystemAliasData";
-import { ISystemConnector, Login, RESTConnection, RFCConnection } from "trm-core";
-import { ConnectArguments } from "../commands";
+import { ISystemConnector } from "trm-core";
+import { IConnect } from "trm-commons";
 export declare class SystemAlias {
-    type: SystemConnectorType;
-    private _connection;
-    private _login;
-    constructor(type: SystemConnectorType, _connection: RFCConnection | RESTConnection, _login: Login);
+    type: string;
+    private _data;
+    constructor(type: string, _data: any);
     getConnection(): ISystemConnector;
     private static generateFile;
     private static getSystemAliasFilePath;
     static getAll(): SystemAliasData[];
     static get(name: string): SystemAlias;
-    static create(name: string, type: SystemConnectorType, connection: RFCConnection | RESTConnection, login: Login): SystemAlias;
+    static create(name: string, type: string, data: any): SystemAlias;
     static delete(name: string): void;
-    static createIfNotExists(connArgs: ConnectArguments): Promise<void>;
+    private static deepEqual;
+    static compare(a: SystemAlias, b: SystemAlias): boolean;
+    static createIfNotExists(connection: IConnect): Promise<void>;
 }

package/dist/systemAlias/SystemAlias.js

@@ -53,16 +53,17 @@ const ini = __importStar(require("ini"));
 const trm_commons_1 = require("trm-commons");
 const SYSTEM_FILE_NAME = "systems.ini";
 class SystemAlias {
-    constructor(type, _connection, _login) {
+    constructor(type, _data) {
         this.type = type;
-        this._connection = _connection;
-        this._login = _login;
+        this._data = _data;
     }
     getConnection() {
-        return (0, utils_1.getSystemConnector)(this.type, {
-            connection: this._connection,
-            login: this._login
-        });
+        const connection = utils_1.Context.getInstance().connections.find(o => o.name === this.type);
+        if (!connection) {
+            throw new Error(`Unknown connection type "${this.type}". Possible values are ${utils_1.Context.getInstance().connections.map(k => k.name).join(', ')}.`);
+        }
+        connection.setData(this._data);
+        return connection.getSystemConnector();
     }
     static generateFile(content, filePath) {
         if (!filePath) {
@@ -70,31 +71,10 @@ class SystemAlias {
         }
         var oContent = {};
         content.forEach(o => {
-            if (o.type === utils_1.SystemConnectorType.RFC) {
-                oContent[o.alias] = {
-                    type: o.type,
-                    dest: o.connection.dest,
-                    ashost: o.connection.ashost,
-                    sysnr: o.connection.sysnr,
-                    client: o.login.client,
-                    user: o.login.user,
-                    passwd: o.login.passwd,
-                    lang: o.login.lang
-                };
-                if (o.connection.saprouter) {
-                    oContent[o.alias].saprouter = o.connection.saprouter;
-                }
-            }
-            else if (o.type === utils_1.SystemConnectorType.REST) {
-                oContent[o.alias] = {
-                    type: o.type,
-                    endpoint: o.connection.endpoint,
-                    rfcdest: o.connection.rfcdest || 'NONE',
-                    client: o.login.client,
-                    user: o.login.user,
-                    passwd: o.login.passwd,
-                    lang: o.login.lang
-                };
+            const connection = utils_1.Context.getInstance().connections.find(k => k.name === o.type);
+            if (connection) {
+                oContent[o.alias] = o.data;
+                oContent[o.alias].type = o.type;
             }
         });
         fs.writeFileSync(filePath, ini.encode(oContent), { encoding: 'utf8', flag: 'w' });
@@ -112,38 +92,16 @@ class SystemAlias {
         const sIni = fs.readFileSync(filePath).toString();
         const oIni = ini.decode(sIni);
         Object.keys(oIni).forEach(sAlias => {
-            if (oIni[sAlias].type === utils_1.SystemConnectorType.RFC || !oIni[sAlias].type) {
-                aAlias.push({
-                    alias: sAlias,
-                    type: utils_1.SystemConnectorType.RFC,
-                    connection: {
-                        dest: oIni[sAlias].dest,
-                        ashost: oIni[sAlias].ashost,
-                        sysnr: oIni[sAlias].sysnr,
-                        saprouter: oIni[sAlias].saprouter
-                    },
-                    login: {
-                        client: oIni[sAlias].client,
-                        user: oIni[sAlias].user,
-                        passwd: oIni[sAlias].passwd,
-                        lang: oIni[sAlias].lang
-                    }
-                });
+            if (!oIni[sAlias].type) {
+                oIni[sAlias].type = 'RFC';
             }
-            else if (oIni[sAlias].type === utils_1.SystemConnectorType.REST) {
+            const connection = utils_1.Context.getInstance().connections.find(o => o.name === oIni[sAlias].type);
+            if (connection) {
+                connection.setData(oIni[sAlias]);
                 aAlias.push({
                     alias: sAlias,
-                    type: utils_1.SystemConnectorType.REST,
-                    connection: {
-                        endpoint: oIni[sAlias].endpoint,
-                        rfcdest: oIni[sAlias].rfcdest || 'NONE'
-                    },
-                    login: {
-                        user: oIni[sAlias].user,
-                        passwd: oIni[sAlias].passwd,
-                        lang: oIni[sAlias].lang,
-                        client: oIni[sAlias].client
-                    }
+                    type: oIni[sAlias].type,
+                    data: connection.getData()
                 });
             }
         });
@@ -153,13 +111,13 @@ class SystemAlias {
         const aAlias = this.getAll();
         const alias = aAlias.find(o => o.alias.trim().toUpperCase() === name.trim().toUpperCase());
         if (alias) {
-            return new SystemAlias(alias.type, alias.connection, alias.login);
+            return new SystemAlias(alias.type, alias);
         }
         else {
             throw new Error(`System alias "${name}" not found.`);
         }
     }
-    static create(name, type, connection, login) {
+    static create(name, type, data) {
         if (!name) {
             throw new Error(`Invalid alias name.`);
         }
@@ -172,55 +130,62 @@ class SystemAlias {
             aAlias.push({
                 alias: name,
                 type,
-                connection,
-                login
+                data
             });
             this.generateFile(aAlias);
         }
-        return new SystemAlias(type, connection, login);
+        return new SystemAlias(type, data);
     }
     static delete(name) {
         var aAlias = this.getAll();
         aAlias = aAlias.filter(o => o.alias.trim().toUpperCase() !== name.trim().toUpperCase());
         this.generateFile(aAlias);
     }
-    static createIfNotExists(connArgs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const aAlias = this.getAll();
-            var alias;
-            if (connArgs.type === utils_1.SystemConnectorType.RFC) {
-                alias = aAlias.find(o => {
-                    if (o.type === utils_1.SystemConnectorType.RFC || !o.type) {
-                        const rfcConn = o.connection;
-                        if (rfcConn.dest === connArgs.dest &&
-                            rfcConn.ashost === connArgs.ashost &&
-                            rfcConn.sysnr === connArgs.sysnr &&
-                            rfcConn.saprouter === connArgs.saprouter &&
-                            o.login.client === connArgs.client &&
-                            o.login.lang === connArgs.lang &&
-                            o.login.user === connArgs.user &&
-                            o.login.passwd === connArgs.passwd) {
-                            return o;
-                        }
-                    }
-                });
+    static deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a && b && typeof a === "object" && typeof b === "object") {
+            if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
             }
-            else if (connArgs.type === utils_1.SystemConnectorType.REST) {
-                alias = aAlias.find(o => {
-                    if (o.type === utils_1.SystemConnectorType.REST) {
-                        const restConn = o.connection;
-                        if (restConn.endpoint === connArgs.endpoint &&
-                            restConn.rfcdest === connArgs.forwardRfcDest &&
-                            o.login.client === connArgs.client &&
-                            o.login.lang === connArgs.lang &&
-                            o.login.user === connArgs.user &&
-                            o.login.passwd === connArgs.passwd) {
-                            return o;
-                        }
-                    }
-                });
+            if (Array.isArray(a) && Array.isArray(b)) {
+                if (a.length !== b.length)
+                    return false;
+                for (let i = 0; i < a.length; i++) {
+                    if (!this.deepEqual(a[i], b[i]))
+                        return false;
+                }
+                return true;
+            }
+            if (a.constructor !== b.constructor)
+                return false;
+            const keysA = Object.keys(a);
+            const keysB = Object.keys(b);
+            if (keysA.length !== keysB.length)
+                return false;
+            for (const key of keysA) {
+                if (!Object.prototype.hasOwnProperty.call(b, key))
+                    return false;
+                if (!this.deepEqual(a[key], b[key]))
+                    return false;
             }
-            if (!alias) {
+            return true;
+        }
+        return false;
+    }
+    static compare(a, b) {
+        if (a.type === b.type) {
+            return this.deepEqual(a._data, b._data);
+        }
+        else {
+            return false;
+        }
+    }
+    static createIfNotExists(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aAlias = this.getAll();
+            const parsedData = connection.getData();
+            if (!aAlias.find(o => this.deepEqual(o, parsedData))) {
                 const aliasName = (yield trm_commons_1.Inquirer.prompt([{
                         name: 'create',
                         message: 'Create new alias for connection?',
@@ -235,7 +200,7 @@ class SystemAlias {
                         }
                     }])).alias;
                 if (aliasName) {
-                    this.create(aliasName, connArgs.type, connArgs, connArgs);
+                    this.create(aliasName, connection.name, parsedData);
                 }
             }
         });

package/dist/systemAlias/SystemAliasData.d.ts

@@ -1,8 +1,5 @@
-import { Login, RESTConnection, RFCConnection } from "trm-core";
-import { SystemConnectorType } from "../utils";
 export type SystemAliasData = {
     alias: string;
-    type: SystemConnectorType;
-    connection: RESTConnection | RFCConnection;
-    login: Login;
+    type: string;
+    data: any;
 };

package/dist/utils/Context.d.ts

@@ -0,0 +1,14 @@
+import { SettingsData } from "./";
+import { IConnect } from "trm-commons";
+export declare class Context {
+    private static _instance;
+    settings: SettingsData;
+    connections: IConnect[];
+    constructor();
+    load(): Promise<void>;
+    setSetting(key: string, value: string): void;
+    private getSettingsFilePath;
+    private getSettings;
+    private generateSettingsFile;
+    static getInstance(): Context;
+}