trm-core 9.10.5 → 10.0.0

package/dist/actions/uninstall/index.js

@@ -0,0 +1,141 @@
+"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.uninstall = uninstall;
+exports.uninstallWithRollback = uninstallWithRollback;
+const commons_1 = require("../commons");
+const utils_1 = require("../commons/utils");
+const init_1 = require("./init");
+const checkDependants_1 = require("./checkDependants");
+const uninstallNestedPackages_1 = require("./uninstallNestedPackages");
+const lockResources_1 = require("./lockResources");
+const generateDeletionTransport_1 = require("./generateDeletionTransport");
+const removePackageData_1 = require("./removePackageData");
+const forwardDeletionTransport_1 = require("./forwardDeletionTransport");
+;
+const WORKFLOW_NAME = 'uninstall';
+/**
+ * Uninstalls a TRM package from the currently connected SAP system.
+ *
+ * This is the opposite of {@link install}: the workflow authorizes the user, checks that no
+ * installed package depends on it, removes the objects of the installed release through a
+ * registry-generated deletion transport, forwards that transport to the landscape target
+ * system so the package is uninstalled there too, and removes the TRM package record. The object
+ * cleanup is the same performed when an install upgrades a package, with no incoming release.
+ * Other TRM packages installed in its SAP packages, at any depth, are uninstalled first by the same
+ * action, with the same options.
+ * Completed reversible steps are rolled back when a later step fails.
+ *
+ * This operation changes the target SAP system. Do not interrupt it while transports are being
+ * generated, imported, or released.
+ *
+ * @param inputData Package identity, registry, and uninstall options.
+ * @returns The uninstalled release manifest, the imported deletion transport, and the landscape
+ * target it was forwarded to.
+ * @throws When authorization, dependants check, deletion transport processing, or the
+ * package record removal fails.
+ */
+function uninstall(inputData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield runUninstall(inputData, false, [])).output;
+    });
+}
+const uninstallWorkflow = [
+    commons_1.checkServerAuth,
+    commons_1.setSystemPackages,
+    init_1.init,
+    checkDependants_1.checkDependants,
+    uninstallNestedPackages_1.uninstallNestedPackages,
+    lockResources_1.lockResources,
+    generateDeletionTransport_1.generateDeletionTransport,
+    forwardDeletionTransport_1.forwardDeletionTransport,
+    removePackageData_1.removePackageData
+];
+function runUninstall(inputData, retainRollback, uninstallingPackages, parentLockScope) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // A nested uninstall locks in its parent scope: the parent cleanup locks the same SAP packages
+        // and objects again, and the parent releases them all once it has finished.
+        const lockScope = parentLockScope || new utils_1.ActionLockScope(WORKFLOW_NAME);
+        const context = { rawInput: inputData, lockScope, uninstallingPackages };
+        yield lockScope.acquire([(0, utils_1.packageLockResource)(inputData.packageData.registry, inputData.packageData.name)]);
+        const release = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let firstError;
+            for (const releaseNested of [...(((_a = context.runtime) === null || _a === void 0 ? void 0 : _a.nestedReleases) || [])].reverse()) {
+                try {
+                    yield releaseNested();
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+            }
+            if (!parentLockScope) {
+                try {
+                    yield lockScope.release();
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+            }
+            if (firstError)
+                throw firstError;
+        });
+        if (!retainRollback) {
+            return (0, utils_1.withLockRelease)(release, () => __awaiter(this, void 0, void 0, function* () {
+                const result = yield (0, commons_1.executeWorkflow)(WORKFLOW_NAME, uninstallWorkflow, context, commons_1.workflowCallbacks);
+                return { output: result.output };
+            }));
+        }
+        let retained;
+        try {
+            retained = yield (0, utils_1.executeRetainedWorkflow)(WORKFLOW_NAME, uninstallWorkflow, context, commons_1.workflowCallbacks);
+        }
+        catch (error) {
+            yield (0, utils_1.releaseLogged)(release);
+            throw error;
+        }
+        // The locks stay held until the parent calls release (or rollback).
+        return {
+            output: retained.context.output,
+            release,
+            rollback: () => __awaiter(this, void 0, void 0, function* () {
+                let firstError;
+                try {
+                    yield retained.rollback();
+                }
+                catch (error) {
+                    firstError = error;
+                }
+                try {
+                    yield release();
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+                if (firstError)
+                    throw firstError;
+            })
+        };
+    });
+}
+/**
+ * Internal transactional entry point used when a parent uninstall must retain rollback ownership:
+ * the package is uninstalled, its locks stay held until `release`, and `rollback` restores it.
+ *
+ * @param uninstallingPackages Other packages uninstalled by the same run, ignored as dependants.
+ * @param parentLockScope Lock scope of the parent uninstall: its locks are taken in it and released by the parent.
+ */
+function uninstallWithRollback(inputData, uninstallingPackages, parentLockScope) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const retained = yield runUninstall(inputData, true, uninstallingPackages, parentLockScope);
+        return { output: retained.output, rollback: retained.rollback, release: retained.release };
+    });
+}

package/dist/actions/uninstall/init.d.ts

@@ -0,0 +1,17 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { UninstallWorkflowContext } from ".";
+/**
+ * Workflow step that finds the installed package and initializes rollback state.
+ *
+ * 1- fill missing input data
+ *
+ * 2- find installed package and its TRM packages table record
+ *
+ * 3- check if package can be deleted
+ *
+ * 4- check/set system target
+ *
+ * 5- fill context data, including the TRM packages installed under the uninstalled one
+ *
+*/
+export declare const init: Step<UninstallWorkflowContext>;

package/dist/actions/uninstall/init.js

@@ -0,0 +1,146 @@
+"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.init = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const registry_1 = require("../../registry");
+const trmPackage_1 = require("../../trmPackage");
+const prompts_1 = require("../commons/prompts");
+const uninstallNestedPackages_1 = require("./uninstallNestedPackages");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that finds the installed package and initializes rollback state.
+ *
+ * 1- fill missing input data
+ *
+ * 2- find installed package and its TRM packages table record
+ *
+ * 3- check if package can be deleted
+ *
+ * 4- check/set system target
+ *
+ * 5- fill context data, including the TRM packages installed under the uninstalled one
+ *
+*/
+exports.init = {
+    name: 'init',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const registry = context.rawInput.packageData.registry;
+        //1- fill missing input data
+        if (!context.rawInput.uninstallData) {
+            context.rawInput.uninstallData = {};
+        }
+        if (!context.rawInput.uninstallData.checks) {
+            context.rawInput.uninstallData.checks = {};
+        }
+        if (!context.rawInput.uninstallData.landscapeTransport) {
+            context.rawInput.uninstallData.landscapeTransport = {};
+        }
+        //2- find installed package
+        //the registry generates the deletion transport
+        if (registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
+            throw new Error(`Uninstall aborted. Deletion transports can't be generated from a local registry.`);
+        }
+        const installed = context.rawInput.contextData.systemPackages.find(o => o.manifest
+            && trmPackage_1.TrmPackage.compare(o, new trmPackage_1.TrmPackage(context.rawInput.packageData.name, registry)));
+        if (!installed) {
+            throw new Error(`Package ${context.rawInput.packageData.name} is not installed in ${systemConnector_1.SystemConnector.getDest()}.`);
+        }
+        // Without its TRM packages table row the record would survive the uninstall:
+        // the row is missing when the backend read failed, so read it again before changing anything.
+        if (!installed.getMetadataSnapshot()) {
+            trm_commons_1.Logger.loading(`Reading TRM data...`, true);
+            const snapshot = (_a = (yield systemConnector_1.SystemConnector.getInstalledPackages(true)).find(o => o.manifest
+                && trmPackage_1.TrmPackage.compare(o, installed))) === null || _a === void 0 ? void 0 : _a.getMetadataSnapshot();
+            if (!snapshot) {
+                throw new Error(`Uninstall aborted. The TRM packages table record of ${context.rawInput.packageData.name} could not be read from ${systemConnector_1.SystemConnector.getDest()}.`);
+            }
+            installed.setMetadataSnapshot(snapshot);
+        }
+        //3- check if package can be deleted
+        if (registry.getRegistryType() === registry_1.RegistryType.PUBLIC
+            && (installed.packageName === systemConnector_1.TRM_SERVER_PACKAGE_NAME || installed.packageName === systemConnector_1.TRM_REST_PACKAGE_NAME)) {
+            throw new Error(`Uninstall aborted. ${installed.packageName} is required by TRM and can't be uninstalled.`);
+        }
+        //4- read install data
+        //install mappings are queried case-sensitively: use the stored name and registry, not the input
+        const previousInstallPackages = yield systemConnector_1.SystemConnector.getInstallPackages(installed.packageName, installed.registry);
+        const previousInstallTransports = yield systemConnector_1.SystemConnector.getInstallTransports(installed.packageName, installed.registry);
+        const nestedPackages = yield (0, uninstallNestedPackages_1.getNestedPackages)(context.rawInput.contextData.systemPackages, installed, previousInstallPackages.map(replacement => replacement.installDevclass));
+        //5- dirty check: changes still being edited would fail the cleanup objects lock check,
+        //so check them before asking anything
+        const allDirtyEntries = yield (0, utils_1.withoutOwnTrmTransports)(installed.getDirtyEntries(), installed.packageName);
+        if (allDirtyEntries.length > 0) {
+            trm_commons_1.Logger.loading(`Checking changed objects locks...`, true);
+            const locks = yield (0, utils_1.getInstalledObjectsLocks)(installed, previousInstallPackages, context.rawInput.contextData.systemPackages, allDirtyEntries);
+            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(`Uninstall aborted. To continue, all cleanup objects and SAP packages must be released`);
+            }
+        }
+        //the TRM packages installed under it confirm their own changes
+        const dirtyEntries = yield (0, uninstallNestedPackages_1.withoutNestedDirtyEntries)(allDirtyEntries, nestedPackages.all);
+        if (dirtyEntries.length > 0 && !context.rawInput.uninstallData.checks.ignoreDirty) {
+            const reason = `${context.rawInput.packageData.name} has changes made on ${systemConnector_1.SystemConnector.getDest()} that will be deleted`;
+            trm_commons_1.Logger.warning(`${reason}!`);
+            (0, utils_1.logDirtyEntries)(dirtyEntries);
+            if (context.rawInput.contextData.noInquirer) {
+                throw new Error(`Uninstall aborted. ${reason}: set the ignoreDirty check to uninstall it without prompts.`);
+            }
+            const { ignoreDirty } = yield trm_commons_1.Inquirer.prompt({
+                message: `Continue with uninstall?`,
+                type: 'confirm',
+                default: false,
+                name: 'ignoreDirty'
+            });
+            if (!ignoreDirty) {
+                throw new Error(`Uninstall aborted. ${reason}.`);
+            }
+        }
+        else if (dirtyEntries.length > 0) {
+            trm_commons_1.Logger.warning(`${context.rawInput.packageData.name} has changes made on ${systemConnector_1.SystemConnector.getDest()} that will be deleted!`, { important: true });
+            (0, utils_1.logDirtyEntries)(dirtyEntries);
+        }
+        //6- check/set system target
+        //objects of a temporary package only exist on this system
+        if (!(installed.getDevclass() || '').trim().startsWith('$')) {
+            context.rawInput.uninstallData.landscapeTransport.targetSystem = yield (0, prompts_1.setLandscapeTarget)(context.rawInput.contextData.noInquirer, context.rawInput.uninstallData.landscapeTransport.targetSystem, "Deletion transport target", "Deletion transport won't be forwarded.");
+        }
+        //7- fill context data
+        context.runtime = {
+            update: installed,
+            previousInstallPackages,
+            previousInstallTransports,
+            dele: undefined,
+            stopWarningShown: false,
+            nestedPackages,
+            nestedRollbacks: [],
+            nestedReleases: [],
+            deletedObjects: []
+        };
+        context.output = {
+            manifest: installed.manifest.get(),
+            transport: undefined,
+            targetSystem: undefined
+        };
+        context.revert = {
+            sapPackages: [],
+            dele: undefined,
+            deleImportStarted: false,
+            deleInTargetTms: false,
+            metadataRemoveStarted: false,
+            metadataPreviousPackageRow: undefined
+        };
+        trm_commons_1.Logger.info(`Ready to uninstall ${installed.packageName} v${installed.manifest.get().version}.`);
+    })
+};

package/dist/actions/uninstall/lockResources.d.ts

@@ -0,0 +1,4 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { UninstallWorkflowContext } from ".";
+/** Lock the installed SAP packages and transport before the deletion selection is computed. */
+export declare const lockResources: Step<UninstallWorkflowContext>;

package/dist/actions/{publish/setTransportTarget.js → uninstall/lockResources.js}

@@ -9,13 +9,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setTransportTarget = void 0;
-const trm_commons_1 = require("trm-commons");
-const prompts_1 = require("../commons/prompts");
-exports.setTransportTarget = {
-    name: 'set-transport-target',
+exports.lockResources = void 0;
+/** Lock the installed SAP packages and transport before the deletion selection is computed. */
+exports.lockResources = {
+    name: "lock-resources",
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Set transport target step', true);
-        context.rawInput.systemData.transportTarget = yield (0, prompts_1.setTransportTarget)(context.rawInput.contextData.noInquirer, context.runtime.systemData.transportTargets, context.rawInput.systemData.transportTarget, "Publish transport target");
+        var _a;
+        const resources = [];
+        for (const previous of context.runtime.previousInstallPackages || []) {
+            resources.push({ type: "DEVCLASS", name: previous.installDevclass });
+        }
+        if (context.runtime.update.getDevclass()) {
+            resources.push({ type: "DEVCLASS", name: context.runtime.update.getDevclass() });
+        }
+        if ((_a = context.runtime.update.getTransport()) === null || _a === void 0 ? void 0 : _a.trkorr) {
+            resources.push({ type: "TRANSPORT", name: context.runtime.update.getTransport().trkorr });
+        }
+        yield context.lockScope.acquire(resources);
     })
 };

package/dist/actions/uninstall/removePackageData.d.ts

@@ -0,0 +1,9 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { UninstallWorkflowContext } from ".";
+/**
+ * Workflow step that removes the uninstalled package from the target system's TRM package table.
+ *
+ * Removes the record in TRM packages table, its install devclass mappings and install transports
+ *
+*/
+export declare const removePackageData: Step<UninstallWorkflowContext>;

package/dist/actions/uninstall/removePackageData.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.removePackageData = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+/**
+ * Workflow step that removes the uninstalled package from the target system's TRM package table.
+ *
+ * Removes the record in TRM packages table, its install devclass mappings and install transports
+ *
+*/
+exports.removePackageData = {
+    name: 'remove-package-data',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        // init reads the record before anything is deleted: never skip its removal.
+        const snapshot = context.runtime.update.getMetadataSnapshot();
+        if (!snapshot) {
+            throw new Error(`TRM packages table record of ${context.runtime.update.packageName} is missing: it can't be removed.`);
+        }
+        trm_commons_1.Logger.loading(`Updating TRM data...`);
+        context.revert.metadataPreviousPackageRow = snapshot;
+        // Mark before the mutating await: SAP may commit the removal and still
+        // fail while returning the response.
+        context.revert.metadataRemoveStarted = true;
+        yield systemConnector_1.SystemConnector.restoreInstallMetadata({
+            package: context.revert.metadataPreviousPackageRow,
+            packageExists: false,
+            installDevc: [],
+            installTr: []
+        });
+        trm_commons_1.Logger.success(`${context.runtime.update.packageName} deleted from ${systemConnector_1.SystemConnector.getDest()}.`);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.revert.metadataRemoveStarted) {
+            return;
+        }
+        const previousRow = context.revert.metadataPreviousPackageRow;
+        yield systemConnector_1.SystemConnector.restoreInstallMetadata({
+            package: previousRow,
+            packageExists: true,
+            installDevc: context.runtime.previousInstallPackages.map(replacement => ({
+                package_name: previousRow.package_name,
+                package_registry: previousRow.package_registry,
+                original_devclass: replacement.originalDevclass,
+                install_devclass: replacement.installDevclass
+            })),
+            installTr: (context.runtime.previousInstallTransports || []).map(transport => ({
+                package_name: previousRow.package_name,
+                package_registry: previousRow.package_registry,
+                trkorr: transport.trkorr,
+                trm_type: transport.trmType
+            }))
+        });
+    })
+};

package/dist/actions/uninstall/uninstallNestedPackages.d.ts

@@ -0,0 +1,26 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import type { UninstallWorkflowContext } from ".";
+import { TrmPackage } from "../../trmPackage";
+import { ZTRM_DIRTY } from "../../client";
+/**
+ * Other TRM packages installed in the SAP packages of the uninstalled one, at any depth: the first
+ * list holds the outermost ones, whose uninstall removes the packages installed under them.
+ */
+export declare function getNestedPackages(systemPackages: TrmPackage[], installed: TrmPackage, installDevclasses: string[]): Promise<{
+    outermost: TrmPackage[];
+    all: TrmPackage[];
+}>;
+/**
+ * Dirty entries of the uninstalled package that belong to the TRM packages installed under it:
+ * their installs (landscape transports) and their own changes, which their uninstall confirms.
+ */
+export declare function withoutNestedDirtyEntries(entries: ZTRM_DIRTY[], nested: TrmPackage[]): Promise<ZTRM_DIRTY[]>;
+/**
+ * Workflow step that deletes the TRM packages installed in the SAP packages of the uninstalled one.
+ *
+ * Their SAP packages are deleted with the package anyway: running the uninstall action for each
+ * also removes their customizing and records, and forwards their deletion. Their rollbacks are
+ * retained, so a later failure restores them too.
+ *
+*/
+export declare const uninstallNestedPackages: Step<UninstallWorkflowContext>;

package/dist/actions/uninstall/uninstallNestedPackages.js

@@ -0,0 +1,174 @@
+"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.uninstallNestedPackages = void 0;
+exports.getNestedPackages = getNestedPackages;
+exports.withoutNestedDirtyEntries = withoutNestedDirtyEntries;
+const trm_commons_1 = require("trm-commons");
+const _1 = require(".");
+const systemConnector_1 = require("../../systemConnector");
+const utils_1 = require("../commons/utils");
+const transport_1 = require("../../transport");
+function normalize(value) {
+    return value.trim().toUpperCase();
+}
+/**
+ * Other TRM packages installed in the SAP packages of the uninstalled one, at any depth: the first
+ * list holds the outermost ones, whose uninstall removes the packages installed under them.
+ */
+function getNestedPackages(systemPackages, installed, installDevclasses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const roots = new Set(installDevclasses);
+        if (installed.getDevclass()) {
+            roots.add(installed.getDevclass());
+        }
+        const subtree = new Set(Array.from(roots, normalize));
+        const parents = new Map();
+        for (const devclass of roots) {
+            for (const subpackage of yield systemConnector_1.SystemConnector.getSubpackages(devclass)) {
+                subtree.add(normalize(subpackage.devclass));
+                if (subpackage.parentcl) {
+                    parents.set(normalize(subpackage.devclass), normalize(subpackage.parentcl));
+                }
+            }
+        }
+        const all = (0, utils_1.getPackagesInstalledIn)(systemPackages, installed, subtree);
+        const nestedDevclasses = new Set(all.map(pkg => normalize(pkg.getDevclass())));
+        const outermost = all.filter(pkg => {
+            const visited = new Set();
+            let parent = parents.get(normalize(pkg.getDevclass()));
+            while (parent && !visited.has(parent)) {
+                if (nestedDevclasses.has(parent)) {
+                    return false;
+                }
+                visited.add(parent);
+                parent = parents.get(parent);
+            }
+            return true;
+        });
+        return { outermost, all };
+    });
+}
+/**
+ * Dirty entries of the uninstalled package that belong to the TRM packages installed under it:
+ * their installs (landscape transports) and their own changes, which their uninstall confirms.
+ */
+function withoutNestedDirtyEntries(entries, nested) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (entries.length === 0 || nested.length === 0) {
+            return entries;
+        }
+        const nestedNames = new Set(nested.map(pkg => pkg.packageName));
+        const nestedEntries = new Set(nested.flatMap(pkg => pkg.getDirtyEntries())
+            .map(o => `${o.trkorr}|${o.pgmid}|${o.object}|${o.objName}`));
+        const nestedTransports = new Set();
+        for (const trkorr of new Set(entries.map(o => o.trkorr))) {
+            if (nestedNames.has(yield new transport_1.Transport(trkorr).getTrmPackageName())) {
+                nestedTransports.add(trkorr);
+            }
+        }
+        return entries.filter(o => !nestedTransports.has(o.trkorr)
+            && !nestedEntries.has(`${o.trkorr}|${o.pgmid}|${o.object}|${o.objName}`));
+    });
+}
+/**
+ * Workflow step that deletes the TRM packages installed in the SAP packages of the uninstalled one.
+ *
+ * Their SAP packages are deleted with the package anyway: running the uninstall action for each
+ * also removes their customizing and records, and forwards their deletion. Their rollbacks are
+ * retained, so a later failure restores them too.
+ *
+*/
+exports.uninstallNestedPackages = {
+    name: 'uninstall-nested-packages',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.nestedPackages.all.length === 0) {
+            trm_commons_1.Logger.log(`Skipping nested packages uninstall (no TRM packages installed under ${context.runtime.update.packageName})`, true);
+            return false;
+        }
+        return true;
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const { outermost, all } = context.runtime.nestedPackages;
+        const nestedMessage = `${all.length} TRM package(s) installed in the SAP packages of ${context.runtime.update.packageName} will be deleted too: ${all.map(pkg => pkg.packageName).join(', ')}`;
+        trm_commons_1.Logger.warning(`${nestedMessage}.`, { important: true });
+        // Deleting other TRM packages is destructive: ask first (without prompts the warning stands).
+        if (!context.rawInput.contextData.noInquirer) {
+            const { uninstallNested } = yield trm_commons_1.Inquirer.prompt({
+                name: 'uninstallNested',
+                type: 'confirm',
+                message: `${nestedMessage}. Continue?`,
+                default: false
+            });
+            if (!uninstallNested) {
+                throw new Error(`Uninstall aborted.`);
+            }
+        }
+        const uninstallingPackages = [...(context.uninstallingPackages || []), context.runtime.update, ...all];
+        const originalLPrefix = trm_commons_1.Logger.getPrefix();
+        const originalIPrefix = trm_commons_1.Inquirer.getPrefix();
+        let counter = 0;
+        for (const nested of outermost) {
+            counter++;
+            const prefix = `(${counter}/${outermost.length}) `;
+            try {
+                trm_commons_1.Logger.setPrefix(originalLPrefix ? `${originalLPrefix}-> ${prefix}` : `  ${prefix}`);
+                trm_commons_1.Inquirer.setPrefix(originalIPrefix ? `${originalIPrefix}-> ${prefix}` : `  ${prefix}`);
+                trm_commons_1.Logger.loading(`Getting ready to uninstall nested package "${nested.packageName}"...`);
+                const result = yield (0, _1.uninstallWithRollback)({
+                    contextData: {
+                        noInquirer: context.rawInput.contextData.noInquirer,
+                        systemPackages: [...context.rawInput.contextData.systemPackages]
+                    },
+                    packageData: {
+                        name: nested.packageName,
+                        registry: nested.registry
+                    },
+                    uninstallData: {
+                        checks: Object.assign({}, context.rawInput.uninstallData.checks),
+                        landscapeTransport: Object.assign({}, context.rawInput.uninstallData.landscapeTransport)
+                    }
+                }, uninstallingPackages.filter(pkg => pkg !== nested), context.lockScope);
+                context.runtime.nestedRollbacks.push(result.rollback);
+                context.runtime.nestedReleases.push(result.release);
+                // The SAP buffers may still list them: the cleanup of this package must not delete them again.
+                if (result.output.transport) {
+                    context.runtime.deletedObjects = [
+                        ...(context.runtime.deletedObjects || []),
+                        ...(yield result.output.transport.getE071()).filter(object => object.pgmid !== '*')
+                    ];
+                }
+            }
+            finally {
+                trm_commons_1.Logger.setPrefix(originalLPrefix);
+                trm_commons_1.Inquirer.setPrefix(originalIPrefix);
+            }
+        }
+        // The cleanup must not see them as installed anymore.
+        context.rawInput.contextData.systemPackages = context.rawInput.contextData.systemPackages
+            .filter(pkg => !all.includes(pkg));
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        let firstError;
+        for (const rollback of [...(context.runtime.nestedRollbacks || [])].reverse()) {
+            try {
+                yield rollback();
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        context.runtime.nestedRollbacks = [];
+        if (firstError) {
+            throw firstError;
+        }
+    })
+};

package/dist/client/ClientError.d.ts

@@ -2,6 +2,8 @@ import { SapMessage } from "./SapMessage";
 export declare class ClientError extends Error {
     exceptionType: string;
     sapMessage: SapMessage;
+    resource?: string;
     messageError?: string;
-    constructor(exceptionType: string, sapMessage: SapMessage, message?: string);
+    messageLog?: string[];
+    constructor(exceptionType: string, sapMessage: SapMessage, message?: string, resource?: string);
 }

package/dist/client/ClientError.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientError = void 0;
 class ClientError extends Error {
-    constructor(exceptionType, sapMessage, message) {
+    constructor(exceptionType, sapMessage, message, resource) {
         super(message);
         this.exceptionType = exceptionType;
         this.sapMessage = sapMessage;
+        this.resource = resource;
         this.name = 'ClientError';
         Object.setPrototypeOf(this, new.target.prototype);
     }