trm-core 9.10.6 → 10.0.1

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

@@ -1,3 +1,31 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
+/**
+ * Workflow step that validates release metadata and reads the source ABAP package.
+ *
+ * 1- fill context data
+ *
+ * 2- validate/clean package name/version
+ *
+ * 3- check publish authorization (if public registry)
+ *
+ * 4- set sap package
+ *
+ * 5- ensure package version and visibility can be published
+ *
+ * 6- set visibility if not already provided
+ *
+ * 7- validate minimum publish data with registry
+ *
+ * 8- read namespace
+ *
+ * 9- read abapGit source code (if abapgit installed)
+ *
+ * 10- remove gitignore objects (if abapgit installed)
+ *
+ * 11- check for locks
+ *
+ * 12- check/set system target
+ *
+*/
 export declare const init: Step<PublishWorkflowContext>;

package/dist/actions/publish/init.js

@@ -19,8 +19,13 @@ const trmPackage_1 = require("../../trmPackage");
 const semver_1 = require("semver");
 const systemConnector_1 = require("../../systemConnector");
 const registry_1 = require("../../registry");
-const transport_1 = require("../../transport");
 const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("../commons/prompts");
+const validators_1 = require("../../validators");
+const abapgit_1 = require("../../abapgit");
+const minimatch_1 = require("minimatch");
+const utils_1 = require("../commons/utils");
+const findDependencies_1 = require("./findDependencies");
 function nextPrerelease(version, identifier) {
     const pre = (0, semver_1.prerelease)(version);
     const currentId = pre && typeof pre[0] === "string" ? String(pre[0]) : undefined;
@@ -33,6 +38,34 @@ function nextPrerelease(version, identifier) {
         return (0, semver_1.inc)(version, "prerelease", currentId);
     }
 }
+/**
+ * Rejects a publish whose ABAP package is inside the SAP packages of another installed TRM package,
+ * or contains the root package of one: their objects would be shipped by two TRM packages.
+ */
+function checkOtherTrmPackages(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const devclass = context.rawInput.packageData.devclass;
+        // The same package name published to another registry (e.g. a .trm file of the same release) is the same package here.
+        const others = (context.rawInput.contextData.systemPackages || []).filter(o => !o.compareName(context.rawInput.packageData.name) && o.getDevclass());
+        if (others.length === 0) {
+            return;
+        }
+        const owner = yield (0, utils_1.getOwningInstallation)(devclass, others);
+        if (owner) {
+            if (owner.getDevclass().trim().toUpperCase() === devclass) {
+                throw new Error(`ABAP package ${devclass} is already published as TRM package "${owner.packageName}": publish a new release of "${owner.packageName}", or publish from another package.`);
+            }
+            throw new Error(`ABAP package ${devclass} is part of TRM package "${owner.packageName}" (SAP package ${owner.getDevclass()}): publish from a package outside of it.`);
+        }
+        const roots = new Map(others.map(o => [o.getDevclass().trim().toUpperCase(), o]));
+        for (const subpackage of yield systemConnector_1.SystemConnector.getSubpackages(devclass)) {
+            const nested = roots.get(subpackage.devclass.trim().toUpperCase());
+            if (nested) {
+                throw new Error(`ABAP package ${devclass} contains package ${subpackage.devclass} of TRM package "${nested.packageName}": move it out of ${devclass}, or publish from a package that doesn't contain it.`);
+            }
+        }
+    });
+}
 function getHighestPrerelease(versions, baseVersion, identifier) {
     const base = (0, semver_1.parse)(baseVersion);
     const filtered = versions.filter((v) => {
@@ -47,101 +80,180 @@ function getHighestPrerelease(versions, baseVersion, identifier) {
             return false;
         return identifier
             ? pre[0] === identifier
-            : typeof pre[0] === "number" || pre.length === 1;
+            : typeof pre[0] === "number" || pre.length === 1; // numeric-only
     });
     if (filtered.length === 0)
         return null;
     return filtered.sort(semver_1.rcompare)[0];
 }
+/**
+ * Workflow step that validates release metadata and reads the source ABAP package.
+ *
+ * 1- fill context data
+ *
+ * 2- validate/clean package name/version
+ *
+ * 3- check publish authorization (if public registry)
+ *
+ * 4- set sap package
+ *
+ * 5- ensure package version and visibility can be published
+ *
+ * 6- set visibility if not already provided
+ *
+ * 7- validate minimum publish data with registry
+ *
+ * 8- read namespace
+ *
+ * 9- read abapGit source code (if abapgit installed)
+ *
+ * 10- remove gitignore objects (if abapgit installed)
+ *
+ * 11- check for locks
+ *
+ * 12- check/set system target
+ *
+*/
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Init step', true);
-        const registry = context.rawInput.packageData.registry;
-        const parsedPackageName = (0, commons_1.parsePackageName)({
+        //1- fill context data
+        context.runtime = {
+            latest: {
+                data: undefined
+            },
+            sapPackage: {
+                objects: [],
+                namespace: undefined
+            },
+            abapGit: {
+                dotAbapGit: undefined,
+                sourceCode: undefined,
+                object: [],
+                excludedObjects: []
+            },
+            manifest: Object.assign(Object.assign({}, context.rawInput.packageData.manifest), { name: undefined, version: undefined, authors: Array.isArray(context.rawInput.packageData.manifest.authors)
+                    ? [...context.rawInput.packageData.manifest.authors]
+                    : context.rawInput.packageData.manifest.authors, dependencies: [...context.rawInput.packageData.manifest.dependencies], keywords: Array.isArray(context.rawInput.packageData.manifest.keywords)
+                    ? [...context.rawInput.packageData.manifest.keywords]
+                    : context.rawInput.packageData.manifest.keywords, postActivities: [...context.rawInput.packageData.manifest.postActivities], sapEntries: Object.assign({}, context.rawInput.packageData.manifest.sapEntries) }),
+            manifestXml: undefined,
+            customizing: {
+                retained: [],
+                new: []
+            },
+            transports: {
+                devc: undefined,
+                tadir: undefined,
+                lang: undefined,
+                cust: []
+            },
+            aggregatedTransports: [],
+            stopWarningShown: false
+        };
+        context.output = {
+            trmArtifact: undefined,
+            trmPackage: undefined
+        };
+        //2- validate/clean package name/version
+        context.rawInput.packageData.name = (0, commons_1.parsePackageName)({
             fullName: context.rawInput.packageData.name
-        });
-        context.rawInput.packageData.name = parsedPackageName.fullName;
-        if (registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
-            trm_commons_1.Logger.log(`Public registry, checking if logged in`, true);
+        }).fullName;
+        context.rawInput.packageData.version = (0, semver_1.clean)(context.rawInput.packageData.version || '');
+        //3- check publish authorization (if public registry)
+        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
+            trm_commons_1.Logger.loading(`Checking publish authorization...`);
             try {
-                yield registry.whoAmI();
+                yield context.rawInput.packageData.registry.whoAmI();
             }
             catch (e) {
-                trm_commons_1.Logger.error(`Cannot publish to public registry without being logged in!`);
+                trm_commons_1.Logger.error(`Cannot publish to public registry without being logged in!`, { important: true });
                 throw e;
             }
         }
-        if (!context.rawInput.contextData) {
-            context.rawInput.contextData = {};
-        }
-        if (!context.rawInput.systemData) {
-            context.rawInput.systemData = {};
-        }
-        if (!context.rawInput.publishData) {
-            context.rawInput.publishData = {
-                keepLatestReleaseManifestValues: true
-            };
-        }
-        if (context.rawInput.packageData.manifest === undefined) {
-            context.rawInput.packageData.manifest = {};
-        }
-        if (!context.rawInput.packageData.manifest.authors) {
-            context.rawInput.packageData.manifest.authors = [];
-        }
-        if (!context.rawInput.packageData.manifest.dependencies) {
-            context.rawInput.packageData.manifest.dependencies = [];
-        }
-        if (!context.rawInput.packageData.manifest.keywords) {
-            context.rawInput.packageData.manifest.keywords = [];
-        }
-        if (context.rawInput.packageData.manifest.sapEntries === undefined) {
-            context.rawInput.packageData.manifest.sapEntries = {};
-        }
-        if (!context.rawInput.packageData.manifest.postActivities) {
-            context.rawInput.packageData.manifest.postActivities = [];
-        }
-        if (!context.rawInput.publishData.customizingTransports) {
-            context.rawInput.publishData.customizingTransports = [];
+        //4- set sap package
+        //resolved before the registry checks and prompts: an invalid package (e.g. temporary) stops publish right away
+        //if not provided, derive it from the system package (previous publish), then prompt (if allowed)
+        //supplied or derived values are normalized and validated, prompted values are validated by the prompt
+        var packageNeedsValidation = true;
+        if (!context.rawInput.packageData.devclass) {
+            const trmPackage = context.rawInput.contextData.systemPackages.find(o => trmPackage_1.TrmPackage.compare(o, new trmPackage_1.TrmPackage(context.rawInput.packageData.name, context.rawInput.packageData.registry)));
+            if (trmPackage) {
+                context.rawInput.packageData.devclass = trmPackage.getDevclass();
+            }
+            if (!context.rawInput.contextData.noInquirer) {
+                context.rawInput.packageData.devclass = (yield trm_commons_1.Inquirer.prompt({
+                    type: 'input',
+                    message: 'ABAP package',
+                    name: 'devclass',
+                    default: context.rawInput.packageData.devclass,
+                    validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                        return yield (0, validators_1.validateDevclass)(input, false);
+                    })
+                })).devclass;
+                packageNeedsValidation = false;
+            }
+            else if (!context.rawInput.packageData.devclass) {
+                throw new Error(`packageData.devclass is required when it cannot be derived from a previous publish and interactive prompts are disabled.`);
+            }
         }
-        if (typeof (context.rawInput.publishData.customizingTransports) === 'string') {
-            context.rawInput.publishData.customizingTransports = context.rawInput.publishData.customizingTransports.split(',').map(trkorr => new transport_1.Transport(trkorr));
+        context.rawInput.packageData.devclass = context.rawInput.packageData.devclass.trim().toUpperCase();
+        trm_commons_1.Logger.log(`Publish devclass set to "${context.rawInput.packageData.devclass}"`, true);
+        if (packageNeedsValidation) {
+            trm_commons_1.Logger.loading(`Validating...`);
+            const validate = yield (0, validators_1.validateDevclass)(context.rawInput.packageData.devclass, false);
+            if (validate && validate !== true) {
+                throw new Error(validate);
+            }
+            trm_commons_1.Logger.info(`ABAP package: "${context.rawInput.packageData.devclass}"`);
         }
-        if (!context.rawInput.packageData.tags) {
-            context.rawInput.packageData.tags = [];
+        //an ABAP package belongs to at most one TRM package: the tree can't contain, or be inside, another one
+        yield checkOtherTrmPackages(context);
+        //dependencies the release can't have refuse the publish before the version and visibility questions
+        if (!context.rawInput.publishData.noDependenciesDetection && !context.rawInput.contextData.noInquirer) {
+            yield (0, findDependencies_1.checkPackageDependencies)(context);
         }
+        //5- ensure package version and visibility can be published
+        //if it's the first package publish assume it's valid (validate publish will throw error later, in case something is wrong with it)
+        //default to 1.0.0 if no version was provided
+        //if the package already exists, check this version was not released yet
+        //if it's public registry, check visibility is not changed too (avoid useless validate publish call)
+        //in all cases, calculate the next prerelease if requested
+        //on automatic version, manual validation by user
         trm_commons_1.Logger.loading(`Validating version...`);
         var automaticVersion = false;
-        var releasesInRegistry;
-        var latestReleaseManifest;
-        context.rawInput.packageData.version = (0, semver_1.clean)(context.rawInput.packageData.version || '');
-        try {
-            trm_commons_1.Logger.loading(`Getting package latest release from registry...`, true);
-            const packageData = yield registry.getPackage(context.rawInput.packageData.name, 'latest');
-            latestReleaseManifest = packageData.manifest;
-            releasesInRegistry = packageData.versions;
+        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
+            //the target file is overwritten, it's not a previous release of this package:
+            //every local artifact is a standalone publication
+            trm_commons_1.Logger.log(`Local publish: target file is not read as latest release`, true);
         }
-        catch (_a) { }
-        if (!latestReleaseManifest) {
-            if (!context.rawInput.packageData.version || !(0, semver_1.valid)(context.rawInput.packageData.version)) {
-                context.rawInput.packageData.version = '1.0.0';
-                automaticVersion = true;
+        else {
+            try {
+                context.runtime.latest.data = yield context.rawInput.packageData.registry.getPackage(context.rawInput.packageData.name, 'latest');
             }
-            if (context.rawInput.packageData.preRelease) {
-                context.rawInput.packageData.version = nextPrerelease(context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
+            catch (e) {
+                if (e instanceof registry_1.RegistryPackageNotFoundError) {
+                    trm_commons_1.Logger.info(`First time publishing "${context.rawInput.packageData.name}". Congratulations!`);
+                }
+                else {
+                    throw e;
+                }
             }
         }
-        else {
+        if (context.runtime.latest.data) {
+            if (!context.runtime.latest.data.dist_tags.latest) {
+                throw new Error(`Package has no latest distribution tag assigned! Unable to locate latest release.`);
+            }
             if (!context.rawInput.packageData.version || !(0, semver_1.valid)(context.rawInput.packageData.version)) {
-                context.rawInput.packageData.version = (0, semver_1.inc)(latestReleaseManifest.version, context.rawInput.packageData.inc || "patch");
+                context.rawInput.packageData.version = (0, semver_1.inc)(context.runtime.latest.data.dist_tags.latest, context.rawInput.packageData.inc || "patch");
                 automaticVersion = true;
             }
             else {
-                if (releasesInRegistry.includes(context.rawInput.packageData.version)) {
+                if (context.runtime.latest.data.versions.concat(context.runtime.latest.data.yanked_versions).includes(context.rawInput.packageData.version)) {
                     throw new Error(`Version "${context.rawInput.packageData.version}" already published.`);
                 }
                 if (context.rawInput.packageData.preRelease) {
-                    const highestPreRelease = getHighestPrerelease(releasesInRegistry, context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
+                    const highestPreRelease = getHighestPrerelease(context.runtime.latest.data.versions.concat(context.runtime.latest.data.yanked_versions), context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
                     if (highestPreRelease) {
                         context.rawInput.packageData.version = highestPreRelease;
                         automaticVersion = true;
@@ -149,33 +261,47 @@ exports.init = {
                     context.rawInput.packageData.version = nextPrerelease(context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
                 }
             }
-            if (registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
+            if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
                 trm_commons_1.Logger.log(`Public registry, checking if visibility is the same as latest release`, true);
-                if (typeof (context.rawInput.publishData.private) === 'boolean' && context.rawInput.publishData.private !== latestReleaseManifest.private) {
-                    throw new Error(`Cannot change package visibility to ${context.rawInput.publishData.private ? 'private' : 'public'}`);
+                if (typeof (context.rawInput.publishData.private) === 'boolean' && context.rawInput.publishData.private !== context.runtime.latest.data.manifest.private) {
+                    throw new Error(`Cannot change package visibility from ${context.runtime.latest.data.manifest.private ? 'private' : 'public'} to ${context.rawInput.publishData.private ? 'private' : 'public'}`);
                 }
             }
         }
+        else {
+            if (!context.rawInput.packageData.version || !(0, semver_1.valid)(context.rawInput.packageData.version)) {
+                context.rawInput.packageData.version = '1.0.0';
+                automaticVersion = true;
+            }
+            if (context.rawInput.packageData.preRelease) {
+                context.rawInput.packageData.version = nextPrerelease(context.rawInput.packageData.version, context.rawInput.packageData.preReleaseIdentifier);
+            }
+        }
         if (automaticVersion) {
             trm_commons_1.Logger.info(`Automatically set publish version to "${context.rawInput.packageData.version}"`);
             if (!context.rawInput.contextData.noInquirer) {
-                context.rawInput.packageData.version = (yield trm_commons_1.Inquirer.prompt([{
+                const promptedVersion = (yield trm_commons_1.Inquirer.prompt([{
                         type: 'confirm',
                         message: `Continue publish as version "${context.rawInput.packageData.version}"?`,
                         default: true,
                         name: 'acceptDefaultVersion'
                     }, {
                         type: 'input',
-                        message: `Input publish version`,
+                        message: `Release version`,
                         name: 'version',
                         default: context.rawInput.packageData.version,
                         when: (hash) => {
                             return !hash.acceptDefaultVersion;
                         },
                         validate: (v) => {
-                            if ((0, semver_1.valid)(v)) {
-                                if (releasesInRegistry.includes(v)) {
-                                    return `Version "${v}" already published.`;
+                            //compare the version as it will be stored (cleaned)
+                            const version = (0, semver_1.clean)(v || '');
+                            if (version) {
+                                const publishedVersions = context.runtime.latest.data
+                                    ? context.runtime.latest.data.versions.concat(context.runtime.latest.data.yanked_versions)
+                                    : [];
+                                if (publishedVersions.includes(version)) {
+                                    return `Version "${version}" is already published.`;
                                 }
                                 else {
                                     return true;
@@ -185,21 +311,26 @@ exports.init = {
                                 return `Invalid version`;
                             }
                         }
-                    }])).version || context.rawInput.packageData.version;
+                    }])).version;
+                context.rawInput.packageData.version = (0, semver_1.clean)(promptedVersion || '') || context.rawInput.packageData.version;
             }
         }
-        var isPrivate;
-        if (registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
+        //6- set visibility if not already provided
+        var isPrivate = undefined;
+        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
             isPrivate = true;
         }
         else {
-            isPrivate = typeof (context.rawInput.publishData.private) === 'undefined' ? (latestReleaseManifest ? latestReleaseManifest.private : undefined) : context.rawInput.publishData.private;
-            if (typeof (isPrivate) === 'undefined') {
+            isPrivate = context.rawInput.publishData.private === undefined ? (context.runtime.latest.data ? context.runtime.latest.data.manifest.private : undefined) : context.rawInput.publishData.private;
+            if (isPrivate === undefined) {
+                if (context.rawInput.contextData.noInquirer) {
+                    throw new Error(`publishData.private is required for the first remote publication when interactive prompts are disabled.`);
+                }
                 isPrivate = (yield trm_commons_1.Inquirer.prompt({
                     type: "list",
                     message: "Package visibility",
                     name: "private",
-                    default: isPrivate,
+                    default: true,
                     choices: [{
                             name: `Public`,
                             value: false
@@ -210,49 +341,102 @@ exports.init = {
                 })).private;
             }
         }
-        trm_commons_1.Logger.loading(`Validating data...`);
-        yield registry.validatePublish(context.rawInput.packageData.name, context.rawInput.packageData.version, isPrivate);
-        if (!latestReleaseManifest) {
-            trm_commons_1.Logger.info(`First time publishing "${context.rawInput.packageData.name}". Congratulations!`, registry.getRegistryType() === registry_1.RegistryType.LOCAL);
+        //7- validate minimum publish data with registry
+        //this is the bare minimum: if it fails there is no need to continue with publish
+        trm_commons_1.Logger.loading(`Validating...`);
+        yield context.rawInput.packageData.registry.validatePublish(context.rawInput.packageData.name, context.rawInput.packageData.version, isPrivate);
+        trm_commons_1.Logger.loading(`Reading ${context.rawInput.packageData.devclass} objects...`);
+        context.runtime.sapPackage.objects = yield systemConnector_1.SystemConnector.getDevclassObjects(context.rawInput.packageData.devclass, true);
+        if (context.runtime.sapPackage.objects.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC')).length === 0) {
+            throw new Error(`ABAP package "${context.rawInput.packageData.devclass}" doesn't contain any object!`);
         }
-        trm_commons_1.Logger.info(`Ready to publish ${context.rawInput.packageData.name} v${context.rawInput.packageData.version}`);
-        trm_commons_1.Logger.info(`Package visibility: ${chalk_1.default.bold(isPrivate ? 'private' : 'public')}`);
-        context.runtime = {
-            stopWarningShown: context.rawInput.contextData.noStopWarning ? true : false,
-            trmPackage: {
-                package: new trmPackage_1.TrmPackage(context.rawInput.packageData.name, registry),
-                registry,
-                latestReleaseManifest,
-                releasesInRegistry,
-                manifest: Object.assign(Object.assign({}, context.rawInput.packageData.manifest), {
-                    name: context.rawInput.packageData.name,
-                    version: context.rawInput.packageData.version,
-                    private: isPrivate
-                })
-            },
-            systemData: {
-                transportTargets: [],
-                devcTransport: undefined,
-                tadirTransport: undefined,
-                releasedTransports: [],
-                originCustomizing: [],
-                custTransports: []
-            },
-            packageData: {
-                tadir: []
-            },
-            abapGitData: {
-                dotAbapGit: undefined,
-                sourceCode: {
-                    ignoredObjects: [],
-                    zip: undefined
-                }
+        //8- read namespace
+        //the package and its subpackages must use at most one reserved namespace
+        const packageNamespace = (0, commons_1.getPackagesNamespace)(context.rawInput.packageData.devclass, context.runtime.sapPackage.objects.flatMap(o => o.pgmid === 'R3TR' && o.object === 'DEVC' ? [o.devclass, o.objName] : [o.devclass]).filter(Boolean));
+        if (packageNamespace[0] === '/') {
+            trm_commons_1.Logger.loading(`Reading namespace ${packageNamespace}...`);
+            const namespace = yield systemConnector_1.SystemConnector.getNamespace(packageNamespace);
+            if (namespace && namespace.trnspacet && namespace.trnspacett.length > 0) {
+                context.runtime.sapPackage.namespace = {
+                    trnspacet: namespace.trnspacet,
+                    trnspacett: namespace.trnspacett
+                };
             }
-        };
-        trm_commons_1.Logger.loading(`Reading ${systemConnector_1.SystemConnector.getDest()} transport targets...`);
-        context.runtime.systemData.transportTargets = yield systemConnector_1.SystemConnector.getTransportTargets();
-        if (context.rawInput.publishData.skipCustomizingTransports) {
-            context.rawInput.publishData.customizingTransports = [];
+            else {
+                throw new Error(`Namespace ${packageNamespace} couldn't be validated.`);
+            }
+        }
+        //9- read abapGit source code (if abapgit installed)
+        //this step is right at the beginning to ensure locks
+        //unfortunately, we have to read the whole source code to figure out the objects path, and evetually ignore gitignored objects
+        //so it's mandatory to do this before checking for locks :(
+        try {
+            const sourceCode = yield systemConnector_1.SystemConnector.getAbapgitSource(context.rawInput.packageData.devclass);
+            context.runtime.abapGit.sourceCode = sourceCode.zip;
+            context.runtime.abapGit.object = sourceCode.objects;
+        }
+        catch (_a) {
+            trm_commons_1.Logger.log(`Couldn't read source code!`, true);
         }
+        //10- remove gitignore objects (if abapgit installed)
+        if (context.runtime.abapGit.sourceCode && context.runtime.abapGit.object.length > 0) {
+            try {
+                context.runtime.abapGit.dotAbapGit = yield abapgit_1.DotAbapGit.fromDevclass(context.rawInput.packageData.devclass);
+            }
+            catch (_b) {
+                trm_commons_1.Logger.log(`.abapgit.xml not found`, true);
+            }
+            if (context.runtime.abapGit.dotAbapGit) {
+                const ignoredPatterns = context.runtime.abapGit.dotAbapGit.getIgnoredFiles();
+                context.runtime.sapPackage.objects.forEach(o => {
+                    const abapgitObject = context.runtime.abapGit.object.find(k => k.pgmid === o.pgmid && k.object === o.object && k.objName === o.objName);
+                    if (abapgitObject) {
+                        ignoredPatterns.forEach(pattern => {
+                            if ((0, minimatch_1.minimatch)(abapgitObject.fullPath, pattern, { matchBase: true })) {
+                                if (o.pgmid === 'R3TR' && o.object === 'DEVC') {
+                                    throw new Error(`Cannot exclude ABAP package "${o.objName}" (.abapGit.xml)!`);
+                                }
+                                if (!context.runtime.abapGit.excludedObjects.find(k => k.pgmid === o.pgmid && k.object === o.object && k.objName === o.objName)) {
+                                    context.runtime.abapGit.excludedObjects.push(o);
+                                    context.runtime.sapPackage.objects = context.runtime.sapPackage.objects.filter(k => !(k.pgmid === o.pgmid && k.object === o.object && k.objName === o.objName));
+                                }
+                            }
+                        });
+                    }
+                });
+            }
+        }
+        //check that after gitignore there are still objects
+        if (context.runtime.sapPackage.objects.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC')).length === 0) {
+            //no more objects, print what was excluded from gitignore
+            context.runtime.abapGit.excludedObjects.forEach(o => trm_commons_1.Logger.info(`Excluding ${o.pgmid} ${o.object} ${o.objName} (.abapgit gitignore)`));
+            throw new Error(`ABAP package "${context.rawInput.packageData.devclass}" doesn't contain any object!`);
+        }
+        //11- check for locks
+        //finally, with excluded objects from gitignore, we can check for locks before continuing
+        const locks = yield systemConnector_1.SystemConnector.getObjectsLocks(context.runtime.sapPackage.objects.map(o => {
+            return {
+                PGMID: o.pgmid,
+                OBJECT: o.object,
+                OBJ_NAME: o.objName
+            };
+        }));
+        if (locks.length > 0) {
+            locks.forEach(l => { trm_commons_1.Logger.error(`${l.pgmid} ${l.object} ${l.objName} is currently locked in transport ${l.trkorr}`, { important: true }); });
+            throw new Error(`To continue, all objects must be released.`);
+        }
+        else {
+            trm_commons_1.Logger.log(`All objects released, continue`, true);
+        }
+        //12- check/set system target
+        trm_commons_1.Logger.loading(`Checking system target...`);
+        context.rawInput.systemData.transportTarget = yield (0, prompts_1.setTransportTarget)(context.rawInput.contextData.noInquirer, yield systemConnector_1.SystemConnector.getTransportTargets(), context.rawInput.systemData.transportTarget, "Publish transport target");
+        trm_commons_1.Logger.info(`Ready to publish ${context.rawInput.packageData.name} v${context.rawInput.packageData.version}`);
+        trm_commons_1.Logger.info(`Package visibility: ${chalk_1.default.bold(isPrivate ? 'private' : 'public')}`);
+        //this is the right time to show the excluded objects
+        context.runtime.abapGit.excludedObjects.forEach(o => trm_commons_1.Logger.info(`Excluding ${o.pgmid} ${o.object} ${o.objName} (.abapgit gitignore)`));
+        context.runtime.manifest.name = context.rawInput.packageData.name;
+        context.runtime.manifest.version = context.rawInput.packageData.version;
+        context.runtime.manifest.private = isPrivate;
     })
 };

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

@@ -0,0 +1,4 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { PublishWorkflowContext } from ".";
+/** Reserve the source package and all workbench objects before creating transports. */
+export declare const lockResources: Step<PublishWorkflowContext>;

package/dist/actions/{install/refreshTmsTxt.js → publish/lockResources.js}

@@ -9,24 +9,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.refreshTmsTxt = void 0;
-const trm_commons_1 = require("trm-commons");
-exports.refreshTmsTxt = {
-    name: 'refresh-tms-txt',
-    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.generatedData.tmsTxtRefresh.length > 0) {
-            return true;
-        }
-        else {
-            trm_commons_1.Logger.log(`Skipping TMS refresh`, true);
-            return false;
-        }
-    }),
+exports.lockResources = void 0;
+const utils_1 = require("../commons/utils");
+/** Reserve the source package and all workbench objects before creating transports. */
+exports.lockResources = {
+    name: "lock-resources",
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Refresh TMS txt step', true);
-        for (const transport of context.runtime.generatedData.tmsTxtRefresh) {
-            trm_commons_1.Logger.loading(`Updating TMS buffer ${transport.trkorr}...`);
-            yield transport.refreshTmsTxt();
+        const resources = [
+            { type: "DEVCLASS", name: context.rawInput.packageData.devclass }
+        ];
+        for (const object of context.runtime.sapPackage.objects) {
+            resources.push((0, utils_1.objectLockResource)(object));
+            if (object.pgmid.trim().toUpperCase() === "R3TR" && object.object.trim().toUpperCase() === "DEVC") {
+                resources.push({ type: "DEVCLASS", name: object.objName });
+            }
         }
+        yield context.lockScope.acquire(resources);
     })
 };

package/dist/actions/publish/publishToRegistry.d.ts

@@ -1,3 +1,11 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
+/**
+ * Workflow step that builds the binary TRM artifact and uploads the release to its registry.
+ *
+ * 1- generate TRM artifact
+ *
+ * 2- publish to registry
+ *
+*/
 export declare const publishToRegistry: Step<PublishWorkflowContext>;