trm-core 9.10.6 → 10.0.1

package/dist/actions/install/releaseLandscapeTransport.js

@@ -0,0 +1,79 @@
+"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.releaseLandscapeTransport = void 0;
+const trm_commons_1 = require("trm-commons");
+const transport_1 = require("../../transport");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that releases the generated landscape transport, when present.
+ *
+ * 1- add upgrade transport to target transport queue
+ *
+ * 2- release
+ *
+*/
+exports.releaseLandscapeTransport = {
+    name: 'release-install-transports',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.output.transport) {
+            return true;
+        }
+        else {
+            trm_commons_1.Logger.log(`Skipping release of landscape transport (transport was not generated)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, utils_1.withScopedPrefix)(`(${transport_1.Transport.getTransportIcon()}  Landscape) `, () => __awaiter(void 0, void 0, void 0, function* () {
+            //1- add upgrade transport to target transport queue
+            //if previous package was temporary, don't add deletion entries
+            if ((0, utils_1.isDeletionForwardable)(context)) {
+                yield (0, utils_1.forwardDeletionTransport)(context, context.rawInput.installData.landscapeTransport.targetSystem);
+            }
+            //2- release
+            trm_commons_1.Logger.loading(`Releasing...`);
+            // Mark before the release: SAP may export the transport and still fail.
+            context.revert.landscapeReleaseStarted = true;
+            yield context.output.transport.release(true, false, context.rawInput.contextData.logTemporaryFolder);
+        }));
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        let firstError;
+        try {
+            yield (0, utils_1.revertForwardedDeletionTransport)(context, context.rawInput.installData.landscapeTransport.targetSystem);
+        }
+        catch (error) {
+            firstError = error;
+        }
+        const transport = context.output.transport;
+        const targetSystem = context.rawInput.installData.landscapeTransport.targetSystem;
+        try {
+            if (yield transport.canBeDeleted()) {
+                yield transport.delete();
+                context.output.transport = undefined;
+            }
+            else if (context.revert.landscapeReleaseStarted) {
+                // A released transport can't be deleted: take it out of the target import queue instead.
+                yield (0, utils_1.removeFromImportQueue)(transport.trkorr, targetSystem, `Released landscape transport`);
+            }
+        }
+        catch (error) {
+            firstError || (firstError = error);
+            if (context.revert.landscapeReleaseStarted) {
+                trm_commons_1.Logger.warning(`Released landscape transport ${transport.trkorr} may be in the ${targetSystem} import queue: check it in STMS.`, { important: true });
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    })
+};

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

@@ -1,3 +1,13 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that resolves publisher ABAP packages to target-system package names.
+ *
+ * 1- find already defined replacements in system
+ *
+ * 2- get root devclass and find namespace
+ *
+ * 3- if all package names like origin, import devc transport
+ *
+*/
 export declare const setInstallDevclass: Step<InstallWorkflowContext>;

package/dist/actions/install/setInstallDevclass.js

@@ -13,20 +13,39 @@ exports.setInstallDevclass = void 0;
 const commons_1 = require("../../commons");
 const systemConnector_1 = require("../../systemConnector");
 const trm_commons_1 = require("trm-commons");
-const registry_1 = require("../../registry");
+const addNamespace_1 = require("./addNamespace");
+const checkInstallDevclass_1 = require("./checkInstallDevclass");
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+}
 function _validateDevclass(input, namespaces) {
     const sInput = input.trim().toUpperCase();
-    namespaces = [...new Set(namespaces)];
     if (sInput.length > 30) {
         return `Package name must not exceede 30 characters limit.`;
     }
-    if (!namespaces.some(ns => sInput.startsWith(ns))) {
-        return `Package name must use one of the following namespaces: ${namespaces.join(', ')}.`;
+    if (namespaces) {
+        namespaces = [...new Set(namespaces)]; //unique
+        if (!namespaces.some(ns => sInput.startsWith(ns))) {
+            return `Package name must use one of the following namespaces: ${namespaces.join(', ')}.`;
+        }
+        else {
+            return true;
+        }
     }
     else {
         return true;
     }
 }
+/**
+ * Workflow step that resolves publisher ABAP packages to target-system package names.
+ *
+ * 1- find already defined replacements in system
+ *
+ * 2- get root devclass and find namespace
+ *
+ * 3- if all package names like origin, import devc transport
+ *
+*/
 exports.setInstallDevclass = {
     name: 'set-install-devclass',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -39,43 +58,115 @@ exports.setInstallDevclass = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        trm_commons_1.Logger.log('Set install devclass step', true);
+        var _a, _b, _c;
+        //1- find already defined replacements in system
         if (context.rawInput.installData.installDevclass.replacements.length <= 0) {
-            context.rawInput.installData.installDevclass.replacements = yield systemConnector_1.SystemConnector.getInstallPackages(context.rawInput.packageData.name, context.rawInput.packageData.registry);
+            //no input replacements = get from the trm table devclass replacements the corresponding name
+            trm_commons_1.Logger.loading(`Checking package replacements...`);
+            context.rawInput.installData.installDevclass.replacements = yield systemConnector_1.SystemConnector.getInstallPackages(context.rawInput.packageData.name, context.runtime.installRegistry);
+        }
+        else if (context.runtime.update) {
+            //explicit replacements win; stored ones keep the devclasses they don't mention renamed
+            const explicit = new Set(context.rawInput.installData.installDevclass.replacements.map(o => o.originalDevclass));
+            const stored = (context.runtime.previousInstallPackages || []).filter(o => !explicit.has(o.originalDevclass));
+            stored.forEach(o => trm_commons_1.Logger.log(`Keeping stored package replacement ${o.originalDevclass} -> ${o.installDevclass}`, true));
+            context.rawInput.installData.installDevclass.replacements = [
+                ...context.rawInput.installData.installDevclass.replacements,
+                ...stored.map(o => ({ originalDevclass: o.originalDevclass, installDevclass: o.installDevclass }))
+            ];
         }
-        var rootDevclass = (_a = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === context.runtime.originalData.hierarchy.devclass)) === null || _a === void 0 ? void 0 : _a.installDevclass;
-        if (!rootDevclass) {
-            rootDevclass = context.runtime.originalData.hierarchy.devclass;
+        //the release root can have a new original name (e.g. moved to a namespace): a renamed installation keeps its root
+        //package, matched by position, so the installation stays where the customer put it
+        const releaseRoot = context.runtime.package.hierarchy.devclass;
+        const installedRoot = (_a = context.runtime.update) === null || _a === void 0 ? void 0 : _a.getDevclass();
+        if (installedRoot && !context.rawInput.installData.installDevclass.replacements.some(o => o.originalDevclass === releaseRoot)) {
+            const storedRoot = context.rawInput.installData.installDevclass.replacements.find(o => o.installDevclass.trim().toUpperCase() === installedRoot.trim().toUpperCase());
+            if (storedRoot && storedRoot.installDevclass !== storedRoot.originalDevclass) {
+                trm_commons_1.Logger.log(`Release root ${releaseRoot} replaces ${storedRoot.originalDevclass}: keeping installed root ${installedRoot}`, true);
+                context.rawInput.installData.installDevclass.replacements.push({ originalDevclass: releaseRoot, installDevclass: installedRoot });
+            }
+        }
+        //drop replacements of devclasses that are not part of the release (e.g. removed in this version)
+        const originalDevclasses = (0, addNamespace_1.flattenDevclasses)(context.runtime.package.hierarchy);
+        context.rawInput.installData.installDevclass.replacements = context.rawInput.installData.installDevclass.replacements.filter(replacement => {
+            if (originalDevclasses.includes(replacement.originalDevclass)) {
+                return true;
+            }
+            trm_commons_1.Logger.log(`Ignoring package replacement ${replacement.originalDevclass} -> ${replacement.installDevclass}: devclass is not part of the release`, true);
+            return false;
+        });
+        //if there are replacements and they all equal to original ask if you should continue
+        const replacementsKeepOriginal = context.rawInput.installData.installDevclass.replacements.length > 0
+            && context.rawInput.installData.installDevclass.replacements.every(replacement => replacement.installDevclass === replacement.originalDevclass);
+        if (replacementsKeepOriginal) {
+            let continueWithReplacements = false;
+            if (!context.rawInput.contextData.noInquirer) {
+                continueWithReplacements = (yield trm_commons_1.Inquirer.prompt({
+                    type: 'confirm',
+                    name: 'continueWithReplacements',
+                    message: `Do you want to change original SAP packages name?`,
+                    default: false
+                })).continueWithReplacements;
+            }
+            if (!continueWithReplacements) {
+                // Later workflow steps use this flag to import the original DEVC transport.
+                context.rawInput.installData.installDevclass.keepOriginal = true;
+                // Packages new in this release keep their name too, and are mapped like the others.
+                originalDevclasses
+                    .filter(originalDevclass => !context.rawInput.installData.installDevclass.replacements.some(o => o.originalDevclass === originalDevclass))
+                    .forEach(originalDevclass => context.rawInput.installData.installDevclass.replacements.push({
+                    originalDevclass,
+                    installDevclass: originalDevclass
+                }));
+                return;
+            }
         }
-        const originalNamespace = (0, commons_1.getPackageNamespace)(rootDevclass);
-        var updateNamespace;
-        if (context.runtime.installData.upgradingPackage) {
-            updateNamespace = (0, commons_1.getPackageNamespace)(context.runtime.installData.upgradingPackage.getDevclass());
+        //2- find the namespace of the original root, carried over onto new devclasses
+        const originalNamespace = (0, commons_1.getPackageNamespace)(context.runtime.package.hierarchy.devclass);
+        // Only carry the currently installed namespace forward onto newly introduced original
+        // devclasses when the package was genuinely customized before (some stored replacement
+        // actually renamed a package). Otherwise "currently installed" is just this package's
+        // own untouched default from whichever version happens to be installed right now, and
+        // has nothing to do with the namespace of the version being installed/rolled back to.
+        const hasCustomization = context.rawInput.installData.installDevclass.replacements.some(replacement => replacement.installDevclass !== replacement.originalDevclass);
+        let updateNamespace;
+        if (context.runtime.update && hasCustomization) {
+            //the installed root devclass can be unknown: fall back to the stored root replacement
+            const installedRootDevclass = context.runtime.update.getDevclass()
+                || ((_c = (_b = context.runtime.previousInstallPackages) === null || _b === void 0 ? void 0 : _b.find(o => o.originalDevclass === context.runtime.package.hierarchy.devclass)) === null || _c === void 0 ? void 0 : _c.installDevclass);
+            if (installedRootDevclass) {
+                updateNamespace = (0, commons_1.getPackageNamespace)(installedRootDevclass);
+            }
+            else {
+                trm_commons_1.Logger.log(`Installed root devclass is unknown, namespace won't be carried over`, true);
+            }
         }
-        var inq1Prompts = [];
-        trm_commons_1.Logger.loading(`Analyzing packages...`);
-        for (const t of context.runtime.packageTransportsData.tdevc) {
-            var adaptDevclassName = t.devclass;
-            const replacement = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === t.devclass);
+        const inq1Prompts = [];
+        trm_commons_1.Logger.loading(`Analyzing package replacements...`);
+        for (const originalDevclass of originalDevclasses) {
+            let adaptDevclassName = originalDevclass;
+            const replacement = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalDevclass);
             if (updateNamespace) {
+                //only for trm-server and trm-rest with /ATRM/: if no replacement and updating from namespace $, adapt naming convention
                 if (!replacement && updateNamespace === '$' && (context.runtime.isTrmServer || context.runtime.isTrmRest)) {
                     adaptDevclassName = (0, commons_1.adjustTrmServerRestDevclass)(adaptDevclassName);
                 }
                 else {
-                    adaptDevclassName = adaptDevclassName.replace(new RegExp(`^${originalNamespace}`, 'gmi'), updateNamespace);
+                    //original names use the original root namespace; a function keeps `$` literal
+                    adaptDevclassName = adaptDevclassName.replace(new RegExp(`^${escapeRegExp(originalNamespace)}`, 'i'), () => updateNamespace);
                 }
             }
             else if (context.runtime.isTrmRest) {
+                //extra guard for trm-rest first install: move /ATRM/ to $
                 adaptDevclassName = (0, commons_1.adjustTrmServerRestDevclass)(adaptDevclassName);
             }
-            const packageExists = yield systemConnector_1.SystemConnector.getDevclass(adaptDevclassName);
             if (!replacement) {
                 if (context.rawInput.contextData.noInquirer || (context.runtime.isTrmServer || context.runtime.isTrmRest)) {
-                    const automaticValue = _validateDevclass(adaptDevclassName, [updateNamespace || originalNamespace, '$', originalNamespace]);
+                    //const automaticValue = _validateDevclass(adaptDevclassName, [updateNamespace || originalNamespace, '$', originalNamespace]);
+                    const automaticValue = _validateDevclass(adaptDevclassName);
                     if (automaticValue === true) {
                         context.rawInput.installData.installDevclass.replacements.push({
-                            originalDevclass: t.devclass,
+                            originalDevclass,
                             installDevclass: adaptDevclassName
                         });
                     }
@@ -86,57 +177,52 @@ exports.setInstallDevclass = {
                 else {
                     inq1Prompts.push({
                         type: "input",
-                        name: t.devclass,
+                        name: originalDevclass,
                         default: adaptDevclassName,
-                        message: packageExists ? `Rename ABAP Package "${adaptDevclassName}"?` : `ABAP Package "${adaptDevclassName}" will be generated. Do you want to rename it?`,
-                        validate: (input) => {
-                            return _validateDevclass(input, [updateNamespace || originalNamespace, '$', originalNamespace]);
-                        }
+                        message: `ABAP Package "${adaptDevclassName}" will be imported. Do you want to rename it?`,
+                        validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                            //return _validateDevclass(input, [updateNamespace || originalNamespace, '$', originalNamespace]);
+                            const valid = _validateDevclass(input);
+                            return valid === true ? yield (0, checkInstallDevclass_1.validateInstallDevclass)(context, input.trim().toUpperCase()) : valid;
+                        })
                     });
                 }
             }
-            else {
-                const devclassValid = _validateDevclass(replacement.installDevclass, [updateNamespace || originalNamespace, '$', originalNamespace]);
-                if (devclassValid !== true) {
-                    throw new Error(devclassValid);
-                }
+            else if (!context.rawInput.contextData.noInquirer) {
+                inq1Prompts.push({
+                    type: "input",
+                    name: originalDevclass,
+                    default: replacement.installDevclass,
+                    message: `Rename ABAP Package "${replacement.installDevclass}"`,
+                    validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                        //return _validateDevclass(input, [updateNamespace || originalNamespace, '$', originalNamespace]);
+                        const valid = _validateDevclass(input);
+                        return valid === true ? yield (0, checkInstallDevclass_1.validateInstallDevclass)(context, input.trim().toUpperCase()) : valid;
+                    })
+                });
             }
         }
         if (inq1Prompts.length > 0) {
             const inq1 = yield trm_commons_1.Inquirer.prompt(inq1Prompts);
             Object.keys(inq1).forEach(k => {
+                //clear before pushing
                 context.rawInput.installData.installDevclass.replacements = context.rawInput.installData.installDevclass.replacements.filter(o => o.originalDevclass !== k);
+                //push
                 context.rawInput.installData.installDevclass.replacements.push({
                     originalDevclass: k,
                     installDevclass: inq1[k].trim().toUpperCase()
                 });
             });
         }
+        //if one install package starts with $, all must start with $
+        //this check is not done by the validator, so it has to be done here
         const hasTemp = context.rawInput.installData.installDevclass.replacements.some(x => x.installDevclass.startsWith('$'));
         if (hasTemp && !context.rawInput.installData.installDevclass.replacements.every(x => x.installDevclass.startsWith('$'))) {
             throw new Error(`All packages must start with prefix $ if one (or more) packages are temporary!`);
         }
-        trm_commons_1.Logger.loading(`Updating install data...`);
-        var installDevc = [];
-        var packageRegistry;
-        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
-            packageRegistry = registry_1.PUBLIC_RESERVED_KEYWORD;
-        }
-        else if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
-            packageRegistry = registry_1.LOCAL_RESERVED_KEYWORD;
-        }
-        else {
-            packageRegistry = context.rawInput.packageData.registry.endpoint;
-        }
-        context.rawInput.installData.installDevclass.replacements.forEach(o => {
-            installDevc.push({
-                package_name: context.rawInput.packageData.name,
-                package_registry: packageRegistry,
-                original_devclass: o.originalDevclass,
-                install_devclass: o.installDevclass
-            });
-        });
-        yield systemConnector_1.SystemConnector.setInstallDevc(installDevc);
+        //fail before locks and dependency installs (add-namespace checks again for original package names)
+        (0, addNamespace_1.getInstallNamespace)(context);
+        //3- if all package names like origin, import devc transport
         context.rawInput.installData.installDevclass.keepOriginal = true;
         context.rawInput.installData.installDevclass.replacements.forEach(o => {
             if (o.installDevclass !== o.originalDevclass) {

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

@@ -1,3 +1,12 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that records the installed release in the target system's TRM package table.
+ *
+ * Creates/update record in TRM packages table, with its install packages and the
+ * customizing and translation transports imported on this system
+ *
+ * 1- commit new values
+ *
+*/
 export declare const updatePackageData: Step<InstallWorkflowContext>;

package/dist/actions/install/updatePackageData.js

@@ -12,26 +12,130 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.updatePackageData = void 0;
 const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
-const registry_1 = require("../../registry");
+const utils_1 = require("../commons/utils");
 const manifest_1 = require("../../manifest");
 const transport_1 = require("../../transport");
+const generateUpdateTransport_1 = require("./generateUpdateTransport");
+function installTransportRows(packageName, packageRegistry, transports) {
+    return transports.map(transport => ({
+        package_name: packageName,
+        package_registry: packageRegistry,
+        trkorr: transport.trkorr,
+        trm_type: transport.trmType
+    }));
+}
+function installDevcRows(packageName, packageRegistry, replacements) {
+    return replacements.map(replacement => ({
+        package_name: packageName,
+        package_registry: packageRegistry,
+        original_devclass: replacement.originalDevclass,
+        install_devclass: replacement.installDevclass
+    }));
+}
+/**
+ * Workflow step that records the installed release in the target system's TRM package table.
+ *
+ * Creates/update record in TRM packages table, with its install packages and the
+ * customizing and translation transports imported on this system
+ *
+ * 1- commit new values
+ *
+*/
 exports.updatePackageData = {
     name: 'update-package-data',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Update package data step', true);
+        var _a, _b;
         trm_commons_1.Logger.loading(`Finalizing install...`);
-        const originalTransport = context.runtime.packageTransports.tadir.binaries.trkorr;
-        const installTransport = context.runtime.installData.transports.find(o => o.type === transport_1.TrmTransportIdentifier.TADIR);
-        const devclass = context.rawInput.installData.installDevclass.keepOriginal ?
-            context.runtime.originalData.hierarchy.devclass :
-            context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass = context.runtime.originalData.hierarchy.devclass).installDevclass;
-        yield systemConnector_1.SystemConnector.updateTrmPackageData({
-            package_name: context.rawInput.packageData.name,
-            package_registry: context.runtime.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : context.runtime.registry.endpoint,
-            manifest: Buffer.from(new manifest_1.Manifest(context.runtime.remotePackageData.manifest).getAbapXml(), 'utf8'),
-            trkorr: installTransport && installTransport.transport ? installTransport.transport.trkorr : originalTransport,
-            integrity: context.runtime.remotePackageData.data.checksum,
+        //1- commit new values
+        trm_commons_1.Logger.loading(`Updating TRM data...`);
+        const originalTransport = context.runtime.transports.tadir.instance.trkorr;
+        const installTransport = (_a = context.output.transport) === null || _a === void 0 ? void 0 : _a.trkorr;
+        const originalDevclass = context.runtime.package.hierarchy.devclass;
+        let devclass = originalDevclass;
+        if (!context.rawInput.installData.installDevclass.keepOriginal) {
+            const rootReplacement = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalDevclass);
+            if (!(rootReplacement === null || rootReplacement === void 0 ? void 0 : rootReplacement.installDevclass)) {
+                throw new Error(`Missing install devclass replacement for root package "${originalDevclass}".`);
+            }
+            devclass = rootReplacement.installDevclass;
+        }
+        const packageRegistry = (0, utils_1.installRegistryKey)(context.runtime.installRegistry);
+        const installDevc = installDevcRows(context.rawInput.packageData.name, packageRegistry, context.rawInput.installData.installDevclass.replacements);
+        // Only transports imported on this system: uninstall and update delete their customizing.
+        // An upgrade that kept the installed customizing still owns the rows of the previous transports.
+        const importedCust = (context.runtime.transports.cust || [])
+            .filter(cust => cust.instance)
+            .map(cust => ({ trkorr: cust.instance.trkorr, trmType: transport_1.TrmTransportIdentifier.CUST }));
+        const keptCust = context.runtime.update && (0, generateUpdateTransport_1.keepsInstalledCustomizing)(context)
+            ? (context.runtime.previousInstallTransports || [])
+                .filter(o => (o.trmType || '').trim().toUpperCase() === transport_1.TrmTransportIdentifier.CUST && !importedCust.some(k => k.trkorr === o.trkorr))
+                .map(o => ({ trkorr: o.trkorr, trmType: transport_1.TrmTransportIdentifier.CUST }))
+            : [];
+        const installTr = installTransportRows(context.rawInput.packageData.name, packageRegistry, [
+            ...keptCust,
+            ...importedCust,
+            ...(((_b = context.runtime.transports.lang) === null || _b === void 0 ? void 0 : _b.instance)
+                ? [{ trkorr: context.runtime.transports.lang.instance.trkorr, trmType: transport_1.TrmTransportIdentifier.LANG }]
+                : [])
+        ]);
+        context.revert.metadataPackageRegistry = packageRegistry;
+        if (context.runtime.update) {
+            // The installed packages may have been read without their rows: read the stored row
+            // before writing, so the revert restores it exactly, or removes the row it wrote.
+            // A failed read aborts before any write.
+            context.revert.metadataPreviousPackageRow = yield systemConnector_1.SystemConnector.getTrmPackageData(context.runtime.package.data.manifest.name, packageRegistry);
+            context.revert.metadataPreviousPackageRead = true;
+        }
+        context.revert.metadataPackageRow = {
+            package_name: context.runtime.package.data.manifest.name,
+            package_registry: packageRegistry,
+            manifest: Buffer.from(new manifest_1.Manifest(context.runtime.package.data.manifest).getAbapXml(), 'utf8'),
+            trkorr: installTransport || originalTransport,
+            integrity: context.runtime.package.data.checksum,
             devclass
+        };
+        // Mappings stored for devclasses that are no longer installed: the write only upserts.
+        const staleInstallDevc = installDevcRows(context.rawInput.packageData.name, packageRegistry, context.runtime.previousInstallPackages.filter(previous => !installDevc.some(o => o.original_devclass === previous.originalDevclass)));
+        context.revert.metadataInstallDevc = installDevc;
+        // Mark before the mutating await: SAP may commit the mapping and still
+        // fail while returning the response.
+        context.revert.metadataWriteStarted = true;
+        yield systemConnector_1.SystemConnector.setInstallDevc(installDevc);
+        if (staleInstallDevc.length > 0) {
+            yield systemConnector_1.SystemConnector.deleteInstallDevc(staleInstallDevc);
+        }
+        context.revert.metadataTransportsWriteStarted = true;
+        yield systemConnector_1.SystemConnector.setInstallTransports(context.rawInput.packageData.name, packageRegistry, installTr);
+        yield systemConnector_1.SystemConnector.updateTrmPackageData(context.revert.metadataPackageRow);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        // First installs remove the newly written row through the same atomic SAP operation.
+        if (!context.revert.metadataWriteStarted) {
+            return;
+        }
+        if (!context.runtime.update) {
+            if (context.revert.metadataPackageRow) {
+                yield systemConnector_1.SystemConnector.restoreInstallMetadata({
+                    package: context.revert.metadataPackageRow,
+                    packageExists: false,
+                    installDevc: [],
+                    installTr: []
+                });
+            }
+            return;
+        }
+        if (!context.revert.metadataPreviousPackageRead) {
+            return;
+        }
+        // One atomic SAP operation restores the row read before writing (or deletes the row this
+        // install wrote when none was stored) and replaces the mappings and install transports.
+        const previousRow = context.revert.metadataPreviousPackageRow;
+        const packageRow = previousRow || context.revert.metadataPackageRow;
+        yield systemConnector_1.SystemConnector.restoreInstallMetadata({
+            package: packageRow,
+            packageExists: !!previousRow,
+            installDevc: installDevcRows(context.rawInput.packageData.name, packageRow.package_registry, context.runtime.previousInstallPackages),
+            installTr: installTransportRows(context.rawInput.packageData.name, packageRow.package_registry, context.runtime.previousInstallTransports || [])
         });
     })
 };

package/dist/actions/installDependency/checkInstalledRelease.d.ts

@@ -0,0 +1,13 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+/**
+ * Workflow step that compares the dependency installed on the system with the requested range.
+ * A compatible installed release is kept and the dependency install becomes a no-op, unless a
+ * lockfile pins the dependency to a different version. A lock outside the range aborts.
+ *
+ * 1- find installed release
+ *
+ * 2- keep compatible installed release
+ *
+*/
+export declare const checkInstalledRelease: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/checkInstalledRelease.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.checkInstalledRelease = void 0;
+const trm_commons_1 = require("trm-commons");
+const semver_1 = require("semver");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that compares the dependency installed on the system with the requested range.
+ * A compatible installed release is kept and the dependency install becomes a no-op, unless a
+ * lockfile pins the dependency to a different version. A lock outside the range aborts.
+ *
+ * 1- find installed release
+ *
+ * 2- keep compatible installed release
+ *
+*/
+exports.checkInstalledRelease = {
+    name: 'check-installed-release',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        //1- find installed release
+        const dependencyName = context.rawInput.dependencyDataPackage.name;
+        const versionRange = context.rawInput.dependencyDataPackage.versionRange;
+        const installed = (0, utils_1.getInstalledDependency)(context.rawInput.contextData.systemPackages, context.runtime.trmPackage, versionRange);
+        if (installed.status === 'manifestUnreadable') {
+            throw new Error(`Cannot verify installed dependency "${dependencyName}": package is installed but its manifest is unreadable.`);
+        }
+        context.runtime.installedVersion = installed.installedVersion;
+        //2- keep compatible installed release
+        if (installed.status !== 'ok') {
+            return;
+        }
+        const lockfile = context.rawInput.installData.checks.lockfile;
+        const lock = lockfile === null || lockfile === void 0 ? void 0 : lockfile.getLock(context.runtime.trmPackage, versionRange);
+        if (lock && !(0, semver_1.eq)(lock.version, installed.installedVersion)) {
+            trm_commons_1.Logger.info(`Dependency "${dependencyName}" v${installed.installedVersion} installed, lockfile requires v${lock.version}.`);
+            return;
+        }
+        context.runtime.alreadyInstalled = true;
+        trm_commons_1.Logger.info(`Dependency "${dependencyName}" v${installed.installedVersion} already installed (${versionRange}).`);
+    })
+};

package/dist/actions/installDependency/confirmDowngrade.d.ts

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallDependencyWorkflowContext } from ".";
+/**
+ * Workflow step that requires explicit confirmation before a dependency install replaces a newer
+ * installed release. `installData.checks.allowDowngrade` confirms it in advance; otherwise the
+ * user is prompted, and without a prompt the install is aborted.
+ *
+ * 1- confirm downgrade
+ *
+*/
+export declare const confirmDowngrade: Step<InstallDependencyWorkflowContext>;