trm-core 9.10.5 → 10.0.0

package/dist/actions/install/lockResources.js

@@ -0,0 +1,100 @@
+"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.lockResources = void 0;
+const trm_commons_1 = require("trm-commons");
+const utils_1 = require("../commons/utils");
+const addNamespace_1 = require("./addNamespace");
+const checkTransports_1 = require("./checkTransports");
+function objectKey(object) {
+    return `${object.pgmid.trim().toUpperCase()} ${object.object.trim().toUpperCase()} ${object.objName.trim().toUpperCase()}`;
+}
+/**
+ * Lock the selected import payload, its resolved target packages and its custom namespace before
+ * dependencies mutate SAP, then repeat the safety checks of check-transports that another action
+ * could have invalidated before the locks were held.
+ */
+exports.lockResources = {
+    name: "lock-resources",
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const replacements = new Map((context.rawInput.installData.installDevclass.replacements || [])
+            .map(row => [row.originalDevclass.trim().toUpperCase(), row.installDevclass.trim().toUpperCase()]));
+        const resources = [];
+        resources.push((0, utils_1.packageLockResource)(context.runtime.installRegistry, context.runtime.package.data.manifest.name));
+        for (const target of replacements.values()) {
+            resources.push({ type: "DEVCLASS", name: target });
+        }
+        for (const previous of context.runtime.previousInstallPackages || []) {
+            resources.push({ type: "DEVCLASS", name: previous.installDevclass });
+        }
+        //a namespace held by a parent install stays locked until that install finishes
+        const namespace = (0, addNamespace_1.getInstallNamespace)(context).trim().toUpperCase();
+        const inheritedNamespaces = (context.inheritedNamespaceLocks || []).map(o => o.trim().toUpperCase());
+        context.runtime.lockedNamespaces = [...inheritedNamespaces];
+        if (namespace.startsWith('/') && !inheritedNamespaces.includes(namespace)) {
+            resources.push({ type: "NAMESPACE", name: namespace });
+            context.runtime.lockedNamespaces.push(namespace);
+        }
+        const slots = [
+            context.runtime.transports.devc,
+            context.runtime.transports.tadir,
+            context.runtime.transports.lang,
+            ...(context.runtime.transports.cust || [])
+        ].filter(Boolean);
+        for (const slot of slots) {
+            if ((_a = slot.binaries) === null || _a === void 0 ? void 0 : _a.trkorr) {
+                resources.push({ type: "TRANSPORT", name: slot.binaries.trkorr });
+            }
+            // TRM comment rows (pgmid *, e.g. "version=1.0.0") are not objects: every package has them,
+            // so a dependency would collide with the lock its parent install holds.
+            for (const entry of (((_c = (_b = slot.binaries) === null || _b === void 0 ? void 0 : _b.entries) === null || _c === void 0 ? void 0 : _c.e071) || []).filter(entry => entry.pgmid.trim() !== '*')) {
+                const original = entry.objName.trim().toUpperCase();
+                const target = entry.pgmid.trim().toUpperCase() === "R3TR" && entry.object.trim().toUpperCase() === "DEVC"
+                    ? replacements.get(original) || original
+                    : original;
+                resources.push((0, utils_1.objectLockResource)(Object.assign(Object.assign({}, entry), { objName: target })));
+                if (entry.pgmid.trim().toUpperCase() === "R3TR" && entry.object.trim().toUpperCase() === "DEVC") {
+                    resources.push({ type: "DEVCLASS", name: target });
+                }
+            }
+            for (const object of ((_e = (_d = slot.binaries) === null || _d === void 0 ? void 0 : _d.entries) === null || _e === void 0 ? void 0 : _e.tadir) || []) {
+                const original = object.objName.trim().toUpperCase();
+                const target = object.pgmid.trim().toUpperCase() === "R3TR" && object.object.trim().toUpperCase() === "DEVC"
+                    ? replacements.get(original) || original
+                    : original;
+                resources.push((0, utils_1.objectLockResource)(Object.assign(Object.assign({}, object), { objName: target })));
+            }
+        }
+        const root = context.runtime.package.hierarchy.devclass.trim().toUpperCase();
+        resources.push({ type: "DEVCLASS", name: replacements.get(root) || root });
+        yield context.lockScope.acquire(resources);
+        //the checks ran before the locks were held: repeat those another action could invalidate
+        const e071 = slots.flatMap(slot => { var _a, _b; return ((_b = (_a = slot.binaries) === null || _a === void 0 ? void 0 : _a.entries) === null || _b === void 0 ? void 0 : _b.e071) || []; });
+        const tadir = slots.flatMap(slot => { var _a, _b; return ((_b = (_a = slot.binaries) === null || _a === void 0 ? void 0 : _a.entries) === null || _b === void 0 ? void 0 : _b.tadir) || []; });
+        trm_commons_1.Logger.loading(`Checking objects locks...`, true);
+        yield (0, checkTransports_1.checkObjectsLocks)(e071);
+        trm_commons_1.Logger.loading(`Checking objects existence...`, true);
+        const accepted = new Set((context.runtime.existingObjects || []).map(objectKey));
+        const checkedTadir = (0, checkTransports_1.existenceCheckObjects)(tadir);
+        const appeared = (checkedTadir.length > 0 ? yield (0, checkTransports_1.findExistingObjects)(context, checkedTadir) : []).filter(o => !accepted.has(objectKey(o)));
+        if (appeared.length > 0) {
+            const noExistingObjects = (_f = context.rawInput.installData.checks) === null || _f === void 0 ? void 0 : _f.noExistingObjects;
+            appeared.forEach(o => {
+                const message = `${o.pgmid} ${o.object} ${o.objName} was created on the target system during the install checks`;
+                noExistingObjects ? trm_commons_1.Logger.warning(message, { important: true }) : trm_commons_1.Logger.error(message, { important: true });
+            });
+            if (!noExistingObjects) {
+                throw new Error(`Install aborted: ${appeared.length} object(s) were created on the target system during the install checks.`);
+            }
+        }
+    })
+};

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

@@ -0,0 +1,13 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that prepares and test-imports each customizing transport.
+ *
+ * 1- generate dummy transport (if registry is not local)
+ *
+ * 2- upload transport binaries
+ *
+ * 3- test import transport
+ *
+*/
+export declare const prepareCust: Step<InstallWorkflowContext>;

package/dist/actions/install/prepareCust.js

@@ -0,0 +1,138 @@
+"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.prepareCust = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+const stopWarning_1 = require("../stopWarning");
+const utils_1 = require("../commons/utils");
+const importBatch_1 = require("./importBatch");
+/**
+ * Workflow step that prepares and test-imports each customizing transport.
+ *
+ * 1- generate dummy transport (if registry is not local)
+ *
+ * 2- upload transport binaries
+ *
+ * 3- test import transport
+ *
+*/
+exports.prepareCust = {
+    name: 'prepare-cust',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.import.noCust) {
+            trm_commons_1.Logger.log(`Skipping import CUST transport (user input)`, true);
+            return false;
+        }
+        else {
+            if (context.runtime.transports.cust.length > 0) {
+                return true;
+            }
+            else {
+                trm_commons_1.Logger.log(`Skipping import CUST transport (no transports in package)`, true);
+                return false;
+            }
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.runtime.stopWarningShown) {
+            context.runtime.stopWarningShown = true;
+            (0, stopWarning_1.stopWarning)('install');
+        }
+        let index = 0;
+        for (const cust of context.runtime.transports.cust) {
+            index++;
+            const prefix = `(${transport_1.Transport.getTransportIcon()}  ${index}/${context.runtime.transports.cust.length} Customizing) `;
+            yield (0, utils_1.withScopedPrefix)(prefix, () => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                //1- generate dummy transport (if registry is not local)
+                //checking if binaries are already loaded in context instead of checking registry local
+                //is equivalent, but better for possible changes in the future
+                //binaries for local registry are loaded in the checkTransports step
+                let trkorr;
+                if (!cust.binaries.binaries) {
+                    trm_commons_1.Logger.loading(`Generating transport...`);
+                    const dummy = yield transport_1.Transport.createToc({
+                        text: ((_a = context.runtime.package.data.transports.find(o => o.trkorr === cust.binaries.trkorr)) === null || _a === void 0 ? void 0 : _a.description) || `CUST ${index} ${context.rawInput.packageData.name}`,
+                        target: systemConnector_1.SystemConnector.getDest(),
+                        trmIdentifier: transport_1.TrmTransportIdentifier.CUST
+                    });
+                    context.revert.createdTransports.cust.push(dummy);
+                    yield dummy.release(false, true);
+                    try {
+                        //saving dummy binaries for a possible revert
+                        context.revert.transports.cust.push({
+                            trkorr: dummy.trkorr,
+                            entries: undefined,
+                            binaries: (yield dummy.download()).binaries
+                        });
+                    }
+                    catch (e) {
+                        trm_commons_1.Logger.error(`Unable to dowload dummy transport!`, true);
+                        trm_commons_1.Logger.error(e.toString(), true);
+                        trm_commons_1.Logger.error(`On failure, revert won't be possible!`, true);
+                    }
+                    cust.binaries.binaries = yield context.rawInput.packageData.registry.transport(cust.binaries.trkorr, dummy.trkorr);
+                    trkorr = dummy.trkorr;
+                }
+                else {
+                    trkorr = cust.binaries.trkorr;
+                }
+                //2- upload transport binaries
+                trm_commons_1.Logger.loading(`Uploading transport...`);
+                cust.instance = yield transport_1.Transport.upload(trkorr, {
+                    binary: cust.binaries.binaries,
+                    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.`);
+                }
+            }));
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.revert.cleanupImported && (context.revert.namespace || context.revert.sapPackages.length > 0)) {
+            yield (0, importBatch_1.deleteImportedEntries)(context);
+        }
+        if (context.revert.cleanupImported && !context.revert.cleanupSucceeded) {
+            return;
+        }
+        // Each customizing transport is independent: attempt all of them, then surface the first failure.
+        let firstError;
+        for (const cust of [...context.revert.transports.cust].reverse()) {
+            const generated = context.revert.createdTransports.cust.find(transport => transport.trkorr === cust.trkorr);
+            try {
+                yield (0, utils_1.revertPreparedTransport)(generated, cust);
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        for (const generated of [...context.revert.createdTransports.cust].reverse()) {
+            const hasSnapshot = context.revert.transports.cust.some(snapshot => snapshot.trkorr === generated.trkorr);
+            if (!hasSnapshot) {
+                try {
+                    yield (0, utils_1.revertPreparedTransport)(generated, undefined);
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    })
+};

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

@@ -0,0 +1,15 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that prepares and test-imports ABAP package definitions.
+ *
+ * 1- read if root already exists in system
+ *
+ * 2- generate dummy transport (if registry is not local)
+ *
+ * 3- upload transport binaries
+ *
+ * 4- test import transport
+ *
+*/
+export declare const prepareDevc: Step<InstallWorkflowContext>;

package/dist/actions/install/prepareDevc.js

@@ -0,0 +1,113 @@
+"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.prepareDevc = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+const stopWarning_1 = require("../stopWarning");
+const utils_1 = require("../commons/utils");
+const importBatch_1 = require("./importBatch");
+/**
+ * Workflow step that prepares and test-imports ABAP package definitions.
+ *
+ * 1- read if root already exists in system
+ *
+ * 2- generate dummy transport (if registry is not local)
+ *
+ * 3- upload transport binaries
+ *
+ * 4- test import transport
+ *
+*/
+exports.prepareDevc = {
+    name: 'prepare-devc',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.installDevclass.keepOriginal) {
+            return true;
+        }
+        else {
+            trm_commons_1.Logger.log(`Skipping import DEVC transport (user input or devclass already generated)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        var _b;
+        //1- read if root already exists in system
+        //this is needed later to understand if keeping the superpackage or not
+        trm_commons_1.Logger.loading(`Getting ready to import...`);
+        //an upgrade reads it before its cleanup deletes the root package (generate-update-transport)
+        (_a = (_b = context.runtime).rootDevclassBeforeImport) !== null && _a !== void 0 ? _a : (_b.rootDevclassBeforeImport = yield systemConnector_1.SystemConnector.getDevclass(context.runtime.package.hierarchy.devclass));
+        if (!context.runtime.stopWarningShown) {
+            context.runtime.stopWarningShown = true;
+            (0, stopWarning_1.stopWarning)('install');
+        }
+        yield (0, utils_1.withScopedPrefix)(`(${transport_1.Transport.getTransportIcon()}  SAP Packages) `, () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            //2- generate dummy transport (if registry is not local)
+            //checking if binaries are already loaded in context instead of checking registry local
+            //is equivalent, but better for possible changes in the future
+            //binaries for local registry are loaded in the checkTransports step
+            let trkorr;
+            if (!context.runtime.transports.devc.binaries.binaries) {
+                trm_commons_1.Logger.loading(`Generating transport...`);
+                const dummy = yield transport_1.Transport.createToc({
+                    text: ((_a = context.runtime.package.data.transports.find(o => o.trkorr === context.runtime.transports.devc.binaries.trkorr)) === null || _a === void 0 ? void 0 : _a.description) || `DEVC ${context.rawInput.packageData.name}`,
+                    target: systemConnector_1.SystemConnector.getDest(),
+                    trmIdentifier: transport_1.TrmTransportIdentifier.DEVC
+                });
+                context.revert.createdTransports.devc = dummy;
+                yield dummy.release(false, true);
+                try {
+                    //saving dummy binaries for a possible revert
+                    context.revert.transports.devc = {
+                        trkorr: dummy.trkorr,
+                        entries: undefined,
+                        binaries: (yield dummy.download()).binaries
+                    };
+                }
+                catch (e) {
+                    trm_commons_1.Logger.error(`Unable to dowload dummy transport!`, true);
+                    trm_commons_1.Logger.error(e.toString(), true);
+                    trm_commons_1.Logger.error(`On failure, revert won't be possible!`, true);
+                }
+                context.runtime.transports.devc.binaries.binaries = yield context.rawInput.packageData.registry.transport(context.runtime.transports.devc.binaries.trkorr, dummy.trkorr);
+                trkorr = dummy.trkorr;
+            }
+            else {
+                trkorr = context.runtime.transports.devc.binaries.trkorr;
+            }
+            //3- upload transport binaries
+            trm_commons_1.Logger.loading(`Uploading transport...`);
+            context.runtime.transports.devc.instance = yield transport_1.Transport.upload(trkorr, {
+                binary: context.runtime.transports.devc.binaries.binaries,
+                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.`);
+            }
+        }));
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.revert.cleanupImported && (context.revert.namespace || context.revert.sapPackages.length > 0)) {
+            yield (0, importBatch_1.deleteImportedEntries)(context);
+        }
+        if (context.revert.cleanupImported && !context.revert.cleanupSucceeded) {
+            return;
+        }
+        const snapshot = context.revert.transports.devc;
+        yield (0, utils_1.revertPreparedTransport)(context.revert.createdTransports.devc, snapshot);
+    })
+};

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

@@ -0,0 +1,13 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that prepares and test-imports the optional language transport.
+ *
+ * 1- generate dummy transport (if registry is not local)
+ *
+ * 2- upload transport binaries
+ *
+ * 3- test import transport
+ *
+*/
+export declare const prepareLang: Step<InstallWorkflowContext>;

package/dist/actions/install/prepareLang.js

@@ -0,0 +1,110 @@
+"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.prepareLang = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+const stopWarning_1 = require("../stopWarning");
+const utils_1 = require("../commons/utils");
+const importBatch_1 = require("./importBatch");
+/**
+ * Workflow step that prepares and test-imports the optional language transport.
+ *
+ * 1- generate dummy transport (if registry is not local)
+ *
+ * 2- upload transport binaries
+ *
+ * 3- test import transport
+ *
+*/
+exports.prepareLang = {
+    name: 'prepare-lang',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.import.noLang) {
+            trm_commons_1.Logger.log(`Skipping import LANG transport (user input)`, true);
+            return false;
+        }
+        else {
+            if (context.runtime.transports.lang) {
+                return true;
+            }
+            else {
+                trm_commons_1.Logger.log(`Skipping import LANG transport (no transports in package)`, true);
+                return false;
+            }
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.runtime.stopWarningShown) {
+            context.runtime.stopWarningShown = true;
+            (0, stopWarning_1.stopWarning)('install');
+        }
+        yield (0, utils_1.withScopedPrefix)(`(${transport_1.Transport.getTransportIcon()}  Translations) `, () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            //1- generate dummy transport (if registry is not local)
+            //checking if binaries are already loaded in context instead of checking registry local
+            //is equivalent, but better for possible changes in the future
+            //binaries for local registry are loaded in the checkTransports step
+            let trkorr;
+            if (!context.runtime.transports.lang.binaries.binaries) {
+                trm_commons_1.Logger.loading(`Generating transport...`);
+                const dummy = yield transport_1.Transport.createToc({
+                    text: ((_a = context.runtime.package.data.transports.find(o => o.trkorr === context.runtime.transports.lang.binaries.trkorr)) === null || _a === void 0 ? void 0 : _a.description) || `LANG ${context.rawInput.packageData.name}`,
+                    target: systemConnector_1.SystemConnector.getDest(),
+                    trmIdentifier: transport_1.TrmTransportIdentifier.LANG
+                });
+                context.revert.createdTransports.lang = dummy;
+                yield dummy.release(false, true);
+                try {
+                    //saving dummy binaries for a possible revert
+                    context.revert.transports.lang = {
+                        trkorr: dummy.trkorr,
+                        entries: undefined,
+                        binaries: (yield dummy.download()).binaries
+                    };
+                }
+                catch (e) {
+                    trm_commons_1.Logger.error(`Unable to dowload dummy transport!`, true);
+                    trm_commons_1.Logger.error(e.toString(), true);
+                    trm_commons_1.Logger.error(`On failure, revert won't be possible!`, true);
+                }
+                context.runtime.transports.lang.binaries.binaries = yield context.rawInput.packageData.registry.transport(context.runtime.transports.lang.binaries.trkorr, dummy.trkorr);
+                trkorr = dummy.trkorr;
+            }
+            else {
+                trkorr = context.runtime.transports.lang.binaries.trkorr;
+            }
+            //2- upload transport binaries
+            trm_commons_1.Logger.loading(`Uploading transport...`);
+            context.runtime.transports.lang.instance = yield transport_1.Transport.upload(trkorr, {
+                binary: context.runtime.transports.lang.binaries.binaries,
+                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.`);
+            }
+        }));
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.revert.cleanupImported && (context.revert.namespace || context.revert.sapPackages.length > 0)) {
+            yield (0, importBatch_1.deleteImportedEntries)(context);
+        }
+        if (context.revert.cleanupImported && !context.revert.cleanupSucceeded) {
+            return;
+        }
+        const snapshot = context.revert.transports.lang;
+        yield (0, utils_1.revertPreparedTransport)(context.revert.createdTransports.lang, snapshot);
+    })
+};

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

@@ -0,0 +1,13 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that prepares and test-imports repository objects.
+ *
+ * 1- generate dummy transport (if registry is not local)
+ *
+ * 2- upload transport binaries
+ *
+ * 3- test import transport
+ *
+*/
+export declare const prepareTadir: Step<InstallWorkflowContext>;

package/dist/actions/install/prepareTadir.js

@@ -0,0 +1,95 @@
+"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.prepareTadir = void 0;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+const stopWarning_1 = require("../stopWarning");
+const utils_1 = require("../commons/utils");
+const importBatch_1 = require("./importBatch");
+/**
+ * Workflow step that prepares and test-imports repository objects.
+ *
+ * 1- generate dummy transport (if registry is not local)
+ *
+ * 2- upload transport binaries
+ *
+ * 3- test import transport
+ *
+*/
+exports.prepareTadir = {
+    name: 'prepare-tadir',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.runtime.stopWarningShown) {
+            context.runtime.stopWarningShown = true;
+            (0, stopWarning_1.stopWarning)('install');
+        }
+        yield (0, utils_1.withScopedPrefix)(`(${transport_1.Transport.getTransportIcon()}  Workbench) `, () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            //1- generate dummy transport (if registry is not local)
+            //checking if binaries are already loaded in context instead of checking registry local
+            //is equivalent, but better for possible changes in the future
+            //binaries for local registry are loaded in the checkTransports step
+            let trkorr;
+            if (!context.runtime.transports.tadir.binaries.binaries) {
+                trm_commons_1.Logger.loading(`Generating transport...`);
+                const dummy = yield transport_1.Transport.createToc({
+                    text: ((_a = context.runtime.package.data.transports.find(o => o.trkorr === context.runtime.transports.tadir.binaries.trkorr)) === null || _a === void 0 ? void 0 : _a.description) || `TADIR ${context.rawInput.packageData.name}`,
+                    target: systemConnector_1.SystemConnector.getDest(),
+                    trmIdentifier: transport_1.TrmTransportIdentifier.TADIR
+                });
+                context.revert.createdTransports.tadir = dummy;
+                yield dummy.release(false, true);
+                try {
+                    //saving dummy binaries for a possible revert
+                    context.revert.transports.tadir = {
+                        trkorr: dummy.trkorr,
+                        entries: undefined,
+                        binaries: (yield dummy.download()).binaries
+                    };
+                }
+                catch (e) {
+                    trm_commons_1.Logger.error(`Unable to dowload dummy transport!`, true);
+                    trm_commons_1.Logger.error(e.toString(), true);
+                    trm_commons_1.Logger.error(`On failure, revert won't be possible!`, true);
+                }
+                context.runtime.transports.tadir.binaries.binaries = yield context.rawInput.packageData.registry.transport(context.runtime.transports.tadir.binaries.trkorr, dummy.trkorr);
+                trkorr = dummy.trkorr;
+            }
+            else {
+                trkorr = context.runtime.transports.tadir.binaries.trkorr;
+            }
+            //2- upload transport binaries
+            trm_commons_1.Logger.loading(`Uploading transport...`);
+            context.runtime.transports.tadir.instance = yield transport_1.Transport.upload(trkorr, {
+                binary: context.runtime.transports.tadir.binaries.binaries,
+                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.`);
+            }
+        }));
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.revert.cleanupImported && (context.revert.namespace || context.revert.sapPackages.length > 0)) {
+            yield (0, importBatch_1.deleteImportedEntries)(context);
+        }
+        if (context.revert.cleanupImported && !context.revert.cleanupSucceeded) {
+            return;
+        }
+        const snapshot = context.revert.transports.tadir;
+        yield (0, utils_1.revertPreparedTransport)(context.revert.createdTransports.tadir, snapshot);
+    })
+};

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

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that releases the generated landscape transport, when present.
+ *
+ * 1- add upgrade transport to target transport queue
+ *
+ * 2- release
+ *
+*/
+export declare const releaseLandscapeTransport: Step<InstallWorkflowContext>;