trm-core 10.0.1 → 10.1.0

package/changelog.txt

@@ -8,6 +8,16 @@ Legend
 + : added
 - : removed
 
+2026-10-12 v10.1.0
+-------------------
+* trm-server/trm-rest upgrade from a backend before trm-server 7.0.0/trm-rest 6.0.0
+* trm-server/trm-rest upgrade cleanup after the install, deleting only objects not in the new release
+* trm-server/trm-rest kept in $ packages unless installed in /ATRM/ packages
+* deletion transport only includes objects that exist on the system
+* release transports missing from registry metadata read from the verified artifact
+! SAP entries check with percentage progress and batched reads
+! existing objects check batched
+
 2026-10-11 v10.0.1
 -------------------
 * rest client https agent import

package/dist/actions/checkEngines/analyze.js

@@ -208,26 +208,31 @@ function evaluate(context, engines, path, required) {
             switch (key) {
                 case 'trm':
                     for (const name of Object.keys(engines.trm)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}trm.${name}...`);
                         ok = push(`${prefix}trm.${name}`, yield checkTrm(context, name, engines.trm[name])) && ok;
                     }
                     break;
                 case 'components':
                     for (const name of Object.keys(engines.components)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}components.${name}...`);
                         ok = push(`${prefix}components.${name}`, yield checkComponent(context, name, engines.components[name])) && ok;
                     }
                     break;
                 case 'products':
                     for (const name of Object.keys(engines.products)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}products.${name}...`);
                         ok = push(`${prefix}products.${name}`, yield checkProduct(context, name, engines.products[name])) && ok;
                     }
                     break;
                 case 'notes':
                     for (const note of Object.keys(engines.notes)) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}notes.${note}...`);
                         ok = push(`${prefix}notes.${note}`, yield checkNote(note, engines.notes[note])) && ok;
                     }
                     break;
                 case 'tables':
                     for (var i = 0; i < engines.tables.length; i++) {
+                        trm_commons_1.Logger.loading(`Checking engine requirement ${prefix}tables[${i}]...`);
                         ok = push(`${prefix}tables[${i}]`, yield checkTable(engines.tables[i])) && ok;
                     }
                     break;
@@ -235,6 +240,7 @@ function evaluate(context, engines, path, required) {
                     var alternatives = [];
                     var anyOk = false;
                     for (var j = 0; j < engines.anyOf.length; j++) {
+                        trm_commons_1.Logger.loading(`Checking engine alternative ${prefix}anyOf[${j}]...`);
                         const alternative = yield evaluate(context, engines.anyOf[j], `${prefix}anyOf[${j}]`, false);
                         alternatives = alternatives.concat(alternative.results);
                         anyOk = anyOk || alternative.ok;

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

@@ -1,5 +1,7 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { CheckSapEntriesWorkflowContext } from ".";
+/** Entries read with one query. */
+export declare const SAP_ENTRIES_BATCH_SIZE = 25;
 /**
  * Workflow step that queries required SAP tables and builds a per-entry status report.
  *

package/dist/actions/checkSapEntries/analyze.js

@@ -9,9 +9,93 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyze = void 0;
+exports.analyze = exports.SAP_ENTRIES_BATCH_SIZE = void 0;
 const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
+const manifest_1 = require("../../manifest");
+const commons_1 = require("../../commons");
+/** Entries read with one query. */
+exports.SAP_ENTRIES_BATCH_SIZE = 25;
+// RFC_READ_TABLE option lines hold 72 characters: a batched condition also carries "OR ( " and " )"
+const BATCHED_CONDITION_MAX_LENGTH = 65;
+function entryError(table, tableEntry, e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    return new Error(`Unable to check required SAP entry ${JSON.stringify(tableEntry)} in table "${table}": ${reason}`);
+}
+function checkEntry(table, tableEntry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield systemConnector_1.SystemConnector.checkSapEntryExists(table, tableEntry);
+        }
+        catch (e) {
+            throw entryError(table, tableEntry, e);
+        }
+    });
+}
+/**
+ * Whether each entry of a table exists. Entries with the same fields are read together, in batches of
+ * {@link SAP_ENTRIES_BATCH_SIZE}; an entry a batch doesn't return is checked on its own, as are the entries
+ * of a batch that can't be read (e.g. rows too wide).
+ */
+function checkTableEntries(table, entries, onChecked) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const status = new Array(entries.length);
+        const batches = new Map();
+        const singles = [];
+        entries.forEach((tableEntry, index) => {
+            let conditions;
+            try {
+                conditions = (0, manifest_1.getSapEntryConditions)(tableEntry);
+            }
+            catch (e) {
+                throw entryError(table, tableEntry, e);
+            }
+            if (conditions.some(condition => condition.length > BATCHED_CONDITION_MAX_LENGTH)) {
+                singles.push(index);
+                return;
+            }
+            const values = new Map(Object.keys(tableEntry).map(field => [field.trim().toUpperCase(), tableEntry[field].toString()]));
+            const fieldsKey = Array.from(values.keys()).sort().join(',');
+            if (!batches.has(fieldsKey)) {
+                batches.set(fieldsKey, []);
+            }
+            batches.get(fieldsKey).push({ index, values, conditions });
+        });
+        for (const [fieldsKey, group] of batches) {
+            const fields = fieldsKey.split(',');
+            // readTable returns camel-cased field names
+            const rowKeys = fields.map(field => Object.keys((0, commons_1.normalize)({ [field]: '' }))[0]);
+            for (let i = 0; i < group.length; i += exports.SAP_ENTRIES_BATCH_SIZE) {
+                const batch = group.slice(i, i + exports.SAP_ENTRIES_BATCH_SIZE);
+                let rows;
+                try {
+                    rows = yield systemConnector_1.SystemConnector.readTable(table.trim().toUpperCase(), fields.map(fieldName => ({ fieldName })), batch.map(o => `( ${o.conditions.join(' AND ')} )`).join(' OR '));
+                }
+                catch (e) {
+                    trm_commons_1.Logger.log(`Batch read of ${batch.length} entries in ${table} failed, checking them one by one: ${e}`, true);
+                    singles.push(...batch.map(o => o.index));
+                    continue;
+                }
+                for (const o of batch) {
+                    const found = rows.some(row => fields.every((field, f) => { var _a; return `${(_a = row[rowKeys[f]]) !== null && _a !== void 0 ? _a : ''}`.trim() === o.values.get(field).trim(); }));
+                    if (found) {
+                        status[o.index] = true;
+                    }
+                    else {
+                        // values the database matches but that read differently (e.g. numbers) are confirmed on their own
+                        singles.push(o.index);
+                    }
+                }
+                onChecked(batch.length - batch.filter(o => !status[o.index]).length);
+            }
+        }
+        for (const index of singles) {
+            status[index] = yield checkEntry(table, entries[index]);
+            onChecked(1);
+        }
+        return status;
+    });
+}
 /**
  * Workflow step that queries required SAP tables and builds a per-entry status report.
  *
@@ -60,7 +144,11 @@ exports.analyze = {
             return;
         }
         //2- check entries
+        let checked = 0;
+        const progress = (table) => trm_commons_1.Logger.loading(`Checking ${entriesCount} SAP entries: ${Math.floor(checked * 100 / entriesCount)}% (${table.trim()})...`);
         for (const table of Object.keys(context.output.sapEntries)) {
+            const requiredEntries = context.output.sapEntries[table];
+            progress(table);
             var tableExists = false;
             try {
                 for (const object of ['TABL', 'VIEW']) {
@@ -80,30 +168,26 @@ exports.analyze = {
             }
             if (!tableExists) {
                 context.runtime.missingTables.push(table);
-                context.output.sapEntries[table].forEach(tableEntry => {
+                requiredEntries.forEach(tableEntry => {
                     context.runtime.entriesStatus.bad.push({
                         table,
                         tableEntry
                     });
                 });
-                trm_commons_1.Logger.error(`Required ${context.output.sapEntries[table].length} entries in ${table}, but table or view was not found`, { debug: !context.rawInput.printOptions.information, important: true });
+                checked += requiredEntries.length;
+                trm_commons_1.Logger.error(`Required ${requiredEntries.length} entries in ${table}, but table or view was not found`, { debug: !context.rawInput.printOptions.information, important: true });
             }
             else {
                 var printTableHead = ['Table name'];
                 var printTableData = [];
-                var tableData;
                 printTableHead = printTableHead.concat(tableFields.find(o => o.tableName === table).fields);
                 printTableHead.push('Status');
-                for (const tableEntry of context.output.sapEntries[table]) {
-                    tableData = [table];
-                    var exists;
-                    try {
-                        exists = yield systemConnector_1.SystemConnector.checkSapEntryExists(table, tableEntry);
-                    }
-                    catch (e) {
-                        const reason = e instanceof Error ? e.message : String(e);
-                        throw new Error(`Unable to check required SAP entry ${JSON.stringify(tableEntry)} in table "${table}": ${reason}`);
-                    }
+                const statuses = yield checkTableEntries(table, requiredEntries, count => {
+                    checked += count;
+                    progress(table);
+                });
+                requiredEntries.forEach((tableEntry, index) => {
+                    const exists = statuses[index];
                     if (exists) {
                         context.runtime.entriesStatus.good.push({
                             table,
@@ -117,10 +201,8 @@ exports.analyze = {
                         });
                     }
                     const entryStatus = exists ? `OK` : `NOT FOUND`;
-                    tableData = tableData.concat(printTableHead.slice(1, -1).map(field => { var _a; return (_a = tableEntry[field]) !== null && _a !== void 0 ? _a : ''; }));
-                    tableData.push(entryStatus);
-                    printTableData.push(tableData);
-                }
+                    printTableData.push([table, ...printTableHead.slice(1, -1).map(field => { var _a; return (_a = tableEntry[field]) !== null && _a !== void 0 ? _a : ''; }), entryStatus]);
+                });
                 logTable.push({
                     header: printTableHead,
                     data: printTableData

package/dist/actions/commons/setSystemPackages.js

@@ -27,7 +27,7 @@ exports.setSystemPackages = {
             context.rawInput.contextData = {};
         }
         if (context.rawInput.contextData.systemPackages === undefined) {
-            trm_commons_1.Logger.loading(`Reading system data...`);
+            trm_commons_1.Logger.loading(`Reading system packages...`);
             context.rawInput.contextData.systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true, true);
         }
     })

package/dist/actions/commons/utils/actionLocks.d.ts

@@ -15,9 +15,10 @@ export declare function objectLockResource(object: {
 /** One non-expiring SAP lock owner; close only after workflow rollback has finished. */
 export declare class ActionLockScope {
     private readonly actionName;
+    private readonly enabled;
     private readonly ownerToken;
     private readonly held;
-    constructor(actionName: string);
+    constructor(actionName: string, enabled?: boolean);
     acquire(resources: LockResource[]): Promise<void>;
     release(): Promise<void>;
 }

package/dist/actions/commons/utils/actionLocks.js

@@ -42,13 +42,17 @@ function objectLockResource(object) {
 }
 /** One non-expiring SAP lock owner; close only after workflow rollback has finished. */
 class ActionLockScope {
-    constructor(actionName) {
+    constructor(actionName, enabled = true) {
         this.actionName = actionName;
+        this.enabled = enabled;
         this.ownerToken = (0, crypto_1.randomUUID)().replace(/-/g, "").toUpperCase();
         this.held = new Map();
     }
     acquire(resources) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
             const requested = resources.map(actionLockKey);
             const fresh = requested.filter(key => !this.held.has(`${key.resourceType}:${key.resourceHash}`));
             if (fresh.length === 0) {
@@ -82,6 +86,9 @@ class ActionLockScope {
     }
     release() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
             if (this.held.size === 0) {
                 return;
             }

package/dist/actions/commons/utils/index.d.ts

@@ -8,3 +8,4 @@ export * from "./installedDependency";
 export * from "./installRegistry";
 export * from "./dirtyEntries";
 export * from "./owningInstallation";
+export * from "./trmBackend";

package/dist/actions/commons/utils/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./installedDependency"), exports);
 __exportStar(require("./installRegistry"), exports);
 __exportStar(require("./dirtyEntries"), exports);
 __exportStar(require("./owningInstallation"), exports);
+__exportStar(require("./trmBackend"), exports);

package/dist/actions/commons/utils/packageCleanup.d.ts

@@ -41,6 +41,8 @@ export interface PackageCleanupRevert {
 /** Minimum workflow context needed to remove an installed release from the target system. */
 export interface PackageCleanupContext {
     lockScope?: ActionLockScope;
+    /** Only the APIs of a backend older than this trm-core can be used: no test imports. */
+    legacyBackend?: boolean;
     rawInput: {
         packageData: {
             name: string;
@@ -74,6 +76,12 @@ export type PackageCleanupTarget = {
     incomingObjects: TADIR[];
     /** SAP packages that hold the incoming release. Empty when uninstalling. */
     keptDevclasses: string[];
+    /**
+     * When `true`, the incoming release is already imported: only the installed objects it doesn't
+     * ship are deleted. Otherwise every installed object is deleted before the import, except the
+     * tables the incoming release ships again.
+     */
+    incomingImported?: boolean;
     /** Logger/Inquirer prefix shown while the cleanup runs. */
     prefix: string;
     /** Action name used in abort messages, e.g. `Update`. */

package/dist/actions/commons/utils/packageCleanup.js

@@ -402,7 +402,8 @@ function getCustomizingSources(context, target) {
         if (sources.length === 0) {
             return [];
         }
-        if (target.keepCustomizing) {
+        // After the import, deleting by key would also delete the rows the incoming release has just written.
+        if (target.keepCustomizing || target.incomingImported) {
             trm_commons_1.Logger.warning(`Keeping customizing of ${sources.length} transports (${sources.join(', ')}).`, { important: true });
             return [];
         }
@@ -513,7 +514,10 @@ function createStagingPackage(context, namespace) {
             ctext: 'TRM upgrade cleanup',
             as4user: systemConnector_1.SystemConnector.getLogonUser(),
             dlvunit: 'HOME',
-            pdevclass: yield systemConnector_1.SystemConnector.getDefaultTransportLayer()
+            pdevclass: yield systemConnector_1.SystemConnector.getDefaultTransportLayer(),
+            // The package immediately receives transported objects. Some systems do not infer
+            // change recording from the transport layer when CREATE_PACKAGE is called directly.
+            korrflag: 'X'
         });
         yield systemConnector_1.SystemConnector.tadirInterface({
             pgmid: 'R3TR', object: 'DEVC', objName: stagingDevclass,
@@ -544,18 +548,46 @@ function cleanupInstalledPackage(context, target) {
                 target: systemConnector_1.SystemConnector.getDest()
             });
             context.revert.updateCleanupTransport = dummy;
-            const { previousNamespaces, previousTransportObjects } = yield readInstalledTransportObjects(installed);
+            const installedTransport = yield readInstalledTransportObjects(installed);
+            const previousNamespaces = installedTransport.previousNamespaces;
+            const previousTransportObjects = installedTransport.previousTransportObjects;
             const incomingObjects = target.incomingObjects;
+            const currentDevclasses = new Set(target.keptDevclasses.map(normalize));
+            const deletedKeys = new Set((context.runtime.deletedObjects || []).map(objectKey));
+            const { previousDevclasses, installedDevclasses, packageParents, otherInstallations, isOtherInstallation } = yield readInstallationTree(installed, context.runtime.previousInstallPackages, previousTransportObjects, context.runtime.deletedObjects || [], ((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.systemPackages) || []);
+            // After the import, the previous release is also what its SAP packages still contain beyond the
+            // incoming release: an installation without transport (e.g. trm-server/trm-rest installed with
+            // abapGit) or leftovers of an earlier upgrade.
+            if (target.incomingImported) {
+                const previousKeys = new Set(previousTransportObjects.map(objectKey));
+                let added = 0;
+                for (const devclass of previousDevclasses.values()) {
+                    if (isOtherInstallation(devclass)) {
+                        continue;
+                    }
+                    for (const object of yield systemConnector_1.SystemConnector.getDevclassObjects(devclass, false)) {
+                        if (!isDevclass(object) && !isNamespace(object) && !deletedKeys.has(objectKey(object)) && !previousKeys.has(objectKey(object))) {
+                            previousKeys.add(objectKey(object));
+                            previousTransportObjects.push({ pgmid: object.pgmid, object: object.object, objName: object.objName });
+                            added++;
+                        }
+                    }
+                }
+                trm_commons_1.Logger.log(`${added} objects of the previous release found in its SAP packages only`, true);
+            }
             // Tables shipped again by the new release are adjusted by its import instead of
             // being dropped and re-created, which would lose their data.
             const incomingKeys = new Set(incomingObjects.map(objectKey));
+            // Already imported, the objects of the incoming release are simply kept.
+            const keptIncoming = target.incomingImported ? previousTransportObjects.filter(object => incomingKeys.has(objectKey(object))) : [];
+            const keptIncomingKeys = new Set(keptIncoming.map(objectKey));
+            if (keptIncoming.length > 0) {
+                trm_commons_1.Logger.log(`Keeping ${keptIncoming.length} objects shipped again by the imported release`, true);
+            }
             const retainedTables = previousTransportObjects.filter(object => normalize(object.pgmid) === 'R3TR' && normalize(object.object) === 'TABL'
-                && incomingKeys.has(objectKey(object)));
+                && incomingKeys.has(objectKey(object)) && !keptIncomingKeys.has(objectKey(object)));
             const retainedKeys = new Set(retainedTables.map(objectKey));
             retainedTables.forEach(object => trm_commons_1.Logger.log(`Keeping table ${object.objName} (present in new release)`, true));
-            const currentDevclasses = new Set(target.keptDevclasses.map(normalize));
-            const deletedKeys = new Set((context.runtime.deletedObjects || []).map(objectKey));
-            const { previousDevclasses, installedDevclasses, packageParents, otherInstallations, isOtherInstallation } = yield readInstallationTree(installed, context.runtime.previousInstallPackages, previousTransportObjects, context.runtime.deletedObjects || [], ((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.systemPackages) || []);
             const generatedDevclasses = new Set(context.revert.sapPackages.map(normalize));
             otherInstallations.forEach(pkg => trm_commons_1.Logger.log(`Ignoring SAP package ${pkg.getDevclass()}: TRM package ${pkg.packageName} is installed there`, true));
             // Local additions remain cleanup candidates even when reused as incoming targets.
@@ -687,7 +719,7 @@ function cleanupInstalledPackage(context, target) {
             }
             // Installed objects moved to a package outside this installation (customer development)
             // are kept unless confirmed; those now in another TRM package belong to it and are kept.
-            const relocatedObjects = yield readRelocatedObjects(previousTransportObjects.filter(object => !retainedKeys.has(objectKey(object))), { previousDevclasses, isOtherInstallation });
+            const relocatedObjects = yield readRelocatedObjects(previousTransportObjects.filter(object => !retainedKeys.has(objectKey(object)) && !keptIncomingKeys.has(objectKey(object))), { previousDevclasses, isOtherInstallation });
             const movedKeys = new Set();
             const movedObjects = [];
             for (const object of relocatedObjects) {
@@ -743,13 +775,30 @@ function cleanupInstalledPackage(context, target) {
             // SAP packages the incoming release keeps are never deleted: a renamed installation has already
             // generated them (generate-devclass), and the import of the others updates them in place.
             const deletionObjects = new Map([...previousTransportObjects, ...additionalObjects]
-                .filter(object => !retainedKeys.has(objectKey(object)) && !movedKeys.has(objectKey(object)))
+                .filter(object => !retainedKeys.has(objectKey(object)) && !movedKeys.has(objectKey(object)) && !keptIncomingKeys.has(objectKey(object)))
                 .filter(object => !(isDevclass(object) && currentDevclasses.has(normalize(object.objName))))
                 .map(object => [objectKey(object), object]));
+            // Only objects that exist can be transported: the installed transport may list objects this system
+            // never had or already lost (e.g. a system copy).
+            const checkedObjects = Array.from(deletionObjects.values()).filter(object => normalize(object.pgmid) === 'R3TR' && !isNamespace(object));
+            if (checkedObjects.length > 0) {
+                const existing = new Set((yield systemConnector_1.SystemConnector.getExistingObjects(checkedObjects.map(object => ({
+                    pgmid: object.pgmid, object: object.object, objName: object.objName, devclass: ''
+                })))).map(objectKey));
+                checkedObjects.filter(object => !existing.has(objectKey(object))).forEach(object => {
+                    trm_commons_1.Logger.log(`Skipping ${object.pgmid} ${object.object} ${object.objName}: not on ${systemConnector_1.SystemConnector.getDest()}, nothing to delete`, true);
+                    deletionObjects.delete(objectKey(object));
+                });
+            }
             // TRM comment rows of the installed transport are not objects to delete.
             const hasObjectsToDelete = Array.from(deletionObjects.values()).some(object => normalize(object.pgmid) !== '*');
             if (!hasObjectsToDelete && retainedTables.length === 0 && customizingSources.length === 0) {
-                trm_commons_1.Logger.warning(`Nothing to delete for package ${context.rawInput.packageData.name}: deletion transport was not generated. Manual cleanup of previous release install might be necessary.`, { important: true });
+                if (target.incomingImported) {
+                    trm_commons_1.Logger.log(`The imported release ships every object of the previous one: nothing to delete`, true);
+                }
+                else {
+                    trm_commons_1.Logger.warning(`Nothing to delete for package ${context.rawInput.packageData.name}: deletion transport was not generated. Manual cleanup of previous release install might be necessary.`, { important: true });
+                }
                 try {
                     if (yield dummy.canBeDeleted()) {
                         yield dummy.delete();

package/dist/actions/commons/utils/releaseDeletionTransport.js

@@ -50,10 +50,17 @@ function releaseDeletionTransport(deletionTransport_1, registry_2, context_1) {
             trTarget: systemConnector_1.SystemConnector.getDest()
         });
         //3- import transport
-        trm_commons_1.Logger.loading(`Testing import...`);
-        const testRc = yield context.runtime.dele.import(true);
-        if (testRc < 0 || testRc > 8) {
-            throw new Error(`Test import of deletion transport failed: check logs.`);
+        // A legacy backend has no test import; in the same process the RFC metadata of its import
+        // function stays cached even after the upgrade is imported.
+        if (context.legacyBackend) {
+            trm_commons_1.Logger.log(`Skipping test import of ${deletionTransport.trkorr}: legacy TRM backend`, true);
+        }
+        else {
+            trm_commons_1.Logger.loading(`Testing import...`);
+            const testRc = yield context.runtime.dele.import(true);
+            if (testRc < 0 || testRc > 8) {
+                throw new Error(`Test import of deletion transport failed: check logs.`);
+            }
         }
         trm_commons_1.Logger.loading(`Importing ${deletionTransport.trkorr}`, true);
         // Mark before the mutating await: the import may change objects and still fail.

package/dist/actions/commons/utils/trmBackend.d.ts

@@ -0,0 +1,20 @@
+import { AbstractRegistry } from "../../../registry";
+/**
+ * First trm-server and trm-rest releases with the backend APIs this trm-core relies on
+ * (action locks, batch import, install transports, test imports, transport object locks).
+ */
+export declare const TRM_SERVER_API_VERSION = "7.0.0";
+export declare const TRM_REST_API_VERSION = "6.0.0";
+/**
+ * Permanent TADIR transport of the public trm-server and trm-rest: the same request in every release.
+ * The registry doesn't deliver it through its transport download: it's read from the release artifact.
+ */
+export declare const TRM_FIXED_TADIR_TRANSPORTS: Readonly<Record<string, string>>;
+/** Whether a package is the public trm-server or trm-rest: the TRM backend itself. */
+export declare function isTrmBackendPackage(registry: AbstractRegistry, name: string): boolean;
+/**
+ * Whether the connected TRM backend predates {@link TRM_SERVER_API_VERSION} / {@link TRM_REST_API_VERSION}.
+ * Such a backend can only upgrade itself, with the APIs of its own generation: the newer APIs exist
+ * only once the upgrade is imported.
+ */
+export declare function isLegacyTrmBackend(): Promise<boolean>;

package/dist/actions/commons/utils/trmBackend.js

@@ -0,0 +1,64 @@
+"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.TRM_FIXED_TADIR_TRANSPORTS = exports.TRM_REST_API_VERSION = exports.TRM_SERVER_API_VERSION = void 0;
+exports.isTrmBackendPackage = isTrmBackendPackage;
+exports.isLegacyTrmBackend = isLegacyTrmBackend;
+const semver_1 = require("semver");
+const trm_commons_1 = require("trm-commons");
+const registry_1 = require("../../../registry");
+const systemConnector_1 = require("../../../systemConnector");
+/**
+ * First trm-server and trm-rest releases with the backend APIs this trm-core relies on
+ * (action locks, batch import, install transports, test imports, transport object locks).
+ */
+exports.TRM_SERVER_API_VERSION = '7.0.0';
+exports.TRM_REST_API_VERSION = '6.0.0';
+/**
+ * Permanent TADIR transport of the public trm-server and trm-rest: the same request in every release.
+ * The registry doesn't deliver it through its transport download: it's read from the release artifact.
+ */
+exports.TRM_FIXED_TADIR_TRANSPORTS = {
+    'trm-server': 'TRMK900000',
+    'trm-rest': 'TRMK900001'
+};
+/** Whether a package is the public trm-server or trm-rest: the TRM backend itself. */
+function isTrmBackendPackage(registry, name) {
+    return registry.getRegistryType() === registry_1.RegistryType.PUBLIC
+        && [systemConnector_1.TRM_SERVER_PACKAGE_NAME, systemConnector_1.TRM_REST_PACKAGE_NAME].includes(name.trim().toLowerCase());
+}
+function installedVersion(read) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            return (_a = (yield read()).manifest) === null || _a === void 0 ? void 0 : _a.get().version;
+        }
+        catch (_b) {
+            // not installed
+            return undefined;
+        }
+    });
+}
+/**
+ * Whether the connected TRM backend predates {@link TRM_SERVER_API_VERSION} / {@link TRM_REST_API_VERSION}.
+ * Such a backend can only upgrade itself, with the APIs of its own generation: the newer APIs exist
+ * only once the upgrade is imported.
+ */
+function isLegacyTrmBackend() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const isLegacy = (version, apiVersion) => !!version && (!(0, semver_1.valid)(version) || (0, semver_1.lt)(version, apiVersion));
+        const serverVersion = yield installedVersion(() => systemConnector_1.SystemConnector.getTrmServerPackage());
+        const restVersion = yield installedVersion(() => systemConnector_1.SystemConnector.getTrmRestPackage());
+        const legacy = isLegacy(serverVersion, exports.TRM_SERVER_API_VERSION) || isLegacy(restVersion, exports.TRM_REST_API_VERSION);
+        trm_commons_1.Logger.log(`TRM backend: trm-server ${serverVersion || '-'}, trm-rest ${restVersion || '-'}${legacy ? ' (legacy APIs)' : ''}`, true);
+        return legacy;
+    });
+}

package/dist/actions/install/checkSapEntries.js

@@ -57,7 +57,7 @@ exports.checkSapEntries = {
             context.runtime.missingSapEntries = missingEntries.length;
         }
         else {
-            trm_commons_1.Logger.success(`SAP entries checked.`);
+            trm_commons_1.Logger.success(`Requirements checked.`);
         }
     })
 };

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) {

package/dist/transport/Transport.js

@@ -623,6 +623,7 @@ class Transport {
             var lastCheck;
             if (this._trTarget) {
                 var inQueueAttempts = 0;
+                var queueReadFailures = 0;
                 trm_commons_1.Logger.loading(`Checking ${this.trkorr} status...`, skipLog);
                 while (!inQueue) {
                     inQueueAttempts++;
@@ -644,15 +645,28 @@ class Transport {
                             }
                         }
                         catch (e) {
-                            trm_commons_1.Logger.loading(`Last check ${lastCheck.toISOString().split("T")[0]} ${lastCheck.toTimeString().split(" ")[0]}, last update /: Unable to read status`, skipLog);
-                            trm_commons_1.Logger.error(`Unable to read status!`, true);
+                            trm_commons_1.Logger.loading(`Last check ${lastCheck.toISOString().split("T")[0]} ${lastCheck.toTimeString().split(" ")[0]}...`, skipLog);
+                            trm_commons_1.Logger.warning(`Unable to read status: check continues, this error can be ignored`, true);
                             trm_commons_1.Logger.error(e.toString(), true);
                         }
                     }
                     //reading the queue is outdated now and getTransportImportStatus should be used
                     //HOWEVER it doesn't work for VIRTUAL TARGETS!
                     //for now, keep it like this
-                    var tmsQueue = yield systemConnector_1.SystemConnector.readTmsQueue(this._trTarget);
+                    var tmsQueue;
+                    try {
+                        tmsQueue = yield systemConnector_1.SystemConnector.readTmsQueue(this._trTarget);
+                        queueReadFailures = 0;
+                    }
+                    catch (e) {
+                        // an import can replace the TRM backend itself (trm-server upgrade): its API can
+                        // fail while it's being imported and activated
+                        if (++queueReadFailures > 10) {
+                            throw e;
+                        }
+                        trm_commons_1.Logger.log(`Unable to read ${this._trTarget} import queue (attempt ${queueReadFailures}), retrying: ${e}`, true);
+                        continue;
+                    }
                     tmsQueue = tmsQueue.filter(o => o.trkorr === this.trkorr);
                     tmsQueue = tmsQueue.sort((a, b) => parseInt(b.bufpos) - parseInt(a.bufpos));
                     if (!checkImpSing) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trm-core",
-  "version": "10.0.1",
+  "version": "10.1.0",
   "description": "TRM (Transport Request Manager) Core",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",