trm-core 9.10.6 → 10.0.0

package/dist/actions/publish/generateLangTransport.js

@@ -13,6 +13,12 @@ exports.generateLangTransport = void 0;
 const trm_commons_1 = require("trm-commons");
 const transport_1 = require("../../transport");
 const stopWarning_1 = require("../stopWarning");
+/**
+ * Workflow step that creates the optional transport containing language data.
+ *
+ * 1- generate transport
+ *
+*/
 exports.generateLangTransport = {
     name: 'generate-lang-transport',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -25,48 +31,39 @@ exports.generateLangTransport = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Generate LANG transport step', true);
-        trm_commons_1.Logger.loading(`Generating transports...`);
-        trm_commons_1.Logger.loading(`Generating LANG transport...`, true);
-        const aDevc = context.runtime.packageData.tadir.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC');
         if (!context.runtime.stopWarningShown) {
             context.runtime.stopWarningShown = true;
             (0, stopWarning_1.stopWarning)('publish');
         }
-        context.runtime.systemData.langTransport = yield transport_1.Transport.createToc({
+        //1- generate transport
+        trm_commons_1.Logger.loading(`Generating transports...`);
+        trm_commons_1.Logger.loading(`Generating LANG transport...`, true);
+        const aDevc = context.runtime.sapPackage.objects.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC');
+        context.runtime.transports.lang = 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)`
+            text: `@X1@TRM (L) ${context.rawInput.packageData.name} v${context.rawInput.packageData.version}`.slice(0, 60)
         });
         var iLanguageObjects = 0;
         try {
-            yield context.runtime.systemData.langTransport.addTranslations(aDevc.map(o => o.objName));
-            iLanguageObjects = (yield context.runtime.systemData.langTransport.getE071()).length;
+            yield context.runtime.transports.lang.addTranslations(aDevc.map(o => o.objName));
+            iLanguageObjects = (yield context.runtime.transports.lang.getE071()).length;
         }
         catch (e) {
-            trm_commons_1.Logger.warning(`Language transport generation error!`);
-            trm_commons_1.Logger.error(e, true);
+            trm_commons_1.Logger.warning(`Language transport generation error: ${e.toString()}`, { important: true });
         }
         finally {
             if (iLanguageObjects === 0) {
                 trm_commons_1.Logger.info(`Language transport has no content, deleting.`, true);
-                yield context.runtime.systemData.langTransport.delete();
-                context.runtime.systemData.langTransport = undefined;
+                yield context.runtime.transports.lang.delete();
+                context.runtime.transports.lang = undefined;
             }
         }
     }),
     revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_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();
-                    trm_commons_1.Logger.success(`Executed rollback on transport ${context.runtime.systemData.langTransport.trkorr}`, true);
-                }
-            }
-            catch (e) {
-                trm_commons_1.Logger.error(`Unable to rollback transport ${context.runtime.systemData.langTransport.trkorr}!`);
-                trm_commons_1.Logger.error(e.toString(), true);
+        if (context.runtime.transports.lang) {
+            if (yield context.runtime.transports.lang.canBeDeleted()) {
+                yield context.runtime.transports.lang.delete();
             }
         }
     })

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

@@ -1,3 +1,9 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
+/**
+ * Workflow step that creates the transport containing repository objects.
+ *
+ * 1- generate transport
+ *
+*/
 export declare const generateTadirTransport: Step<PublishWorkflowContext>;

package/dist/actions/publish/generateTadirTransport.js

@@ -13,34 +13,35 @@ exports.generateTadirTransport = void 0;
 const trm_commons_1 = require("trm-commons");
 const transport_1 = require("../../transport");
 const stopWarning_1 = require("../stopWarning");
+/**
+ * Workflow step that creates the transport containing repository objects.
+ *
+ * 1- generate transport
+ *
+*/
 exports.generateTadirTransport = {
     name: 'generate-tadir-transport',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Generate TADIR transport step', true);
-        var aTadir = context.runtime.packageData.tadir.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC'));
-        context.runtime.abapGitData.sourceCode.ignoredObjects.forEach(o => {
-            const objectIndex = aTadir.findIndex(k => k.pgmid === o.pgmid && k.object === o.object && k.objName === o.objName);
-            if (objectIndex >= 0) {
-                aTadir.splice(objectIndex, 1);
-            }
-        });
-        if (aTadir.length === 0) {
-            throw new Error(`Package ${context.rawInput.packageData.devclass} has no content.`);
-        }
-        trm_commons_1.Logger.loading(`Generating transports...`);
-        trm_commons_1.Logger.loading(`Generating TADIR transport...`, true);
         if (!context.runtime.stopWarningShown) {
             context.runtime.stopWarningShown = true;
             (0, stopWarning_1.stopWarning)('publish');
         }
-        context.runtime.systemData.tadirTransport = yield transport_1.Transport.createToc({
+        //1- generate transport
+        trm_commons_1.Logger.loading(`Generating transports...`);
+        trm_commons_1.Logger.loading(`Generating TADIR transport...`, true);
+        const aTadir = context.runtime.sapPackage.objects.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC'));
+        context.runtime.transports.tadir = 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}`
+            text: `@X1@TRM ${context.rawInput.packageData.name} v${context.rawInput.packageData.version}`.slice(0, 60)
         });
-        yield context.runtime.systemData.tadirTransport.addObjects(aTadir, false);
+        yield context.runtime.transports.tadir.addObjects(aTadir, false);
     }),
     revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Rollback generate TADIR transport step', true);
+        if (context.runtime.transports.tadir) {
+            if (yield context.runtime.transports.tadir.canBeDeleted()) {
+                yield context.runtime.transports.tadir.delete();
+            }
+        }
     })
 };

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

@@ -0,0 +1,27 @@
+import { TrmManifestEngines } from "../../manifest";
+/** Example engines used when the system can't be read (formally invalid on purpose: must be edited). */
+export declare const ENGINES_TEMPLATE: {
+    components: {
+        '<<COMPONENT>>': {
+            release: string;
+            sp: string;
+        };
+    };
+};
+/**
+ * Builds an engines declaration from the connected system: each SAP software component
+ * as "this release at this SP or newer, or any newer release", and each installed product as "this version or newer".
+ *
+ * SAP Notes and table checks can't be inferred and are never included.
+ *
+ * @returns Engines declaration, or {@link ENGINES_TEMPLATE} if the system can't be read.
+ */
+export declare function getSystemEngines(): Promise<TrmManifestEngines>;
+/**
+ * Adds the `trm-core` engine (the version in use or newer) in front of an engines declaration.
+ *
+ * @param engines Engines declaration, left untouched.
+ * @param coreVersion Version of trm-core supplied by the client, defaults to the version read from trm-core package.json.
+ * @returns A new engines declaration, or `engines` itself if the trm-core version can't be determined.
+ */
+export declare function withTrmEngines(engines: TrmManifestEngines, coreVersion?: string): TrmManifestEngines;

package/dist/actions/publish/getSystemEngines.js

@@ -0,0 +1,112 @@
+"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.ENGINES_TEMPLATE = void 0;
+exports.getSystemEngines = getSystemEngines;
+exports.withTrmEngines = withTrmEngines;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../systemConnector");
+const commons_1 = require("../../commons");
+const manifest_1 = require("../../manifest");
+//CVERS-COMP_TYPE of components that are not delivered by SAP (local, home, customer)
+const EXCLUDED_COMPONENT_TYPES = ['L', 'M', 'J', 'K'];
+/** Example engines used when the system can't be read (formally invalid on purpose: must be edited). */
+exports.ENGINES_TEMPLATE = {
+    components: {
+        '<<COMPONENT>>': {
+            release: '<<release range>>',
+            sp: '<<sp range>>'
+        }
+    }
+};
+/**
+ * Builds an engines declaration from the connected system: each SAP software component
+ * as "this release at this SP or newer, or any newer release", and each installed product as "this version or newer".
+ *
+ * SAP Notes and table checks can't be inferred and are never included.
+ *
+ * @returns Engines declaration, or {@link ENGINES_TEMPLATE} if the system can't be read.
+ */
+function getSystemEngines() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const engines = {
+                components: {},
+                products: {}
+            };
+            //a malformed row is skipped on its own, without discarding the rest of the prefill
+            for (const component of yield systemConnector_1.SystemConnector.getSoftwareComponents()) {
+                try {
+                    const name = component.component.trim().toUpperCase();
+                    const release = (0, manifest_1.normalizeSapValue)(component.release, 'release');
+                    if (!name || !release || release === 'DEV' || EXCLUDED_COMPONENT_TYPES.includes(component.compType)) {
+                        continue;
+                    }
+                    const sp = (0, manifest_1.normalizeSapValue)(component.extrelease, 'number') || '0';
+                    const constraint = [
+                        { release, sp: `>=${sp}` },
+                        { release: `>${release}` }
+                    ];
+                    engines.components[name] = constraint;
+                }
+                catch (e) {
+                    trm_commons_1.Logger.warning(`Skipping software component ${JSON.stringify(component)}: ${e}`, true);
+                }
+            }
+            const productVersions = {};
+            for (const product of yield systemConnector_1.SystemConnector.getInstalledProducts()) {
+                try {
+                    const name = product.name.trim().toUpperCase().replace(/\s+/g, ' ');
+                    const version = (0, manifest_1.normalizeSapValue)(product.version, 'version');
+                    if (!name || !version) {
+                        continue;
+                    }
+                    if (!productVersions[name] || (0, manifest_1.compareSapValues)(version, productVersions[name], 'version') > 0) {
+                        productVersions[name] = version;
+                    }
+                }
+                catch (e) {
+                    trm_commons_1.Logger.warning(`Skipping installed product ${JSON.stringify(product)}: ${e}`, true);
+                }
+            }
+            Object.keys(productVersions).forEach(name => {
+                engines.products[name] = { version: `>=${productVersions[name]}` };
+            });
+            if (Object.keys(engines.components).length === 0) {
+                delete engines.components;
+            }
+            if (Object.keys(engines.products).length === 0) {
+                delete engines.products;
+            }
+            return Object.keys(engines).length > 0 ? engines : exports.ENGINES_TEMPLATE;
+        }
+        catch (e) {
+            trm_commons_1.Logger.error(e.toString(), true);
+            trm_commons_1.Logger.warning(`Couldn't read system components and products, engines will not be prefilled.`);
+            return exports.ENGINES_TEMPLATE;
+        }
+    });
+}
+/**
+ * Adds the `trm-core` engine (the version in use or newer) in front of an engines declaration.
+ *
+ * @param engines Engines declaration, left untouched.
+ * @param coreVersion Version of trm-core supplied by the client, defaults to the version read from trm-core package.json.
+ * @returns A new engines declaration, or `engines` itself if the trm-core version can't be determined.
+ */
+function withTrmEngines(engines, coreVersion) {
+    const version = (0, commons_1.resolveCoreVersion)(coreVersion);
+    if (!version) {
+        trm_commons_1.Logger.warning(`Couldn't determine trm-core version, trm engines will not be prefilled.`, true);
+        return engines;
+    }
+    return Object.assign({ trm: Object.assign(Object.assign({}, engines === null || engines === void 0 ? void 0 : engines.trm), { 'trm-core': `>=${version}` }) }, Object.fromEntries(Object.entries(engines || {}).filter(([key]) => key !== 'trm')));
+}

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

@@ -1,89 +1,214 @@
+import { PackageDependencies } from "../../dependencies";
 import { TrmArtifact, TrmPackage } from "../../trmPackage";
 import { IActionContext } from "..";
-import { AbstractRegistry } from "../../registry";
-import { DEVCLASS, TADIR, TARSYSTEM, TR_TARGET, TRNSPACET, TRNSPACETT } from "../../client";
+import { ReleaseType } from "semver";
+import { DEVCLASS, TADIR, TR_TARGET, TRKORR, TRNSPACET, TRNSPACETT, ZTY_SER_OBJ } from "../../client";
 import { TrmManifest, TrmManifestBase } from "../../manifest";
-import { Transport } from "../../transport";
+import { AbstractRegistry } from "../../registry";
+import { Package } from "trm-registry-types";
 import { DotAbapGit } from "../../abapgit";
-import { ReleaseType } from "semver";
+import { Transport } from "../../transport";
+import { ActionLockScope } from "../commons/utils";
+/** Input required to build and publish a TRM package release from the connected SAP system. */
 export interface PublishActionInput {
+    /**
+     * Optional context data.
+     */
     contextData?: {
+        /**
+         * Snapshot of packages installed on the origin system. When omitted, the action queries SAP.
+         */
         systemPackages?: TrmPackage[];
+        /**
+         * Disable interactive prompts. Missing required values then cause an error.
+         */
         noInquirer?: boolean;
+        /**
+         * Directory in which transport-release logs and temporary files are written.
+         */
         logTemporaryFolder?: string;
-        noStopWarning?: boolean;
+        /**
+         * Version of trm-core in use, used to prefill the `trm-core` engine when engines are declared.
+         * Supply it when the client resolves trm-core itself; defaults to the version read from trm-core package.json.
+         */
+        coreVersion?: string;
     };
+    /**
+     * Data related to the package being published.
+     */
     packageData: {
+        /**
+         * TRM package name to publish.
+         */
         name: string;
+        /**
+         * Exact semantic version or `latest`/omitted for automatic version calculation.
+         *
+         * If blank/latest the latest version is retrieved from the registry:
+         *
+         * - first time publishing = 1.0.0
+         *
+         * - package exists = latest + inc
+         */
         version?: string;
+        /**
+         * Semantic-version increment used when `version` is omitted or `latest`.
+         */
         inc?: ReleaseType;
+        /**
+         * Publish a prerelease instead of a stable release.
+         */
         preRelease?: boolean;
+        /**
+         * Prerelease identifier such as `alpha` or `beta`.
+         */
         preReleaseIdentifier?: string;
+        /**
+         * Registry distribution tags assigned to the release. Defaults to an empty array.
+         */
         tags?: string[];
+        /**
+         * Destination registry used for validation, version lookup, and publication.
+         */
         registry: AbstractRegistry;
+        /**
+         * Source ABAP package. When omitted, the action derives or prompts for it.
+         */
         devclass?: DEVCLASS;
+        /**
+         * Manifest values supplied by the caller. Missing values may be copied from the latest
+         * release or collected interactively, depending on `publishData`.
+         */
         manifest?: TrmManifestBase;
     };
+    /**
+         * Data related to the origin system.
+         */
     systemData?: {
+        /**
+         * TMS target assigned to generated publish transports. It is selected interactively when omitted.
+         */
         transportTarget?: TR_TARGET;
     };
+    /**
+     * Data related to package publish.
+     */
     publishData?: {
+        /**
+         * Do not infer TRM dependencies from the source package hierarchy.
+         */
         noDependenciesDetection?: boolean;
+        /**
+         * Merge unspecified manifest metadata from the latest release. Defaults to `true`.
+         */
         keepLatestReleaseManifestValues?: boolean;
+        /**
+         * Set release visibility to private where supported by the registry.
+         * Required for the first remote publication when interactive prompts are disabled.
+         */
         private?: boolean;
+        /**
+         * Markdown readme stored with the release. Remote registries may prompt when omitted.
+         */
         readme?: string;
+        /**
+         * Markdown changelog stored with the release. Remote registries may prompt when omitted.
+         */
         changelog?: string;
-        skipCustomizingTransports?: boolean;
-        customizingTransports?: string | Transport[];
+        /**
+         * Exclude all customizing transports from this release.
+         */
+        noCustomizingTransports?: boolean;
+        /**
+         * Existing customizing request numbers to include. Retained transports from the latest
+         * release are merged into this list, except those listed in `dropCustomizingTransports`. Ignored when `noCustomizingTransports` is `true`.
+         */
+        customizingTransports?: string[];
+        /**
+         * Customizing transports carried over from the latest release to drop from this release,
+         * identified by their transport request number as published in the latest release.
+         * `all` drops every carried-over transport. An identifier that is not a customizing
+         * transport of the latest release, or that is also listed in `customizingTransports`,
+         * fails the publish. When prompts are enabled, the remaining selection is still shown for
+         * editing. Ignored when `noCustomizingTransports` is `true`.
+         */
+        dropCustomizingTransports?: string[];
+        /**
+         * Do not generate a language transport for translatable package content.
+         */
         noLanguageTransport?: boolean;
     };
 }
+type EnrichedTransport = {
+    trkorr: TRKORR;
+    description: string;
+};
 type WorkflowRuntime = {
-    stopWarningShown: boolean;
-    trmPackage: {
-        package: TrmPackage;
-        registry: AbstractRegistry;
-        latestReleaseManifest?: TrmManifest;
-        releasesInRegistry?: string[];
-        manifest: TrmManifest;
-        manifestXml?: string;
-        artifact?: TrmArtifact;
-    };
-    systemData: {
-        transportTargets: TARSYSTEM[];
-        originCustomizing: {
-            transports: Transport[];
-            description: string;
-        }[];
-        devcTransport: Transport;
-        tadirTransport: Transport;
-        langTransport?: Transport;
-        custTransports: Transport[];
-        releasedTransports: Transport[];
+    /** Dependency analysis of the ABAP package, run once before the publish questions. */
+    packageDependencies?: PackageDependencies;
+    latest: {
+        data: Package;
     };
-    packageData: {
-        tadir: TADIR[];
-        namespace?: {
+    sapPackage: {
+        objects: TADIR[];
+        namespace: {
             trnspacet: TRNSPACET;
             trnspacett: TRNSPACETT[];
         };
     };
-    abapGitData: {
-        dotAbapGit?: DotAbapGit;
-        sourceCode?: {
-            zip: Buffer;
-            ignoredObjects: TADIR[];
-        };
+    abapGit: {
+        dotAbapGit: DotAbapGit;
+        sourceCode: Buffer;
+        object: ZTY_SER_OBJ[];
+        excludedObjects: TADIR[];
     };
+    manifest: TrmManifest;
+    manifestXml: string;
+    customizing: {
+        retained: EnrichedTransport[];
+        new: EnrichedTransport[];
+    };
+    transports: {
+        devc: Transport;
+        tadir: Transport;
+        lang?: Transport;
+        cust?: Transport[];
+    };
+    aggregatedTransports: Transport[];
+    stopWarningShown: boolean;
 };
+/** Artifacts produced by a successful {@link publish} action. */
 export type PublishActionOutput = {
+    /** Published package model, including its normalized manifest and registry identity. */
     trmPackage: TrmPackage;
+    /** Generated release artifact containing transports, manifest, and optional source archive. */
     trmArtifact: TrmArtifact;
 };
+/** Internal state shared by package-publish workflow steps. */
 export interface PublishWorkflowContext extends IActionContext {
+    lockScope?: ActionLockScope;
+    /** Original action input; optional groups and collections are normalized before execution. */
     rawInput: PublishActionInput;
+    /** Latest release, SAP objects, generated transports, manifest, and source data. */
     runtime?: WorkflowRuntime;
+    /** Package and artifact assembled by the workflow. */
     output?: PublishActionOutput;
 }
+/**
+ * Builds an ABAP package release from the connected SAP system and publishes it to a TRM registry.
+ *
+ * The workflow validates authorization and release metadata, detects dependencies, serializes
+ * the source package, creates and releases DEVC/TADIR plus optional language/customizing
+ * transports, uploads the artifact, and records the published package on the origin system.
+ *
+ * This operation creates and releases SAP transports. Do not interrupt it after processing begins.
+ * The function normalizes missing optional input groups and arrays in place.
+ *
+ * @param inputData Source package, destination registry, release metadata, and publish options.
+ * @returns The published package model and generated binary artifact.
+ * @throws When validation, authorization, source serialization, transport generation/release,
+ * or registry publication fails. A final local package-record update failure is logged without
+ * rejecting because the registry publication has already succeeded.
+ */
 export declare function publish(inputData: PublishActionInput): Promise<PublishActionOutput>;
 export {};

package/dist/actions/publish/index.js

@@ -8,50 +8,66 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.publish = publish;
-const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
-const util_1 = require("util");
-const trm_commons_1 = require("trm-commons");
 const __1 = require("..");
 const init_1 = require("./init");
-const setDevclass_1 = require("./setDevclass");
-const setTransportTarget_1 = require("./setTransportTarget");
 const findDependencies_1 = require("./findDependencies");
-const setManifestValues_1 = require("./setManifestValues");
-const setReadme_1 = require("./setReadme");
 const setCustomizingTransports_1 = require("./setCustomizingTransports");
+const setManifestValues_1 = require("./setManifestValues");
+const setOptionalPublishData_1 = require("./setOptionalPublishData");
 const generateDevcTransport_1 = require("./generateDevcTransport");
 const generateTadirTransport_1 = require("./generateTadirTransport");
 const generateLangTransport_1 = require("./generateLangTransport");
 const generateCustTransport_1 = require("./generateCustTransport");
 const releaseTransports_1 = require("./releaseTransports");
-const updatePackageData_1 = require("./updatePackageData");
 const publishToRegistry_1 = require("./publishToRegistry");
-const getSourceCode_1 = require("./getSourceCode");
-const checkAllObjectsReleased_1 = require("./checkAllObjectsReleased");
-const setChangelog_1 = require("./setChangelog");
+const updatePackageData_1 = require("./updatePackageData");
+const utils_1 = require("../commons/utils");
+const lockResources_1 = require("./lockResources");
 ;
 const WORKFLOW_NAME = 'publish';
+/**
+ * Builds an ABAP package release from the connected SAP system and publishes it to a TRM registry.
+ *
+ * The workflow validates authorization and release metadata, detects dependencies, serializes
+ * the source package, creates and releases DEVC/TADIR plus optional language/customizing
+ * transports, uploads the artifact, and records the published package on the origin system.
+ *
+ * This operation creates and releases SAP transports. Do not interrupt it after processing begins.
+ * The function normalizes missing optional input groups and arrays in place.
+ *
+ * @param inputData Source package, destination registry, release metadata, and publish options.
+ * @returns The published package model and generated binary artifact.
+ * @throws When validation, authorization, source serialization, transport generation/release,
+ * or registry publication fails. A final local package-record update failure is logged without
+ * rejecting because the registry publication has already succeeded.
+ */
 function publish(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _o, _p, _q, _r, _s, _t, _u, _v, _w;
+        (_a = inputData.contextData) !== null && _a !== void 0 ? _a : (inputData.contextData = {});
+        (_b = inputData.systemData) !== null && _b !== void 0 ? _b : (inputData.systemData = {});
+        (_c = inputData.publishData) !== null && _c !== void 0 ? _c : (inputData.publishData = { keepLatestReleaseManifestValues: true });
+        (_d = (_o = inputData.publishData).keepLatestReleaseManifestValues) !== null && _d !== void 0 ? _d : (_o.keepLatestReleaseManifestValues = true);
+        (_e = (_p = inputData.publishData).customizingTransports) !== null && _e !== void 0 ? _e : (_p.customizingTransports = []);
+        (_f = (_q = inputData.packageData).manifest) !== null && _f !== void 0 ? _f : (_q.manifest = {});
+        (_g = (_r = inputData.packageData.manifest).authors) !== null && _g !== void 0 ? _g : (_r.authors = []);
+        (_h = (_s = inputData.packageData.manifest).dependencies) !== null && _h !== void 0 ? _h : (_s.dependencies = []);
+        (_j = (_t = inputData.packageData.manifest).keywords) !== null && _j !== void 0 ? _j : (_t.keywords = []);
+        (_k = (_u = inputData.packageData.manifest).postActivities) !== null && _k !== void 0 ? _k : (_u.postActivities = []);
+        (_l = (_v = inputData.packageData.manifest).sapEntries) !== null && _l !== void 0 ? _l : (_v.sapEntries = {});
+        (_m = (_w = inputData.packageData).tags) !== null && _m !== void 0 ? _m : (_w.tags = []);
         const workflow = [
             __1.checkServerAuth,
-            init_1.init,
             __1.setSystemPackages,
-            __1.trmServerPa,
-            setTransportTarget_1.setTransportTarget,
-            setDevclass_1.setDevclass,
+            init_1.init,
             findDependencies_1.findDependencies,
-            setManifestValues_1.setManifestValues,
             setCustomizingTransports_1.setCustomizingTransports,
-            setReadme_1.setReadme,
-            setChangelog_1.setChangelog,
-            getSourceCode_1.getSourceCode,
-            checkAllObjectsReleased_1.checkAllObjectsReleased,
+            setManifestValues_1.setManifestValues,
+            setOptionalPublishData_1.setOptionalReleaseData,
+            lockResources_1.lockResources,
             generateDevcTransport_1.generateDevcTransport,
             generateTadirTransport_1.generateTadirTransport,
             generateLangTransport_1.generateLangTransport,
@@ -60,16 +76,17 @@ function publish(inputData) {
             publishToRegistry_1.publishToRegistry,
             updatePackageData_1.updatePackageData
         ];
-        trm_commons_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
-            rawInput: inputData
-        });
-        trm_commons_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        const trmPackage = result.runtime.trmPackage.package;
-        const trmArtifact = result.runtime.trmPackage.artifact;
-        return {
-            trmPackage,
-            trmArtifact
-        };
+        const lockScope = new utils_1.ActionLockScope(WORKFLOW_NAME);
+        yield lockScope.acquire([(0, utils_1.packageLockResource)(inputData.packageData.registry, inputData.packageData.name)]);
+        return (0, utils_1.withActionLockScope)(lockScope, () => __awaiter(this, void 0, void 0, function* () {
+            const result = yield (0, __1.executeWorkflow)(WORKFLOW_NAME, workflow, {
+                rawInput: inputData,
+                lockScope
+            }, __1.workflowCallbacks);
+            return {
+                trmPackage: result.output.trmPackage,
+                trmArtifact: result.output.trmArtifact
+            };
+        }));
     });
 }