trm-core 2.2.3 → 3.0.0

package/dist/inquirer/validators/validateDevclass.js

@@ -10,16 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateDevclass = void 0;
-function validateDevclass(devclass, system) {
+const systemConnector_1 = require("../../systemConnector");
+function validateDevclass(devclass, allowTemporaryPackages) {
     return __awaiter(this, void 0, void 0, function* () {
         if (devclass) {
             devclass = devclass.trim().toUpperCase();
             const c = devclass.charAt(0);
-            if (c === '$') {
+            if (c === '$' && !allowTemporaryPackages) {
                 return 'Temporary packages cannot be released. Move content to a transportable package.';
             }
             else {
-                const tdevc = yield system.getDevclass(devclass);
+                const tdevc = yield systemConnector_1.SystemConnector.getDevclass(devclass);
                 if (!tdevc) {
                     return `Package ${devclass} does not exist.`;
                 }

package/dist/inquirer/validators/validateTransportTarget.d.ts

@@ -1,3 +1,2 @@
-import { TR_TARGET } from "../../rfc/components";
-import { TMSCSYS } from "../../rfc/struct";
+import { TR_TARGET, TMSCSYS } from "../../client";
 export declare function validateTransportTarget(target: TR_TARGET, systemTmscsys: TMSCSYS[]): Promise<string | true | void>;

package/dist/logger/CliLogFileLogger.d.ts

@@ -0,0 +1,25 @@
+import { ResponseMessage } from "trm-registry-types";
+import { CliLogger } from "./CliLogger";
+import { TreeLog } from "./TreeLog";
+export declare class CliLogFileLogger extends CliLogger {
+    private _dir;
+    private _filePath;
+    private _sessionId;
+    constructor(_dir: string, debug?: boolean);
+    getSessionId(): string;
+    private _getStackTrace;
+    private _getDebugString;
+    private _append;
+    endLog(): void;
+    getFilePath(): string;
+    loading(text: string, debug?: boolean): void;
+    success(text: string, debug?: boolean): void;
+    error(text: string, debug?: boolean): void;
+    warning(text: string, debug?: boolean): void;
+    info(text: string, debug?: boolean): void;
+    log(text: string, debug?: boolean): void;
+    table(header: any, data: any, debug?: boolean): void;
+    registryResponse(response: ResponseMessage, debug?: boolean): void;
+    tree(data: TreeLog, debug?: boolean): void;
+    forceStop(): void;
+}

package/dist/logger/CliLogFileLogger.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliLogFileLogger = void 0;
+const CliLogger_1 = require("./CliLogger");
+const fs_1 = require("fs");
+const uuid_1 = require("uuid");
+const path_1 = require("path");
+const get_stack_trace_1 = require("get-stack-trace");
+class CliLogFileLogger extends CliLogger_1.CliLogger {
+    constructor(_dir, debug) {
+        super(debug);
+        this._dir = _dir;
+        if (!(0, fs_1.existsSync)(this._dir)) {
+            (0, fs_1.mkdirSync)(this._dir, {
+                recursive: true
+            });
+        }
+        this._sessionId = (0, uuid_1.v4)();
+        this._filePath = (0, path_1.join)(this._dir, `${this._sessionId}.txt`);
+        (0, fs_1.writeFileSync)(this.getFilePath(), `*** STARTING LOG SESSION ID ${this._sessionId}, ${new Date().toISOString()} ***`);
+    }
+    getSessionId() {
+        return this._sessionId;
+    }
+    _getStackTrace() {
+        var sStackTrace;
+        try {
+            const aStackTrace = (0, get_stack_trace_1.getStackTrace)();
+            const oStackTrace = aStackTrace[5];
+            const moduleName = /(trm-[^\\\/]*)(?:\\{1,2}|\/{1,2})dist/gmi.exec(oStackTrace.fileName)[1];
+            sStackTrace = `[${moduleName}] ${oStackTrace.functionName} ${oStackTrace.lineNumber},${oStackTrace.columnNumber}`;
+        }
+        catch (e) {
+            sStackTrace = ``;
+        }
+        return sStackTrace;
+    }
+    _getDebugString(text, type) {
+        const sStackTrace = this._getStackTrace();
+        return `${type} ${new Date().toISOString()} ${sStackTrace}   ${text}`;
+    }
+    _append(text, type) {
+        (0, fs_1.appendFileSync)(this.getFilePath(), `\n${this._getDebugString(text, type)}`);
+    }
+    endLog() {
+        (0, fs_1.appendFileSync)(this.getFilePath(), `\n*** ENDING LOG SESSION ID ${this._sessionId}, ${new Date().toISOString()} ***`);
+    }
+    getFilePath() {
+        return this._filePath;
+    }
+    loading(text, debug) {
+        this._append(text, 'WAIT');
+        super.loading(text, debug);
+    }
+    success(text, debug) {
+        this._append(text, 'OK  ');
+        super.success(text, debug);
+    }
+    error(text, debug) {
+        this._append(text, 'ERR ');
+        super.error(text, debug);
+    }
+    warning(text, debug) {
+        this._append(text, 'WARN');
+        super.warning(text, debug);
+    }
+    info(text, debug) {
+        this._append(text, 'INFO');
+        super.info(text, debug);
+    }
+    log(text, debug) {
+        this._append(text, 'LOG ');
+        super.log(text, debug);
+    }
+    table(header, data, debug) {
+        this._append(`${JSON.stringify(header)}${JSON.stringify(data)}`, 'TABL');
+        super.table(header, data, debug);
+    }
+    registryResponse(response, debug) {
+        this._append(`${JSON.stringify(response)}`, 'REG ');
+        super.registryResponse(response, debug);
+    }
+    tree(data, debug) {
+        this._append(`${JSON.stringify(data)}`, 'TREE');
+        super.tree(data, debug);
+    }
+    forceStop() {
+        this.log(`Forcing loader stop.`, true);
+        super.forceStop();
+    }
+}
+exports.CliLogFileLogger = CliLogFileLogger;

package/dist/logger/CliLogger.d.ts

@@ -0,0 +1,20 @@
+import { ResponseMessage } from "trm-registry-types";
+import { ILogger } from "./ILogger";
+import { TreeLog } from "./TreeLog";
+export declare class CliLogger implements ILogger {
+    private _cliObj;
+    private _loader;
+    debug: boolean;
+    constructor(debug: boolean);
+    loading(text: string, debug?: boolean): void;
+    success(text: string, debug?: boolean): void;
+    error(text: string, debug?: boolean): void;
+    warning(text: string, debug?: boolean): void;
+    info(text: string, debug?: boolean): void;
+    log(text: string, debug?: boolean): void;
+    table(header: any, data: any, debug?: boolean): void;
+    registryResponse(response: ResponseMessage, debug?: boolean): void;
+    tree(data: TreeLog, debug?: boolean): void;
+    forceStop(): void;
+    private _clearLoader;
+}

package/dist/logger/CliLogger.js

@@ -0,0 +1,178 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliLogger = void 0;
+const loading_cli_1 = __importDefault(require("loading-cli"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const trm_registry_types_1 = require("trm-registry-types");
+const printTree = __importStar(require("print-tree"));
+class CliLogger {
+    constructor(debug) {
+        this._cliObj = (0, loading_cli_1.default)({
+            frames: ["⊶", "⊷"],
+            interval: 1000
+        });
+    }
+    loading(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        this._loader = this._cliObj.render().start(text);
+    }
+    success(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const aText = text.split('\n');
+        aText.forEach(s => {
+            if (this._loader) {
+                this._loader.succeed(s);
+                this._clearLoader();
+            }
+            else {
+                this._cliObj.succeed(s);
+            }
+        });
+    }
+    error(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const aText = text.split('\n');
+        aText.forEach(s => {
+            if (this._loader) {
+                this._loader.fail(s);
+                this._clearLoader();
+            }
+            else {
+                this._cliObj.fail(s);
+            }
+        });
+    }
+    warning(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const aText = text.split('\n');
+        aText.forEach(s => {
+            if (this._loader) {
+                this._loader.warn(s);
+                this._clearLoader();
+            }
+            else {
+                this._cliObj.warn(s);
+            }
+        });
+    }
+    info(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const aText = text.split('\n');
+        aText.forEach(s => {
+            if (this._loader) {
+                this._loader.info(s);
+                this._clearLoader();
+            }
+            else {
+                this._cliObj.info(s);
+            }
+        });
+    }
+    log(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const aText = text.split('\n');
+        aText.forEach(s => {
+            if (this._loader) {
+                this.forceStop();
+            }
+            console.log(s);
+        });
+    }
+    table(header, data, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        var table = new cli_table3_1.default({
+            head: header,
+        });
+        data.forEach(arr => {
+            table.push(arr);
+        });
+        console.log(table.toString());
+    }
+    registryResponse(response, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        if (response.type === trm_registry_types_1.MessageType.ERROR) {
+            this.error(response.text, debug);
+        }
+        if (response.type === trm_registry_types_1.MessageType.INFO) {
+            this.info(response.text, debug);
+        }
+        if (response.type === trm_registry_types_1.MessageType.WARNING) {
+            this.warning(response.text, debug);
+        }
+    }
+    tree(data, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const _parseBranch = (o) => {
+            var children = [];
+            o.children.forEach(k => {
+                children.push(_parseBranch(k));
+            });
+            return {
+                name: o.text,
+                children
+            };
+        };
+        const treeData = _parseBranch(data);
+        this.forceStop();
+        printTree.default(treeData, (node) => {
+            return node.name;
+        }, (node) => {
+            return node.children;
+        });
+    }
+    forceStop() {
+        try {
+            this._loader.stop();
+            this._clearLoader();
+        }
+        catch (e) { }
+    }
+    _clearLoader() {
+        delete this._loader;
+    }
+}
+exports.CliLogger = CliLogger;

package/dist/logger/ConsoleLogger.d.ts

@@ -0,0 +1,16 @@
+import { ResponseMessage } from "trm-registry-types";
+import { ILogger } from "./ILogger";
+import { TreeLog } from "./TreeLog";
+export declare class ConsoleLogger implements ILogger {
+    debug: boolean;
+    constructor(debug: boolean);
+    loading(text: string, debug?: boolean): void;
+    success(text: string, debug?: boolean): void;
+    error(text: string, debug?: boolean): void;
+    warning(text: string, debug?: boolean): void;
+    info(text: string, debug?: boolean): void;
+    log(text: string, debug?: boolean): void;
+    table(header: any, data: any, debug?: boolean): void;
+    registryResponse(response: ResponseMessage, debug?: boolean): void;
+    tree(data: TreeLog, debug?: boolean): void;
+}

package/dist/logger/ConsoleLogger.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const trm_registry_types_1 = require("trm-registry-types");
+class ConsoleLogger {
+    constructor(debug) { }
+    loading(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.log(text);
+    }
+    success(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.log(text);
+    }
+    error(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.error(text);
+    }
+    warning(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.warn(text);
+    }
+    info(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.info(text);
+    }
+    log(text, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.log(text);
+    }
+    table(header, data, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        const table = {
+            header,
+            data
+        };
+        console.log(JSON.stringify(table));
+    }
+    registryResponse(response, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        if (response.type === trm_registry_types_1.MessageType.ERROR) {
+            this.error(response.text, debug);
+        }
+        if (response.type === trm_registry_types_1.MessageType.INFO) {
+            this.info(response.text, debug);
+        }
+        if (response.type === trm_registry_types_1.MessageType.WARNING) {
+            this.warning(response.text, debug);
+        }
+    }
+    tree(data, debug) {
+        if (debug && !this.debug) {
+            return;
+        }
+        console.log(JSON.stringify(data));
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;

package/dist/logger/DummyLogger.d.ts

@@ -0,0 +1,16 @@
+import { ResponseMessage } from "trm-registry-types";
+import { ILogger } from "./ILogger";
+import { TreeLog } from "./TreeLog";
+export declare class DummyLogger implements ILogger {
+    debug: boolean;
+    constructor();
+    loading(text: string, debug?: boolean): void;
+    success(text: string, debug?: boolean): void;
+    error(text: string, debug?: boolean): void;
+    warning(text: string, debug?: boolean): void;
+    info(text: string, debug?: boolean): void;
+    log(text: string, debug?: boolean): void;
+    table(header: any, data: any, debug?: boolean): void;
+    registryResponse(response: ResponseMessage, debug?: boolean): void;
+    tree(data: TreeLog, debug?: boolean): void;
+}

package/dist/logger/DummyLogger.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyLogger = void 0;
+class DummyLogger {
+    constructor() { }
+    loading(text, debug) { }
+    success(text, debug) { }
+    error(text, debug) { }
+    warning(text, debug) { }
+    info(text, debug) { }
+    log(text, debug) { }
+    table(header, data, debug) { }
+    registryResponse(response, debug) { }
+    tree(data, debug) { }
+}
+exports.DummyLogger = DummyLogger;

package/dist/logger/ILogger.d.ts

@@ -0,0 +1,14 @@
+import { ResponseMessage } from "trm-registry-types";
+import { TreeLog } from "./TreeLog";
+export interface ILogger {
+    debug: boolean;
+    loading: (text: string, debug?: boolean) => void;
+    success: (text: string, debug?: boolean) => void;
+    error: (text: string, debug?: boolean) => void;
+    warning: (text: string, debug?: boolean) => void;
+    info: (text: string, debug?: boolean) => void;
+    log: (text: string, debug?: boolean) => void;
+    table: (header: any, data: any, debug?: boolean) => void;
+    registryResponse: (response: ResponseMessage, debug?: boolean) => void;
+    tree: (data: TreeLog, debug?: boolean) => void;
+}

package/dist/logger/ILogger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/logger/Logger.d.ts

@@ -1,20 +1,15 @@
-import { CoreEnv } from "../commons";
-import { TraceLevel } from "./TraceLevel";
 import { ResponseMessage } from "trm-registry-types";
-export declare class Logger {
-    coreEnv: CoreEnv;
-    traceLevel: TraceLevel;
-    cliObj: any;
-    loader: any;
-    constructor(coreEnv: CoreEnv, traceLevel: TraceLevel);
-    loading(text: string): void;
-    success(text: string): void;
-    error(text: string): void;
-    warning(text: string): void;
-    info(text: string): void;
-    log(text: string): void;
-    table(header: any, data: any): void;
-    registryResponse(response: ResponseMessage): void;
-    forceStop(): void;
-    static getDummy(): Logger;
+import { ILogger } from "./ILogger";
+import { TreeLog } from "./TreeLog";
+export declare namespace Logger {
+    var logger: ILogger;
+    function loading(text: string, debug?: boolean): void;
+    function success(text: string, debug?: boolean): void;
+    function error(text: string, debug?: boolean): void;
+    function warning(text: string, debug?: boolean): void;
+    function info(text: string, debug?: boolean): void;
+    function log(text: string, debug?: boolean): void;
+    function table(header: any, data: any, debug?: boolean): void;
+    function registryResponse(response: ResponseMessage, debug?: boolean): void;
+    function tree(data: TreeLog, debug?: boolean): void;
 }