trm-core 2.2.3 → 3.1.0

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);

package/dist/actions/install/checkAlreadyInstalled.d.ts

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

package/dist/actions/install/checkAlreadyInstalled.js

@@ -0,0 +1,59 @@
+"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.checkAlreadyInstalled = void 0;
+const logger_1 = require("../../logger");
+const manifest_1 = require("../../manifest");
+const semver_1 = require("semver");
+exports.checkAlreadyInstalled = {
+    name: 'check-already-installed',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.skipAlreadyInstalledCheck) {
+            logger_1.Logger.log(`Skipping already installed check (input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const installedPackages = context.parsedInput.systemPackages;
+        const oManifest = context.runtime.manifest;
+        const trmManifest = context.runtime.trmManifest;
+        const installedPackage = installedPackages.find(o => manifest_1.Manifest.compare(o.manifest, oManifest, false));
+        if (installedPackage) {
+            const installVersion = trmManifest.version;
+            const installedVersion = installedPackage.manifest.get().version;
+            if ((0, semver_1.eq)(installVersion, installedVersion)) {
+                if (context.parsedInput.forceInstallSameVersion) {
+                    logger_1.Logger.log(`Package ${trmManifest.name} version ${installedVersion} already installed, but install is forced (input)`, true);
+                }
+                else {
+                    throw new Error(`Package ${trmManifest.name} version ${installedVersion} already installed.`);
+                }
+            }
+            else {
+                if (context.parsedInput.overwriteInstall) {
+                    logger_1.Logger.log(`Package ${trmManifest.name} version ${installedVersion} already installed, but install is forced (input)`, true);
+                    if ((0, semver_1.gt)(installVersion, installedVersion)) {
+                        logger_1.Logger.info(`Upgrading ${installedVersion} -> ${installVersion}`);
+                    }
+                    else {
+                        logger_1.Logger.warning(`Downgrading ${installedVersion} -> ${installVersion}`);
+                    }
+                }
+                else {
+                    throw new Error(`Package ${trmManifest.name} version ${installedVersion} already installed.`);
+                }
+            }
+        }
+    })
+};

package/dist/actions/install/checkDependencies.d.ts

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

package/dist/actions/install/checkDependencies.js

@@ -0,0 +1,69 @@
+"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.checkDependencies = void 0;
+const logger_1 = require("../../logger");
+const util_1 = require("util");
+const checkPackageDependencies_1 = require("../checkPackageDependencies");
+const SUBWORKFLOW_NAME = 'check-dependencies-sub-install';
+exports.checkDependencies = {
+    name: 'check-dependencies',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.parsedInput.checkDependencies) {
+            logger_1.Logger.log(`Skipping dependencies check (input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const trmManifest = context.runtime.trmManifest;
+        const dependencies = trmManifest.dependencies || [];
+        logger_1.Logger.info(`Package has ${dependencies.length} dependencies.`);
+        context.runtime.dependenciesToInstall = [];
+        if (dependencies.length === 0) {
+            return;
+        }
+        const trmPackage = context.runtime.trmPackage;
+        const systemPackages = context.parsedInput.systemPackages;
+        const inputData = {
+            trmPackage,
+            systemPackages,
+            print: false
+        };
+        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        logger_1.Logger.loading(`Checking package dependencies...`);
+        const result = yield (0, checkPackageDependencies_1.checkPackageDependencies)(inputData);
+        logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const dependenciesOutput = result.dependencyStatus;
+        var dependenciesToInstall = [];
+        if (dependenciesOutput) {
+            dependenciesOutput.forEach(o => {
+                if (!o.match) {
+                    dependenciesToInstall.push(o.dependency);
+                }
+                else {
+                    if (!o.safe) {
+                        logger_1.Logger.warning(`Dependency "${o.dependency.name}" is installed, but integrity doesn't match.`);
+                    }
+                }
+            });
+            if (dependenciesToInstall.length === 0) {
+                logger_1.Logger.success(`Package dependencies ok.`);
+            }
+            else {
+                logger_1.Logger.info(`There's a total of ${dependenciesToInstall} dependencies needed in order to install "${trmManifest.name}".`);
+            }
+        }
+        context.runtime.dependenciesToInstall = dependenciesToInstall;
+    })
+};

package/dist/actions/install/checkIntegrity.d.ts

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

package/dist/actions/install/checkIntegrity.js

@@ -0,0 +1,42 @@
+"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.checkIntegrity = void 0;
+const logger_1 = require("../../logger");
+exports.checkIntegrity = {
+    name: 'check-integrity',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.parsedInput.installIntegrity) {
+            logger_1.Logger.log(`Skipping integrity check (input not provided)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const trmManifest = context.runtime.trmManifest;
+        const installIntegrity = context.runtime.fetchedIntegrity;
+        const inputIntegrity = context.parsedInput.installIntegrity;
+        const safe = context.parsedInput.safeInstall;
+        if (installIntegrity !== inputIntegrity) {
+            logger_1.Logger.warning(`ATTENTION!! Integrity check failed on package ${trmManifest.name}, version ${trmManifest.version}.`);
+            logger_1.Logger.warning(`            Local:  ${inputIntegrity}`);
+            logger_1.Logger.warning(`            Remote: ${installIntegrity}`);
+            if (safe) {
+                logger_1.Logger.warning(`            Install will continue.`);
+            }
+            else {
+                throw new Error(`Package installation aborted due to integrity check failure and running in safe mode.`);
+            }
+        }
+    })
+};

package/dist/actions/install/checkSapEntries.d.ts

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

package/dist/actions/install/checkSapEntries.js

@@ -0,0 +1,52 @@
+"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.checkSapEntries = void 0;
+const logger_1 = require("../../logger");
+const checkSapEntries_1 = require("../checkSapEntries");
+const util_1 = require("util");
+const SUBWORKFLOW_NAME = 'check-sap-entries-sub-install';
+exports.checkSapEntries = {
+    name: 'check-sap-entries',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.parsedInput.checkSapEntries) {
+            logger_1.Logger.log(`Skipping SAP entries check (input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const trmPackage = context.runtime.trmPackage;
+        const inputData = {
+            trmPackage,
+            print: false
+        };
+        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        logger_1.Logger.loading(`Checking SAP entries...`);
+        const result = yield (0, checkSapEntries_1.checkSapEntries)(inputData);
+        logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const sapEntriesOutput = result.sapEntriesStatus;
+        if (sapEntriesOutput) {
+            var missingEntries = [];
+            Object.keys(sapEntriesOutput).forEach(t => {
+                missingEntries = missingEntries.concat(sapEntriesOutput[t].filter(o => !o.status));
+            });
+            if (missingEntries.length > 0) {
+                throw new Error(`Package requires SAP entries that don't exist on your system.`);
+            }
+            else {
+                logger_1.Logger.success(`SAP entries checked.`);
+            }
+        }
+    })
+};

package/dist/actions/install/checkTadirContent.d.ts

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

package/dist/actions/install/checkTadirContent.js

@@ -0,0 +1,50 @@
+"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.checkTadirContent = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+exports.checkTadirContent = {
+    name: 'check-tadir-content',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.tadirTransport) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skip TADIR content check (no tadir transports were found in package)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const r3trans = context.runtime.r3trans;
+        const tadirTransport = context.runtime.tadirTransport;
+        const transportData = tadirTransport.binaries.data;
+        const tdevc = context.runtime.tdevcData;
+        logger_1.Logger.loading(`Checking package objects content...`);
+        const aTadir = (0, commons_1.normalize)(yield r3trans.getTableEntries(transportData, 'TADIR'));
+        logger_1.Logger.log(`Adding ${aTadir.length} objects to workbench transport (not generated yet)`, true);
+        const wbObjects = context.runtime.workbenchObjects.concat(aTadir.map(o => {
+            return {
+                pgmid: o.pgmid,
+                object: o.object,
+                objName: o.objName
+            };
+        }));
+        context.runtime.workbenchObjects = wbObjects;
+        aTadir.forEach(o => {
+            if (!tdevc.find(k => k.devclass === o.devclass)) {
+                logger_1.Logger.error(`Object ${o.pgmid} ${o.object} ${o.objName}, devclass ${o.devclass} not found in DEVC transport!`, true);
+                throw new Error(`Package includes objects without devclass.`);
+            }
+        });
+        context.runtime.tadirData = aTadir;
+    })
+};

package/dist/actions/install/checkTadirObjectTypes.d.ts

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

package/dist/actions/install/checkTadirObjectTypes.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.checkTadirObjectTypes = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+exports.checkTadirObjectTypes = {
+    name: 'check-tadir-object-types',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.tadirTransport) {
+            if (context.parsedInput.checkObjectTypes) {
+                return true;
+            }
+            else {
+                logger_1.Logger.log(`Skip TADIR object type check (input)`, true);
+                return false;
+            }
+        }
+        else {
+            logger_1.Logger.log(`Skip TADIR object type check (no tadir transports were found in package)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const aTadir = context.runtime.tadirData;
+        logger_1.Logger.loading(`Checking package objects types...`);
+        const systemObjectList = yield systemConnector_1.SystemConnector.getObjectsList();
+        aTadir.forEach(o => {
+            if (!systemObjectList.find(k => k.pgmid === o.pgmid && k.object === o.object)) {
+                logger_1.Logger.error(`TADIR transport contains object ${o.pgmid} ${o.object} ${o.objName}, which is not supported by target install system`, true);
+                throw new Error(`Transport contains unknown object type ${o.pgmid} ${o.object}.`);
+            }
+        });
+        logger_1.Logger.success(`All objects in package "${packageName}" supported.`);
+    })
+};

package/dist/actions/install/checkTransports.d.ts

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

package/dist/actions/install/checkTransports.js

@@ -0,0 +1,71 @@
+"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.checkTransports = void 0;
+const logger_1 = require("../../logger");
+const transport_1 = require("../../transport");
+exports.checkTransports = {
+    name: 'check-transports',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const packageName = context.parsedInput.packageName;
+        const r3trans = context.runtime.r3trans;
+        const oArtifact = context.runtime.trmArtifact;
+        logger_1.Logger.loading(`Reading transports...`);
+        const aTransports = yield oArtifact.getTransportBinaries();
+        logger_1.Logger.log(`Package content: ${aTransports.map(o => {
+            return {
+                trkorr: o.trkorr,
+                type: o.type
+            };
+        })}`, true);
+        for (const transport of aTransports) {
+            try {
+                yield r3trans.isTransportValid(transport.binaries.data);
+                logger_1.Logger.log(`Transport ${transport.trkorr} is valid.`, true);
+            }
+            catch (e) {
+                throw new Error(`Package contains invalid transport.`);
+            }
+        }
+        const aDevcTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.DEVC);
+        const aTadirTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.TADIR);
+        const aLangTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.LANG);
+        const aCustTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.CUST);
+        if (aDevcTransports.length !== 1) {
+            throw new Error(`Unexpected declaration of devclass in package ${packageName}.`);
+        }
+        else {
+            context.runtime.devcTransport = aDevcTransports[0];
+            logger_1.Logger.log(`DEVC transport is ${aDevcTransports[0].trkorr}.`, true);
+        }
+        if (aTadirTransports.length > 0) {
+            if (aTadirTransports.length !== 1) {
+                throw new Error(`Unexpected declaration of objects in package ${packageName}.`);
+            }
+            context.runtime.tadirTransport = aTadirTransports[0];
+            logger_1.Logger.log(`TADIR transport is ${aTadirTransports[0].trkorr}.`, true);
+        }
+        if (aLangTransports.length > 0) {
+            if (aLangTransports.length !== 1) {
+                throw new Error(`Unexpected declaration of translations in package ${packageName}.`);
+            }
+            context.runtime.langTransport = aLangTransports[0];
+            logger_1.Logger.log(`LANG transport is ${aLangTransports[0].trkorr}.`, true);
+        }
+        if (aCustTransports.length > 0) {
+            if (aCustTransports.length !== 1) {
+                throw new Error(`Unexpected declaration of customizing in package ${packageName}.`);
+            }
+            context.runtime.custTransport = aCustTransports[0];
+            logger_1.Logger.log(`CUST transport is ${aCustTransports[0].trkorr}.`, true);
+        }
+    })
+};

package/dist/actions/install/generateDevclass.d.ts

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