trm-core 9.10.6 → 10.0.1

package/dist/actions/checkEngines/analyze.js

@@ -0,0 +1,294 @@
+"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.analyze = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const commons_1 = require("../../commons");
+const semver_1 = require("semver");
+const manifest_1 = require("../../manifest");
+//note implementation statuses (CWBNTCUST-PRSTATUS)
+const NOTE_IMPLEMENTED = 'E';
+const NOTE_OBSOLETE = 'O'; //correction already contained in the support package level
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+function getUnsupportedProps(o, supported) {
+    return Object.keys(o).filter(k => !supported.includes(k));
+}
+//a property this TRM version doesn't know can't be verified, so the constraint declaring it never matches
+function unsupportedReason(props) {
+    const unique = Array.from(new Set(props));
+    if (unique.length === 0) {
+        return undefined;
+    }
+    return `Unsupported ${unique.length === 1 ? 'property' : 'properties'} ${unique.map(o => `"${o}"`).join(', ')}, update TRM to verify ${unique.length === 1 ? 'it' : 'them'}`;
+}
+function describeConstraints(constraints) {
+    return constraints.map(o => {
+        const parts = Object.keys(o).map(k => `${k} ${o[k]}`);
+        return parts.length > 0 ? parts.join(', ') : 'installed';
+    }).join(' || ');
+}
+//the read is cached as a promise, so a failed read is not retried for every requirement
+function getComponents(context) {
+    if (!context.runtime.components) {
+        context.runtime.components = systemConnector_1.SystemConnector.getSoftwareComponents();
+    }
+    return context.runtime.components;
+}
+function getProducts(context) {
+    if (!context.runtime.products) {
+        context.runtime.products = systemConnector_1.SystemConnector.getInstalledProducts();
+    }
+    return context.runtime.products;
+}
+function getTrmServer(context) {
+    if (!context.runtime.trmServer) {
+        context.runtime.trmServer = systemConnector_1.SystemConnector.getTrmServerPackage();
+    }
+    return context.runtime.trmServer;
+}
+function checkTrm(context, name, range) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const requirement = `version ${range}`;
+        var version;
+        switch (name) {
+            case 'trm-core':
+                version = (0, commons_1.resolveCoreVersion)((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.coreVersion);
+                if (!version) {
+                    return { requirement, ok: false, reason: `Cannot determine trm-core version` };
+                }
+                break;
+            case 'trm-server':
+                try {
+                    version = (yield getTrmServer(context)).manifest.get().version;
+                }
+                catch (e) {
+                    return { requirement, actual: 'not installed', ok: false, reason: errorMessage(e) };
+                }
+                break;
+            default:
+                return { requirement, ok: false, reason: `Unsupported TRM package "${name}", update TRM to verify it` };
+        }
+        return { requirement, actual: `version ${version}`, ok: (0, semver_1.satisfies)(version, range, { includePrerelease: true }) };
+    });
+}
+//a blank CVERS-EXTRELEASE means no support package is installed (level 0)
+function getComponentSp(component) {
+    var _a;
+    const extrelease = (component.extrelease || '').trim() || '0';
+    return (_a = (0, manifest_1.normalizeSapValue)(extrelease, 'number')) !== null && _a !== void 0 ? _a : extrelease;
+}
+function matchComponent(component, constraint) {
+    if (constraint.release !== undefined && !(0, manifest_1.satisfiesSapRange)(component.release, constraint.release, 'release')) {
+        return false;
+    }
+    if (constraint.sp !== undefined && !(0, manifest_1.satisfiesSapRange)(getComponentSp(component), constraint.sp, 'number')) {
+        return false;
+    }
+    return true;
+}
+function checkComponent(context, name, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requirement = value === true ? 'installed' : value === false ? 'not installed' : describeConstraints(Array.isArray(value) ? value : [value]);
+        var components;
+        try {
+            components = yield getComponents(context);
+        }
+        catch (e) {
+            return { requirement, ok: false, reason: `Cannot read software components: ${errorMessage(e)}` };
+        }
+        const component = components.find(o => o.component.trim().toUpperCase() === name);
+        const actual = component ? `release ${component.release}, sp ${getComponentSp(component)}` : 'not installed';
+        if (value === false) {
+            return { requirement, actual, ok: !component };
+        }
+        if (!component) {
+            return { requirement, actual, ok: false };
+        }
+        if (value === true) {
+            return { requirement, actual, ok: true };
+        }
+        const constraints = Array.isArray(value) ? value : [value];
+        const unsupported = constraints.map(o => getUnsupportedProps(o, Object.keys(manifest_1.ENGINES_COMPONENT_PROPS)));
+        const ok = constraints.some((o, i) => unsupported[i].length === 0 && matchComponent(component, o));
+        return { requirement, actual, ok, reason: ok ? undefined : unsupportedReason(unsupported.flat()) };
+    });
+}
+function checkProduct(context, name, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requirement = value === true ? 'installed' : value === false ? 'not installed' : describeConstraints(Array.isArray(value) ? value : [value]);
+        var products;
+        try {
+            products = yield getProducts(context);
+        }
+        catch (e) {
+            return { requirement, ok: false, reason: `Cannot read products: ${errorMessage(e)}` };
+        }
+        const installed = products.filter(o => o.name.trim().toUpperCase().replace(/\s+/g, ' ') === name);
+        const actual = installed.length > 0 ? `version ${installed.map(o => o.version).join(', ')}` : 'not installed';
+        if (value === false) {
+            return { requirement, actual, ok: installed.length === 0 };
+        }
+        if (value === true) {
+            return { requirement, actual, ok: installed.length > 0 };
+        }
+        const constraints = Array.isArray(value) ? value : [value];
+        const unsupported = constraints.map(o => getUnsupportedProps(o, Object.keys(manifest_1.ENGINES_PRODUCT_PROPS)));
+        const ok = installed.some(product => constraints.some((o, i) => unsupported[i].length === 0 && (o.version === undefined || (0, manifest_1.satisfiesSapRange)(product.version, o.version, 'version'))));
+        return { requirement, actual, ok, reason: ok ? undefined : unsupportedReason(unsupported.flat()) };
+    });
+}
+function checkNote(note, value) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requirement = value === true || value.version === undefined ? 'implemented' : `implemented, version ${value.version}`;
+        const unsupported = unsupportedReason(value === true ? [] : getUnsupportedProps(value, Object.keys(manifest_1.ENGINES_NOTE_PROPS)));
+        if (unsupported) {
+            return { requirement, ok: false, reason: unsupported };
+        }
+        var status;
+        try {
+            status = yield systemConnector_1.SystemConnector.getNoteStatus(note);
+        }
+        catch (e) {
+            return { requirement, ok: false, reason: `Cannot read SAP Note status: ${errorMessage(e)}` };
+        }
+        if (status.prstatus === NOTE_OBSOLETE) {
+            return { requirement, actual: 'obsolete (contained in support package)', ok: true };
+        }
+        if (status.prstatus !== NOTE_IMPLEMENTED) {
+            return { requirement, actual: status.prstatus === undefined ? 'not downloaded' : `status ${status.prstatus || 'undefined'}`, ok: false };
+        }
+        const actual = `implemented, version ${parseInt(status.versno, 10) || '?'}`;
+        if (value === true || value.version === undefined) {
+            return { requirement, actual, ok: true };
+        }
+        return { requirement, actual, ok: status.versno !== undefined && (0, manifest_1.satisfiesSapRange)(status.versno, value.version, 'number') };
+    });
+}
+function checkTable(check) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requirement = `${check.table} where ${check.where.map(o => `${o.field} ${o.op || 'EQ'} '${o.value}'`).join(' AND ')}`;
+        const unsupported = unsupportedReason([
+            ...getUnsupportedProps(check, manifest_1.ENGINES_TABLE_PROPS),
+            ...check.where.flatMap(o => getUnsupportedProps(o, manifest_1.ENGINES_TABLE_CONDITION_PROPS))
+        ]);
+        if (unsupported) {
+            return { requirement, ok: false, reason: unsupported };
+        }
+        try {
+            const exists = yield systemConnector_1.SystemConnector.checkTableCondition(check.table, check.where);
+            return { requirement, actual: exists ? 'found' : 'not found', ok: exists };
+        }
+        catch (e) {
+            return { requirement, ok: false, reason: `Cannot read table ${check.table}: ${errorMessage(e)}` };
+        }
+    });
+}
+function evaluate(context, engines, path, required) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = [];
+        const push = (itemPath, o) => {
+            results.push(Object.assign({ path: itemPath, required }, o));
+            return o.ok;
+        };
+        const prefix = path ? `${path}.` : '';
+        var ok = true;
+        for (const key of Object.keys(engines)) {
+            switch (key) {
+                case 'trm':
+                    for (const name of Object.keys(engines.trm)) {
+                        ok = push(`${prefix}trm.${name}`, yield checkTrm(context, name, engines.trm[name])) && ok;
+                    }
+                    break;
+                case 'components':
+                    for (const name of Object.keys(engines.components)) {
+                        ok = push(`${prefix}components.${name}`, yield checkComponent(context, name, engines.components[name])) && ok;
+                    }
+                    break;
+                case 'products':
+                    for (const name of Object.keys(engines.products)) {
+                        ok = push(`${prefix}products.${name}`, yield checkProduct(context, name, engines.products[name])) && ok;
+                    }
+                    break;
+                case 'notes':
+                    for (const note of Object.keys(engines.notes)) {
+                        ok = push(`${prefix}notes.${note}`, yield checkNote(note, engines.notes[note])) && ok;
+                    }
+                    break;
+                case 'tables':
+                    for (var i = 0; i < engines.tables.length; i++) {
+                        ok = push(`${prefix}tables[${i}]`, yield checkTable(engines.tables[i])) && ok;
+                    }
+                    break;
+                case 'anyOf':
+                    var alternatives = [];
+                    var anyOk = false;
+                    for (var j = 0; j < engines.anyOf.length; j++) {
+                        const alternative = yield evaluate(context, engines.anyOf[j], `${prefix}anyOf[${j}]`, false);
+                        alternatives = alternatives.concat(alternative.results);
+                        anyOk = anyOk || alternative.ok;
+                    }
+                    ok = push(`${prefix}anyOf`, {
+                        requirement: `at least 1 of ${engines.anyOf.length} alternatives`,
+                        actual: anyOk ? 'satisfied' : 'no alternative satisfied',
+                        ok: anyOk
+                    }) && ok;
+                    results.push(...alternatives);
+                    break;
+                default:
+                    ok = push(`${prefix}${key}`, {
+                        requirement: key,
+                        ok: false,
+                        reason: `Unsupported engine check "${key}", update TRM to verify it`
+                    }) && ok;
+            }
+        }
+        return { ok, results };
+    });
+}
+/**
+ * Workflow step that evaluates the engines declaration against the connected system.
+ *
+ * 1- evaluate engines
+ *
+ * 2- print table
+ *
+*/
+exports.analyze = {
+    name: 'analyze',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (Object.keys(context.output.engines).length > 0) {
+            return true;
+        }
+        else {
+            trm_commons_1.Logger.info(`Package ${context.rawInput.packageData.manifest.name} has no engines`, !context.rawInput.printOptions.information);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        //1- evaluate engines
+        const evaluation = yield evaluate(context, context.output.engines, '', true);
+        context.output.passed = evaluation.ok;
+        context.output.results = evaluation.results;
+        const failed = evaluation.results.filter(o => o.required && !o.ok).length;
+        trm_commons_1.Logger.info(`Package ${context.rawInput.packageData.manifest.name} engines: ${evaluation.results.filter(o => o.required).length - failed} satisfied, ${failed} not satisfied`, !context.rawInput.printOptions.information);
+        //2- print table
+        trm_commons_1.Logger.table(['Requirement', 'Expected', 'Actual', 'Status'], evaluation.results.map(o => [
+            o.path,
+            o.requirement,
+            o.reason || o.actual || '',
+            o.ok ? 'OK' : o.required ? 'NOT MET' : 'NOT MET (alternative)'
+        ]), !context.rawInput.printOptions.enginesStatus);
+    })
+};

package/dist/actions/checkEngines/index.d.ts

@@ -0,0 +1,87 @@
+import { TrmManifest, TrmManifestEngines } from "../../manifest";
+import { CVERS, PRDVERS } from "../../client/struct";
+import { TrmPackage } from "../../trmPackage";
+/** Input used to verify a manifest's engines (TRM, SAP release/components, products, notes, tables). */
+export interface CheckEnginesActionInput {
+    /**
+     * Data related to the running environment.
+     */
+    contextData?: {
+        /**
+         * Version of trm-core in use, checked against `engines.trm.trm-core`.
+         * Supply it when the client resolves trm-core itself; defaults to the version read from trm-core package.json.
+         */
+        coreVersion?: string;
+    };
+    /**
+     * Data related to the package being checked.
+     */
+    packageData: {
+        /**
+         * Manifest whose `engines` declaration will be checked against the connected system.
+         */
+        manifest: TrmManifest;
+    };
+    /**
+     * Print options.
+     */
+    printOptions?: {
+        /**
+         * Print a table containing each requirement and its status. Defaults to `false`.
+         */
+        enginesStatus?: boolean;
+        /**
+         * Print informational summary messages. Defaults to `false`.
+         */
+        information?: boolean;
+    };
+}
+/** Result of a single engines requirement. */
+export type EngineCheckResult = {
+    /** Path of the requirement in the engines declaration, e.g. `components.SAP_BASIS` or `anyOf[1].notes.1234567`. */
+    path: string;
+    /** Human readable requirement, e.g. `release >=750, sp >=5`. */
+    requirement: string;
+    /** Human readable value found on the system, when available. */
+    actual?: string;
+    /** Whether the requirement is satisfied. */
+    ok: boolean;
+    /** Whether this requirement must be satisfied on its own (`false` for requirements nested in `anyOf` alternatives). */
+    required: boolean;
+    /** Explanation when the requirement couldn't be verified. */
+    reason?: string;
+};
+/** Engines report returned by {@link checkEngines}. */
+export type CheckEnginesActionOutput = {
+    /** Normalized engines declaration copied from `manifest.engines`. */
+    engines: TrmManifestEngines;
+    /** Whether all engines requirements are satisfied. */
+    passed: boolean;
+    /** Result of each requirement. */
+    results: EngineCheckResult[];
+};
+type WorkflowRuntime = {
+    trmServer?: Promise<TrmPackage>;
+    components?: Promise<CVERS[]>;
+    products?: Promise<PRDVERS[]>;
+};
+/** Internal state shared by the engines-check workflow steps. */
+export interface CheckEnginesWorkflowContext {
+    /** Original action input. */
+    rawInput: CheckEnginesActionInput;
+    /** System data read once and reused across requirements. */
+    runtime?: WorkflowRuntime;
+    /** Report assembled by the workflow. */
+    output?: CheckEnginesActionOutput;
+}
+/**
+ * Checks whether the connected SAP system satisfies the engines declared by a manifest.
+ *
+ * Unmet or unverifiable requirements (e.g. unreadable tables, unsupported engine checks) are reported as failed.
+ *
+ * @param inputData Manifest and optional print settings.
+ * @returns The normalized engines and the result of each requirement.
+ * @throws When the engines declaration is malformed.
+ */
+export declare function checkEngines(inputData: CheckEnginesActionInput): Promise<CheckEnginesActionOutput>;
+export {};

package/dist/actions/checkEngines/index.js

@@ -0,0 +1,38 @@
+"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.checkEngines = checkEngines;
+const init_1 = require("./init");
+const analyze_1 = require("./analyze");
+const commons_1 = require("../commons");
+;
+const WORKFLOW_NAME = 'check-engines';
+/**
+ * Checks whether the connected SAP system satisfies the engines declared by a manifest.
+ *
+ * Unmet or unverifiable requirements (e.g. unreadable tables, unsupported engine checks) are reported as failed.
+ *
+ * @param inputData Manifest and optional print settings.
+ * @returns The normalized engines and the result of each requirement.
+ * @throws When the engines declaration is malformed.
+ */
+function checkEngines(inputData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflow = [
+            init_1.init,
+            analyze_1.analyze
+        ];
+        const result = yield (0, commons_1.executeWorkflow)(WORKFLOW_NAME, workflow, {
+            rawInput: inputData
+        }, commons_1.workflowCallbacks);
+        return result.output;
+    });
+}

package/dist/actions/checkEngines/init.d.ts

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { CheckEnginesWorkflowContext } from ".";
+/**
+ * Workflow step that initializes engines-check state from the supplied manifest.
+ *
+ * 1- validate and set engines (read manifest)
+ *
+ * 2- fill missing input data
+ *
+*/
+export declare const init: Step<CheckEnginesWorkflowContext>;

package/dist/actions/checkEngines/init.js

@@ -0,0 +1,45 @@
+"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.init = void 0;
+const manifest_1 = require("../../manifest");
+/**
+ * Workflow step that initializes engines-check state from the supplied manifest.
+ *
+ * 1- validate and set engines (read manifest)
+ *
+ * 2- fill missing input data
+ *
+*/
+exports.init = {
+    name: 'init',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        context.output = {
+            engines: {},
+            passed: true,
+            results: []
+        };
+        context.runtime = {};
+        //1- validate and set engines
+        const engines = context.rawInput.packageData.manifest.engines;
+        if (engines) {
+            const errors = (0, manifest_1.validateEngines)(engines);
+            if (errors.length > 0) {
+                throw new Error(`Invalid engines declaration: ${errors[0]}`);
+            }
+            context.output.engines = (0, manifest_1.normalizeEngines)(engines);
+        }
+        //2- fill missing input data
+        if (!context.rawInput.printOptions) {
+            context.rawInput.printOptions = {};
+        }
+    })
+};

package/dist/actions/checkPackageDependencies/analyze.d.ts

@@ -1,3 +1,13 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { CheckPackageDependenciesWorkflowContext } from ".";
+/**
+ * Workflow step that compares manifest dependency ranges with installed package versions.
+ *
+ * 1- build required tables fields
+ *
+ * 2- check dependencies
+ *
+ * 3- print tables
+ *
+*/
 export declare const analyze: Step<CheckPackageDependenciesWorkflowContext>;

package/dist/actions/checkPackageDependencies/analyze.js

@@ -13,7 +13,17 @@ exports.analyze = void 0;
 const trm_commons_1 = require("trm-commons");
 const trmPackage_1 = require("../../trmPackage");
 const registry_1 = require("../../registry");
-const semver_1 = require("semver");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that compares manifest dependency ranges with installed package versions.
+ *
+ * 1- build required tables fields
+ *
+ * 2- check dependencies
+ *
+ * 3- print tables
+ *
+*/
 exports.analyze = {
     name: 'analyze',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -26,60 +36,48 @@ exports.analyze = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Analyze step', true);
         trm_commons_1.Logger.info(`Package ${context.rawInput.packageData.manifest.name} has ${context.output.dependencies.length} TRM package dependencies`, !context.rawInput.printOptions.information);
+        //1- build required tables fields
         var table = {
             header: ['Dependency', 'Registry', 'Dependency range', 'Version on system', 'Version status'],
             data: []
         };
+        //2- check dependencies
         var tableData;
         for (const dependency of context.output.dependencies) {
             tableData = [dependency.name, dependency.registry || registry_1.PUBLIC_RESERVED_KEYWORD, dependency.version];
             const dependencyTrmPackage = new trmPackage_1.TrmPackage(dependency.name, registry_1.RegistryProvider.getRegistry(dependency.registry));
-            const systemInstalledPackage = context.rawInput.contextData.systemPackages.find(o => trmPackage_1.TrmPackage.compare(o, dependencyTrmPackage));
-            if (systemInstalledPackage && systemInstalledPackage.manifest) {
-                const installedVersion = systemInstalledPackage.manifest.get().version;
-                tableData.push(installedVersion);
-                if ((0, semver_1.satisfies)(installedVersion, dependency.version)) {
-                    tableData.push('OK');
-                    context.runtime.dependenciesStatus.goodVersion.push(dependency);
-                }
-                else {
-                    tableData.push('ERR!');
-                    context.runtime.dependenciesStatus.badVersion.push(dependency);
-                }
-            }
-            else {
+            const installed = (0, utils_1.getInstalledDependency)(context.rawInput.contextData.systemPackages, dependencyTrmPackage, dependency.version);
+            const status = installed.status;
+            if (status === 'notFound') {
                 tableData.push('Not found');
-                tableData.push('ERR!');
-                context.runtime.dependenciesStatus.badVersion.push(dependency);
             }
-            table.data.push(tableData);
-        }
-        trm_commons_1.Logger.table(table.header, table.data, !context.rawInput.printOptions.dependencyStatus);
-        context.runtime.dependenciesStatus.goodVersion.forEach(o => {
-            const i = context.output.dependencyStatus.findIndex(k => k.dependency.name === o.name && k.dependency.registry === o.registry);
-            if (i >= 0) {
-                context.output.dependencyStatus[i].match = true;
+            else if (status === 'manifestUnreadable') {
+                if (installed.error) {
+                    trm_commons_1.Logger.error(installed.error.toString(), true);
+                }
+                tableData.push('Installed, manifest unreadable');
             }
             else {
-                context.output.dependencyStatus.push({
-                    dependency: o,
-                    match: true
-                });
+                tableData.push(installed.installedVersion);
             }
-        });
-        context.runtime.dependenciesStatus.badVersion.forEach(o => {
-            const i = context.output.dependencyStatus.findIndex(k => k.dependency.name === o.name && k.dependency.registry === o.registry);
-            if (i >= 0) {
-                context.output.dependencyStatus[i].match = false;
+            const match = status === 'ok';
+            tableData.push(match ? 'OK' : 'ERR!');
+            if (match) {
+                context.runtime.dependenciesStatus.goodVersion.push(dependency);
             }
             else {
-                context.output.dependencyStatus.push({
-                    dependency: o,
-                    match: false
-                });
+                context.runtime.dependenciesStatus.badVersion.push(dependency);
             }
-        });
+            context.output.dependencyStatus.push({
+                dependency,
+                match,
+                status,
+                installedVersion: installed.installedVersion
+            });
+            table.data.push(tableData);
+        }
+        //3- print tables
+        trm_commons_1.Logger.table(table.header, table.data, !context.rawInput.printOptions.dependencyStatus);
     })
 };