trm-core 10.0.1 → 10.2.0

package/dist/actions/install/checkTransports.js

@@ -19,6 +19,7 @@ const trm_commons_2 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
 const commons_1 = require("../../commons");
 const utils_1 = require("../commons/utils");
+const crypto_1 = require("crypto");
 /** Throws when any of the objects is locked in a SAP transport request. */
 function checkObjectsLocks(e071) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -205,6 +206,11 @@ exports.checkTransports = {
                 if (skippedCust.includes(transport.trkorr)) {
                     readEntries = false;
                 }
+                // the fixed TADIR transport of trm-server/trm-rest only comes with the artifact (below)
+                if ((context.runtime.isTrmServer || context.runtime.isTrmRest) && transport.type === transport_1.TrmTransportIdentifier.TADIR
+                    && utils_1.TRM_FIXED_TADIR_TRANSPORTS[context.runtime.package.data.manifest.name] === 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 = {
@@ -235,6 +241,29 @@ exports.checkTransports = {
                     }
                 }
             }
+            // The registry metadata can omit a transport of the release, and the fixed TADIR transport of
+            // trm-server and trm-rest is never downloaded alone: read them from the artifact, once its integrity is verified.
+            if (!context.runtime.transports.devc || !context.runtime.transports.tadir) {
+                trm_commons_1.Logger.log(`No ${!context.runtime.transports.devc ? 'DEVC' : 'TADIR'} transport to download from the registry: reading the release artifact`, true);
+                trm_commons_1.Logger.loading(`Reading package transports from the release artifact...`);
+                const artifact = yield context.rawInput.packageData.registry.downloadArtifact(context.runtime.package.data.manifest.name, context.runtime.package.data.manifest.version);
+                const expectedChecksum = context.runtime.package.data.checksum;
+                const checksum = (0, crypto_1.createHash)('sha512').update(artifact.binary).digest('base64');
+                if (!expectedChecksum || checksum !== expectedChecksum) {
+                    trm_commons_1.Logger.error(`SECURITY ISSUE! Release artifact integrity does NOT match the registry SHA ${expectedChecksum}: received ${checksum}`, { important: true });
+                    throw new Error(`Cannot continue due to security issues.`);
+                }
+                for (const binary of yield artifact.getTransportBinaries()) {
+                    if (binary.type === transport_1.TrmTransportIdentifier.DEVC && !context.runtime.transports.devc) {
+                        context.runtime.transports.devc = { binaries: binary };
+                        mergeEntries(binary.entries);
+                    }
+                    else if (binary.type === transport_1.TrmTransportIdentifier.TADIR && !context.runtime.transports.tadir) {
+                        context.runtime.transports.tadir = { binaries: binary };
+                        mergeEntries(binary.entries);
+                    }
+                }
+            }
         }
         //4- check devc and tadir existance
         if (!context.runtime.transports.devc) {
@@ -272,6 +301,7 @@ exports.checkTransports = {
         }
         //8- check objects existance
         const checkedTadir = existenceCheckObjects(mergedTADIR);
+        trm_commons_1.Logger.loading(`Checking whether ${checkedTadir.length} package object${checkedTadir.length === 1 ? '' : 's'} already exist${checkedTadir.length === 1 ? 's' : ''}...`);
         const existingObjects = checkedTadir.length > 0 ? yield findExistingObjects(context, checkedTadir) : [];
         // lock-resources checks again, once locked, that no other object appeared
         context.runtime.existingObjects = existingObjects;
@@ -279,9 +309,18 @@ exports.checkTransports = {
         //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.
+            trm_commons_1.Logger.loading(`Checking ownership of ${existingObjects.length} existing object${existingObjects.length === 1 ? '' : 's'}...`);
             const owners = new Map();
+            // objects share few SAP packages: look each one up once
+            const packageOwners = 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 (!o.devclass) {
+                    continue;
+                }
+                if (!packageOwners.has(o.devclass)) {
+                    packageOwners.set(o.devclass, (0, utils_1.getOwningInstallation)(o.devclass, context.rawInput.contextData.systemPackages || [], context.runtime.update));
+                }
+                const owner = yield packageOwners.get(o.devclass);
                 if (owner) {
                     owners.set(o, owner.packageName);
                 }

package/dist/actions/install/generateLandscapeTransport.js

@@ -125,7 +125,10 @@ exports.generateLandscapeTransport = {
         //8- lock objects
         //what is lockable gets locked here
         //all workbench should be lockable here
-        yield context.output.transport.lock();
+        //a legacy backend has no API for it
+        if (!context.legacyBackend) {
+            yield context.output.transport.lock();
+        }
     }),
     revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
         if (context.output.transport && (yield context.output.transport.canBeDeleted())) {

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

@@ -18,3 +18,10 @@ export declare function keepsInstalledCustomizing(context: InstallWorkflowContex
  * release without an incoming one.
 */
 export declare const generateUpdateTransport: Step<InstallWorkflowContext>;
+/**
+ * Workflow step that cleans up an upgrade of trm-server or trm-rest, last in the install (see
+ * {@link generateUpdateTransport}); every other package is cleaned up before its import. The installed
+ * release runs the install: deleting its objects first would remove the APIs the install still calls.
+ * Once the upgrade is complete, only the objects the new release doesn't ship are deleted, with its APIs.
+ */
+export declare const generatePostImportUpdateTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/generateUpdateTransport.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUpdateTransport = exports.deleteTemporaryCleanupPackages = void 0;
+exports.generatePostImportUpdateTransport = exports.generateUpdateTransport = exports.deleteTemporaryCleanupPackages = void 0;
 exports.keepsInstalledCustomizing = keepsInstalledCustomizing;
 const trm_commons_1 = require("trm-commons");
 const stopWarning_1 = require("../stopWarning");
@@ -60,6 +60,11 @@ function keepsInstalledCustomizing(context) {
 exports.generateUpdateTransport = {
     name: 'generate-update-transport',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.selfUpdate) {
+            // The installed release runs this install: its objects are cleaned up after the import
+            trm_commons_1.Logger.log(`Upgrade cleanup of ${context.rawInput.packageData.name} runs after the import`, true);
+            return false;
+        }
         //a local (.trm) upgrade generates its deletion transport through the registry the artifact was published to
         if (context.runtime.update) {
             return true;
@@ -70,19 +75,78 @@ exports.generateUpdateTransport = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
+        yield cleanupPreviousRelease(context, false);
+    }),
+    revert: revertUpdateCleanup
+};
+/**
+ * Workflow step that cleans up an upgrade of trm-server or trm-rest, last in the install (see
+ * {@link generateUpdateTransport}); every other package is cleaned up before its import. The installed
+ * release runs the install: deleting its objects first would remove the APIs the install still calls.
+ * Once the upgrade is complete, only the objects the new release doesn't ship are deleted, with its APIs.
+ */
+exports.generatePostImportUpdateTransport = {
+    name: 'generate-post-import-update-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () { return !!context.runtime.selfUpdate; }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        // The new release is installed: a failed cleanup leaves objects of the previous one, it doesn't undo the install
+        try {
+            yield cleanupPreviousRelease(context, true);
+        }
+        catch (error) {
+            let revertError;
+            if (!context.revert.deleImportStarted) {
+                try {
+                    yield revertUpdateCleanup(context);
+                }
+                catch (e) {
+                    revertError = e;
+                }
+            }
+            const version = context.runtime.update.manifest.get().version;
+            trm_commons_1.Logger.warning(`Cleanup of ${context.rawInput.packageData.name} ${version} failed: ${error instanceof Error ? error.message : String(error)}`, { important: true });
+            if (revertError) {
+                trm_commons_1.Logger.warning(`Cleanup could not be undone either: ${revertError instanceof Error ? revertError.message : String(revertError)}`, { important: true });
+            }
+            trm_commons_1.Logger.warning(`${context.rawInput.packageData.name} ${context.runtime.package.data.manifest.version} is installed. Objects of ${version} it doesn't ship may be left on ${systemConnector_1.SystemConnector.getDest()}: delete them manually.`, { important: true });
+            return;
+        }
+        // The landscape transport is already released: the deletion follows it to the target
+        const targetSystem = (_b = (_a = context.rawInput.installData) === null || _a === void 0 ? void 0 : _a.landscapeTransport) === null || _b === void 0 ? void 0 : _b.targetSystem;
+        if (targetSystem && ((_c = context.output) === null || _c === void 0 ? void 0 : _c.transport) && (0, utils_1.isDeletionForwardable)(context)) {
+            try {
+                yield (0, utils_1.forwardDeletionTransport)(context, targetSystem);
+            }
+            catch (error) {
+                trm_commons_1.Logger.warning(`Deletion transport ${context.revert.dele.trkorr} could not be added to the ${targetSystem} import queue: ${error instanceof Error ? error.message : String(error)}. Add it in STMS after ${context.output.transport.trkorr}.`, { important: true });
+            }
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        // The imported release stays (see import-batch): objects it doesn't ship stay deleted too.
+        // A cleanup that stopped before its deletion transport is undone.
+        if (context.revert.deleImportStarted) {
+            trm_commons_1.Logger.log(`Keeping the cleanup of ${context.rawInput.packageData.name}: its imported release is not rolled back`, true);
+            return;
+        }
+        yield revertUpdateCleanup(context);
+    })
+};
+function cleanupPreviousRelease(context, incomingImported) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         if (!context.runtime.stopWarningShown) {
             context.runtime.stopWarningShown = true;
             (0, stopWarning_1.stopWarning)('install');
         }
         // The cleanup deletes and re-imports the root package: read it now, so the import can put it back
         // under the superpackage it has on this system (prepare-devc reads it after the cleanup).
-        if (((_b = (_a = context.rawInput.installData) === null || _a === void 0 ? void 0 : _a.installDevclass) === null || _b === void 0 ? void 0 : _b.keepOriginal) && !context.runtime.rootDevclassBeforeImport) {
+        if (!incomingImported && ((_b = (_a = context.rawInput.installData) === null || _a === void 0 ? void 0 : _a.installDevclass) === null || _b === void 0 ? void 0 : _b.keepOriginal) && !context.runtime.rootDevclassBeforeImport) {
             context.runtime.rootDevclassBeforeImport = yield systemConnector_1.SystemConnector.getDevclass(context.runtime.package.hierarchy.devclass);
         }
         // Read the target lazily: a failure reading the previous release must still be tracked first.
         const installDevclass = (_c = context.rawInput.installData) === null || _c === void 0 ? void 0 : _c.installDevclass;
-        const importData = (_d = context.rawInput.installData) === null || _d === void 0 ? void 0 : _d.import;
         const keepCustomizing = keepsInstalledCustomizing(context);
         if (keepCustomizing) {
             const skipped = context.runtime.skippedCust || [];
@@ -97,6 +161,7 @@ exports.generateUpdateTransport = {
                     ? flattenDevclasses(context.runtime.package.hierarchy)
                     : installDevclass.replacements.map(replacement => replacement.installDevclass);
             },
+            incomingImported,
             prefix: `(${transport_1.Transport.getTransportIcon()}  Upgrade cleanup) `,
             actionName: 'Update',
             requireDeletion: false,
@@ -107,8 +172,10 @@ exports.generateUpdateTransport = {
                 return incomingCustomizingRows(context);
             }
         });
-    }),
-    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+    });
+}
+function revertUpdateCleanup(context) {
+    return __awaiter(this, void 0, void 0, function* () {
         // Rollback of the imported objects ran first: when it failed, they are still on the system
         // and the previous release must not be restored over them.
         const restore = !(context.revert.cleanupImported && !context.revert.cleanupSucceeded);
@@ -118,5 +185,5 @@ exports.generateUpdateTransport = {
         if (restore) {
             yield (0, utils_1.deleteCleanupStagingPackages)(context);
         }
-    })
-};
+    });
+}

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

@@ -222,6 +222,11 @@ type WorkflowRuntime = {
     lockedNamespaces?: string[];
     /** Required SAP entries missing on the system: the install is aborted by check-engines, with the unmet engines. */
     missingSapEntries?: number;
+    /**
+     * Upgrade of trm-server or trm-rest: the installed release runs the install itself. Its objects are
+     * only cleaned up after the incoming release is imported, and the import can't be rolled back.
+     */
+    selfUpdate?: boolean;
 };
 /** Dependency queued for install: missing from the system, or installed in an incompatible version. */
 export type InstallDependencyEntry = {
@@ -300,6 +305,11 @@ export type InstallActionOutput = {
 /** Internal state shared by package-install workflow steps and rollback handlers. */
 export interface InstallWorkflowContext extends IActionContext {
     lockScope?: ActionLockScope;
+    /**
+     * trm-server/trm-rest upgrade on a backend older than the APIs this trm-core needs (see isLegacyTrmBackend):
+     * only the APIs of the installed generation are used.
+     */
+    legacyBackend?: boolean;
     /** Custom namespaces already locked by the parent installs of a dependency install. */
     inheritedNamespaceLocks?: string[];
     /** Original action input; optional groups are normalized during initialization. */

package/dist/actions/install/index.js

@@ -87,15 +87,18 @@ const installWorkflow = [
     generateLandscapeTransport_1.generateLandscapeTransport,
     executePostActivities_1.executePostActivities,
     releaseLandscapeTransport_1.releaseLandscapeTransport,
-    updatePackageData_1.updatePackageData
+    updatePackageData_1.updatePackageData,
+    generateUpdateTransport_1.generatePostImportUpdateTransport
 ];
 function runInstall(inputData_1, retainRollback_1) {
     return __awaiter(this, arguments, void 0, function* (inputData, retainRollback, inheritedNamespaceLocks = []) {
         var _a;
-        const lockScope = new utils_2.ActionLockScope(WORKFLOW_NAME);
-        const context = { rawInput: inputData, lockScope, inheritedNamespaceLocks };
         //a local artifact is locked under the package it installs, as a remote install of it would be
         const lockPackage = yield (0, utils_2.resolveInstallPackage)(inputData.packageData.registry, inputData.packageData.name);
+        // A legacy backend has no action locks: only trm-server and trm-rest can install there, to upgrade it.
+        const legacyBackend = (0, utils_2.isTrmBackendPackage)(lockPackage.registry, lockPackage.name) && (yield (0, utils_2.isLegacyTrmBackend)());
+        const lockScope = new utils_2.ActionLockScope(WORKFLOW_NAME, !legacyBackend);
+        const context = { rawInput: inputData, lockScope, inheritedNamespaceLocks, legacyBackend };
         yield lockScope.acquire([(0, utils_2.packageLockResource)(lockPackage.registry, lockPackage.name)]);
         const release = () => __awaiter(this, void 0, void 0, function* () {
             var _a;

package/dist/actions/install/init.js

@@ -225,10 +225,16 @@ exports.init = {
         //5- check if already installed
         context.runtime.update = context.rawInput.contextData.systemPackages.find(o => manifest_1.Manifest.compare(o.manifest, new manifest_1.Manifest(context.runtime.package.data.manifest), false));
         if (context.runtime.update) {
+            const installedVersion = context.runtime.update.manifest.get().version;
+            // trm-server and trm-rest run this install: see the selfUpdate steps
+            context.runtime.selfUpdate = context.runtime.isTrmServer || context.runtime.isTrmRest;
             context.runtime.previousInstallPackages = yield systemConnector_1.SystemConnector.getInstallPackages(context.rawInput.packageData.name, context.runtime.installRegistry);
-            context.runtime.previousInstallTransports = yield systemConnector_1.SystemConnector.getInstallTransports(context.rawInput.packageData.name, context.runtime.installRegistry);
+            // A legacy backend has no install transports table: trm-server and trm-rest ship
+            // no customizing or translations, so there is nothing recorded to read.
+            if (!context.legacyBackend) {
+                context.runtime.previousInstallTransports = yield systemConnector_1.SystemConnector.getInstallTransports(context.rawInput.packageData.name, context.runtime.installRegistry);
+            }
             const installVersion = context.runtime.package.data.manifest.version;
-            const installedVersion = context.runtime.update.manifest.get().version;
             //transports TRM generated for the package (e.g. of a rolled back release) aren't changes made on the system
             const dirtyEntries = yield (0, utils_1.withoutOwnTrmTransports)(context.runtime.update.getDirtyEntries(), context.runtime.update.packageName);
             if ((0, semver_1.eq)(installVersion, installedVersion)) {
@@ -266,6 +272,10 @@ exports.init = {
                     trm_commons_1.Logger.warning(`${context.rawInput.packageData.name} has changes made on ${systemConnector_1.SystemConnector.getDest()} that will be overwritten!`, { important: true });
                     (0, utils_1.logDirtyEntries)(dirtyEntries);
                 }
+                if (context.runtime.isTrmServer && (0, semver_1.valid)(installedVersion) && (0, semver_1.lt)(installedVersion, utils_1.TRM_SERVER_API_VERSION) && !(0, semver_1.lt)(installVersion, utils_1.TRM_SERVER_API_VERSION)) {
+                    // the install continues with the imported release: an unauthorized user can't complete it
+                    trm_commons_1.Logger.warning(`trm-server ${utils_1.TRM_SERVER_API_VERSION} authorizes users with authorization object ZTRM_AUTH (ACTVT 16) instead of table /ATRM/USERS: ${systemConnector_1.SystemConnector.getLogonUser()} and the other TRM users need it.`, { important: true });
+                }
             }
         }
         else {

package/dist/actions/install/prepareCust.js

@@ -94,10 +94,15 @@ exports.prepareCust = {
                     trTarget: systemConnector_1.SystemConnector.getDest()
                 });
                 //3- test import transport
-                trm_commons_1.Logger.loading(`Testing import...`);
-                const testRc = yield cust.instance.import(true);
-                if (testRc < 0 || testRc > 8) {
-                    throw new Error(`Test import of customizing failed: check logs.`);
+                if (context.legacyBackend) {
+                    trm_commons_1.Logger.log(`Skipping test import: legacy TRM backend`, true);
+                }
+                else {
+                    trm_commons_1.Logger.loading(`Testing import...`);
+                    const testRc = yield cust.instance.import(true);
+                    if (testRc < 0 || testRc > 8) {
+                        throw new Error(`Test import of customizing failed: check logs.`);
+                    }
                 }
             }));
         }

package/dist/actions/install/prepareDevc.js

@@ -93,10 +93,15 @@ exports.prepareDevc = {
                 trTarget: systemConnector_1.SystemConnector.getDest()
             });
             //4- test import transport
-            trm_commons_1.Logger.loading(`Testing import...`);
-            const testRc = yield context.runtime.transports.devc.instance.import(true);
-            if (testRc < 0 || testRc > 8) {
-                throw new Error(`Test import of SAP packages failed: check logs.`);
+            if (context.legacyBackend) {
+                trm_commons_1.Logger.log(`Skipping test import: legacy TRM backend`, true);
+            }
+            else {
+                trm_commons_1.Logger.loading(`Testing import...`);
+                const testRc = yield context.runtime.transports.devc.instance.import(true);
+                if (testRc < 0 || testRc > 8) {
+                    throw new Error(`Test import of SAP packages failed: check logs.`);
+                }
             }
         }));
     }),

package/dist/actions/install/prepareLang.js

@@ -90,10 +90,15 @@ exports.prepareLang = {
                 trTarget: systemConnector_1.SystemConnector.getDest()
             });
             //3- test import transport
-            trm_commons_1.Logger.loading(`Testing import...`);
-            const testRc = yield context.runtime.transports.lang.instance.import(true);
-            if (testRc < 0 || testRc > 8) {
-                throw new Error(`Test import of translations failed: check logs.`);
+            if (context.legacyBackend) {
+                trm_commons_1.Logger.log(`Skipping test import: legacy TRM backend`, true);
+            }
+            else {
+                trm_commons_1.Logger.loading(`Testing import...`);
+                const testRc = yield context.runtime.transports.lang.instance.import(true);
+                if (testRc < 0 || testRc > 8) {
+                    throw new Error(`Test import of translations failed: check logs.`);
+                }
             }
         }));
     }),

package/dist/actions/install/prepareTadir.js

@@ -75,10 +75,15 @@ exports.prepareTadir = {
                 trTarget: systemConnector_1.SystemConnector.getDest()
             });
             //3- test import transport
-            trm_commons_1.Logger.loading(`Testing import...`);
-            const testRc = yield context.runtime.transports.tadir.instance.import(true);
-            if (testRc < 0 || testRc > 8) {
-                throw new Error(`Test import of workbench failed: check logs.`);
+            if (context.legacyBackend) {
+                trm_commons_1.Logger.log(`Skipping test import: legacy TRM backend`, true);
+            }
+            else {
+                trm_commons_1.Logger.loading(`Testing import...`);
+                const testRc = yield context.runtime.transports.tadir.instance.import(true);
+                if (testRc < 0 || testRc > 8) {
+                    throw new Error(`Test import of workbench failed: check logs.`);
+                }
             }
         }));
     }),

package/dist/actions/install/setInstallDevclass.js

@@ -58,7 +58,21 @@ exports.setInstallDevclass = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
+        // trm-server and trm-rest are installed in `$` packages (`$TRM...`), unless they are already in their
+        // original `/ATRM/` packages: then they stay there. They are never renamed otherwise.
+        if (context.runtime.isTrmServer || context.runtime.isTrmRest) {
+            const original = (((_a = context.runtime.update) === null || _a === void 0 ? void 0 : _a.getDevclass()) || '').trim().toUpperCase().startsWith('/ATRM/');
+            context.rawInput.installData.installDevclass.replacements = (0, addNamespace_1.flattenDevclasses)(context.runtime.package.hierarchy).map(originalDevclass => ({
+                originalDevclass,
+                installDevclass: original ? originalDevclass : (0, commons_1.adjustTrmServerRestDevclass)(originalDevclass)
+            }));
+            context.rawInput.installData.installDevclass.keepOriginal = context.rawInput.installData.installDevclass.replacements
+                .every(o => o.installDevclass === o.originalDevclass);
+            (0, addNamespace_1.getInstallNamespace)(context);
+            trm_commons_1.Logger.log(`${context.rawInput.packageData.name} SAP packages: ${context.rawInput.installData.installDevclass.replacements.map(o => `${o.originalDevclass} -> ${o.installDevclass}`).join(', ')}`, true);
+            return;
+        }
         //1- find already defined replacements in system
         if (context.rawInput.installData.installDevclass.replacements.length <= 0) {
             //no input replacements = get from the trm table devclass replacements the corresponding name
@@ -78,7 +92,7 @@ exports.setInstallDevclass = {
         //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();
+        const installedRoot = (_b = context.runtime.update) === null || _b === void 0 ? void 0 : _b.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) {
@@ -133,7 +147,7 @@ exports.setInstallDevclass = {
         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);
+                || ((_d = (_c = context.runtime.previousInstallPackages) === null || _c === void 0 ? void 0 : _c.find(o => o.originalDevclass === context.runtime.package.hierarchy.devclass)) === null || _d === void 0 ? void 0 : _d.installDevclass);
             if (installedRootDevclass) {
                 updateNamespace = (0, commons_1.getPackageNamespace)(installedRootDevclass);
             }

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

@@ -1,5 +1,10 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Records the installed release: TRM packages table row, install packages and install transports.
+ * A trm-server/trm-rest upgrade also records it right after its import, which is never rolled back.
+ */
+export declare function recordInstalledRelease(context: InstallWorkflowContext): Promise<void>;
 /**
  * Workflow step that records the installed release in the target system's TRM package table.
  *

package/dist/actions/install/updatePackageData.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updatePackageData = void 0;
+exports.recordInstalledRelease = recordInstalledRelease;
 const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
 const utils_1 = require("../commons/utils");
@@ -33,20 +34,12 @@ function installDevcRows(packageName, packageRegistry, replacements) {
     }));
 }
 /**
- * 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* () {
+ * Records the installed release: TRM packages table row, install packages and install transports.
+ * A trm-server/trm-rest upgrade also records it right after its import, which is never rolled back.
+ */
+function recordInstalledRelease(context) {
+    return __awaiter(this, void 0, void 0, function* () {
         var _a, _b;
-        trm_commons_1.Logger.loading(`Finalizing install...`);
-        //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;
@@ -79,7 +72,8 @@ exports.updatePackageData = {
                 : [])
         ]);
         context.revert.metadataPackageRegistry = packageRegistry;
-        if (context.runtime.update) {
+        // A trm-server/trm-rest upgrade is not rolled back after its import: nothing to restore
+        if (context.runtime.update && !context.runtime.selfUpdate) {
             // 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.
@@ -101,18 +95,43 @@ exports.updatePackageData = {
         // 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);
+        // A legacy backend has neither API: trm-server and trm-rest have no stale mappings nor install transports
+        if (!context.legacyBackend) {
+            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);
         }
-        context.revert.metadataTransportsWriteStarted = true;
-        yield systemConnector_1.SystemConnector.setInstallTransports(context.rawInput.packageData.name, packageRegistry, installTr);
         yield systemConnector_1.SystemConnector.updateTrmPackageData(context.revert.metadataPackageRow);
+    });
+}
+/**
+ * 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.loading(`Finalizing install...`);
+        //1- commit new values
+        yield recordInstalledRelease(context);
     }),
     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.selfUpdate) {
+            // The imported release stays installed (see import-batch): its record is kept
+            trm_commons_1.Logger.log(`Keeping the TRM data of the imported ${context.rawInput.packageData.name}`, true);
+            return;
+        }
         if (!context.runtime.update) {
             if (context.revert.metadataPackageRow) {
                 yield systemConnector_1.SystemConnector.restoreInstallMetadata({

package/dist/client/RESTClient.js

@@ -510,11 +510,8 @@ class RESTClient {
     }
     importTransport(trkorr, system, test) {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = (yield this._axiosInstance.post('/import_tr', {
-                system: system.trim().toUpperCase(),
-                trkorr: trkorr.trim().toUpperCase(),
-                test: test ? 'X' : ' '
-            })).data;
+            // as RFC: TEST is only sent for a test import
+            const result = (yield this._axiosInstance.post('/import_tr', Object.assign({ system: system.trim().toUpperCase(), trkorr: trkorr.trim().toUpperCase() }, (test ? { test: 'X' } : {})))).data;
             if (result && result.testResult) {
                 return result.testResult;
             }

package/dist/client/RFCClient.js

@@ -631,11 +631,9 @@ class RFCClient {
     }
     importTransport(trkorr, system, test) {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this._call("/ATRM/IMPORT_TR", {
-                system: system.trim().toUpperCase(),
-                trkorr: trkorr.trim().toUpperCase(),
-                test: test ? 'X' : ' '
-            });
+            // TEST is only sent for a test import: releases before trm-server 7 have no such parameter, and
+            // their RFC metadata stays cached in this process even after a newer release is imported
+            const result = yield this._call("/ATRM/IMPORT_TR", Object.assign({ system: system.trim().toUpperCase(), trkorr: trkorr.trim().toUpperCase() }, (test ? { test: 'X' } : {})));
             if (result && result.testResult) {
                 return this.parseImportTransportResult(result['testResult'], '/ATRM/IMPORT_TR');
             }

package/dist/systemConnector/SystemConnectorBase.js

@@ -430,14 +430,36 @@ class SystemConnectorBase {
     }
     getExistingObjects(objects) {
         return __awaiter(this, void 0, void 0, function* () {
-            var ret = [];
+            // TADIR is read in batches of objects of the same type: one read per object is slow on large packages
+            const batchSize = 25;
+            const key = (pgmid, object, objName) => `${pgmid.trim().toUpperCase()} ${object.trim().toUpperCase()} ${objName.trim().toUpperCase()}`;
+            const found = new Map();
+            const singles = [];
+            const byType = new Map();
             for (const object of objects) {
+                // an option line holds 72 characters: "OR ( OBJ_NAME EQ '...' )"
+                if (object.objName.trim().replace(/'/g, "''").length > 50 || /\s(AND|OR)\s/i.test(object.objName)) {
+                    singles.push(object);
+                    continue;
+                }
+                const type = `${object.pgmid.trim().toUpperCase()} ${object.object.trim().toUpperCase()}`;
+                byType.set(type, [...(byType.get(type) || []), object]);
+            }
+            for (const [type, typeObjects] of byType) {
+                const [pgmid, object] = type.split(' ');
+                for (let i = 0; i < typeObjects.length; i += batchSize) {
+                    const names = typeObjects.slice(i, i + batchSize).map(o => o.objName.trim().toUpperCase().replace(/'/g, "''"));
+                    const tadir = yield this.readTable('TADIR', [{ fieldName: 'PGMID' }, { fieldName: 'OBJECT' }, { fieldName: 'OBJ_NAME' }, { fieldName: 'DEVCLASS' }, { fieldName: 'SRCSYSTEM' }, { fieldName: 'AUTHOR' }], `PGMID EQ '${pgmid}' AND OBJECT EQ '${object}' AND ( ${names.map(name => `OBJ_NAME EQ '${name}'`).join(' OR ')} )`);
+                    tadir.forEach(o => found.set(key(o.pgmid, o.object, o.objName), o));
+                }
+            }
+            for (const object of singles) {
                 const oTadir = yield this.getObject(object.pgmid, object.object, object.objName);
                 if (oTadir) {
-                    ret.push(oTadir);
+                    found.set(key(object.pgmid, object.object, object.objName), oTadir);
                 }
             }
-            return ret;
+            return objects.map(o => found.get(key(o.pgmid, o.object, o.objName))).filter(Boolean);
         });
     }
     getNamespace(namespace) {