trm-core 5.0.0 → 6.0.0

package/dist/actions/findDependencies/setTrmDependencies.js

@@ -10,10 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setTrmDependencies = void 0;
+const logger_1 = require("../../logger");
 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);
@@ -49,7 +49,7 @@ const _getRootDevclass = (devclass) => __awaiter(void 0, void 0, void 0, functio
 const _getTadirDependencies = (tadirDependencies) => __awaiter(void 0, void 0, void 0, function* () {
     var trmDependencies = [];
     for (const tadirDependency of tadirDependencies) {
-        const tadir = tadirDependency.tableDependency;
+        const tadir = tadirDependency.object;
         var trmRelevantTransports = [];
         var latestTransport;
         var devclass;
@@ -57,13 +57,9 @@ const _getTadirDependencies = (tadirDependencies) => __awaiter(void 0, void 0, v
         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);
+        logger_1.Logger.log(`Searching transports for object ${tadir.pgmid} ${tadir.object} ${tadir.objName}`, true);
+        const allTransports = yield transport_1.Transport.getTransportsFromObject(tadir);
+        logger_1.Logger.log(`Found ${allTransports.length} transports for object ${tadir.pgmid} ${tadir.object} ${tadir.objName}`, true);
         for (const transport of allTransports) {
             if (yield transport.isTrmRelevant()) {
                 logger_1.Logger.log(`Transport ${transport.trkorr} is TRM relevant`, true);
@@ -74,7 +70,7 @@ const _getTadirDependencies = (tadirDependencies) => __awaiter(void 0, void 0, v
         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));
+            const alreadyInArray = trmDependencies.find(o => o.package && trmPackage_1.TrmPackage.compare(o.package, trmPackage));
             if (alreadyInArray) {
                 devclass = alreadyInArray.devclass;
                 integrity = alreadyInArray.integrity;
@@ -94,13 +90,13 @@ const _getTadirDependencies = (tadirDependencies) => __awaiter(void 0, void 0, v
         }
         else {
             logger_1.Logger.log(`Object without TRM package`, true);
-            devclass = yield _getRootDevclass(tadir.DEVCLASS);
+            devclass = yield _getRootDevclass(tadir.devclass);
         }
         arrayIndex1 = trmDependencies.findIndex(o => o.devclass === devclass);
         if (arrayIndex1 < 0) {
             arrayIndex1 = trmDependencies.push({
                 devclass,
-                trmPackage,
+                package: trmPackage,
                 integrity,
                 sapEntries: []
             });
@@ -120,27 +116,16 @@ const _getTadirDependencies = (tadirDependencies) => __awaiter(void 0, void 0, v
 });
 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;
+        logger_1.Logger.log('Set TRM dependencies step', true);
         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));
+        for (const entryDependency of context.runtime.dependencies.customObjects) {
+            if (entryDependency.table === 'TADIR') {
+                trmDependencies = trmDependencies.concat(yield _getTadirDependencies(entryDependency.dependencies));
             }
         }
-        context.output.trmDependencies = trmDependencies.filter(o => o.trmPackage);
-        context.output.unknownDependencies = trmDependencies.filter(o => !o.trmPackage);
+        context.runtime.dependencies.withTrmPackage = trmDependencies.filter(o => o.package);
+        context.runtime.dependencies.withoutTrmPackage = trmDependencies.filter(o => !o.package);
     })
 };
-//# sourceMappingURL=setTrmDependencies.js.map

package/dist/actions/index.d.ts

@@ -1,5 +1,7 @@
-export * from "./findDependencies";
-export * from "./publish";
+export * from "./commons";
+export * from "./installDependency";
 export * from "./checkPackageDependencies";
 export * from "./checkSapEntries";
+export * from "./findDependencies";
 export * from "./install";
+export * from "./publish";

package/dist/actions/index.js

@@ -14,9 +14,10 @@ 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("./commons"), exports);
+__exportStar(require("./installDependency"), exports);
 __exportStar(require("./checkPackageDependencies"), exports);
 __exportStar(require("./checkSapEntries"), exports);
+__exportStar(require("./findDependencies"), exports);
 __exportStar(require("./install"), exports);
-//# sourceMappingURL=index.js.map
+__exportStar(require("./publish"), exports);

package/dist/actions/install/{readDevcTransport.d.ts → addNamespace.d.ts}

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

package/dist/actions/install/addNamespace.js

@@ -0,0 +1,133 @@
+"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.addNamespace = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+const systemConnector_1 = require("../../systemConnector");
+const inquirer_1 = require("../../inquirer");
+exports.addNamespace = {
+    name: 'add-namespace',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Add namespace step', true);
+        context.runtime.rollback = true;
+        var originalNamespace = (0, commons_1.getPackageNamespace)(context.runtime.originalData.hierarchy.devclass);
+        logger_1.Logger.log(`Package original namespace is ${originalNamespace}`, true);
+        if (!context.rawInput.installData.installDevclass.keepOriginal && context.rawInput.installData.installDevclass.replacements.length > 0) {
+            context.runtime.installData.namespace = (0, commons_1.getPackageNamespace)(context.rawInput.installData.installDevclass.replacements[0].installDevclass);
+        }
+        else {
+            context.runtime.installData.namespace = originalNamespace;
+        }
+        if (context.runtime.installData.namespace[0] !== '/') {
+            logger_1.Logger.log(`Package install namespace is ${context.runtime.installData.namespace}`, true);
+            return;
+        }
+        logger_1.Logger.loading(`Checking namespace ${context.runtime.installData.namespace}...`);
+        var namespace;
+        const namespaceCheck = yield systemConnector_1.SystemConnector.getNamespace(context.runtime.installData.namespace);
+        if (namespaceCheck) {
+            namespace = namespaceCheck.trnspacet;
+        }
+        if (namespace) {
+            logger_1.Logger.log(`Namespace ${context.runtime.installData.namespace} already defined`, true);
+            return;
+        }
+        var replicense;
+        var texts;
+        var aTexts = [];
+        if (context.runtime.installData.namespace !== originalNamespace) {
+            if (!context.rawInput.contextData.noInquirer) {
+                replicense = (yield inquirer_1.Inquirer.prompt({
+                    message: `Input repair license for namespace ${context.runtime.installData.namespace}`,
+                    name: 'replicense',
+                    type: 'input',
+                    validate: (input) => {
+                        if (/^\d+$/.test(input)) {
+                            return true;
+                        }
+                        else {
+                            return 'Invalid characters';
+                        }
+                    }
+                })).replicense;
+                texts = yield inquirer_1.Inquirer.prompt([{
+                        message: `dummy`,
+                        name: 'namespace',
+                        type: 'input',
+                        when: false,
+                        default: context.runtime.installData.namespace
+                    }, {
+                        message: `Namespace owner`,
+                        name: 'owner',
+                        type: 'input'
+                    }, {
+                        message: `Namespace language`,
+                        name: 'spras',
+                        type: 'input'
+                    }, {
+                        message: `Namespace description`,
+                        name: 'descriptn',
+                        type: 'input'
+                    }]);
+            }
+        }
+        else {
+            if (context.runtime.remotePackageData.trmManifest.namespace) {
+                replicense = context.runtime.remotePackageData.trmManifest.namespace.replicense;
+                if (context.runtime.remotePackageData.trmManifest.namespace.texts && context.runtime.remotePackageData.trmManifest.namespace.texts.length > 0) {
+                    if (context.runtime.remotePackageData.trmManifest.namespace.texts.length === 1 || context.rawInput.contextData.noInquirer) {
+                        texts = {
+                            namespace: context.runtime.installData.namespace,
+                            descriptn: context.runtime.remotePackageData.trmManifest.namespace.texts[0].description,
+                            owner: context.runtime.remotePackageData.trmManifest.namespace.texts[0].owner,
+                            spras: context.runtime.remotePackageData.trmManifest.namespace.texts[0].language
+                        };
+                    }
+                    else {
+                        if (!context.rawInput.contextData.noInquirer) {
+                            texts = (yield inquirer_1.Inquirer.prompt({
+                                type: 'list',
+                                message: 'Choose namespace install text',
+                                name: 'choice',
+                                choices: context.runtime.remotePackageData.trmManifest.namespace.texts.map(o => {
+                                    return {
+                                        name: `${o.language} ${o.description} ${o.owner}`,
+                                        value: o
+                                    };
+                                })
+                            })).choice;
+                        }
+                    }
+                }
+            }
+        }
+        if (!replicense) {
+            throw new Error(`Cannot use namespace ${context.runtime.installData.namespace}: repair license missing.`);
+        }
+        if (!texts) {
+            throw new Error(`Cannot use namespace ${context.runtime.installData.namespace}: data missing.`);
+        }
+        else {
+            aTexts.push(texts);
+            if (texts.spras != systemConnector_1.SystemConnector.getLogonLanguage(true)) {
+                aTexts.push(Object.assign(Object.assign({}, texts), { spras: systemConnector_1.SystemConnector.getLogonLanguage(true) }));
+            }
+        }
+        logger_1.Logger.loading(`Installing namespace ${context.runtime.installData.namespace}...`);
+        yield systemConnector_1.SystemConnector.addNamespace(context.runtime.installData.namespace, replicense, aTexts);
+        context.runtime.generatedData.namespace = context.runtime.installData.namespace;
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.generatedData.namespace) {
+        }
+    })
+};

package/dist/actions/install/checkAlreadyInstalled.js

@@ -15,46 +15,36 @@ 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));
+        logger_1.Logger.log('Check already installed step', true);
+        const installedPackages = context.rawInput.contextData.systemPackages;
+        const manifest = context.runtime.remotePackageData.manifest;
+        const trmManifest = context.runtime.remotePackageData.trmManifest;
+        const installedPackage = installedPackages.find(o => manifest_1.Manifest.compare(o.manifest, manifest, false));
         if (installedPackage) {
             const installVersion = trmManifest.version;
             const installedVersion = installedPackage.manifest.get().version;
+            context.runtime.update = true;
             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);
+                if (context.rawInput.packageData.overwrite) {
+                    logger_1.Logger.info(`Package "${trmManifest.name}" version ${installedVersion} already installed.`);
                 }
                 else {
-                    throw new Error(`Package ${trmManifest.name} version ${installedVersion} already installed.`);
+                    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}`);
-                    }
+                if ((0, semver_1.gt)(installVersion, installedVersion)) {
+                    logger_1.Logger.info(`Upgrading ${installedVersion} -> ${installVersion}`);
                 }
                 else {
-                    throw new Error(`Package ${trmManifest.name} version ${installedVersion} already installed.`);
+                    logger_1.Logger.warning(`Downgrading ${installedVersion} -> ${installVersion}`);
                 }
             }
         }
+        else {
+            context.runtime.update = false;
+            logger_1.Logger.info(`Package not installed yet`, true);
+        }
     })
 };
-//# sourceMappingURL=checkAlreadyInstalled.js.map

package/dist/actions/install/checkDependencies.js

@@ -12,12 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkDependencies = void 0;
 const logger_1 = require("../../logger");
 const checkPackageDependencies_1 = require("../checkPackageDependencies");
-const SUBWORKFLOW_NAME = 'check-dependencies-sub-install';
+const SUBWORKFLOW_NAME = 'check-package-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);
+        if (context.rawInput.installData.checks.noDependencies) {
+            logger_1.Logger.log(`Skipping dependencies check (user input)`, true);
             return false;
         }
         else {
@@ -25,46 +25,45 @@ exports.checkDependencies = {
         }
     }),
     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;
-        }
-        var trmPackage = context.runtime.trmPackage;
-        trmPackage.manifest = yield trmPackage.fetchRemoteManifest(context.parsedInput.version);
-        const systemPackages = context.parsedInput.systemPackages;
+        logger_1.Logger.log('Check dependencies step', true);
         const inputData = {
-            trmPackage,
-            systemPackages,
-            print: false
+            packageData: {
+                package: context.runtime.remotePackageData.trmPackage
+            },
+            contextData: {
+                systemPackages: context.rawInput.contextData.systemPackages
+            },
+            printOptions: {
+                dependencyStatus: false,
+                information: false
+            }
         };
+        logger_1.Logger.loading(`Checking dependencies...`);
         logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_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, logger_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.`);
+        if (result.dependencies.length > 0) {
+            if (result.dependencies.length === 1) {
+                logger_1.Logger.info(`"${context.rawInput.packageData.name}" has ${result.dependencies.length} dependency: ${result.dependencyStatus.filter(o => o.match).length} installed, ${result.dependencyStatus.filter(o => !o.match).length} missing.`);
             }
             else {
-                logger_1.Logger.info(`There's a total of ${dependenciesToInstall.length} dependencies needed in order to install "${trmManifest.name}".`);
+                logger_1.Logger.info(`"${context.rawInput.packageData.name}" has ${result.dependencies.length} dependencies: ${result.dependencyStatus.filter(o => o.match).length} installed, ${result.dependencyStatus.filter(o => !o.match).length} missing.`);
             }
         }
-        context.runtime.dependenciesToInstall = dependenciesToInstall;
+        result.dependencyStatus.forEach(o => {
+            if (!o.match) {
+                context.runtime.dependenciesToInstall.push(o.dependency);
+            }
+            else {
+                if (!o.safe) {
+                    if (context.rawInput.installData.checks.safe) {
+                        throw new Error(`Dependency "${o.dependency.name}" is installed, but integrity doesn't match.`);
+                    }
+                    else {
+                        logger_1.Logger.warning(`Dependency "${o.dependency.name}" is installed, but integrity doesn't match.`);
+                    }
+                }
+            }
+        });
     })
 };
-//# sourceMappingURL=checkDependencies.js.map

package/dist/actions/install/checkIntegrity.js

@@ -13,20 +13,20 @@ 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;
+        logger_1.Logger.log('Check integrity step', true);
+        const inputIntegrity = context.rawInput.packageData.integrity;
+        const safe = context.rawInput.installData.checks.safe;
+        if (!inputIntegrity) {
+            if (safe) {
+                throw new Error(`Running in safe mode but no integrity checksum was provided.`);
+            }
+            else {
+                return;
+            }
+        }
+        const trmManifest = context.runtime.remotePackageData.trmManifest;
+        const installIntegrity = context.runtime.remotePackageData.integrity;
         if (installIntegrity !== inputIntegrity) {
             logger_1.Logger.warning(`ATTENTION!! Integrity check failed on package ${trmManifest.name}, version ${trmManifest.version}.`);
             logger_1.Logger.warning(`            Local:  ${inputIntegrity}`);
@@ -35,9 +35,8 @@ exports.checkIntegrity = {
                 logger_1.Logger.warning(`            Install will continue.`);
             }
             else {
-                throw new Error(`Package installation aborted due to integrity check failure and running in safe mode.`);
+                throw new Error(`Safe mode: package installation aborted due to integrity check failure.`);
             }
         }
     })
 };
-//# sourceMappingURL=checkIntegrity.js.map

package/dist/actions/install/{checkTadirContent.d.ts → checkObjectTypes.d.ts}

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

package/dist/actions/install/checkObjectTypes.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.checkObjectTypes = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+exports.checkObjectTypes = {
+    name: 'check-object-types',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.checks.noObjectTypes) {
+            logger_1.Logger.log(`Skipping object types check (user input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Check object types step', true);
+        logger_1.Logger.loading(`Checking package objects types...`);
+        const systemObjectList = yield systemConnector_1.SystemConnector.getObjectsList();
+        var unsupportedObjectTypes = [];
+        context.runtime.packageTransportsData.e071.forEach(o => {
+            if (!systemObjectList.find(k => k.pgmid === o.pgmid && k.object === k.object)) {
+                if (!unsupportedObjectTypes.find(k => k.pgmid === o.pgmid && k.object === k.object)) {
+                    unsupportedObjectTypes.push({
+                        pgmid: o.pgmid,
+                        object: o.object,
+                        text: `${o.pgmid} ${o.object}`
+                    });
+                }
+            }
+        });
+        if (unsupportedObjectTypes.length > 0) {
+            logger_1.Logger.error(`Package contains ${unsupportedObjectTypes.length} unsupported objects:`);
+            unsupportedObjectTypes.forEach(o => {
+                logger_1.Logger.error(`  ${o.text}`);
+            });
+            throw new Error(`Package is not supported on ${systemConnector_1.SystemConnector.getDest()}.`);
+        }
+    })
+};

package/dist/actions/install/checkSapEntries.js

@@ -16,8 +16,8 @@ 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);
+        if (context.rawInput.installData.checks.noSapEntries) {
+            logger_1.Logger.log(`Skipping SAP entries check (user input)`, true);
             return false;
         }
         else {
@@ -25,29 +25,31 @@ exports.checkSapEntries = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const trmPackage = context.runtime.trmPackage;
+        logger_1.Logger.log('Check sap entries step', true);
         const inputData = {
-            trmPackage,
-            print: false
+            packageData: {
+                package: context.runtime.remotePackageData.trmPackage
+            },
+            printOptions: {
+                entriesStatus: false,
+                information: false
+            }
         };
-        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
         logger_1.Logger.loading(`Checking SAP entries...`);
+        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
         const result = yield (0, checkSapEntries_1.checkSapEntries)(inputData);
         logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, logger_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) {
-                logger_1.Logger.error(JSON.stringify(missingEntries), true);
-                throw new Error(`Package requires ${missingEntries.length} SAP entries that don't exist on your system (run in verbose for more detail).`);
-            }
-            else {
-                logger_1.Logger.success(`SAP entries checked.`);
-            }
+        var missingEntries = [];
+        Object.keys(sapEntriesOutput).forEach(t => {
+            missingEntries = missingEntries.concat(sapEntriesOutput[t].filter(o => !o.status));
+        });
+        if (missingEntries.length > 0) {
+            logger_1.Logger.error(JSON.stringify(missingEntries), true);
+            throw new Error(`Package requires ${missingEntries.length} SAP entries that don't exist on your system (run in verbose for more detail).`);
+        }
+        else {
+            logger_1.Logger.success(`SAP entries checked.`);
         }
     })
 };
-//# sourceMappingURL=checkSapEntries.js.map