trm-core 9.10.6 → 10.0.0

package/dist/actions/install/checkTransports.js

@@ -10,213 +10,372 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkTransports = void 0;
+exports.checkObjectsLocks = checkObjectsLocks;
+exports.findExistingObjects = findExistingObjects;
+exports.existenceCheckObjects = existenceCheckObjects;
 const trm_commons_1 = require("trm-commons");
 const transport_1 = require("../../transport");
-const commons_1 = require("../../commons");
 const trm_commons_2 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
-const node_r3trans_1 = require("node-r3trans");
-exports.checkTransports = {
-    name: 'check-transports',
-    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Check transports step', true);
-        var checkExistance = [];
-        trm_commons_1.Logger.loading(`Reading transports contents...`);
-        try {
-            context.runtime.packageTransportsData = (yield context.rawInput.packageData.registry.contents(context.rawInput.packageData.name, context.rawInput.packageData.version || 'latest'));
-            context.runtime.remotePackageData.contents = true;
-        }
-        catch (e) {
-            context.runtime.remotePackageData.contents = false;
-            const options = context.rawInput.contextData.r3transOptions;
-            trm_commons_1.Logger.log(`Loading R3Trans with options ${JSON.stringify(options)}`, true);
-            trm_commons_1.Logger.log(`R3TRANS_HOME ${process.env.R3TRANS_HOME}`, true);
-            context.runtime.r3trans = new node_r3trans_1.R3trans(options);
-            const r3transVersion = yield context.runtime.r3trans.getVersion();
-            const unicode = yield context.runtime.r3trans.isUnicode();
-            trm_commons_1.Logger.info(r3transVersion, context.rawInput.contextData.noR3transInfo);
-            trm_commons_1.Logger.log(`R3Trans unicode?: ${unicode}`, true);
-        }
-        trm_commons_1.Logger.loading(`Validating package transports...`);
-        const aTransports = yield context.runtime.remotePackageData.artifact.getTransportBinaries(context.rawInput.contextData.r3transOptions, context.runtime.remotePackageData.contents);
-        trm_commons_1.Logger.log(`Package content: ${aTransports.map(o => {
+const commons_1 = require("../../commons");
+const utils_1 = require("../commons/utils");
+/** Throws when any of the objects is locked in a SAP transport request. */
+function checkObjectsLocks(e071) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const locks = yield systemConnector_1.SystemConnector.getObjectsLocks(e071.map(o => {
             return {
-                trkorr: o.trkorr,
-                type: o.type
+                PGMID: o.pgmid,
+                OBJECT: o.object,
+                OBJ_NAME: o.objName
             };
-        })}`, true);
-        if (!context.runtime.remotePackageData.contents) {
-            for (const transport of aTransports) {
-                const valid = yield context.runtime.r3trans.isTransportValid(transport.binaries.data);
-                if (valid) {
-                    trm_commons_1.Logger.log(`Transport ${transport.trkorr} is valid.`, true);
-                }
-                else {
-                    trm_commons_1.Logger.error(`Transport ${transport.trkorr} is invalid.`, true);
-                    throw new Error(`Package contains invalid transports`);
-                }
-            }
+        }));
+        if (locks.length > 0) {
+            locks.forEach(l => {
+                trm_commons_1.Logger.error(`${l.pgmid} ${l.object} ${l.objName} is currently locked in transport ${l.trkorr}`, { important: true });
+            });
+            throw new Error(`Install aborted. To continue, all objects must be released`);
         }
-        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) {
-            trm_commons_1.Logger.error(`Zero or multiple DEVC transports found`, true);
-            throw new Error(`Unexpected content in package.`);
+    });
+}
+/** Returns the objects of the release that already exist on the target system. */
+function findExistingObjects(context, tadir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const checkTadir = tadir.map(o => {
+            return Object.assign(Object.assign({}, o), {
+                devclass: context.runtime.isTrmServer || context.runtime.isTrmRest ? (0, commons_1.adjustTrmServerRestDevclass)(o.devclass) : o.devclass
+            });
+        });
+        if (!systemConnector_1.SystemConnector.getSupportedBulk().getExistingObjects) {
+            return systemConnector_1.SystemConnector.getExistingObjects(checkTadir);
         }
         else {
-            context.runtime.packageTransports.devc.binaries = aDevcTransports[0];
-            trm_commons_1.Logger.log(`DEVC transport is ${context.runtime.packageTransports.devc.binaries.trkorr}.`, true);
-            if (context.rawInput.installData.installDevclass.keepOriginal) {
-                checkExistance.push(context.runtime.packageTransports.devc.binaries.trkorr);
-            }
+            return systemConnector_1.SystemConnector.getExistingObjectsBulk(checkTadir);
         }
-        if (aTadirTransports.length !== 1) {
-            trm_commons_1.Logger.error(`Zero or multiple TADIR transports found`, true);
-            throw new Error(`Unexpected content in package.`);
+    });
+}
+/**
+ * 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.
+ */
+function existenceCheckObjects(tadir) {
+    return tadir.filter(o => !(o.pgmid.trim().toUpperCase() === 'R3TR' && o.object.trim().toUpperCase() === 'DEVC'));
+}
+/** Labels a customizing transport by number, so transports with the same description can be told apart. */
+function custLabel(transport) {
+    return transport.description ? `${transport.trkorr} "${transport.description}"` : transport.trkorr;
+}
+/**
+ * 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
+ *
+*/
+exports.checkTransports = {
+    name: 'check-transports',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        let mergedE071 = [];
+        let mergedTDEVC = [];
+        let mergedTADIR = [];
+        function mergeEntries(entries) {
+            mergedE071 = mergedE071.concat(entries.e071 || []);
+            mergedTDEVC = mergedTDEVC.concat(entries.tdevc || []);
+            context.runtime.transportEntries.tdevct = context.runtime.transportEntries.tdevct.concat(entries.tdevct || []);
+            mergedTADIR = mergedTADIR.concat(entries.tadir || []);
         }
-        else {
-            context.runtime.packageTransports.tadir.binaries = aTadirTransports[0];
-            trm_commons_1.Logger.log(`TADIR transport is ${context.runtime.packageTransports.tadir.binaries.trkorr}.`, true);
-            checkExistance.push(context.runtime.packageTransports.tadir.binaries.trkorr);
-            if (!context.runtime.remotePackageData.contents) {
-                const tadirE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.tadir.binaries.binaries.data, 'E071'));
-                trm_commons_1.Logger.log(`TADIR E071: ${JSON.stringify(tadirE071)}`, true);
-                context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(tadirE071);
+        //1- fill lang import
+        let importLang = context.rawInput.installData.import.noLang === false;
+        if (context.rawInput.installData.import.noLang === undefined && context.runtime.package.data.transports.find(o => o.type === transport_1.TrmTransportIdentifier.LANG)) {
+            if (!context.rawInput.contextData.noInquirer) {
+                importLang = (yield trm_commons_2.Inquirer.prompt({
+                    name: 'importLang',
+                    type: 'confirm',
+                    message: `Do you want to import the package translations?`,
+                    default: true
+                })).importLang;
+            }
+            else {
+                //no prompts: import, as when noLang is false
+                importLang = true;
             }
         }
-        if (aLangTransports.length > 0) {
-            if (context.rawInput.installData.import.noLang === undefined) {
-                if (!context.rawInput.contextData.noInquirer) {
-                    context.rawInput.installData.import.noLang = !(yield trm_commons_2.Inquirer.prompt({
-                        type: `confirm`,
-                        name: `noLang`,
-                        message: `Import translations transport?`,
-                        default: true,
-                    })).noLang;
+        //2- fill cust import
+        const custTransports = context.runtime.package.data.transports.filter(o => o.type === transport_1.TrmTransportIdentifier.CUST);
+        let skippedCust = [];
+        if (context.rawInput.installData.import.noCust === undefined) {
+            if (!context.rawInput.contextData.noInquirer && trm_commons_2.Inquirer.isUi()) {
+                if (custTransports.length > 0) {
+                    const importCust = (yield trm_commons_2.Inquirer.prompt({
+                        name: 'importCust',
+                        type: 'select',
+                        message: `Select customizing to import`,
+                        choices: custTransports.map(o => ({
+                            name: custLabel(o),
+                            value: o.trkorr
+                        })),
+                        default: custTransports.map(o => o.trkorr)
+                    })).importCust || [];
+                    skippedCust = custTransports.filter(o => !importCust.includes(o.trkorr)).map(o => o.trkorr);
                 }
             }
-            if (!context.rawInput.installData.import.noLang) {
-                if (aLangTransports.length !== 1) {
-                    trm_commons_1.Logger.error(`Multiple LANG transports found`, true);
-                    throw new Error(`Unexpected content in package.`);
-                }
-                context.runtime.packageTransports.lang.binaries = aLangTransports[0];
-                trm_commons_1.Logger.log(`LANG transport is ${context.runtime.packageTransports.lang.binaries.trkorr}.`, true);
-                checkExistance.push(context.runtime.packageTransports.lang.binaries.trkorr);
-                if (!context.runtime.remotePackageData.contents) {
-                    const langE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.lang.binaries.binaries.data, 'E071'));
-                    trm_commons_1.Logger.log(`LANG E071: ${JSON.stringify(langE071)}`, true);
-                    context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(langE071);
+            else if (!context.rawInput.contextData.noInquirer) {
+                for (const cust of custTransports) {
+                    const importCust = (yield trm_commons_2.Inquirer.prompt({
+                        name: 'importCust',
+                        type: 'confirm',
+                        message: `Do you want to import customizing ${custLabel(cust)}?`,
+                        default: true
+                    })).importCust;
+                    if (!importCust) {
+                        skippedCust.push(cust.trkorr);
+                    }
                 }
             }
+            //no prompts: import all, as when noCust is false
         }
-        if (aCustTransports.length > 0) {
-            if (context.rawInput.installData.import.noCust === undefined) {
-                if (!context.rawInput.contextData.noInquirer) {
-                    context.rawInput.installData.import.noCust = !(yield trm_commons_2.Inquirer.prompt({
-                        type: `confirm`,
-                        name: `noCust`,
-                        message: `Import ${aCustTransports.length} customizing transport(s)?`,
-                        default: true,
-                    })).noCust;
+        else if (context.rawInput.installData.import.noCust) {
+            skippedCust = custTransports.map(o => o.trkorr);
+        }
+        context.runtime.skippedCust = skippedCust;
+        //3- get entries of requested transports
+        if (context.runtime.isLocal) {
+            trm_commons_1.Logger.loading(`Extracting package transports contents...`);
+            const artifact = yield context.rawInput.packageData.registry.downloadArtifact(context.runtime.package.data.manifest.name, context.runtime.package.data.manifest.version);
+            const binaries = yield artifact.getTransportBinaries();
+            binaries.forEach(o => {
+                switch (o.type) {
+                    case transport_1.TrmTransportIdentifier.DEVC:
+                        context.runtime.transports.devc = {
+                            binaries: o
+                        };
+                        mergeEntries(o.entries);
+                        break;
+                    case transport_1.TrmTransportIdentifier.TADIR:
+                        context.runtime.transports.tadir = {
+                            binaries: o
+                        };
+                        mergeEntries(o.entries);
+                        break;
+                    case transport_1.TrmTransportIdentifier.LANG:
+                        if (importLang) {
+                            context.runtime.transports.lang = {
+                                binaries: o
+                            };
+                            mergeEntries(o.entries);
+                        }
+                        break;
+                    case transport_1.TrmTransportIdentifier.CUST:
+                        if (!skippedCust.includes(o.trkorr)) {
+                            context.runtime.transports.cust.push({
+                                binaries: o
+                            });
+                            mergeEntries(o.entries);
+                        }
+                        break;
+                    default:
+                        break;
                 }
-            }
-            if (!context.rawInput.installData.import.noCust) {
-                context.runtime.packageTransports.cust = aCustTransports.map(o => {
-                    return {
-                        binaries: o
+            });
+        }
+        else {
+            //here we're just reading entries: actual download of transport is done after confirming import of each is allowed
+            trm_commons_1.Logger.loading(`Reading package transports contents...`);
+            for (const transport of context.runtime.package.data.transports) {
+                let readEntries = true;
+                if (!importLang && transport.type === transport_1.TrmTransportIdentifier.LANG) {
+                    readEntries = false;
+                }
+                if (skippedCust.includes(transport.trkorr)) {
+                    readEntries = false;
+                }
+                if (readEntries) {
+                    const entries = yield context.rawInput.packageData.registry.transportEntries(context.runtime.package.data.manifest.name, context.runtime.package.data.manifest.version, transport.trkorr);
+                    const binaries = {
+                        binaries: undefined,
+                        entries,
+                        trkorr: transport.trkorr,
+                        type: transport.type
                     };
-                });
-                trm_commons_1.Logger.log(`CUST transport are ${context.runtime.packageTransports.cust.map(o => o.binaries.trkorr)}.`, true);
-                checkExistance = checkExistance.concat(context.runtime.packageTransports.cust.map(o => o.binaries.trkorr));
-                if (!context.runtime.remotePackageData.contents) {
-                    var custE071 = [];
-                    for (const transport of context.runtime.packageTransports.cust) {
-                        custE071 = custE071.concat((0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(transport.binaries.binaries.data, 'E071')));
+                    switch (transport.type) {
+                        case transport_1.TrmTransportIdentifier.DEVC:
+                            context.runtime.transports.devc = { binaries };
+                            mergeEntries(entries);
+                            break;
+                        case transport_1.TrmTransportIdentifier.TADIR:
+                            context.runtime.transports.tadir = { binaries };
+                            mergeEntries(entries);
+                            break;
+                        case transport_1.TrmTransportIdentifier.LANG:
+                            context.runtime.transports.lang = { binaries };
+                            mergeEntries(entries);
+                            break;
+                        case transport_1.TrmTransportIdentifier.CUST:
+                            context.runtime.transports.cust.push({ binaries });
+                            mergeEntries(entries);
+                            break;
+                        default:
+                            break;
                     }
-                    trm_commons_1.Logger.log(`CUST E071: ${JSON.stringify(custE071)}`, true);
-                    context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(custE071);
                 }
             }
         }
-        if (!context.runtime.remotePackageData.contents) {
-            if (context.runtime.packageTransportsData.e071.find(o => o.pgmid === 'R3TR' && o.object === 'DEVC')) {
-                throw new Error(`Package has undeclared devclass.`);
-            }
+        //4- check devc and tadir existance
+        if (!context.runtime.transports.devc) {
+            throw new Error(`Package transport (type DEVC) was not found.`);
+        }
+        if (!context.runtime.transports.tadir) {
+            throw new Error(`Workbench transport (type TADIR) was not found.`);
+        }
+        if (mergedE071.length === 0) {
+            throw new Error(`Package transports contain no objects.`);
+        }
+        //5- set original hierarchy
+        try {
+            context.runtime.package.hierarchy = (0, commons_1.getPackageHierarchy)(mergedTDEVC);
+        }
+        catch (e) {
+            throw new Error(`Original SAP packages hierarchy inconsistency: ${e.toString()}`);
         }
-        if (!context.runtime.remotePackageData.contents) {
-            var devcE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.devc.binaries.binaries.data, 'E071'));
-            trm_commons_1.Logger.log(`DEVC E071: ${JSON.stringify(devcE071)}`, true);
-            devcE071 = devcE071.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC');
-            if (devcE071.length === 0) {
-                throw new Error(`Package has no devclass.`);
+        //6- check objects aren't locked
+        //all e071 type R3TR, excluding DEVC. DEVC will be checked for locks later when user may decide new package names
+        trm_commons_1.Logger.loading(`Checking objects locks...`);
+        yield checkObjectsLocks(mergedE071);
+        trm_commons_1.Logger.log(`All objects released, DEVC locks will be checked later`, true);
+        //7- check all object types are supported
+        trm_commons_1.Logger.loading(`Checking objects support...`);
+        const missingTypes = [];
+        const systemObjectList = yield systemConnector_1.SystemConnector.getObjectsList();
+        mergedE071.filter(o => o.pgmid !== '*').forEach(o => {
+            if (!systemObjectList.find(k => k.pgmid === o.pgmid && k.object === o.object) && !missingTypes.includes(`${o.pgmid} ${o.object}`)) {
+                missingTypes.push(`${o.pgmid} ${o.object}`);
             }
-            context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(devcE071);
-        }
-        context.runtime.installData.entries = context.runtime.packageTransportsData.e071;
-        trm_commons_1.Logger.loading(`Checking package transports in system...`);
-        for (const trkorr of checkExistance) {
-            const oTransport = new transport_1.Transport(trkorr);
-            const e070 = yield oTransport.getE070();
-            if (e070) {
-                var rewrite = false;
-                trm_commons_1.Logger.warning(`${trkorr} already exists in system!`, true);
-                const trmRelevant = yield oTransport.isTrmRelevant();
-                const linkedPackage = yield oTransport.getLinkedPackage();
-                if (linkedPackage) {
-                    trm_commons_1.Logger.log(`${trkorr} package is ${linkedPackage.packageName}`, true);
-                    if (linkedPackage.compareName(context.runtime.remotePackageData.manifest.name) && linkedPackage.compareRegistry(context.runtime.registry)) {
-                        trm_commons_1.Logger.log(`${trkorr} same package (updating?)`, true);
-                        context.runtime.generatedData.tmsTxtRefresh.push(oTransport);
-                    }
-                    else {
-                        trm_commons_1.Logger.log(`${trkorr} is linked to another package, will later be migrated`, true);
-                        rewrite = true;
-                    }
-                }
-                else if (trmRelevant) {
-                    trm_commons_1.Logger.log(`${trkorr} is TRM relevant but no linked package (could be DEVC, LANG etc..).`, true);
-                    context.runtime.generatedData.tmsTxtRefresh.push(oTransport);
+        });
+        if (missingTypes.length > 0) {
+            throw new Error(`Package contains objects that aren't supported in your system: ${missingTypes.join(', ')}`);
+        }
+        //8- check objects existance
+        const checkedTadir = existenceCheckObjects(mergedTADIR);
+        const existingObjects = checkedTadir.length > 0 ? yield findExistingObjects(context, checkedTadir) : [];
+        // lock-resources checks again, once locked, that no other object appeared
+        context.runtime.existingObjects = existingObjects;
+        trm_commons_1.Logger.log(`TADIR object that already exist in system: ${JSON.stringify(existingObjects)}`, true);
+        //if updating and existing object is part of the package (devclass in hierarchy) ok, else throw error
+        if (existingObjects.length > 0) {
+            // Name the installed TRM package that contains each existing object: it can't be taken over silently.
+            const owners = new Map();
+            for (const o of existingObjects) {
+                const owner = o.devclass ? yield (0, utils_1.getOwningInstallation)(o.devclass, context.rawInput.contextData.systemPackages || [], context.runtime.update) : undefined;
+                if (owner) {
+                    owners.set(o, owner.packageName);
                 }
-                else {
-                    if (yield oTransport.isReleased()) {
-                        rewrite = true;
+            }
+            const label = (o) => `${o.pgmid} ${o.object} ${o.objName}${owners.has(o) ? ` (TRM package ${owners.get(o)})` : ''}`;
+            const ownerNames = [...new Set(owners.values())];
+            const ownersHint = ownerNames.length > 0
+                ? `\n${ownerNames.map(o => `"${o}"`).join(', ')} still ${ownerNames.length === 1 ? 'contains' : 'contain'} these objects: upgrade ${ownerNames.length === 1 ? 'it' : 'them'} to a release that no longer ships them, or uninstall ${ownerNames.length === 1 ? 'it' : 'them'}, then install again.`
+                : '';
+            const sObjs = existingObjects.map(label).join('\n') + ownersHint;
+            if (context.runtime.update) {
+                //the installed package being updated (a same-named package of another registry is a different package)
+                const rootPackage = context.runtime.update;
+                if (rootPackage) {
+                    const rootDevclass = rootPackage.getDevclass();
+                    if (rootDevclass) {
+                        const subpackages = (yield systemConnector_1.SystemConnector.getSubpackages(rootDevclass)).map(o => o.devclass);
+                        const outside = existingObjects.filter(o => {
+                            if (subpackages.includes(o.devclass) || rootDevclass === o.devclass) {
+                                trm_commons_1.Logger.log(`${o.pgmid} ${o.object} ${o.objName} already in system but devclass ${o.devclass} is part of the same trm package in update`, true);
+                                return false;
+                            }
+                            return true;
+                        });
+                        // Objects of the installed release that the customer moved to another (non-TRM) SAP package:
+                        // overwriting them moves them back, so it can be confirmed. Anything else can't be taken over.
+                        const installedKeys = new Set(outside.length > 0 && rootPackage.getTransport()
+                            ? (yield rootPackage.getTransport().getE071()).map(e => `${e.pgmid}|${e.object}|${e.objName}`.toUpperCase())
+                            : []);
+                        const movedOut = outside.filter(o => !owners.has(o) && installedKeys.has(`${o.pgmid}|${o.object}|${o.objName}`.toUpperCase()));
+                        const foreign = outside.filter(o => !movedOut.includes(o));
+                        const noExistingObjects = context.rawInput.installData.checks.noExistingObjects;
+                        foreign.forEach(o => {
+                            if (noExistingObjects) {
+                                trm_commons_1.Logger.warning(`${label(o)} already exist on target system ${systemConnector_1.SystemConnector.getDest()}`, { important: true });
+                            }
+                            else {
+                                trm_commons_1.Logger.error(`${label(o)} already exist on target system ${systemConnector_1.SystemConnector.getDest()}`, { important: true });
+                            }
+                        });
+                        if (foreign.length > 0 && !noExistingObjects) {
+                            throw new Error(`Cannot overwrite existing objects.${ownersHint}`);
+                        }
+                        if (movedOut.length > 0 && !noExistingObjects) {
+                            const movedList = movedOut.map(o => `${o.pgmid} ${o.object} ${o.objName} (now in SAP package ${o.devclass})`).join('\n');
+                            trm_commons_1.Logger.warning(`${movedOut.length} object(s) of the installed release were moved outside its SAP packages:\n${movedList}`, { important: true });
+                            if (context.rawInput.contextData.noInquirer) {
+                                throw new Error(`Cannot overwrite objects moved outside ${rootPackage.packageName}: confirm interactively, or install with the noExistingObjects check.`);
+                            }
+                            const { overwriteMoved } = yield trm_commons_2.Inquirer.prompt({
+                                name: 'overwriteMoved',
+                                type: 'confirm',
+                                message: `Overwrite them and move them back into the SAP packages of ${rootPackage.packageName}?`,
+                                default: false
+                            });
+                            if (!overwriteMoved) {
+                                throw new Error(`Install aborted.`);
+                            }
+                        }
                     }
                     else {
-                        throw new Error(`Transport ${trkorr} already exists in target system ${systemConnector_1.SystemConnector.getDest()} and is not released.`);
-                    }
-                }
-                if (rewrite) {
-                    trm_commons_1.Logger.warning(`Transport ${trkorr} already exists in target system ${systemConnector_1.SystemConnector.getDest()}`);
-                    trm_commons_1.Logger.warning(`If you continue, TRM will replace the content of transport ${trkorr} with the content of the transport with the same number of package "${context.runtime.remotePackageData.manifest.name}".`);
-                    trm_commons_1.Logger.warning(`All of its original content (objects or customizing) will remain untouched, however you may need to manually create a new transport for it.`);
-                    trm_commons_1.Logger.warning(`Consider doing a copy now before the install will replace it.`);
-                    if (!context.rawInput.installData.import.replaceExistingTransports) {
-                        var continueInstall;
-                        if (!context.rawInput.contextData.noInquirer) {
-                            continueInstall = (yield trm_commons_2.Inquirer.prompt({
-                                name: `continue`,
-                                message: `Continue install?`,
-                                type: `confirm`,
-                                default: true
-                            })).continue;
-                        }
-                        else {
-                            continueInstall = false;
+                        if (context.rawInput.installData.checks.noExistingObjects) {
+                            trm_commons_1.Logger.warning(`${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}:\n${sObjs}`, { important: true });
                         }
-                        if (continueInstall) {
-                            context.runtime.generatedData.tmsTxtRefresh.push(oTransport);
+                        else if (context.rawInput.contextData.noInquirer) {
+                            //can't confirm the overwrite without a prompt: fail closed
+                            throw new Error(`Couldn't determine root SAP package for "${rootPackage.packageName}", ${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}:\n${sObjs}`);
                         }
                         else {
-                            throw new Error(`Transport ${trkorr} already exists in target system ${systemConnector_1.SystemConnector.getDest()} and transport rewrite was denied.`);
+                            const ow = (yield trm_commons_2.Inquirer.prompt({
+                                message: `Couldn't determine root SAP package for "${rootPackage.packageName}", ${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}. Continue?`,
+                                type: 'confirm',
+                                name: 'ow',
+                                default: true
+                            })).ow;
+                            if (!ow) {
+                                throw new Error(`${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}:\n${sObjs}`);
+                            }
                         }
                     }
                 }
+                else {
+                    if (!context.rawInput.installData.checks.noExistingObjects) {
+                        throw new Error(`${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}:\n${sObjs}`);
+                    }
+                }
             }
             else {
-                trm_commons_1.Logger.success(`${trkorr} does not exist in system.`, true);
+                if (context.rawInput.installData.checks.noExistingObjects) {
+                    trm_commons_1.Logger.warning(`${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}:\n${sObjs}`, { important: true });
+                }
+                else {
+                    throw new Error(`${existingObjects.length} object(s) already exist on target system ${systemConnector_1.SystemConnector.getDest()}, install without object check (expert mode):\n${sObjs}`);
+                }
             }
         }
     })

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

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that changes nothing: its revert cleans up what the install itself changed.
+ *
+ * It runs right after `install-dependencies`, so a rollback cleans up the generated SAP packages
+ * and namespace, and restores the package transport layers and hierarchy, before the dependencies
+ * are rolled back (a dependency rollback may delete the namespace these packages are in).
+ * Every restore is attempted; the first failure is thrown afterwards.
+ */
+export declare const cleanupCheckpoint: Step<InstallWorkflowContext>;

package/dist/actions/install/cleanupCheckpoint.js

@@ -0,0 +1,62 @@
+"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.cleanupCheckpoint = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const importBatch_1 = require("./importBatch");
+/**
+ * Workflow step that changes nothing: its revert cleans up what the install itself changed.
+ *
+ * It runs right after `install-dependencies`, so a rollback cleans up the generated SAP packages
+ * and namespace, and restores the package transport layers and hierarchy, before the dependencies
+ * are rolled back (a dependency rollback may delete the namespace these packages are in).
+ * Every restore is attempted; the first failure is thrown afterwards.
+ */
+exports.cleanupCheckpoint = {
+    name: 'cleanup-checkpoint',
+    run: () => __awaiter(void 0, void 0, void 0, function* () {
+        // Nothing to do: the step only orders the revert.
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.revert.cleanupImported && (context.revert.importStarted || context.revert.importedEntries.length > 0
+            || context.revert.cleanupTransport || context.revert.namespace || context.revert.sapPackages.length > 0)) {
+            yield (0, importBatch_1.deleteImportedEntries)(context);
+        }
+        if (context.revert.cleanupImported && !context.revert.cleanupSucceeded) {
+            return;
+        }
+        let firstError;
+        for (const layer of context.revert.packageTransportLayers || []) {
+            try {
+                yield systemConnector_1.SystemConnector.setPackageTransportLayer(layer.devclass, layer.transportLayer);
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        for (const pkg of context.revert.packageHierarchy || []) {
+            try {
+                if (pkg.parentcl) {
+                    yield systemConnector_1.SystemConnector.setPackageSuperpackage(pkg.devclass, pkg.parentcl);
+                }
+                else {
+                    yield systemConnector_1.SystemConnector.clearPackageSuperpackage(pkg.devclass);
+                }
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    })
+};

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

@@ -0,0 +1,5 @@
+/**
+ * Reads the system's default transport layer, used for transportable packages when the install
+ * input doesn't specify one.
+ */
+export declare function getDefaultTransportLayer(): Promise<string>;