trm-core 9.10.6 → 10.0.0

package/dist/actions/install/defaultTransportLayer.js

@@ -0,0 +1,36 @@
+"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.getDefaultTransportLayer = getDefaultTransportLayer;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+/**
+ * Reads the system's default transport layer, used for transportable packages when the install
+ * input doesn't specify one.
+ */
+function getDefaultTransportLayer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        trm_commons_1.Logger.loading(`Checking transport layer...`);
+        let defaultTransportLayer;
+        try {
+            defaultTransportLayer = yield systemConnector_1.SystemConnector.getDefaultTransportLayer();
+        }
+        catch (e) {
+            trm_commons_1.Logger.error(e.toString(), true);
+            throw new Error(`Couldn't determine system's default transport layer.`);
+        }
+        if (!defaultTransportLayer) {
+            throw new Error(`System has no default transport layer, specify one.`);
+        }
+        trm_commons_1.Logger.log(`System default transport layer: ${defaultTransportLayer}`, true);
+        return defaultTransportLayer;
+    });
+}

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

@@ -1,3 +1,9 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that executes post-install activities declared by the package manifest.
+ *
+ * 1- execute post activities
+ *
+*/
 export declare const executePostActivities: Step<InstallWorkflowContext>;

package/dist/actions/install/executePostActivities.js

@@ -12,7 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executePostActivities = void 0;
 const trm_commons_1 = require("trm-commons");
 const manifest_1 = require("../../manifest");
-const transport_1 = require("../../transport");
+/**
+ * Workflow step that executes post-install activities declared by the package manifest.
+ *
+ * 1- execute post activities
+ *
+*/
 exports.executePostActivities = {
     name: 'execute-post-activities',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -20,52 +25,37 @@ exports.executePostActivities = {
             trm_commons_1.Logger.log(`Skipping post activities (user input)`, true);
             return false;
         }
-        else {
-            if (context.runtime.remotePackageData.manifest.postActivities && context.runtime.remotePackageData.manifest.postActivities.length > 0) {
-                return true;
-            }
-            else {
-                trm_commons_1.Logger.log(`Skipping post activities (none defined)`, true);
-                return false;
-            }
+        if (context.runtime.package.data.manifest.postActivities && context.runtime.package.data.manifest.postActivities.length > 0) {
+            return true;
         }
+        trm_commons_1.Logger.log(`Skipping post activities (none defined)`, true);
+        return false;
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Execute post activities step', true);
-        var counter = 0;
-        for (var data of context.runtime.remotePackageData.manifest.postActivities) {
+        //1- execute post activities
+        let counter = 0;
+        for (const data of context.runtime.package.data.manifest.postActivities) {
             counter++;
-            trm_commons_1.Logger.setPrefix(`(${counter}/${context.runtime.remotePackageData.manifest.postActivities.length}) `);
+            trm_commons_1.Logger.setPrefix(`(${counter}/${context.runtime.package.data.manifest.postActivities.length}) `);
             try {
-                if (Array.isArray(data.parameters)) {
-                    data.parameters.forEach(param => {
-                        switch (param.value) {
-                            case '&INSTALL_WB_TRANSPORT&':
-                                try {
-                                    param.value = context.runtime.installData.transports.find(o => o.type === transport_1.TrmTransportIdentifier.TADIR).transport.trkorr;
-                                }
-                                catch (x) {
-                                    throw new Error(`Cannot find install workbench transport number`);
-                                }
-                                break;
-                            case '&INSTALL_CUST_TRANSPORT&':
-                                try {
-                                    param.value = context.runtime.installData.transports.find(o => o.type === transport_1.TrmTransportIdentifier.CUST).transport.trkorr;
-                                }
-                                catch (x) {
-                                    throw new Error(`Cannot find install customizing transport number`);
-                                }
-                                break;
-                        }
-                    });
-                }
-                const postActivity = new manifest_1.PostActivity(data);
+                const activity = Object.assign(Object.assign({}, data), { parameters: Array.isArray(data.parameters)
+                        ? data.parameters.map(param => {
+                            var _a;
+                            return (Object.assign(Object.assign({}, param), { value: param.value === '&LANDSCAPE_TRANSPORT&'
+                                    ? (_a = context.output.transport) === null || _a === void 0 ? void 0 : _a.trkorr
+                                    : param.value }));
+                        })
+                        : data.parameters });
+                const postActivity = new manifest_1.PostActivity(activity);
                 yield postActivity.execute();
             }
             catch (e) {
-                trm_commons_1.Logger.error(`Failed execution of post activity: ${e.message}`);
+                trm_commons_1.Logger.error(`Failed execution of post activity: ${e.message}`, { important: true });
+                throw e;
+            }
+            finally {
+                trm_commons_1.Logger.removePrefix();
             }
-            trm_commons_1.Logger.removePrefix();
         }
     })
 };

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

@@ -1,3 +1,13 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that validates target SAP packages and creates any that are missing.
+ *
+ * 1- find packages to generate
+ *
+ * 2- generate missing packages (the default transport layer is resolved only for transportable packages)
+ *
+ * 3- build the package hierarchy, based on the original
+ *
+*/
 export declare const generateDevclass: Step<InstallWorkflowContext>;

package/dist/actions/install/generateDevclass.js

@@ -14,11 +14,22 @@ const trm_commons_1 = require("trm-commons");
 const commons_1 = require("../../commons");
 const systemConnector_1 = require("../../systemConnector");
 const stopWarning_1 = require("../stopWarning");
+const defaultTransportLayer_1 = require("./defaultTransportLayer");
+/**
+ * Workflow step that validates target SAP packages and creates any that are missing.
+ *
+ * 1- find packages to generate
+ *
+ * 2- generate missing packages (the default transport layer is resolved only for transportable packages)
+ *
+ * 3- build the package hierarchy, based on the original
+ *
+*/
 exports.generateDevclass = {
     name: 'generate-devclass',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
         if (context.rawInput.installData.installDevclass.keepOriginal || context.runtime.isTrmServer) {
-            trm_commons_1.Logger.log(`Skipping generate devclass devclass (user input)`, true);
+            trm_commons_1.Logger.log(`Skipping generate devclass (user input)`, true);
             return false;
         }
         else {
@@ -26,40 +37,73 @@ exports.generateDevclass = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
-        trm_commons_1.Logger.log('Generate devclass step', true);
-        trm_commons_1.Logger.loading(`Checking ABAP packages...`);
-        var generate = [];
+        var _a, _b, _c;
+        //1- find packages to generated
+        trm_commons_1.Logger.loading(`Checking SAP packages...`);
+        const generate = [];
+        const existing = new Set();
         for (const replacement of context.rawInput.installData.installDevclass.replacements) {
             trm_commons_1.Logger.loading(`Checking existance of devclass ${replacement.installDevclass}...`, true);
             const oDevclass = yield systemConnector_1.SystemConnector.getDevclass(replacement.installDevclass);
             if (oDevclass) {
                 trm_commons_1.Logger.log(`Devclass ${replacement.installDevclass} exists, skipping generation`, true);
+                existing.add(replacement.installDevclass);
+                if (!context.revert.packageHierarchy.some(pkg => pkg.devclass === oDevclass.devclass)) {
+                    context.revert.packageHierarchy.push(oDevclass);
+                }
             }
             else {
                 trm_commons_1.Logger.log(`Devclass ${replacement.installDevclass} doesn't exist, will be generated`, true);
                 generate.push(replacement.installDevclass);
             }
         }
+        if (existing.size > 0) {
+            trm_commons_1.Logger.loading(`Checking objects locks...`);
+            const locks = yield systemConnector_1.SystemConnector.getObjectsLocks(Array.from(existing, devclass => ({
+                PGMID: 'R3TR',
+                OBJECT: 'DEVC',
+                OBJ_NAME: devclass
+            })));
+            if (locks.length > 0) {
+                locks.forEach(lock => {
+                    trm_commons_1.Logger.error(`${lock.pgmid} ${lock.object} ${lock.objName} is currently locked in transport ${lock.trkorr}`, { important: true });
+                });
+                throw new Error(`Install aborted. To continue, all ABAP packages must be released`);
+            }
+            trm_commons_1.Logger.log(`All existing SAP packages released, continue`, true);
+        }
+        //2- generate missing packages
         if (generate.length > 0) {
+            const dlvunit = context.runtime.namespace === '$' ? 'LOCAL' : 'HOME';
+            if (dlvunit !== 'LOCAL' && !context.rawInput.installData.installDevclass.transportLayer) {
+                context.rawInput.installData.installDevclass.transportLayer = yield (0, defaultTransportLayer_1.getDefaultTransportLayer)();
+                trm_commons_1.Logger.log(`Setting transport layer to default: ${context.rawInput.installData.installDevclass.transportLayer}`, true);
+            }
             if (!context.runtime.stopWarningShown) {
                 context.runtime.stopWarningShown = true;
                 (0, stopWarning_1.stopWarning)('install');
             }
-            const dlvunit = context.runtime.installData.namespace === '$' ? 'LOCAL' : 'HOME';
             for (const devclass of generate) {
                 trm_commons_1.Logger.loading(`Creating package ${devclass}...`);
                 const originalDevclass = context.rawInput.installData.installDevclass.replacements.find(o => o.installDevclass === devclass).originalDevclass;
                 trm_commons_1.Logger.log(`Original devclass ${originalDevclass}`, true);
-                const ctext = ((_a = context.runtime.packageTransportsData.tdevct.find(o => o.devclass === originalDevclass)) === null || _a === void 0 ? void 0 : _a.ctext) || `TRM ${context.rawInput.packageData.name}`;
-                yield systemConnector_1.SystemConnector.createPackage({
+                const originalPackageData = (_a = context.runtime.transports.devc.binaries.entries.tdevc) === null || _a === void 0 ? void 0 : _a.find((o) => o.devclass === originalDevclass);
+                if (!originalPackageData) {
+                    throw new Error(`Original TDEVC data for package ${originalDevclass} was not found.`);
+                }
+                const ctext = ((_b = context.runtime.transportEntries.tdevct.find(o => o.devclass === originalDevclass)) === null || _b === void 0 ? void 0 : _b.ctext) || `TRM ${context.rawInput.packageData.name}`;
+                // Track before the mutating await because the package may have been
+                // created even when the connector response fails.
+                if (!context.revert.sapPackages.includes(devclass)) {
+                    context.revert.sapPackages.push(devclass);
+                }
+                yield systemConnector_1.SystemConnector.createPackage((0, commons_1.packageDataFromTdevc)(originalPackageData, {
                     as4user: systemConnector_1.SystemConnector.getLogonUser(),
-                    pdevclass: context.rawInput.installData.installDevclass.transportLayer,
+                    pdevclass: context.rawInput.installData.installDevclass.transportLayer || '',
                     devclass,
                     ctext,
                     dlvunit
-                });
-                context.runtime.generatedData.devclass.push(devclass);
+                }));
                 if (dlvunit !== 'LOCAL') {
                     yield systemConnector_1.SystemConnector.tadirInterface({
                         pgmid: 'R3TR',
@@ -71,15 +115,15 @@ exports.generateDevclass = {
                 }
             }
         }
-        trm_commons_1.Logger.loading(`Updating ABAP packages hierarchy...`);
+        //3- build the package hierarchy, based on the original
+        trm_commons_1.Logger.loading(`Updating SAP packages hierarchy...`);
         const aDummyTdevc = [];
-        var parentcl;
-        const originalPackageHierarchy = (0, commons_1.getPackageHierarchy)(context.runtime.packageTransportsData.tdevc);
+        let parentcl;
         for (const packageReplacement of context.rawInput.installData.installDevclass.replacements) {
             parentcl = '';
-            const originalRoot = originalPackageHierarchy.devclass === packageReplacement.originalDevclass;
+            const originalRoot = context.runtime.package.hierarchy.devclass === packageReplacement.originalDevclass;
             if (!originalRoot) {
-                const originalParentCl = context.runtime.packageTransportsData.tdevc.find(o => o.devclass === packageReplacement.originalDevclass).parentcl;
+                const originalParentCl = (0, commons_1.getParentFromHierarchy)(context.runtime.package.hierarchy, packageReplacement.originalDevclass);
                 if (originalParentCl) {
                     parentcl = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalParentCl).installDevclass;
                 }
@@ -87,11 +131,12 @@ exports.generateDevclass = {
             aDummyTdevc.push({
                 devclass: packageReplacement.installDevclass,
                 parentcl: parentcl,
-                dlvunit: '',
-                tpclass: ''
+                dlvunit: '', // not used
+                tpclass: '' // not used
             });
         }
         const installPackageHierarchy = (0, commons_1.getPackageHierarchy)(aDummyTdevc);
+        //clear all parentcl, except for root
         if (!context.runtime.stopWarningShown) {
             context.runtime.stopWarningShown = true;
             (0, stopWarning_1.stopWarning)('install');
@@ -102,11 +147,12 @@ exports.generateDevclass = {
                 yield systemConnector_1.SystemConnector.clearPackageSuperpackage(packageReplacement.installDevclass);
             }
         }
+        //add parentcl
         for (const packageReplacement of context.rawInput.installData.installDevclass.replacements) {
             const installRoot = installPackageHierarchy.devclass === packageReplacement.installDevclass;
-            const originalParentCl = context.runtime.packageTransportsData.tdevc.find(o => o.devclass === packageReplacement.originalDevclass).parentcl;
+            const originalParentCl = (0, commons_1.getParentFromHierarchy)(context.runtime.package.hierarchy, packageReplacement.originalDevclass);
             if (originalParentCl) {
-                const installParentCl = (_b = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalParentCl)) === null || _b === void 0 ? void 0 : _b.installDevclass;
+                const installParentCl = (_c = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalParentCl)) === null || _c === void 0 ? void 0 : _c.installDevclass;
                 if (installParentCl) {
                     if (!installRoot) {
                         yield systemConnector_1.SystemConnector.setPackageSuperpackage(packageReplacement.installDevclass, installParentCl);

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

@@ -0,0 +1,23 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that creates the landscape transport used to carry installed changes onward.
+ *
+ * 1- generate landscape transport
+ *
+ * 2- add sap packages
+ *
+ * 3- add workbench objects
+ *
+ * 4- add namespace (if generated)
+ *
+ * 5- add translations (if imported)
+ *
+ * 6- add customizing (if imported)
+ *
+ * 7- add comments and documentation
+ *
+ * 8- lock objects
+ *
+*/
+export declare const generateLandscapeTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/generateLandscapeTransport.js

@@ -0,0 +1,136 @@
+"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.generateLandscapeTransport = void 0;
+const trm_commons_1 = require("trm-commons");
+const transport_1 = require("../../transport");
+const manifest_1 = require("../../manifest");
+const systemConnector_1 = require("../../systemConnector");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that creates the landscape transport used to carry installed changes onward.
+ *
+ * 1- generate landscape transport
+ *
+ * 2- add sap packages
+ *
+ * 3- add workbench objects
+ *
+ * 4- add namespace (if generated)
+ *
+ * 5- add translations (if imported)
+ *
+ * 6- add customizing (if imported)
+ *
+ * 7- add comments and documentation
+ *
+ * 8- lock objects
+ *
+*/
+exports.generateLandscapeTransport = {
+    name: 'generate-landscape-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.namespace === '$') {
+            trm_commons_1.Logger.log(`Skipping install transport generation (package is temporary)`, true);
+            return false;
+        }
+        else if (!context.rawInput.installData.landscapeTransport.targetSystem) {
+            trm_commons_1.Logger.log(`Skipping install transport generation (system has no transport targets)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        //1- generate landscape transport
+        trm_commons_1.Logger.loading(`Generating landscape transport...`);
+        context.output.transport = yield transport_1.Transport.createWb({
+            text: `@X1@TRM ${context.runtime.package.data.manifest.name} ${context.runtime.package.data.manifest.version}`,
+            target: context.rawInput.installData.landscapeTransport.targetSystem
+        });
+        //2- add sap packages
+        trm_commons_1.Logger.loading(`Locking transport...`);
+        if (context.rawInput.installData.installDevclass.keepOriginal) {
+            trm_commons_1.Logger.loading(`Including objects from DEVC transport...`, true);
+            yield context.output.transport.addObjectsFromTransport(context.runtime.transports.devc.instance.trkorr);
+        }
+        else {
+            trm_commons_1.Logger.loading(`Adding package replacements...`, true);
+            yield context.output.transport.addObjects(context.rawInput.installData.installDevclass.replacements.map(o => {
+                return {
+                    pgmid: 'R3TR',
+                    object: 'DEVC',
+                    objName: o.installDevclass
+                };
+            }), true);
+        }
+        //3- add workbench objects
+        trm_commons_1.Logger.loading(`Including objects from TADIR transport...`, true);
+        yield context.output.transport.addObjectsFromTransport(context.runtime.transports.tadir.instance.trkorr);
+        //4- add namespace (if generated)
+        //revert namespace is used as the soruce of an actual namespace that was generated
+        //using context.runtime.namespace would be wrong because it's the package namespace, but it doesn't necessarily mean it was generated
+        //check addNamespace step for clarification
+        if (context.revert.namespace) {
+            trm_commons_1.Logger.loading(`Checking namespace ${context.revert.namespace} lock...`, true);
+            const nspcLock = yield systemConnector_1.SystemConnector.getObjectsLocks([{
+                    PGMID: 'R3TR',
+                    OBJECT: 'NSPC',
+                    OBJ_NAME: context.revert.namespace
+                }]);
+            if (nspcLock.length === 0) {
+                trm_commons_1.Logger.loading(`Adding namespace ${context.revert.namespace}...`, true);
+                yield context.output.transport.addObjects([{
+                        pgmid: 'R3TR',
+                        object: 'NSPC',
+                        objName: context.revert.namespace
+                    }], true);
+            }
+            else {
+                const lockTransports = [...new Set(nspcLock.map(o => o.trkorr))].join(', ');
+                trm_commons_1.Logger.warning(`Namespace ${context.revert.namespace} is locked in transport ${lockTransports} and won't be included in the landscape transport.`, { important: true });
+            }
+        }
+        //5- add translations (if imported)
+        if (context.runtime.transports.lang) {
+            trm_commons_1.Logger.loading(`Including objects from LANG transport...`, true);
+            yield context.output.transport.addObjectsFromTransport(context.runtime.transports.lang.instance.trkorr);
+        }
+        //6- add customizing (if imported)
+        trm_commons_1.Logger.loading(`Including objects from ${context.runtime.transports.cust.length} CUST transports...`, true);
+        for (const cust of context.runtime.transports.cust) {
+            yield context.output.transport.addObjectsFromTransport(cust.instance.trkorr);
+        }
+        //7- add comments and documentation
+        yield context.output.transport.removeComments(); //start clean without TRM comments
+        yield context.output.transport.addComment(`name=${context.runtime.package.data.manifest.name}`);
+        yield context.output.transport.addComment(`version=${context.runtime.package.data.manifest.version}`);
+        //if previous package was temporary, don't add deletion entries
+        if ((0, utils_1.isDeletionForwardable)(context)) {
+            //avoiding the transport attribute and CTS dependency (requires a CTS project...)
+            //this is the easy solution
+            //for a clean upgrade, first deletion transport then landscape transport should be imported
+            yield context.output.transport.addComment(`upgrade=${context.revert.dele.trkorr}`);
+        }
+        yield context.output.transport.setDocumentation(new manifest_1.Manifest(context.runtime.package.data.manifest).getAbapXml());
+        //8- lock objects
+        //what is lockable gets locked here
+        //all workbench should be lockable here
+        yield context.output.transport.lock();
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.output.transport && (yield context.output.transport.canBeDeleted())) {
+            yield context.output.transport.delete();
+            context.output.transport = undefined;
+        }
+    })
+};

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

@@ -0,0 +1,20 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export { deleteTemporaryCleanupPackages } from "../commons/utils";
+/**
+ * Whether an upgrade keeps the customizing of the installed release: customizing of the incoming
+ * release is skipped (noCust) or one of its transports was not imported. Deleting the installed
+ * rows would then leave them missing.
+ */
+export declare function keepsInstalledCustomizing(context: InstallWorkflowContext): boolean;
+/**
+ * Workflow step that creates a transport for objects removed by an upgrade.
+ * It's necessary when:
+ *   - upgrading/downgrading a package: to ensure old entries are cleaned up
+ *   - sap packages were changes after upgrade/downgrade: to ensure empty packages are cleaned up
+ * For these reasons, it's not generated on first install.
+ *
+ * The cleanup itself is shared with the uninstall action, which removes the installed
+ * release without an incoming one.
+*/
+export declare const generateUpdateTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/generateUpdateTransport.js

@@ -0,0 +1,122 @@
+"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.generateUpdateTransport = exports.deleteTemporaryCleanupPackages = void 0;
+exports.keepsInstalledCustomizing = keepsInstalledCustomizing;
+const trm_commons_1 = require("trm-commons");
+const stopWarning_1 = require("../stopWarning");
+const transport_1 = require("../../transport");
+const systemConnector_1 = require("../../systemConnector");
+const utils_1 = require("../commons/utils");
+var utils_2 = require("../commons/utils");
+Object.defineProperty(exports, "deleteTemporaryCleanupPackages", { enumerable: true, get: function () { return utils_2.deleteTemporaryCleanupPackages; } });
+function flattenDevclasses(pkg) {
+    return [pkg.devclass, ...pkg.sub.flatMap(flattenDevclasses)];
+}
+/** Table content of the customizing transports the upgrade imports, from their transport entries. */
+function incomingCustomizingRows(context) {
+    var _a;
+    return (((_a = context.runtime.transports) === null || _a === void 0 ? void 0 : _a.cust) || []).flatMap(cust => {
+        var _a;
+        const entries = ((_a = cust.binaries) === null || _a === void 0 ? void 0 : _a.entries) || {};
+        // Registry entries are camel-cased: E071K becomes e071K.
+        const keys = (entries.e071K || entries.e071k || []).map((key) => ({
+            table: (key.objname || key.mastername || '').trim(),
+            tabkey: (key.tabkey || '').trim()
+        }));
+        const wholeTables = (entries.e071 || [])
+            .filter((o) => (o.object || '').trim().toUpperCase() === 'TABU' && (o.objfunc || '').trim().toUpperCase() !== 'K')
+            .map((o) => ({ table: (o.objName || '').trim() }));
+        return [...keys, ...wholeTables];
+    });
+}
+/**
+ * Whether an upgrade keeps the customizing of the installed release: customizing of the incoming
+ * release is skipped (noCust) or one of its transports was not imported. Deleting the installed
+ * rows would then leave them missing.
+ */
+function keepsInstalledCustomizing(context) {
+    var _a, _b;
+    return !!((_b = (_a = context.rawInput.installData) === null || _a === void 0 ? void 0 : _a.import) === null || _b === void 0 ? void 0 : _b.noCust) || (context.runtime.skippedCust || []).length > 0;
+}
+/**
+ * Workflow step that creates a transport for objects removed by an upgrade.
+ * It's necessary when:
+ *   - upgrading/downgrading a package: to ensure old entries are cleaned up
+ *   - sap packages were changes after upgrade/downgrade: to ensure empty packages are cleaned up
+ * For these reasons, it's not generated on first install.
+ *
+ * The cleanup itself is shared with the uninstall action, which removes the installed
+ * release without an incoming one.
+*/
+exports.generateUpdateTransport = {
+    name: 'generate-update-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        //a local (.trm) upgrade generates its deletion transport through the registry the artifact was published to
+        if (context.runtime.update) {
+            return true;
+        }
+        else {
+            trm_commons_1.Logger.log(`Skipping generate deletion transport (first install?)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        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) {
+            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 || [];
+            trm_commons_1.Logger.warning(`Customizing transports are skipped${skipped.length > 0 ? ` (${skipped.join(', ')})` : ''}: the customizing of the installed release is kept.`, { important: true });
+        }
+        yield (0, utils_1.cleanupInstalledPackage)(context, {
+            get incomingObjects() {
+                return context.runtime.transports.tadir.binaries.entries.tadir || [];
+            },
+            get keptDevclasses() {
+                return installDevclass.keepOriginal
+                    ? flattenDevclasses(context.runtime.package.hierarchy)
+                    : installDevclass.replacements.map(replacement => replacement.installDevclass);
+            },
+            prefix: `(${transport_1.Transport.getTransportIcon()}  Upgrade cleanup) `,
+            actionName: 'Update',
+            requireDeletion: false,
+            // Old customizing is deleted before the new customizing is imported: rows the new
+            // release still ships are written again. Without that import, nothing would restore them.
+            keepCustomizing,
+            get incomingCustomizing() {
+                return incomingCustomizingRows(context);
+            }
+        });
+    }),
+    revert: (context) => __awaiter(void 0, 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);
+        yield (0, utils_1.revertInstalledPackageCleanup)(context, restore);
+        // Objects might still be assigned to a staging package if restoring failed or was skipped:
+        // only delete staging packages after a complete restore.
+        if (restore) {
+            yield (0, utils_1.deleteCleanupStagingPackages)(context);
+        }
+    })
+};

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

@@ -0,0 +1,22 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare function deleteImportedEntries(context: InstallWorkflowContext): Promise<void>;
+/**
+ * Workflow step that imports every prepared transport in one TMS batch.
+ *
+ * 1- collect prepared transport instances
+ *
+ * 2- back up imported objects already on the system
+ *
+ * 3- resolve the transport layer of the imported SAP packages
+ *
+ * 4- import transports in batch
+ *
+ * 5- reconnect when system is not stateless
+ *
+ * 6- finalize SAP Packages import
+ *
+ * 7- finalize workbench import
+ *
+ */
+export declare const importBatch: Step<InstallWorkflowContext>;