trm-client 6.1.1 → 7.0.0

package/dist/command/AbstractCommand.js

@@ -0,0 +1,418 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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) {
+        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.AbstractCommand = void 0;
+const utils_1 = require("../utils");
+const LoggerType_1 = require("./LoggerType");
+const InquirerType_1 = require("./InquirerType");
+const Core = __importStar(require("trm-core"));
+const Commons = __importStar(require("trm-commons"));
+const registryAlias_1 = require("../registryAlias");
+const systemAlias_1 = require("../systemAlias");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("./prompts");
+const fs_1 = require("fs");
+class AbstractCommand {
+    constructor(program, name, aliases) {
+        this.name = name;
+        this.aliases = aliases;
+        this.registerOpts = {};
+        this.args = {};
+        this.registryAuthData = false;
+        this.command = program.command(this.name);
+        if (aliases) {
+            this.command.aliases(aliases);
+        }
+        this.init();
+    }
+    getCliVersionStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cliVersionStatus) {
+                this.cliVersionStatus = yield (0, utils_1.checkCliUpdate)(true);
+            }
+            return this.cliVersionStatus;
+        });
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    hasRegistryAuthData() {
+        return this.registryAuthData;
+    }
+    getRegistryAuthError() {
+        return this.registryAuthFailed;
+    }
+    registryWhoAmI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const registry = this.getRegistry();
+            if (registry) {
+                Commons.Logger.loading(`Authenticating...`);
+                const whoAmI = yield registry.whoAmI();
+                Commons.Logger.info(`Username: ${whoAmI.user}`);
+                if (whoAmI.messages) {
+                    whoAmI.messages.forEach(m => Commons.Logger.registryResponse(m));
+                }
+            }
+        });
+    }
+    viewRegistryPackage(packageName_1) {
+        return __awaiter(this, arguments, void 0, function* (packageName, print = true) {
+            Commons.Logger.loading(`Reading registry...`);
+            var oRegistryView;
+            try {
+                oRegistryView = yield this.getRegistry().getPackage(packageName, 'latest');
+            }
+            catch (e) {
+                Commons.Logger.error(e, true);
+                oRegistryView = null;
+            }
+            if (print) {
+                if (!oRegistryView) {
+                    Commons.Logger.warning(`${chalk_1.default.bold('WARNING')}: This package was not found on the registry.`);
+                    Commons.Logger.warning(`${chalk_1.default.bold('WARNING')}: This package may have been deleted!`);
+                }
+                else {
+                    if (oRegistryView.deprecated) {
+                        if (oRegistryView.deprecated_message) {
+                            Commons.Logger.warning(`${chalk_1.default.bold('WARNING deprecate')}: ${oRegistryView.deprecated_message}`);
+                        }
+                        else {
+                            Commons.Logger.warning(`${chalk_1.default.bold('WARNING deprecate')}: v${oRegistryView.manifest.version} is deprecated`);
+                        }
+                    }
+                }
+            }
+            return oRegistryView;
+        });
+    }
+    getSystemPackages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.systemPackages) {
+                Commons.Logger.loading(`Reading "${Core.SystemConnector.getDest()}" packages...`);
+                this.systemPackages = yield Core.SystemConnector.getInstalledPackages(true, true, true);
+            }
+            return this.systemPackages;
+        });
+    }
+    getTrmDependenciesCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.trmDependenciesCheck) {
+                const packages = yield this.getSystemPackages();
+                this.trmDependenciesCheck = yield Core.checkCoreTrmDependencies(packages);
+            }
+            return this.trmDependenciesCheck;
+        });
+    }
+    register() {
+        const defaultLogger = utils_1.GlobalContext.getInstance().getSettings().loggerType;
+        const logOutputFolder = utils_1.GlobalContext.getInstance().getSettings().logOutputFolder;
+        this.command
+            .option(`--logger <logger type>`, `Logger type.`, defaultLogger)
+            .option(`--logger-out-dir <logger out dir>`, `Logger output directory.`, logOutputFolder)
+            .option(`--debug`, `Debug.`, false);
+        if (this.registerOpts.requiresConnection) {
+            this.command
+                .option(`-d, --dest <destination>`, `RFC System ID (Destination).`)
+                .option(`-u, --user <username>`, `Logon username.`)
+                .option(`-p, --password <password>`, `Logon password.`)
+                .option(`-m, --mandt <mandt>`, `Logon client.`)
+                .option(`-l, --lang <language>`, `Logon language.`)
+                .option(`-h, --application-server <address>`, `RFC Application server address.`)
+                .option(`-r, --sap-router <sap router>`, `RFC SAP Router.`)
+                .option(`-n, --sys-nr <sysnr>`, `Instance number.`)
+                .option(`-e, --endpoint <endpoint>`, `REST endpoint.`)
+                .option(`-x, --forward-rfc-dest [destination]`, `REST forward destination.`, `NONE`);
+            if (!this.registerOpts.noSystemAlias) {
+                this.command
+                    .option(`-a, --alias <alias>`, `System Alias.`);
+            }
+        }
+        if (this.registerOpts.requiresRegistry) {
+            this.command
+                .option(`-R, --registry <registry>`, `Registry.`);
+            if (!this.registerOpts.onlyRegistryAlias) {
+                this.command
+                    .option(`-E, --registry-endpoint <endpoint>`, `Registry endpoint.`)
+                    .option(`-A, --registry-auth <authentication>`, `Registry authentication (JSON or path to JSON file).`);
+            }
+        }
+        if (this.registerOpts.requiresR3trans) {
+            this.command
+                .option(`--r3trans-path <path>`, `R3trans program path. (default: Environment variable R3TRANS_HOME)`);
+        }
+        this.command.action(this.execute.bind(this));
+    }
+    getLogger(type, debug, logOutputFolder) {
+        if (!logOutputFolder || logOutputFolder.trim().toLowerCase() === 'default') {
+            logOutputFolder = (0, utils_1.getLogFolder)();
+        }
+        switch (type) {
+            case LoggerType_1.LoggerType.CLI: return new Commons.CliLogger(debug);
+            case LoggerType_1.LoggerType.CLI_LOG: return new Commons.CliLogFileLogger(logOutputFolder, debug);
+            case LoggerType_1.LoggerType.CONSOLE: return new Commons.ConsoleLogger(debug);
+            case LoggerType_1.LoggerType.VOID: return new Commons.DummyLogger();
+            default: throw new Error(`Unknown logger type "${type}". Possible values are ${Object.keys(LoggerType_1.LoggerType).map(k => LoggerType_1.LoggerType[k]).join(', ')}.`);
+        }
+    }
+    getInquirer(type) {
+        switch (type) {
+            case InquirerType_1.InquirerType.CLI: return new Commons.CliInquirer();
+            default: throw new Error(`Unknown inquirer type "${type}". Possible values are ${Object.keys(InquirerType_1.InquirerType).map(k => InquirerType_1.InquirerType[k]).join(', ')}.`);
+        }
+    }
+    parseCommandArgs(args1, args2) {
+        var args = this.command['_optionValues'] || {};
+        if (!args1) {
+            args1 = {};
+        }
+        if (!args2) {
+            args2 = {};
+        }
+        if (typeof (args1) === 'string') {
+            const oArg1 = this.command["_args"][0];
+            args[oArg1.name()] = args1;
+            if (typeof (args2) === 'string') {
+                const oArg2 = this.command["_args"][1];
+                args[oArg2.name()] = args2;
+            }
+            else {
+                args = Object.assign(Object.assign({}, args), args2);
+            }
+        }
+        else {
+            args = Object.assign(Object.assign({}, args), args1);
+        }
+        args = Object.entries(args).reduce((acc, [key, value]) => {
+            const newKey = key.includes(" ") ? key.replace(/ (\w)/g, (_, char) => char.toUpperCase()) : key;
+            acc[newKey] = value;
+            return acc;
+        }, {});
+        return args;
+    }
+    onArgs() {
+    }
+    onTrmDepMissing(dependency) {
+        return true;
+    }
+    onTrmDepVersionNotSatisfied(trmPackage) {
+        return true;
+    }
+    checkTrmDependencies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trmDependenciesCheck = yield this.getTrmDependenciesCheck();
+            const trmDependencies = Core.getCoreTrmDependencies();
+            trmDependenciesCheck.missingDependencies.forEach(missingDependency => {
+                if (this.onTrmDepMissing(missingDependency)) {
+                    throw new Error(`Package "${missingDependency}" is not installed on ${Core.SystemConnector.getDest()}.`);
+                }
+            });
+            trmDependenciesCheck.versionNotSatisfiedDependencies.forEach(dependency => {
+                if (this.onTrmDepVersionNotSatisfied(dependency)) {
+                    const versionRange = trmDependencies[dependency.packageName];
+                    throw new Error(`Package "${dependency.packageName}" version ${dependency.manifest.get().version} is installed on ${Core.SystemConnector.getDest()}, but does not satisfy dependency version ${versionRange}. Update with command ${chalk_1.default.italic('trm update ' + dependency.packageName)}`);
+                }
+            });
+        });
+    }
+    parseTextArg(name) {
+        if (this.args[name]) {
+            try {
+                return (0, fs_1.readFileSync)(this.args[name]).toString();
+            }
+            catch (_a) {
+                return this.args[name];
+            }
+        }
+    }
+    parseJsonArg(name) {
+        if (this.args[name]) {
+            var sValue;
+            try {
+                sValue = (0, fs_1.readFileSync)(this.args[name]).toString();
+            }
+            catch (_a) {
+                sValue = this.args[name];
+            }
+            try {
+                return JSON.parse(sValue);
+            }
+            catch (_b) { }
+        }
+    }
+    parseArrayArg(name) {
+        if (this.args[name]) {
+            try {
+                return this.args[name].split(',').map(s => s.trim());
+            }
+            catch (_a) { }
+        }
+    }
+    parseNumberArg(name) {
+        if (this.args[name]) {
+            try {
+                return Number(this.args[name]);
+            }
+            catch (_a) { }
+        }
+    }
+    execute(args1, args2) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.args = this.parseCommandArgs(args1, args2);
+            this.onArgs();
+            var exitCode;
+            try {
+                if (this.registerOpts.requiresR3trans && process.platform === 'darwin') {
+                }
+                yield utils_1.GlobalContext.getInstance().load();
+                yield Commons.Plugin.call("client", "loadCore", { core: Core });
+                yield Commons.Plugin.call("client", "loadCommons", { commons: Commons });
+                Commons.Inquirer.inquirer = this.getInquirer(InquirerType_1.InquirerType.CLI);
+                Commons.Logger.logger = this.getLogger(this.args.logger, this.args.debug, this.args.loggerOutDir);
+                if (process.platform !== 'win32' && process.platform !== 'darwin') {
+                    Commons.Logger.warning(`Running on untested OS "${process.platform}"! Some features aren't tested yet.`);
+                }
+                yield this.getCliVersionStatus();
+                if (this.registerOpts.requiresRegistry) {
+                    var registryAlias;
+                    var registry;
+                    if (this.args.registry) {
+                        registryAlias = registryAlias_1.RegistryAlias.get(this.args.registry);
+                    }
+                    else if (this.args.registryEndpoint) {
+                        registryAlias = registryAlias_1.RegistryAlias.getTemporaryInstance(this.args.registryEndpoint, this.parseJsonArg('registryAuth'));
+                    }
+                    else {
+                        registryAlias = yield (0, prompts_1.pickRegistry)();
+                    }
+                    registry = registryAlias.getRegistry();
+                    try {
+                        const registryPing = yield registry.ping();
+                        if (this.registerOpts.registryAuthBlacklist && this.registerOpts.registryAuthBlacklist.includes(registryPing.authentication_type)) {
+                            throw new Error(`This command is not supported by registry "${registry.name}".`);
+                        }
+                        if (registryPing.messages) {
+                            registryPing.messages.forEach(m => Commons.Logger.registryResponse(m));
+                        }
+                    }
+                    catch (e) {
+                        Commons.Logger.error(e, true);
+                        if (!this.registerOpts.ignoreRegistryUnreachable) {
+                            throw new Error(`Registry "${registry.name}" is unreachable.`);
+                        }
+                    }
+                    if (registryAlias.authData) {
+                        try {
+                            yield registry.authenticate(registryAlias.authData);
+                        }
+                        catch (e) {
+                            this.registryAuthFailed = e;
+                            Commons.Logger.error(e, true);
+                            Commons.Logger.warning(`Registry "${registry.name}" login failed.`);
+                        }
+                    }
+                    this.registry = registry;
+                    this.registryAuthData = !!registryAlias.authData;
+                    Core.RegistryProvider.registry.push(registry);
+                }
+                registryAlias_1.RegistryAlias.getAll().forEach(o => {
+                    var append = true;
+                    var aliasRegistry = registryAlias_1.RegistryAlias.get(o.alias).getRegistry();
+                    Core.RegistryProvider.registry.forEach(k => {
+                        if (append) {
+                            append = !k.compare(aliasRegistry);
+                        }
+                    });
+                    if (append) {
+                        Core.RegistryProvider.registry.push(aliasRegistry);
+                    }
+                });
+                if (this.registerOpts.requiresConnection) {
+                    var system;
+                    if (this.args.alias) {
+                        system = systemAlias_1.SystemAlias.get(this.args.alias).getConnection();
+                    }
+                    else {
+                        system = (yield (0, prompts_1.connect)(this.args, true, this.registerOpts.addNoConnection)).getSystemConnector();
+                    }
+                    yield system.connect();
+                    Core.SystemConnector.systemConnector = system;
+                    yield Commons.Plugin.call("client", "onInitializeSystemConnector", Core.SystemConnector.systemConnector);
+                    if (this.registerOpts.requiresTrmDependencies) {
+                        yield this.checkTrmDependencies();
+                    }
+                }
+                yield this.handler();
+                if (Commons.Logger.logger instanceof Commons.CliLogger || Commons.Logger.logger instanceof Commons.CliLogFileLogger) {
+                    Commons.Logger.logger.forceStop();
+                }
+                exitCode = 0;
+            }
+            catch (e) {
+                yield (0, utils_1.logError)(e);
+                exitCode = 1;
+            }
+            finally {
+                if (Core.SystemConnector.systemConnector) {
+                    try {
+                        yield Core.SystemConnector.closeConnection();
+                    }
+                    catch (e) {
+                        Commons.Logger.error(`Couldn't close system connection!`, true);
+                        Commons.Logger.log(e.toString(), true);
+                    }
+                }
+                if (Commons.Logger.logger instanceof Commons.CliLogFileLogger) {
+                    const sessionId = Commons.Logger.logger.getSessionId();
+                    const logFilePath = Commons.Logger.logger.getFilePath();
+                    Commons.Logger.info(`Saved log output "${logFilePath}" for session ID ${sessionId}.`);
+                }
+                process.exit(exitCode);
+            }
+        });
+    }
+}
+exports.AbstractCommand = AbstractCommand;

package/dist/command/InquirerType.d.ts

@@ -0,0 +1,3 @@
+export declare enum InquirerType {
+    CLI = "CLI"
+}

package/dist/command/InquirerType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InquirerType = void 0;
+var InquirerType;
+(function (InquirerType) {
+    InquirerType["CLI"] = "CLI";
+})(InquirerType || (exports.InquirerType = InquirerType = {}));

package/dist/{utils/executeCommand.d.ts → command/LoggerType.d.ts}

@@ -5,7 +5,3 @@ export declare enum LoggerType {
     VOID = "VOID",
     KEY = "VALUE"
 }
-export declare enum InquirerType {
-    CLI = "CLI"
-}
-export declare function executeCommand(args: any): Promise<void>;

package/dist/command/LoggerType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerType = void 0;
+var LoggerType;
+(function (LoggerType) {
+    LoggerType["CLI"] = "CLI";
+    LoggerType["CLI_LOG"] = "CLI_LOG";
+    LoggerType["CONSOLE"] = "CONSOLE";
+    LoggerType["VOID"] = "VOID";
+    LoggerType["KEY"] = "VALUE";
+})(LoggerType || (exports.LoggerType = LoggerType = {}));

package/dist/{utils/registerCommand.d.ts → command/RegisterCommandOpts.d.ts}

@@ -1,11 +1,12 @@
-import { Command } from "commander";
 import { AuthenticationType } from "trm-registry-types";
-export declare function registerCommand(command: Command, args?: {
+export interface RegisterCommandOpts {
     requiresConnection?: boolean;
     addNoConnection?: boolean;
     requiresTrmDependencies?: boolean;
     requiresRegistry?: boolean;
+    onlyRegistryAlias?: boolean;
     registryAuthBlacklist?: AuthenticationType[];
     noSystemAlias?: boolean;
     ignoreRegistryUnreachable?: boolean;
-}): void;
+    requiresR3trans?: boolean;
+}

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

@@ -0,0 +1,8 @@
+import { AbstractCommand } from "../AbstractCommand";
+export declare class Alias extends AbstractCommand {
+    protected init(): void;
+    private view;
+    private check;
+    private edit;
+    protected handler(): Promise<void>;
+}

package/dist/command/implementations/Alias.js

@@ -0,0 +1,172 @@
+"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.Alias = void 0;
+const trm_commons_1 = require("trm-commons");
+const AbstractCommand_1 = require("../AbstractCommand");
+const prompts_1 = require("../prompts");
+const systemAlias_1 = require("../../systemAlias");
+const utils_1 = require("../../utils");
+class Alias extends AbstractCommand_1.AbstractCommand {
+    init() {
+        if (this.name.includes('create')) {
+            this.command.description(`Create a new system alias.`);
+            this.command.argument(`<alias>`, `Alias name.`);
+        }
+        else if (this.name.includes('delete')) {
+            this.command.description(`Delete a system alias.`);
+            this.command.argument(`<alias>`, `Alias name.`);
+        }
+        else {
+            this.command.description(`List and manage aliases.`);
+        }
+    }
+    view(alias) {
+        const connection = utils_1.GlobalContext.getInstance().getConnections().find(o => o.name === alias.type);
+        if (!connection) {
+            throw new Error(`Unknown connection type "${alias.type}".`);
+        }
+        connection.setData(alias.data);
+        if (connection.logData) {
+            connection.logData();
+        }
+        else {
+            trm_commons_1.Logger.info(`No data to show.`);
+        }
+    }
+    check(alias) {
+        return __awaiter(this, void 0, void 0, function* () {
+            trm_commons_1.Logger.loading(`Checking connection with alias "${alias.alias}"...`);
+            const oSystemAlias = new systemAlias_1.SystemAlias(alias.type, alias.data);
+            try {
+                yield oSystemAlias.getConnection().connect();
+                trm_commons_1.Logger.success(`Connection to alias "${alias.alias}" OK.`);
+            }
+            catch (e) {
+                trm_commons_1.Logger.error(`Connection failed!`);
+                trm_commons_1.Logger.error(e.toString());
+            }
+        });
+    }
+    edit(alias) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var connectionSuccess = true;
+            const connectionArgs = yield (0, prompts_1.connect)(Object.assign(Object.assign({}, alias.data), {
+                type: alias.type,
+                noSystemAlias: true,
+                force: true
+            }), false);
+            const newData = connectionArgs.getData();
+            try {
+                systemAlias_1.SystemAlias.delete(alias.alias);
+                yield systemAlias_1.SystemAlias.create(alias.alias, connectionArgs.name, newData).getConnection().connect();
+            }
+            catch (e) {
+                connectionSuccess = false;
+                throw e;
+            }
+            finally {
+                if (connectionSuccess) {
+                    trm_commons_1.Logger.success(`Alias "${alias.alias}" updated.`);
+                }
+                else {
+                    trm_commons_1.Logger.error(`Alias "${alias.alias}" couldn't be updated.`);
+                    systemAlias_1.SystemAlias.delete(alias.alias);
+                    systemAlias_1.SystemAlias.create(alias.alias, alias.type, alias.data);
+                }
+            }
+        });
+    }
+    handler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.args.create && this.args.add.trim().toLowerCase() === 'create') {
+                yield (0, prompts_1.createAlias)(this.args.alias);
+            }
+            else if (this.args.delete && this.args.rm.trim().toLowerCase() === 'delete') {
+                yield (0, prompts_1.deleteAlias)(this.args.alias);
+            }
+            else {
+                const aAlias = systemAlias_1.SystemAlias.getAll();
+                const choices = [{
+                        name: `Create alias`,
+                        value: `create`
+                    }, {
+                        name: `View alias`,
+                        value: `pick_view`
+                    }, {
+                        name: `Check alias connection`,
+                        value: `pick_check`
+                    }, {
+                        name: `Edit alias`,
+                        value: `pick_edit`
+                    }, {
+                        name: `Delete alias`,
+                        value: `pick_delete`
+                    }];
+                const inq1 = yield trm_commons_1.Inquirer.prompt({
+                    name: `action`,
+                    message: `Action`,
+                    type: `list`,
+                    choices
+                });
+                var aliasPick;
+                if (inq1.action.startsWith(`pick_`)) {
+                    aliasPick = (yield trm_commons_1.Inquirer.prompt({
+                        name: `aliasPick`,
+                        message: `Select system alias`,
+                        type: `list`,
+                        choices: aAlias.map(o => {
+                            return {
+                                name: o.alias,
+                                value: o
+                            };
+                        })
+                    })).aliasPick;
+                }
+                const action = inq1.action.replace(/^pick_/gmi, '');
+                switch (action) {
+                    case 'create':
+                        const newAlias = (yield trm_commons_1.Inquirer.prompt({
+                            name: `alias`,
+                            message: `New alias name`,
+                            type: `input`,
+                            validate: (name) => {
+                                if (!name) {
+                                    return 'Cannot create alias with empty name.';
+                                }
+                                if (aAlias.find(o => o.alias.trim().toUpperCase() === name.trim().toUpperCase())) {
+                                    return `Alias "${name}" already exists`;
+                                }
+                                else {
+                                    return true;
+                                }
+                            }
+                        })).alias;
+                        yield (0, prompts_1.createAlias)(newAlias);
+                        break;
+                    case 'view':
+                        this.view(aliasPick);
+                        break;
+                    case 'check':
+                        yield this.check(aliasPick);
+                        break;
+                    case 'edit':
+                        yield this.edit(aliasPick);
+                        break;
+                    case 'delete':
+                        yield (0, prompts_1.deleteAlias)(aliasPick.alias);
+                        break;
+                }
+            }
+        });
+    }
+}
+exports.Alias = Alias;

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

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