trm-core 2.2.2 → 3.0.0

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

@@ -0,0 +1,52 @@
+import { DEVCLASS, SENVI, TADIR } from "../../client";
+import { TrmPackage } from "../../trmPackage";
+export type TadirObjectSenvi = {
+    tadir: TADIR;
+    senvi: SENVI[];
+};
+export type TableDependency = {
+    dependencyIn: TADIR;
+    tableDependency: any;
+};
+export type SapEntriesDependency = {
+    table: string;
+    dependencies: TableDependency[];
+};
+export type TrmDependency = {
+    devclass: DEVCLASS;
+    trmPackage?: TrmPackage;
+    integrity?: string;
+    sapEntries: SapEntriesDependency[];
+};
+export type FindDependencyActionInput = {
+    devclass: DEVCLASS;
+    tadir?: TADIR[];
+    systemPackages?: TrmPackage[];
+    print?: boolean;
+    printSapEntries?: boolean;
+};
+type WorkflowParsedInput = {
+    devclass?: DEVCLASS;
+    tadir?: TADIR[];
+    systemPackages?: TrmPackage[];
+    print?: boolean;
+    printSapEntries?: boolean;
+};
+type WorkflowRuntime = {
+    devclassIgnore?: DEVCLASS[];
+    objectsSenvi?: TadirObjectSenvi[];
+    parsedSenvi?: SapEntriesDependency[];
+};
+export type FindDependencyActionOutput = {
+    sapEntries?: SapEntriesDependency[];
+    trmDependencies?: TrmDependency[];
+    unknownDependencies?: TrmDependency[];
+};
+export type FindDependenciesWorkflowContext = {
+    rawInput: FindDependencyActionInput;
+    parsedInput: WorkflowParsedInput;
+    runtime: WorkflowRuntime;
+    output: FindDependencyActionOutput;
+};
+export declare function findDependencies(inputData: FindDependencyActionInput): Promise<FindDependencyActionOutput>;
+export {};

package/dist/actions/findDependencies/index.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDependencies = void 0;
+const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const logger_1 = require("../../logger");
+const util_1 = require("util");
+const init_1 = require("./init");
+const setSystemPackages_1 = require("./setSystemPackages");
+const readPackageData_1 = require("./readPackageData");
+const readPackageObjects_1 = require("./readPackageObjects");
+const readRepositoryEnvironment_1 = require("./readRepositoryEnvironment");
+const parseSenvi_1 = require("./parseSenvi");
+const setTrmDependencies_1 = require("./setTrmDependencies");
+const print_1 = require("./print");
+const acknowledgementSize_1 = require("./acknowledgementSize");
+const WORKFLOW_NAME = 'find-dependencies';
+function findDependencies(inputData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflow = [
+            init_1.init,
+            setSystemPackages_1.setSystemPackages,
+            readPackageData_1.readPackageData,
+            readPackageObjects_1.readPackageObjects,
+            acknowledgementSize_1.acknowledgementSize,
+            readRepositoryEnvironment_1.readRepositoryEnvironment,
+            parseSenvi_1.parseSenvi,
+            setTrmDependencies_1.setTrmDependencies,
+            print_1.print
+        ];
+        logger_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
+            rawInput: inputData,
+            parsedInput: {},
+            runtime: {},
+            output: {}
+        });
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        return result.output;
+    });
+}
+exports.findDependencies = findDependencies;

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const init: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/init.js

@@ -0,0 +1,36 @@
+"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 inquirer_1 = require("../../inquirer");
+exports.init = {
+    name: 'init',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var devclass = context.rawInput.devclass;
+        const devclassValid = yield (0, inquirer_1.validateDevclass)(devclass, true);
+        if (devclassValid && devclassValid !== true) {
+            throw new Error(devclassValid);
+        }
+        context.parsedInput.devclass = devclass;
+        context.parsedInput.print = context.rawInput.print ? true : false;
+        if (context.parsedInput.print) {
+            context.parsedInput.printSapEntries = context.rawInput.printSapEntries ? true : false;
+        }
+        else {
+            context.parsedInput.printSapEntries = false;
+        }
+        context.parsedInput.tadir = context.rawInput.tadir || [];
+        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
+        context.output.trmDependencies = [];
+        context.output.unknownDependencies = [];
+        context.output.sapEntries = [];
+    })
+};

package/dist/actions/findDependencies/parseSenvi.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const parseSenvi: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/parseSenvi.js

@@ -0,0 +1,76 @@
+"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.parseSenvi = void 0;
+const dependency_1 = require("../../dependency");
+const logger_1 = require("../../logger");
+const SAP_SOURCE_SYSTEMS = ['SAP'];
+const SAP_AUTHORS = ['SAP'];
+const _addEntry = (tableName, sapEntries, dependencyIn, dependency) => {
+    logger_1.Logger.log(`Adding dependency to table ${tableName}, dependency in object ${JSON.stringify(dependencyIn)} with ${JSON.stringify(dependency)}`, true);
+    var index = sapEntries.findIndex(o => o.table === tableName);
+    if (index < 0) {
+        index = sapEntries.push({
+            table: tableName,
+            dependencies: []
+        });
+        index--;
+    }
+    sapEntries[index].dependencies.push({
+        dependencyIn,
+        tableDependency: dependency
+    });
+    return sapEntries;
+};
+exports.parseSenvi = {
+    name: 'parse-senvi',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const objectsSenvi = context.runtime.objectsSenvi;
+        const aIgnoredDevclass = context.runtime.devclassIgnore;
+        const senviParser = new dependency_1.SenviParser();
+        context.runtime.parsedSenvi = [];
+        context.output.sapEntries = [];
+        logger_1.Logger.loading(`Reading object dependencies...`);
+        for (const objectSenvi of objectsSenvi) {
+            logger_1.Logger.log(`Parsing SENVI of TADIR object ${objectSenvi.tadir.pgmid} ${objectSenvi.tadir.object} ${objectSenvi.tadir.objName}, ${objectSenvi.senvi} entries`, true);
+            for (const senvi of objectSenvi.senvi) {
+                logger_1.Logger.loading(`Parsing SENVI object ${senvi.type} ${senvi.object} ${senvi.enclObj}...`, true);
+                const parsedSenvi = yield senviParser.parse(senvi);
+                logger_1.Logger.log(`Result: ${JSON.stringify(parsedSenvi)}`, true);
+                if (parsedSenvi && !aIgnoredDevclass.includes(parsedSenvi.devclass)) {
+                    var aParsedSenvi;
+                    if (SAP_SOURCE_SYSTEMS.includes(parsedSenvi.srcsystem) || SAP_AUTHORS.includes(parsedSenvi.author)) {
+                        aParsedSenvi = context.output.sapEntries;
+                        logger_1.Logger.log(`Dependency with SAP object`, true);
+                    }
+                    else {
+                        aParsedSenvi = context.runtime.parsedSenvi;
+                        logger_1.Logger.log(`Dependency with custom object`, true);
+                    }
+                    aParsedSenvi = _addEntry('TADIR', aParsedSenvi, objectSenvi.tadir, {
+                        'PGMID': parsedSenvi.pgmid,
+                        'OBJECT': parsedSenvi.object,
+                        'OBJ_NAME': parsedSenvi.objName,
+                        'DEVCLASS': parsedSenvi.devclass
+                    });
+                    if (parsedSenvi.subObject) {
+                        if (parsedSenvi.subObject.func) {
+                            aParsedSenvi = _addEntry('TFDIR', aParsedSenvi, objectSenvi.tadir, {
+                                'FUNCNAME': parsedSenvi.subObject.func,
+                                'PNAME': `SAPL${parsedSenvi.objName}`
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    })
+};

package/dist/actions/findDependencies/print.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const print: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/print.js

@@ -0,0 +1,120 @@
+"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.print = void 0;
+const logger_1 = require("../../logger");
+const registry_1 = require("../../registry");
+const _getTableTreeText = (tableData) => {
+    var aValues = [];
+    Object.keys(tableData).forEach(k => {
+        aValues.push(`${k}: ${tableData[k]}`);
+    });
+    return aValues.join(', ');
+};
+const _getSapEntriesTreeChildren = (sapEntries) => {
+    var treeChildren = [];
+    sapEntries.forEach(k => {
+        var referenceTableTree = {
+            text: k.table,
+            children: []
+        };
+        k.dependencies.forEach(y => {
+            const tableKey = _getTableTreeText(y.tableDependency);
+            const tadirKey = `${y.dependencyIn.pgmid} ${y.dependencyIn.object} ${y.dependencyIn.objName}`;
+            const arrayIndex = referenceTableTree.children.findIndex(o => o.text === tableKey);
+            const usedByTree = {
+                text: `Used by`,
+                children: []
+            };
+            const usedByTadirTree = {
+                text: tadirKey,
+                children: []
+            };
+            usedByTree.children.push(usedByTadirTree);
+            if (arrayIndex >= 0) {
+                if (!referenceTableTree.children[arrayIndex].children[0].children.find(o => o.text === tadirKey)) {
+                    referenceTableTree.children[arrayIndex].children[0].children.push(usedByTadirTree);
+                }
+            }
+            else {
+                referenceTableTree.children.push({
+                    text: tableKey,
+                    children: [usedByTree]
+                });
+            }
+        });
+        treeChildren.push(referenceTableTree);
+    });
+    return treeChildren;
+};
+exports.print = {
+    name: 'print',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.print) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping print (input)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const sapEntries = context.output.sapEntries;
+        const unknownDependencies = context.output.unknownDependencies;
+        const trmDependencies = context.output.trmDependencies;
+        var baseTree = {
+            text: context.parsedInput.devclass,
+            children: []
+        };
+        var sapEntriesTree = {
+            text: `Required SAP Entries`,
+            children: _getSapEntriesTreeChildren(sapEntries)
+        };
+        var unknownDependenciesTree = {
+            text: `Without TRM Package`,
+            children: []
+        };
+        var trmDependenciesTree = {
+            text: `TRM Packages`,
+            children: []
+        };
+        unknownDependencies.forEach(o => {
+            unknownDependenciesTree.children.push({
+                text: o.devclass,
+                children: [{
+                        text: `References`,
+                        children: _getSapEntriesTreeChildren(o.sapEntries)
+                    }]
+            });
+        });
+        trmDependencies.forEach(o => {
+            trmDependenciesTree.children.push({
+                text: o.trmPackage.packageName,
+                children: [{
+                        text: `Registry: ${o.trmPackage.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? 'public' : o.trmPackage.registry.endpoint}`,
+                        children: []
+                    }, {
+                        text: `Version: ${o.trmPackage.manifest.get().version}`,
+                        children: []
+                    }, {
+                        text: `References`,
+                        children: _getSapEntriesTreeChildren(o.sapEntries)
+                    }]
+            });
+        });
+        if (context.parsedInput.printSapEntries) {
+            baseTree.children.push(sapEntriesTree);
+        }
+        baseTree.children.push(unknownDependenciesTree);
+        baseTree.children.push(trmDependenciesTree);
+        logger_1.Logger.tree(baseTree);
+    })
+};

package/dist/actions/findDependencies/readPackageData.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const readPackageData: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/readPackageData.js

@@ -0,0 +1,22 @@
+"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.readPackageData = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.readPackageData = {
+    name: 'read-package-data',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const devclass = context.parsedInput.devclass;
+        logger_1.Logger.loading(`Reading package data...`);
+        context.runtime.devclassIgnore = [devclass].concat((yield systemConnector_1.SystemConnector.getSubpackages(devclass)).map(o => o.devclass));
+    })
+};

package/dist/actions/findDependencies/readPackageObjects.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const readPackageObjects: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/readPackageObjects.js

@@ -0,0 +1,26 @@
+"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.readPackageObjects = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.readPackageObjects = {
+    name: 'read-package-objects',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const devclass = context.parsedInput.devclass;
+        logger_1.Logger.loading(`Reading package objects...`);
+        var tadirObjects = context.parsedInput.tadir;
+        if (tadirObjects.length === 0) {
+            tadirObjects = yield systemConnector_1.SystemConnector.getDevclassObjects(devclass, true);
+        }
+        context.parsedInput.tadir = tadirObjects;
+    })
+};

package/dist/actions/findDependencies/readRepositoryEnvironment.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const readRepositoryEnvironment: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/readRepositoryEnvironment.js

@@ -0,0 +1,31 @@
+"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.readRepositoryEnvironment = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.readRepositoryEnvironment = {
+    name: 'read-repository-environment',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var aSenvi = [];
+        var tadir = context.parsedInput.tadir;
+        tadir = tadir.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC'));
+        logger_1.Logger.loading(`Reading objects...`);
+        for (const tadirObj of tadir) {
+            const senvi = yield systemConnector_1.SystemConnector.repositoryEnvironment(tadirObj.object, tadirObj.objName);
+            aSenvi.push({
+                tadir: tadirObj,
+                senvi
+            });
+        }
+        context.runtime.objectsSenvi = aSenvi;
+    })
+};

package/dist/actions/findDependencies/setSystemPackages.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const setSystemPackages: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/setSystemPackages.js

@@ -0,0 +1,25 @@
+"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.setSystemPackages = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.setSystemPackages = {
+    name: 'set-system-packages',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var systemPackages = context.parsedInput.systemPackages;
+        if (systemPackages.length === 0) {
+            logger_1.Logger.loading(`Reading system packages`, true);
+            systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
+        }
+        context.parsedInput.systemPackages = systemPackages;
+    })
+};

package/dist/actions/findDependencies/setTrmDependencies.d.ts

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { FindDependenciesWorkflowContext } from ".";
+export declare const setTrmDependencies: Step<FindDependenciesWorkflowContext>;

package/dist/actions/findDependencies/setTrmDependencies.js

@@ -0,0 +1,145 @@
+"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.setTrmDependencies = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+const trmPackage_1 = require("../../trmPackage");
+const logger_1 = require("../../logger");
+var aRootDevclass = [];
+const _getRootDevclass = (devclass) => __awaiter(void 0, void 0, void 0, function* () {
+    const oRootDevclass = aRootDevclass.find(o => o.devclass === devclass);
+    if (oRootDevclass) {
+        return oRootDevclass.rootDevclass;
+    }
+    else {
+        logger_1.Logger.loading(`Searching root of devclass ${devclass}...`, true);
+        var tdevcDevclass = devclass;
+        var rootDevclass = null;
+        while (rootDevclass === null) {
+            const tdevc = yield systemConnector_1.SystemConnector.getDevclass(tdevcDevclass);
+            logger_1.Logger.log(`Parent of ${tdevcDevclass} is ${tdevc.parentcl}`, true);
+            if (tdevc.parentcl) {
+                tdevcDevclass = tdevc.parentcl;
+                aRootDevclass.push({
+                    devclass: tdevcDevclass,
+                    rootDevclass: tdevc.parentcl
+                });
+            }
+            else {
+                rootDevclass = tdevcDevclass;
+                aRootDevclass.push({
+                    devclass: tdevcDevclass,
+                    rootDevclass: tdevcDevclass
+                });
+            }
+        }
+        logger_1.Logger.success(`Root devclass of ${devclass} is ${rootDevclass}`, true);
+        return rootDevclass;
+    }
+});
+const _getTadirDependencies = (tadirDependencies) => __awaiter(void 0, void 0, void 0, function* () {
+    var trmDependencies = [];
+    for (const tadirDependency of tadirDependencies) {
+        const tadir = tadirDependency.tableDependency;
+        var trmRelevantTransports = [];
+        var latestTransport;
+        var devclass;
+        var trmPackage;
+        var integrity;
+        var arrayIndex1;
+        var arrayIndex2;
+        logger_1.Logger.log(`Searching transports for object ${tadir.PGMID} ${tadir.OBJECT} ${tadir.OBJ_NAME}`, true);
+        const allTransports = yield transport_1.Transport.getTransportsFromObject({
+            pgmid: tadir.PGMID,
+            object: tadir.OBJECT,
+            objName: tadir.OBJ_NAME
+        });
+        logger_1.Logger.log(`Found ${allTransports.length} transports for object ${tadir.PGMID} ${tadir.OBJECT} ${tadir.OBJ_NAME}`, true);
+        for (const transport of allTransports) {
+            if (yield transport.isTrmRelevant()) {
+                logger_1.Logger.log(`Transport ${transport.trkorr} is TRM relevant`, true);
+                trmRelevantTransports.push(transport);
+            }
+        }
+        latestTransport = yield transport_1.Transport.getLatest(trmRelevantTransports);
+        if (latestTransport) {
+            logger_1.Logger.log(`Latest transport is ${latestTransport.trkorr}`, true);
+            trmPackage = yield latestTransport.getLinkedPackage();
+            const alreadyInArray = trmDependencies.find(o => o.trmPackage && trmPackage_1.TrmPackage.compare(o.trmPackage, trmPackage));
+            if (alreadyInArray) {
+                devclass = alreadyInArray.devclass;
+                integrity = alreadyInArray.integrity;
+            }
+            else {
+                integrity = yield systemConnector_1.SystemConnector.getPackageIntegrity(trmPackage);
+                if (!integrity) {
+                    throw new Error(`Package "${trmPackage.packageName}", integrity not found!`);
+                }
+                try {
+                    devclass = yield latestTransport.getDevclass();
+                }
+                catch (e) {
+                    devclass = '';
+                }
+            }
+        }
+        else {
+            logger_1.Logger.log(`Object without TRM package`, true);
+            devclass = yield _getRootDevclass(tadir.DEVCLASS);
+        }
+        arrayIndex1 = trmDependencies.findIndex(o => o.devclass === devclass);
+        if (arrayIndex1 < 0) {
+            arrayIndex1 = trmDependencies.push({
+                devclass,
+                trmPackage,
+                integrity,
+                sapEntries: []
+            });
+            arrayIndex1--;
+        }
+        arrayIndex2 = trmDependencies[arrayIndex1].sapEntries.findIndex(o => o.table === 'TADIR');
+        if (arrayIndex2 < 0) {
+            arrayIndex2 = trmDependencies[arrayIndex1].sapEntries.push({
+                table: 'TADIR',
+                dependencies: []
+            });
+            arrayIndex2--;
+        }
+        trmDependencies[arrayIndex1].sapEntries[arrayIndex2].dependencies.push(tadirDependency);
+    }
+    return trmDependencies;
+});
+exports.setTrmDependencies = {
+    name: 'set-trm-dependencies',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const aParsedSenvi = context.runtime.parsedSenvi || [];
+        if (aParsedSenvi.length === 0) {
+            logger_1.Logger.log(`Skipping set TRM dependencies (no custom object found)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const aParsedSenvi = context.runtime.parsedSenvi;
+        var trmDependencies = [];
+        logger_1.Logger.loading(`Searching TRM dependencies...`);
+        for (const parsedSenvi of aParsedSenvi) {
+            if (parsedSenvi.table === 'TADIR') {
+                trmDependencies = trmDependencies.concat(yield _getTadirDependencies(parsedSenvi.dependencies));
+            }
+        }
+        context.output.trmDependencies = trmDependencies.filter(o => o.trmPackage);
+        context.output.unknownDependencies = trmDependencies.filter(o => !o.trmPackage);
+    })
+};

package/dist/actions/index.d.ts

@@ -1,6 +1,5 @@
+export * from "./findDependencies";
 export * from "./publish";
-export * from "./findTadirDependencies";
-export * from "./install";
-export * from "./installDependency";
-export * from "./checkDependencies";
+export * from "./checkPackageDependencies";
 export * from "./checkSapEntries";
+export * from "./install";

package/dist/actions/index.js

@@ -14,9 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./findDependencies"), exports);
 __exportStar(require("./publish"), exports);
-__exportStar(require("./findTadirDependencies"), exports);
-__exportStar(require("./install"), exports);
-__exportStar(require("./installDependency"), exports);
-__exportStar(require("./checkDependencies"), exports);
+__exportStar(require("./checkPackageDependencies"), exports);
 __exportStar(require("./checkSapEntries"), exports);
+__exportStar(require("./install"), exports);