trm-core 5.0.0 → 6.0.0

package/dist/actions/installDependency/init.js

@@ -10,32 +10,67 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = void 0;
+const logger_1 = require("../../logger");
 const commons_1 = require("../../commons");
 const semver_1 = require("semver");
+const inquirer_1 = require("../../inquirer");
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var packageName = context.rawInput.packageName;
-        var versionRange = context.rawInput.versionRange;
-        const registry = context.rawInput.registry;
-        packageName = (0, commons_1.parsePackageName)({
-            fullName: packageName
+        logger_1.Logger.log('Init step', true);
+        context.rawInput.dependencyDataPackage.name = (0, commons_1.parsePackageName)({
+            fullName: context.rawInput.dependencyDataPackage.name
         }).fullName;
-        versionRange = (0, semver_1.validRange)(versionRange);
-        if (!versionRange) {
-            throw new Error(`Dependency "${packageName}", invalid version range.`);
-        }
-        context.parsedInput.packageName = packageName;
-        context.parsedInput.versionRange = versionRange;
-        context.parsedInput.forceInstall = context.rawInput.forceInstall ? true : false;
-        context.parsedInput.integrity = context.rawInput.integrity;
-        context.parsedInput.installOptions = context.rawInput.installOptions || {
-            packageName,
-            registry
+        context.rawInput.dependencyDataPackage.versionRange = (0, semver_1.validRange)(context.rawInput.dependencyDataPackage.versionRange);
+        if (!context.rawInput.dependencyDataPackage.versionRange) {
+            throw new Error(`Dependency "${context.rawInput.dependencyDataPackage.name}", invalid version range.`);
+        }
+        context.runtime = {
+            rollback: false,
+            installOutput: undefined,
+            installVersion: undefined
         };
-        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
-        context.runtime.registry = registry;
-        context.output = {};
+        if (!context.rawInput.contextData) {
+            context.rawInput.contextData = {};
+        }
+        if (!context.rawInput.installData) {
+            context.rawInput.installData = {};
+        }
+        if (!context.rawInput.installData.import) {
+            context.rawInput.installData.import = {};
+        }
+        if (!context.rawInput.installData.installDevclass) {
+            context.rawInput.installData.installDevclass = {};
+        }
+        if (context.rawInput.contextData.noInquirer) {
+            logger_1.Logger.info(`Dependency "${context.rawInput.dependencyDataPackage.name}" will be installed with default options.`);
+        }
+        else {
+            const inq = yield inquirer_1.Inquirer.prompt([{
+                    name: 'noLang',
+                    message: `Dependency "${context.rawInput.dependencyDataPackage.name}": Import language transport (if exists)?`,
+                    type: 'confirm',
+                    default: !context.rawInput.installData.import.noLang
+                }, {
+                    name: 'noCust',
+                    message: `Dependency "${context.rawInput.dependencyDataPackage.name}": Import customizing transport (if exists)?`,
+                    type: 'confirm',
+                    default: !context.rawInput.installData.import.noCust
+                }, {
+                    name: 'keepOriginal',
+                    message: `Dependency "${context.rawInput.dependencyDataPackage.name}": Keep original ABAP package(s)?`,
+                    type: 'confirm',
+                    default: context.rawInput.installData.installDevclass.keepOriginal ? true : false
+                }]);
+            context.rawInput.installData.import.noLang = inq.noLang;
+            context.rawInput.installData.import.noCust = inq.noCust;
+            context.rawInput.installData.installDevclass.keepOriginal = inq.keepOriginal;
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Rollback init step', true);
+        if (context.runtime && context.runtime.rollback) {
+            logger_1.Logger.success(`Rollback executed.`);
+        }
     })
 };
-//# sourceMappingURL=init.js.map

package/dist/actions/installDependency/installRelease.js

@@ -11,33 +11,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installRelease = void 0;
 const logger_1 = require("../../logger");
-const install_1 = require("../install");
-const SUBWORKFLOW_NAME = 'install-dependency-sub-install';
+const __1 = require("..");
+const SUBWORKFLOW_NAME = 'install-sub-install-dependency';
 exports.installRelease = {
     name: 'install-release',
-    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.skipInstall) {
-            logger_1.Logger.log(`Skipping install release (skipInstall)`, true);
-            return false;
-        }
-        else {
-            return true;
-        }
-    }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const packageName = context.parsedInput.packageName;
-        const version = context.output.version;
-        const registry = context.runtime.registry;
-        const integrity = context.parsedInput.integrity;
-        const installOptions = context.parsedInput.installOptions;
-        const inputData = Object.assign(Object.assign({}, installOptions), { packageName,
-            version,
-            integrity,
-            registry });
+        logger_1.Logger.log('Install release step', true);
+        if (!context.runtime.installVersion) {
+            throw new Error(`Couldn't find dependency "${context.rawInput.dependencyDataPackage.name}" on registry. Try manual install.`);
+        }
+        const inputData = {
+            packageData: {
+                name: context.rawInput.dependencyDataPackage.name,
+                registry: context.rawInput.dependencyDataPackage.registry,
+                integrity: context.rawInput.dependencyDataPackage.integrity,
+                version: context.runtime.installVersion,
+                overwrite: false
+            },
+            contextData: context.rawInput.contextData,
+            installData: context.rawInput.installData
+        };
         logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-        const result = yield (0, install_1.install)(inputData);
+        const result = yield (0, __1.install)(inputData);
         logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        context.output.installOutput = result;
+        context.runtime.installOutput = result;
     })
 };
-//# sourceMappingURL=installRelease.js.map

package/dist/actions/publish/finalizePublish.js

@@ -17,36 +17,22 @@ const registry_1 = require("../../registry");
 exports.finalizePublish = {
     name: 'finalize-publish',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        logger_1.Logger.loading(`Finalizing...`);
+        logger_1.Logger.log('Finalize publish step', true);
         try {
-            yield systemConnector_1.SystemConnector.addSrcTrkorr(context.runtime.tadirTransport.trkorr);
-            logger_1.Logger.log(`TADIR added to src trkorr table, setting try revert to true as reverting is possible`, true);
-            context.runtime.tryTadirDeleteRevert = true;
+            logger_1.Logger.loading(`Finalizing...`);
+            yield systemConnector_1.SystemConnector.addSrcTrkorr(context.runtime.systemData.tadirTransport.trkorr);
             logger_1.Logger.log(`Generating SHA512`, true);
-            const integrity = (0, crypto_1.createHash)("sha512").update(context.runtime.artifact.binary).digest("hex");
+            const integrity = (0, crypto_1.createHash)("sha512").update(context.runtime.trmPackage.artifact.binary).digest("hex");
             logger_1.Logger.log(`SHA512: ${integrity}`, true);
-            logger_1.Logger.log(`Setting package integrity`, true);
             yield systemConnector_1.SystemConnector.setPackageIntegrity({
-                package_name: context.parsedInput.packageName,
-                package_registry: context.runtime.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : context.runtime.registry.endpoint,
+                package_name: context.rawInput.packageData.name,
+                package_registry: context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : context.rawInput.packageData.registry.endpoint,
                 integrity
             });
-            context.output = {
-                trmPackage: context.runtime.trmPackage
-            };
         }
         catch (e) {
+            logger_1.Logger.error(`An error occurred during publish finalize. The package has been published, however TRM on ${systemConnector_1.SystemConnector.getDest()} migh be inconsistent.`);
             logger_1.Logger.error(e.toString(), true);
-            logger_1.Logger.error(`An error occurred during publish finalize. The package has been published, however TRM is inconsistent.`);
-        }
-        if (process.env.TRM_ENV === 'DEV') {
-            throw new Error(`Running in development, rolling back publish`);
-        }
-    }),
-    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.output) {
-            delete context.output.trmPackage;
         }
     })
 };
-//# sourceMappingURL=finalizePublish.js.map

package/dist/actions/publish/findDependencies.js

@@ -11,41 +11,155 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findDependencies = void 0;
 const logger_1 = require("../../logger");
-const findDependencies_1 = require("../findDependencies");
+const __1 = require("..");
+const registry_1 = require("../../registry");
+const inquirer_1 = require("../../inquirer");
 const SUBWORKFLOW_NAME = 'find-dependencies-sub-publish';
 exports.findDependencies = {
     name: 'find-dependencies',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.parsedInput.skipDependencies) {
-            logger_1.Logger.info(`Skipping dependencies.`);
-            logger_1.Logger.warning(`Skipping dependencies can cause your package to fail activation. Make sure to manually edit the dependencies if necessary.`);
+        if (context.rawInput.publishData.noDependenciesDetection) {
+            logger_1.Logger.log(`Skipping automatic dependencies detection (user input)`, true);
+            logger_1.Logger.warning(`Skipping automatic dependency detection can cause your package to fail activation during install. Make sure to manually edit the dependencies later if necessary.`);
             return false;
         }
         else {
-            if (context.runtime.tadirObjects.length > 0) {
-                return true;
-            }
-            else {
-                logger_1.Logger.log(`Skipping dependencies search beacuse no objects were found`, true);
-                return false;
-            }
+            return true;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Find dependencies step', true);
+        logger_1.Logger.loading(`Searching for dependencies in package "${context.rawInput.packageData.devclass}"...`);
         const inputData = {
-            devclass: context.parsedInput.devclass,
-            tadir: context.runtime.tadirObjects,
-            silent: context.parsedInput.silent || !context.parsedInput.skipDependencies
+            packageData: {
+                package: context.rawInput.packageData.devclass,
+                objects: context.runtime.packageData.tadir
+            },
+            contextData: {
+                noInquirer: context.rawInput.contextData.noInquirer
+            },
+            printOptions: {
+                sapObjectDependencies: false,
+                trmDependencies: false
+            }
         };
-        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${JSON.stringify(inputData)}`, true);
-        logger_1.Logger.loading(`Searching package dependencies...`);
-        const result = yield (0, findDependencies_1.findDependencies)(inputData);
-        logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${JSON.stringify(result)}`, true);
-        const aUnknownDependencyDevclass = (result.unknownDependencies).map(o => o.devclass);
+        logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        const result = yield (0, __1.findDependencies)(inputData);
+        logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const aUnknownDependencyDevclass = (result.trmPackageDependencies.withoutTrmPackage).map(o => o.devclass);
         if (aUnknownDependencyDevclass.length > 0) {
-            throw new Error(`Dependencies found with packages ${aUnknownDependencyDevclass.join(', ')}: Unknown TRM package!`);
+            logger_1.Logger.error(`Package "${context.rawInput.packageData.devclass}" has ${aUnknownDependencyDevclass.length} missing ${aUnknownDependencyDevclass.length === 1 ? 'dependency' : 'dependencies'}:`);
+            aUnknownDependencyDevclass.forEach((d, i) => {
+                logger_1.Logger.error(`  (${i + 1}/{${aUnknownDependencyDevclass.length}) ${d}`);
+            });
+            throw new Error(`Resolve missing dependencies by publishing them as TRM packages.`);
+        }
+        logger_1.Logger.info(`Package "${context.rawInput.packageData.devclass}" has ${result.trmPackageDependencies.withTrmPackage.length} TRM package ${result.trmPackageDependencies.withTrmPackage.length === 1 ? 'dependency' : 'dependencies'} and ${result.objectDependencies.sapObjects.length} required SAP ${result.objectDependencies.sapObjects.length === 1 ? 'object' : 'objects'}.`);
+        logger_1.Logger.log(`Adding TRM package dependencies to manifest`, true);
+        logger_1.Logger.loading(`Updating manifest...`);
+        result.trmPackageDependencies.withTrmPackage.forEach((o, i) => {
+            if (o.package.manifest) {
+                const dependencyManifest = o.package.manifest.get();
+                const dependencyVersionRange = `^${dependencyManifest.version}`;
+                const dependencyRegistry = o.package.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? undefined : o.package.registry.endpoint;
+                if (!o.integrity) {
+                    throw new Error(`  (${i + 1}/{${result.trmPackageDependencies.withTrmPackage}) ${dependencyManifest.name}: Integrity not found!`);
+                }
+                logger_1.Logger.info(`  (${i + 1}/{${result.trmPackageDependencies.withTrmPackage}) ${dependencyManifest.name} ${dependencyVersionRange}`);
+                context.runtime.trmPackage.manifest.dependencies.push({
+                    name: dependencyManifest.name,
+                    version: dependencyVersionRange,
+                    integrity: o.integrity,
+                    registry: dependencyRegistry
+                });
+            }
+            else {
+                logger_1.Logger.error(`  (${i + 1}/{${result.trmPackageDependencies.withTrmPackage}) Cannot find manifest of dependency in ABAP package "${o.devclass}"`);
+            }
+        });
+        if (!context.rawInput.contextData.noInquirer) {
+            const inq = yield inquirer_1.Inquirer.prompt([{
+                    message: `Do you want to manually edit dependencies?`,
+                    type: 'confirm',
+                    name: 'editDependencies',
+                    default: false
+                }, {
+                    message: 'Editor dependencies',
+                    type: 'editor',
+                    name: 'dependencies',
+                    postfix: '.json',
+                    when: (hash) => {
+                        return hash.editDependencies;
+                    },
+                    default: JSON.stringify(context.runtime.trmPackage.manifest.dependencies, null, 2),
+                    validate: (input) => {
+                        try {
+                            const parsedInput = JSON.parse(input);
+                            if (Array.isArray(parsedInput)) {
+                                return true;
+                            }
+                            else {
+                                return 'Invalid array';
+                            }
+                        }
+                        catch (e) {
+                            return 'Invalid JSON';
+                        }
+                    }
+                }]);
+            if (inq.dependencies) {
+                logger_1.Logger.log(`Dependencies were manually changed: before -> ${JSON.stringify(context.runtime.trmPackage.manifest.dependencies)}, after -> ${JSON.parse(inq.dependencies)}`, true);
+                context.runtime.trmPackage.manifest.dependencies = JSON.parse(inq.dependencies);
+            }
+        }
+        logger_1.Logger.log(`Adding SAP objects dependencies to manifest`, true);
+        logger_1.Logger.loading(`Updating manifest...`);
+        result.objectDependencies.sapObjects.forEach(o => {
+            if (!context.runtime.trmPackage.manifest.sapEntries[o.table]) {
+                context.runtime.trmPackage.manifest.sapEntries[o.table] = [];
+            }
+            o.dependencies.forEach(k => {
+                var tableKeys = k.object;
+                if (o.table === 'TADIR') {
+                    delete tableKeys['DEVCLASS'];
+                }
+                context.runtime.trmPackage.manifest.sapEntries[o.table].push(tableKeys);
+            });
+        });
+        if (!context.rawInput.contextData.noInquirer) {
+            const inq = yield inquirer_1.Inquirer.prompt([{
+                    message: `Do you want to manually required SAP objects?`,
+                    type: 'confirm',
+                    name: 'editSapEntries',
+                    default: false
+                }, {
+                    message: 'Edit SAP entries',
+                    type: 'editor',
+                    name: 'sapEntries',
+                    postfix: '.json',
+                    when: (hash) => {
+                        return hash.editSapEntries;
+                    },
+                    default: JSON.stringify(context.runtime.trmPackage.manifest.sapEntries, null, 2),
+                    validate: (input) => {
+                        try {
+                            const parsedInput = JSON.parse(input);
+                            if (typeof (parsedInput) === 'object' && !Array.isArray(parsedInput)) {
+                                return true;
+                            }
+                            else {
+                                return 'Invalid object';
+                            }
+                        }
+                        catch (e) {
+                            return 'Invalid JSON';
+                        }
+                    }
+                }]);
+            if (inq.sapEntries) {
+                logger_1.Logger.log(`SAP entries were manually changed: before -> ${JSON.stringify(context.runtime.trmPackage.manifest.sapEntries)}, after -> ${JSON.parse(inq.sapEntries)}`, true);
+                context.runtime.trmPackage.manifest.sapEntries = JSON.parse(inq.sapEntries);
+            }
         }
-        context.runtime.dependencies = result;
     })
 };
-//# sourceMappingURL=findDependencies.js.map

package/dist/actions/publish/generateCustTr.js

@@ -70,4 +70,3 @@ exports.generateCustTr = {
         }
     })
 };
-//# sourceMappingURL=generateCustTr.js.map

package/dist/actions/publish/{checkPackageExistance.d.ts → generateCustTransport.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
-export declare const checkPackageExistance: Step<PublishWorkflowContext>;
+export declare const generateCustTransport: Step<PublishWorkflowContext>;

package/dist/actions/publish/generateCustTransport.js

@@ -0,0 +1,63 @@
+"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.generateCustTransport = void 0;
+const logger_1 = require("../../logger");
+const transport_1 = require("../../transport");
+exports.generateCustTransport = {
+    name: 'generate-cust-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.publishData.customizingTransports.length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping CUST transport generation (no customizing transports)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Generate CUST transport step', true);
+        logger_1.Logger.loading(`Generating transports...`);
+        logger_1.Logger.loading(`Generating CUST transport...`, true);
+        context.runtime.systemData.custTransport = yield transport_1.Transport.createToc({
+            trmIdentifier: transport_1.TrmTransportIdentifier.CUST,
+            target: context.rawInput.systemData.transportTarget,
+            text: `@X1@TRM: ${context.rawInput.packageData.name} v${context.rawInput.packageData.version} (C)`
+        });
+        for (const transport of context.rawInput.publishData.customizingTransports) {
+            yield context.runtime.systemData.custTransport.addObjectsFromTransport(transport.trkorr);
+        }
+        const e071 = yield context.runtime.systemData.custTransport.getE071();
+        if (e071.length === 0) {
+            logger_1.Logger.info(`Customizing transport has no content, deleting.`, true);
+            yield context.runtime.systemData.custTransport.delete();
+            context.runtime.systemData.custTransport = undefined;
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Rollback generate CUST transport step', true);
+        if (context.runtime.systemData.custTransport) {
+            try {
+                if (yield context.runtime.systemData.custTransport.canBeDeleted()) {
+                    yield context.runtime.systemData.custTransport.delete();
+                    logger_1.Logger.success(`Executed rollback on transport ${context.runtime.systemData.custTransport.trkorr}`, true);
+                }
+                else {
+                    throw new Error(`Transport ${context.runtime.systemData.custTransport.trkorr} cannot be deleted (released?)`);
+                }
+            }
+            catch (e) {
+                logger_1.Logger.error(`Unable to rollback transport ${context.runtime.systemData.custTransport.trkorr}!`);
+                logger_1.Logger.error(e.toString(), true);
+            }
+        }
+    })
+};

package/dist/actions/publish/{editTrmDependencies.d.ts → generateDevcTransport.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
-export declare const editTrmDependencies: Step<PublishWorkflowContext>;
+export declare const generateDevcTransport: Step<PublishWorkflowContext>;

package/dist/actions/publish/generateDevcTransport.js

@@ -0,0 +1,48 @@
+"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.generateDevcTransport = void 0;
+const logger_1 = require("../../logger");
+const transport_1 = require("../../transport");
+exports.generateDevcTransport = {
+    name: 'generate-devc-transport',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Generate DEVC transport step', true);
+        context.runtime.rollback = true;
+        logger_1.Logger.loading(`Generating transports...`);
+        logger_1.Logger.loading(`Generating DEVC transport...`, true);
+        const aDevc = context.runtime.packageData.tadir.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC');
+        context.runtime.systemData.devcTransport = yield transport_1.Transport.createToc({
+            trmIdentifier: transport_1.TrmTransportIdentifier.DEVC,
+            target: context.rawInput.systemData.transportTarget,
+            text: `@X1@TRM: ${context.rawInput.packageData.name} v${context.rawInput.packageData.version} (D)`
+        });
+        yield context.runtime.systemData.devcTransport.addObjects(aDevc, false);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Rollback generate DEVC transport step', true);
+        if (context.runtime.systemData.devcTransport) {
+            try {
+                if (yield context.runtime.systemData.devcTransport.canBeDeleted()) {
+                    yield context.runtime.systemData.devcTransport.delete();
+                    logger_1.Logger.success(`Executed rollback on transport ${context.runtime.systemData.devcTransport.trkorr}`, true);
+                }
+                else {
+                    throw new Error(`Transport ${context.runtime.systemData.devcTransport.trkorr} cannot be deleted (released?)`);
+                }
+            }
+            catch (e) {
+                logger_1.Logger.error(`Unable to rollback transport ${context.runtime.systemData.devcTransport.trkorr}!`);
+                logger_1.Logger.error(e.toString(), true);
+            }
+        }
+    })
+};

package/dist/actions/publish/{editSapEntries.d.ts → generateLangTransport.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
-export declare const editSapEntries: Step<PublishWorkflowContext>;
+export declare const generateLangTransport: Step<PublishWorkflowContext>;

package/dist/actions/publish/generateLangTransport.js

@@ -0,0 +1,71 @@
+"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.generateLangTransport = void 0;
+const logger_1 = require("../../logger");
+const transport_1 = require("../../transport");
+exports.generateLangTransport = {
+    name: 'generate-lang-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.publishData.noLanguageTransport) {
+            logger_1.Logger.log(`Skipping LANG transport generation (user input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Generate LANG transport step', true);
+        logger_1.Logger.loading(`Generating transports...`);
+        logger_1.Logger.loading(`Generating LANG transport...`, true);
+        const aTadir = context.runtime.packageData.tadir.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC'));
+        context.runtime.systemData.langTransport = yield transport_1.Transport.createToc({
+            trmIdentifier: transport_1.TrmTransportIdentifier.LANG,
+            target: context.rawInput.systemData.transportTarget,
+            text: `@X1@TRM: ${context.rawInput.packageData.name} v${context.rawInput.packageData.version} (L)`
+        });
+        var iLanguageObjects = 0;
+        try {
+            yield context.runtime.systemData.langTransport.addTranslations(aTadir.map(o => o.objName));
+            iLanguageObjects = (yield context.runtime.systemData.langTransport.getE071()).length;
+        }
+        catch (e) {
+            logger_1.Logger.warning(`Language transport generation error!`);
+            logger_1.Logger.error(e, true);
+        }
+        finally {
+            if (iLanguageObjects === 0) {
+                logger_1.Logger.info(`Language transport has no content, deleting.`, true);
+                yield context.runtime.systemData.langTransport.delete();
+                context.runtime.systemData.langTransport = undefined;
+            }
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Rollback generate LANG transport step', true);
+        if (context.runtime.systemData.langTransport) {
+            try {
+                if (yield context.runtime.systemData.langTransport.canBeDeleted()) {
+                    yield context.runtime.systemData.langTransport.delete();
+                    logger_1.Logger.success(`Executed rollback on transport ${context.runtime.systemData.langTransport.trkorr}`, true);
+                }
+                else {
+                    throw new Error(`Transport ${context.runtime.systemData.langTransport.trkorr} cannot be deleted (released?)`);
+                }
+            }
+            catch (e) {
+                logger_1.Logger.error(`Unable to rollback transport ${context.runtime.systemData.langTransport.trkorr}!`);
+                logger_1.Logger.error(e.toString(), true);
+            }
+        }
+    })
+};

package/dist/actions/publish/{setBackwardsCompatible.d.ts → generateTadirTransport.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
-export declare const setBackwardsCompatible: Step<PublishWorkflowContext>;
+export declare const generateTadirTransport: Step<PublishWorkflowContext>;

package/dist/actions/publish/generateTadirTransport.js

@@ -0,0 +1,53 @@
+"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.generateTadirTransport = void 0;
+const logger_1 = require("../../logger");
+const transport_1 = require("../../transport");
+const manifest_1 = require("../../manifest");
+const systemConnector_1 = require("../../systemConnector");
+exports.generateTadirTransport = {
+    name: 'generate-tadir-transport',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Generate TADIR transport step', true);
+        logger_1.Logger.loading(`Generating transports...`);
+        logger_1.Logger.loading(`Generating TADIR transport...`, true);
+        const aTadir = context.runtime.packageData.tadir.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC'));
+        const sManifestXml = new manifest_1.Manifest(context.runtime.trmPackage.manifest).getAbapXml();
+        context.runtime.systemData.tadirTransport = yield transport_1.Transport.createToc({
+            trmIdentifier: transport_1.TrmTransportIdentifier.TADIR,
+            target: context.rawInput.systemData.transportTarget,
+            text: `@X1@TRM: ${context.rawInput.packageData.name} v${context.rawInput.packageData.version}`
+        });
+        yield context.runtime.systemData.tadirTransport.addComment(`name=${context.rawInput.packageData.name}`);
+        yield context.runtime.systemData.tadirTransport.addComment(`version=${context.rawInput.packageData.version}`);
+        yield context.runtime.systemData.tadirTransport.setDocumentation(sManifestXml);
+        yield context.runtime.systemData.tadirTransport.addObjects(aTadir, false);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Rollback generate TADIR transport step', true);
+        if (context.runtime.systemData.tadirTransport) {
+            try {
+                if (yield context.runtime.systemData.tadirTransport.canBeDeleted()) {
+                    yield context.runtime.systemData.tadirTransport.delete();
+                    logger_1.Logger.success(`Executed rollback on transport ${context.runtime.systemData.tadirTransport.trkorr}`, true);
+                }
+                else {
+                    yield systemConnector_1.SystemConnector.addSkipTrkorr(context.runtime.systemData.tadirTransport.trkorr);
+                }
+            }
+            catch (e) {
+                logger_1.Logger.error(`Unable to rollback transport ${context.runtime.systemData.tadirTransport.trkorr}!`);
+                logger_1.Logger.error(e.toString(), true);
+            }
+        }
+    })
+};