trm-core 9.10.6 → 10.0.1

package/dist/actions/install/checkInstallDevclass.js

@@ -0,0 +1,110 @@
+"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.checkInstallDevclass = void 0;
+exports.validateInstallDevclass = validateInstallDevclass;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const addNamespace_1 = require("./addNamespace");
+const utils_1 = require("../commons/utils");
+function getTree(devclass) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return [devclass, ...(yield systemConnector_1.SystemConnector.getSubpackages(devclass)).map(o => o.devclass)];
+    });
+}
+/**
+ * Validates one install package name chosen by the user, so the prompt can ask again: it must be
+ * outside the SAP packages of the other installed TRM packages and, when it exists, contain none of
+ * their root packages. check-install-devclass repeats the check on the final choice.
+ */
+function validateInstallDevclass(context, devclass) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const systemPackages = context.rawInput.contextData.systemPackages || [];
+        const owner = yield (0, utils_1.getOwningInstallation)(devclass, systemPackages, context.runtime.update);
+        if (owner) {
+            return `ABAP package ${devclass} belongs to installed TRM package "${owner.packageName}": choose a package outside of it.`;
+        }
+        if (yield systemConnector_1.SystemConnector.getDevclass(devclass)) {
+            const roots = new Map(systemPackages.filter(o => o !== context.runtime.update && o.getDevclass()).map(o => [o.getDevclass().trim().toUpperCase(), o]));
+            for (const subpackage of yield systemConnector_1.SystemConnector.getSubpackages(devclass)) {
+                const nested = roots.get(subpackage.devclass.trim().toUpperCase());
+                if (nested) {
+                    return `ABAP package ${devclass} contains package ${subpackage.devclass} of installed TRM package "${nested.packageName}": choose a package outside of it.`;
+                }
+            }
+        }
+        return true;
+    });
+}
+/**
+ * Workflow step that rejects an install whose target ABAP packages would nest it with another
+ * installed TRM package, before anything is locked or installed.
+ *
+ * 1- collect the ABAP package trees of the other installed TRM packages
+ *
+ * 2- reject install packages inside one of those trees
+ *
+ * 3- reject existing install packages that contain another TRM package
+ *
+ * On update, the package's own installed tree stays allowed, also when it is already nested
+ * in another TRM package.
+ *
+*/
+exports.checkInstallDevclass = {
+    name: 'check-install-devclass',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const replacements = context.rawInput.installData.installDevclass.replacements;
+        const installDevclasses = [...new Set((0, addNamespace_1.flattenDevclasses)(context.runtime.package.hierarchy)
+                .map(originalDevclass => { var _a; return ((_a = replacements.find(o => o.originalDevclass === originalDevclass)) === null || _a === void 0 ? void 0 : _a.installDevclass) || originalDevclass; })
+                .map(devclass => devclass.trim().toUpperCase()))];
+        trm_commons_1.Logger.loading(`Checking installed packages...`);
+        const updateRoot = (_a = context.runtime.update) === null || _a === void 0 ? void 0 : _a.getDevclass();
+        const ownTree = new Set(updateRoot ? yield getTree(updateRoot) : []);
+        //1- collect the ABAP package trees of the other installed TRM packages
+        const owners = new Map();
+        const otherRoots = new Map();
+        for (const trmPackage of context.rawInput.contextData.systemPackages || []) {
+            const root = trmPackage.getDevclass();
+            if (!root || trmPackage === context.runtime.update) {
+                continue;
+            }
+            otherRoots.set(root, trmPackage.packageName);
+            const tree = yield getTree(root);
+            //installed package already nested in this one: its own tree is not owned by this one
+            const containsOwn = updateRoot && tree.includes(updateRoot);
+            for (const devclass of tree) {
+                if (!(containsOwn && ownTree.has(devclass))) {
+                    owners.set(devclass, trmPackage.packageName);
+                }
+            }
+        }
+        //2- reject install packages inside one of those trees
+        for (const devclass of installDevclasses) {
+            const owner = owners.get(devclass);
+            if (owner) {
+                throw new Error(`ABAP package ${devclass} belongs to installed TRM package "${owner}": choose a package outside of it.`);
+            }
+        }
+        //3- reject existing install packages that contain another TRM package
+        for (const devclass of installDevclasses) {
+            if (ownTree.has(devclass) || !(yield systemConnector_1.SystemConnector.getDevclass(devclass))) {
+                continue;
+            }
+            for (const subpackage of yield getTree(devclass)) {
+                const nested = otherRoots.get(subpackage);
+                if (nested) {
+                    throw new Error(`ABAP package ${devclass} contains package ${subpackage} of installed TRM package "${nested}": choose a package outside of it.`);
+                }
+            }
+        }
+    })
+};

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

@@ -1,3 +1,12 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that checks the required SAP table entries: missing ones block the installation
+ * in check-engines, together with the unmet engines.
+ *
+ * 1- execute check sap entries workflow
+ *
+ * 2- check result
+ *
+*/
 export declare const checkSapEntries: Step<InstallWorkflowContext>;

package/dist/actions/install/checkSapEntries.js

@@ -12,7 +12,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkSapEntries = void 0;
 const trm_commons_1 = require("trm-commons");
 const checkSapEntries_1 = require("../checkSapEntries");
-const SUBWORKFLOW_NAME = 'check-sap-entries-sub-install';
+/**
+ * Workflow step that checks the required SAP table entries: missing ones block the installation
+ * in check-engines, together with the unmet engines.
+ *
+ * 1- execute check sap entries workflow
+ *
+ * 2- check result
+ *
+*/
 exports.checkSapEntries = {
     name: 'check-sap-entries',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -25,28 +33,28 @@ exports.checkSapEntries = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Check sap entries step', true);
+        //1- execute check sap entries workflow
         const inputData = {
             packageData: {
-                manifest: context.runtime.remotePackageData.manifest
+                manifest: context.runtime.package.data.manifest
             },
             printOptions: {
                 entriesStatus: false,
                 information: false
             }
         };
-        trm_commons_1.Logger.loading(`Checking SAP entries...`);
-        trm_commons_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, trm_commons_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        trm_commons_1.Logger.loading(`Checking system requirements...`);
         const result = yield (0, checkSapEntries_1.checkSapEntries)(inputData);
-        trm_commons_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, trm_commons_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        //2- check result
         const sapEntriesOutput = result.sapEntriesStatus;
-        var missingEntries = [];
-        Object.keys(sapEntriesOutput).forEach(t => {
-            missingEntries = missingEntries.concat(sapEntriesOutput[t].filter(o => !o.status));
-        });
+        const missingEntries = Object.entries(sapEntriesOutput).flatMap(([table, entries]) => entries.filter(o => !o.status).map(o => ({ table, entry: o.entry })));
         if (missingEntries.length > 0) {
-            trm_commons_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).`);
+            missingEntries.forEach(o => {
+                const fields = Object.entries(o.entry).map(([field, value]) => `${field} = ${value}`).join(', ');
+                trm_commons_1.Logger.error(`Required entry not found in table ${o.table}: ${fields}`, { important: true });
+            });
+            // Aborted by check-engines, so unmet engines are reported in the same run.
+            context.runtime.missingSapEntries = missingEntries.length;
         }
         else {
             trm_commons_1.Logger.success(`SAP entries checked.`);

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

@@ -1,3 +1,37 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+import { E071, TADIR } from "../../client";
+/** Throws when any of the objects is locked in a SAP transport request. */
+export declare function checkObjectsLocks(e071: E071[]): Promise<void>;
+/** Returns the objects of the release that already exist on the target system. */
+export declare function findExistingObjects(context: InstallWorkflowContext, tadir: TADIR[]): Promise<TADIR[]>;
+/**
+ * Objects of the release whose existence blocks an install. SAP packages are left out: the release
+ * carries their original names, while the install packages are chosen later and checked by
+ * check-install-devclass.
+ */
+export declare function existenceCheckObjects(tadir: TADIR[]): TADIR[];
+/**
+ * Workflow step that validates artifact transports and classifies them by TRM identifier.
+ * A package must contain exactly one DEVC transport and one TADIR transport.
+ *
+ * Optionally, one LANG (Translation) and one (or more) CUST (Customizing) transport.
+ *
+ * 1- fill lang import
+ *
+ * 2- fill cust import
+ *
+ * 3- get entries of requested transports
+ *
+ * 4- check devc and tadir existance
+ *
+ * 5- set original hierarchy
+ *
+ * 6- check objects aren't locked
+ *
+ * 7- check all object types are supported
+ *
+ * 8- check objects existance
+ *
+*/
 export declare const checkTransports: Step<InstallWorkflowContext>;