trm-core 4.1.4 → 6.0.0

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

@@ -1,76 +1,69 @@
-import { DEVCLASS, TADIR, TR_TARGET } from "../../client";
-import { TrmManifest } from "../../manifest";
-import { Registry } from "../../registry";
 import { TrmArtifact, TrmPackage } from "../../trmPackage";
+import { IActionContext } from "..";
+import { Registry } from "../../registry";
+import { DEVCLASS, TADIR, TMSCSYS, TR_TARGET, TRNSPACET, TRNSPACETT } from "../../client";
+import { TrmManifest, TrmManifestBase } from "../../manifest";
 import { Transport } from "../../transport";
-import { FindDependencyActionOutput } from "../findDependencies";
-export type PublishActionInput = {
-    package: TrmManifest;
-    registry: Registry;
-    devclass?: DEVCLASS;
-    target?: TR_TARGET;
-    skipDependencies?: boolean;
-    forceManifestInput?: boolean;
-    overwriteManifestValues?: boolean;
-    skipEditSapEntries?: boolean;
-    skipEditDependencies?: boolean;
-    skipReadme?: boolean;
-    skipLang?: boolean;
-    skipCust?: boolean;
-    customizingTransports?: string[];
-    readme?: string;
-    releaseTimeout?: number;
-    tmpFolder?: string;
-    silent?: boolean;
-};
-export type WorkflowParsedInput = {
-    packageName?: string;
-    version?: string;
-    devclass?: string;
-    trTarget?: string;
-    readme?: string;
-    releaseFolder?: string;
-    releaseTimeout?: number;
-    customizingTransports?: string[];
-    skipEditSapEntries?: boolean;
-    skipEditDependencies?: boolean;
-    skipDependencies?: boolean;
-    skipLang?: boolean;
-    overwriteManifestValues?: boolean;
-    packageBackwardsCompatible?: boolean;
-    skipCust?: boolean;
-    forceManifestInput?: boolean;
-    packagePrivate?: boolean;
-    skipReadme?: boolean;
-    target?: string;
-    silent?: boolean;
-};
-export type WorkflowRuntime = {
-    registry?: Registry;
-    dummyPackage?: TrmPackage;
-    packageExistsOnRegistry?: boolean;
-    tadirObjects?: TADIR[];
-    manifest?: TrmManifest;
-    trmPackage?: TrmPackage;
-    devcTransport?: Transport;
-    tryDevcDeleteRevert?: boolean;
-    tadirTransport?: Transport;
-    tryTadirDeleteRevert?: boolean;
-    langTransport?: Transport;
-    tryLangDeleteRevert?: boolean;
-    inputCustTransports?: Transport[];
-    custTransport?: Transport;
-    tryCustDeleteRevert?: boolean;
-    artifact?: TrmArtifact;
-    dependencies?: FindDependencyActionOutput;
+export interface PublishActionInput {
+    contextData?: {
+        systemPackages?: TrmPackage[];
+        noInquirer?: boolean;
+        logTemporaryFolder?: string;
+    };
+    packageData: {
+        name: string;
+        version?: string;
+        registry: Registry;
+        devclass?: DEVCLASS;
+        manifest?: TrmManifestBase;
+    };
+    systemData?: {
+        transportTarget?: TR_TARGET;
+        releaseTimeout: number;
+    };
+    publishData?: {
+        noDependenciesDetection?: boolean;
+        keepLatestReleaseManifestValues?: boolean;
+        private?: boolean;
+        readme?: string;
+        skipCustomizingTransports?: boolean;
+        customizingTransports?: string | Transport[];
+        noLanguageTransport?: boolean;
+    };
+}
+type WorkflowRuntime = {
+    rollback: boolean;
+    trmPackage: {
+        package: TrmPackage;
+        registry: Registry;
+        latestReleaseManifest?: TrmManifest;
+        manifest: TrmManifest;
+        artifact?: TrmArtifact;
+    };
+    systemData: {
+        transportTargets: TMSCSYS[];
+        devcTransport: Transport;
+        tadirTransport: Transport;
+        langTransport?: Transport;
+        custTransport?: Transport;
+        releasedTransports: Transport[];
+    };
+    packageData: {
+        tadir: TADIR[];
+        namespace?: {
+            trnspacet: TRNSPACET;
+            trnspacett: TRNSPACETT[];
+        };
+    };
 };
 export type PublishActionOutput = {
     trmPackage: TrmPackage;
+    trmArtifact: TrmArtifact;
 };
-export type PublishWorkflowContext = {
+export interface PublishWorkflowContext extends IActionContext {
     rawInput: PublishActionInput;
-    parsedInput: WorkflowParsedInput;
-    runtime: WorkflowRuntime;
+    runtime?: WorkflowRuntime;
     output?: PublishActionOutput;
-};
-export declare function publish(inputData: PublishActionInput): Promise<TrmPackage>;
+}
+export declare function publish(inputData: PublishActionInput): Promise<PublishActionOutput>;
+export {};

package/dist/actions/publish/index.js

@@ -12,87 +12,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.publish = void 0;
+exports.publish = publish;
 const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const util_1 = require("util");
+const logger_1 = require("../../logger");
+const __1 = require("..");
 const init_1 = require("./init");
 const setDevclass_1 = require("./setDevclass");
-const checkPublishAllowed_1 = require("./checkPublishAllowed");
 const setTransportTarget_1 = require("./setTransportTarget");
-const setDevclassObjs_1 = require("./setDevclassObjs");
 const findDependencies_1 = require("./findDependencies");
-const logger_1 = require("../../logger");
-const setTrmDependencies_1 = require("./setTrmDependencies");
-const setSapEntries_1 = require("./setSapEntries");
-const editSapEntries_1 = require("./editSapEntries");
-const editTrmDependencies_1 = require("./editTrmDependencies");
-const logDependencies_1 = require("./logDependencies");
-const checkPackageExistance_1 = require("./checkPackageExistance");
-const overwriteManifestValues_1 = require("./overwriteManifestValues");
-const setBackwardsCompatible_1 = require("./setBackwardsCompatible");
-const setPrivate_1 = require("./setPrivate");
 const setManifestValues_1 = require("./setManifestValues");
-const buildTrmPackageInstance_1 = require("./buildTrmPackageInstance");
 const setReadme_1 = require("./setReadme");
-const generateDevcTr_1 = require("./generateDevcTr");
-const generateTadirTr_1 = require("./generateTadirTr");
-const generateLangTr_1 = require("./generateLangTr");
-const releaseTadirTr_1 = require("./releaseTadirTr");
-const releaseLangTr_1 = require("./releaseLangTr");
-const releaseDevcTr_1 = require("./releaseDevcTr");
-const generateTrmArtifact_1 = require("./generateTrmArtifact");
-const publishTrmArtifact_1 = require("./publishTrmArtifact");
+const setCustomizingTransports_1 = require("./setCustomizingTransports");
+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 finalizePublish_1 = require("./finalizePublish");
-const generateCustTr_1 = require("./generateCustTr");
-const releaseCustTr_1 = require("./releaseCustTr");
-const setCustTransports_1 = require("./setCustTransports");
+const publishToRegistry_1 = require("./publishToRegistry");
+;
 const WORKFLOW_NAME = 'publish';
 function publish(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             init_1.init,
-            checkPackageExistance_1.checkPackageExistance,
-            checkPublishAllowed_1.checkPublishAllowed,
-            setDevclass_1.setDevclass,
+            __1.setSystemPackages,
             setTransportTarget_1.setTransportTarget,
-            setDevclassObjs_1.setDevclassObjs,
+            setDevclass_1.setDevclass,
             findDependencies_1.findDependencies,
-            setTrmDependencies_1.setTrmDependencies,
-            setSapEntries_1.setSapEntries,
-            editTrmDependencies_1.editTrmDependencies,
-            editSapEntries_1.editSapEntries,
-            logDependencies_1.logDependencies,
-            overwriteManifestValues_1.overwriteManifestValues,
-            setBackwardsCompatible_1.setBackwardsCompatible,
-            setPrivate_1.setPrivate,
             setManifestValues_1.setManifestValues,
-            buildTrmPackageInstance_1.buildTrmPackageInstance,
             setReadme_1.setReadme,
-            setCustTransports_1.setCustTransports,
-            generateDevcTr_1.generateDevcTr,
-            generateTadirTr_1.generateTadirTr,
-            generateLangTr_1.generateLangTr,
-            generateCustTr_1.generateCustTr,
-            releaseTadirTr_1.releaseTadirTr,
-            releaseLangTr_1.releaseLangTr,
-            releaseCustTr_1.releaseCustTr,
-            releaseDevcTr_1.releaseDevcTr,
-            generateTrmArtifact_1.generateTrmArtifact,
-            publishTrmArtifact_1.publishTrmArtifact,
+            setCustomizingTransports_1.setCustomizingTransports,
+            generateDevcTransport_1.generateDevcTransport,
+            generateTadirTransport_1.generateTadirTransport,
+            generateLangTransport_1.generateLangTransport,
+            generateCustTransport_1.generateCustTransport,
+            releaseTransports_1.releaseTransports,
+            publishToRegistry_1.publishToRegistry,
             finalizePublish_1.finalizePublish
         ];
-        logger_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        logger_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,
-            parsedInput: {},
-            runtime: {}
+            rawInput: inputData
         });
-        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        if (result.output && result.output.trmPackage) {
-            return result.output.trmPackage;
-        }
-        else {
-            throw new Error(`An error occurred during publish.`);
-        }
+        logger_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
+        };
     });
 }
-exports.publish = publish;

package/dist/actions/publish/init.js

@@ -11,105 +11,182 @@ 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 trmPackage_1 = require("../../trmPackage");
-const Inquirer_1 = require("../../inquirer/Inquirer");
+const inquirer_1 = require("../../inquirer");
 const semver_1 = require("semver");
-const commons_1 = require("../../commons");
+const systemConnector_1 = require("../../systemConnector");
+const registry_1 = require("../../registry");
+const transport_1 = require("../../transport");
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const registry = context.rawInput.registry;
-        if (process.env.TRM_ENV === 'DEV') {
-            logger_1.Logger.warning(`Running in development, rolling back after publish (PACKAGE WON'T BE UNPUBLISHED FROM REGISTRY!)`);
+        logger_1.Logger.log('Init step', true);
+        const registry = context.rawInput.packageData.registry;
+        if (registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
+            logger_1.Logger.log(`Public registry, checking if logged in`, true);
+            try {
+                yield registry.whoAmI();
+            }
+            catch (e) {
+                throw new Error(`Publish not allowed: ${e.message}`);
+            }
         }
-        var packageName = context.rawInput.package.name.toLowerCase().trim();
-        packageName = (0, commons_1.parsePackageName)({
-            fullName: packageName
+        context.rawInput.packageData.name = (0, commons_1.parsePackageName)({
+            fullName: context.rawInput.packageData.name
         }).fullName;
-        var packageVersion = context.rawInput.package.version;
-        if (!packageVersion) {
-            throw new Error(`Package version empty.`);
+        if (!context.rawInput.contextData) {
+            context.rawInput.contextData = {};
+        }
+        if (!context.rawInput.systemData) {
+            context.rawInput.systemData = {
+                releaseTimeout: 180
+            };
+        }
+        if (!context.rawInput.publishData) {
+            context.rawInput.publishData = {
+                keepLatestReleaseManifestValues: true,
+                customizingTransports: []
+            };
+        }
+        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 (typeof (context.rawInput.publishData.customizingTransports) === 'string') {
+            context.rawInput.publishData.customizingTransports = context.rawInput.publishData.customizingTransports.split(',').map(o => {
+                try {
+                    return new transport_1.Transport(o.trim());
+                }
+                catch (e) {
+                    throw new Error(`Invalid customizing transport values: trkorr.`);
+                }
+            });
+        }
+        if (!context.rawInput.packageData.version) {
+            context.rawInput.packageData.version = 'latest';
         }
-        context.parsedInput.silent = context.rawInput.silent;
         var normalizeVersion = true;
         var normalizedVersion;
         logger_1.Logger.loading(`Checking package version...`);
         while (normalizeVersion) {
-            normalizedVersion = yield trmPackage_1.TrmPackage.normalizeVersion(packageName, packageVersion, registry);
-            if (normalizedVersion !== packageVersion) {
-                logger_1.Logger.info(`Version ${packageVersion} -> ${normalizedVersion}`);
-                const inq1 = yield Inquirer_1.Inquirer.prompt([{
-                        name: 'acceptNormalized',
-                        message: `Continue publish as version ${normalizedVersion}?`,
-                        type: 'confirm',
-                        default: true,
-                        when: !context.parsedInput.silent
-                    }, {
-                        name: 'inputVersion',
-                        message: `Input version to publish`,
-                        type: 'input',
-                        when: (hash) => {
-                            return !context.parsedInput.silent && !hash.acceptNormalized;
-                        },
-                        validate: (input) => {
-                            if (!input) {
-                                return false;
-                            }
-                            else {
-                                if (input.trim().toLowerCase() === 'latest') {
-                                    return true;
+            normalizedVersion = yield trmPackage_1.TrmPackage.normalizeVersion(context.rawInput.packageData.name, context.rawInput.packageData.version, registry);
+            if (normalizedVersion !== context.rawInput.packageData.version) {
+                logger_1.Logger.info(`Version ${context.rawInput.packageData.version} -> ${normalizedVersion}`);
+                if (!context.rawInput.contextData.noInquirer) {
+                    const inq = yield inquirer_1.Inquirer.prompt([{
+                            name: 'acceptNormalized',
+                            message: `Continue publish as version ${normalizedVersion}?`,
+                            type: 'confirm',
+                            default: true
+                        }, {
+                            name: 'inputVersion',
+                            message: `Input version to publish`,
+                            type: 'input',
+                            when: (hash) => {
+                                return !hash.acceptNormalized;
+                            },
+                            validate: (input) => {
+                                if (!input) {
+                                    return false;
                                 }
                                 else {
-                                    return (0, semver_1.clean)(input) ? true : false;
+                                    if (input.trim().toLowerCase() === 'latest') {
+                                        return true;
+                                    }
+                                    else {
+                                        return (0, semver_1.clean)(input) ? true : false;
+                                    }
                                 }
                             }
-                        }
-                    }]);
-                if (inq1.acceptNormalized || context.parsedInput.silent) {
-                    normalizeVersion = false;
+                        }]);
+                    if (inq.acceptNormalized) {
+                        normalizeVersion = false;
+                        context.rawInput.packageData.version = normalizedVersion;
+                    }
+                    else {
+                        normalizeVersion = true;
+                        context.rawInput.packageData.version = inq.inputVersion;
+                    }
                 }
                 else {
-                    normalizeVersion = true;
-                    packageVersion = inq1.inputVersion;
+                    normalizeVersion = false;
+                    context.rawInput.packageData.version = normalizedVersion;
                 }
             }
             else {
                 normalizeVersion = false;
             }
         }
-        context.parsedInput.packageName = packageName;
-        context.parsedInput.version = normalizedVersion;
-        context.parsedInput.releaseFolder = context.rawInput.tmpFolder;
-        context.parsedInput.releaseTimeout = context.rawInput.releaseTimeout || 180;
-        context.parsedInput.customizingTransports = context.rawInput.customizingTransports || [];
-        context.parsedInput.skipEditSapEntries = context.rawInput.skipEditSapEntries;
-        context.parsedInput.skipEditDependencies = context.rawInput.skipEditDependencies;
-        context.parsedInput.skipDependencies = context.rawInput.skipDependencies;
-        context.parsedInput.skipLang = context.rawInput.skipLang;
-        context.parsedInput.overwriteManifestValues = context.rawInput.overwriteManifestValues;
-        context.parsedInput.packageBackwardsCompatible = context.rawInput.package ? context.rawInput.package.backwardsCompatible : null;
-        context.parsedInput.skipCust = context.rawInput.skipCust;
-        context.parsedInput.devclass = context.rawInput.devclass;
-        context.parsedInput.forceManifestInput = context.rawInput.forceManifestInput;
-        context.parsedInput.packagePrivate = context.rawInput.package ? context.rawInput.package.private : null;
-        context.parsedInput.skipReadme = context.rawInput.skipReadme;
-        context.parsedInput.readme = context.rawInput.readme || '';
-        context.parsedInput.target = context.rawInput.target;
-        context.runtime.registry = registry;
-        context.runtime.dummyPackage = new trmPackage_1.TrmPackage(packageName, registry);
-        context.runtime.manifest = context.rawInput.package;
-        context.runtime.manifest.name = packageName;
-        context.runtime.manifest.version = normalizedVersion;
-        if (!context.runtime.manifest.sapEntries) {
-            context.runtime.manifest.sapEntries = {};
-        }
-        if (!context.runtime.manifest.dependencies) {
-            context.runtime.manifest.dependencies = [];
-        }
-        context.runtime.dependencies = {
-            sapEntries: [],
-            trmDependencies: [],
-            unknownDependencies: []
+        context.runtime = {
+            rollback: false,
+            trmPackage: {
+                package: new trmPackage_1.TrmPackage(context.rawInput.packageData.name, registry),
+                registry,
+                manifest: Object.assign(Object.assign({}, context.rawInput.packageData.manifest), {
+                    name: context.rawInput.packageData.name,
+                    version: context.rawInput.packageData.version
+                })
+            },
+            systemData: {
+                transportTargets: [],
+                devcTransport: undefined,
+                tadirTransport: undefined,
+                releasedTransports: []
+            },
+            packageData: {
+                tadir: []
+            }
         };
+        logger_1.Logger.loading(`Reading ${systemConnector_1.SystemConnector.getDest()} transport targets...`);
+        context.runtime.systemData.transportTargets = (yield systemConnector_1.SystemConnector.getTransportTargets()).sort((a, b) => {
+            if (a.systyp === 'V') {
+                return -1;
+            }
+            else if (b.systyp === 'V') {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+        if (context.rawInput.publishData.skipCustomizingTransports) {
+            context.rawInput.publishData.customizingTransports = [];
+        }
+        logger_1.Logger.loading(`Checking package "${context.rawInput.packageData.name}"...`);
+        const packageExists = yield context.runtime.trmPackage.package.exists();
+        const canPublishReleases = yield context.runtime.trmPackage.package.canPublishReleases();
+        if (!canPublishReleases.canPublishReleases) {
+            if (canPublishReleases.cause) {
+                logger_1.Logger.error(canPublishReleases.cause);
+            }
+            throw new Error(`You are not not authorized to publish "${context.rawInput.packageData.name}" releases.`);
+        }
+        if (!packageExists) {
+            logger_1.Logger.info(`First time publishing "${context.rawInput.packageData.name}". Congratulations!`);
+        }
+        else {
+            context.runtime.trmPackage.latestReleaseManifest = (yield context.runtime.trmPackage.package.fetchRemoteManifest('latest')).get();
+            if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC && !!(context.rawInput.publishData.private) !== !!(context.runtime.trmPackage.latestReleaseManifest.private)) {
+                throw new Error(`Cannot change package "${context.rawInput.packageData.name}" visibility from ${context.runtime.trmPackage.latestReleaseManifest.private ? 'private' : 'public'} to ${context.rawInput.publishData.private ? 'private' : 'public'}.`);
+            }
+        }
+    }),
+    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.`);
+        }
     })
 };

package/dist/actions/publish/{setCustTransports.d.ts → publishToRegistry.d.ts}

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

package/dist/actions/publish/{buildTrmPackageInstance.js → publishToRegistry.js}

@@ -9,14 +9,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildTrmPackageInstance = void 0;
-const manifest_1 = require("../../manifest");
+exports.publishToRegistry = void 0;
+const logger_1 = require("../../logger");
 const trmPackage_1 = require("../../trmPackage");
-exports.buildTrmPackageInstance = {
-    name: 'build-trm-package-instance',
+const manifest_1 = require("../../manifest");
+exports.publishToRegistry = {
+    name: 'publish-to-registry',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        context.runtime.manifest = manifest_1.Manifest.normalize(context.runtime.manifest, false);
-        const oManifest = new manifest_1.Manifest(context.runtime.manifest);
-        context.runtime.trmPackage = new trmPackage_1.TrmPackage(context.runtime.manifest.name, context.runtime.registry, oManifest);
+        logger_1.Logger.log('Publish to registry step', true);
+        logger_1.Logger.loading(`Creating TRM package...`);
+        context.runtime.trmPackage.artifact = yield trmPackage_1.TrmArtifact.create(context.runtime.systemData.releasedTransports, new manifest_1.Manifest(context.runtime.trmPackage.manifest));
+        logger_1.Logger.loading(`Publishing...`);
+        yield context.runtime.trmPackage.package.publish({
+            artifact: context.runtime.trmPackage.artifact,
+            readme: context.rawInput.publishData.readme
+        });
     })
 };

package/dist/actions/publish/{generateLangTr.d.ts → releaseTransports.d.ts}

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

package/dist/actions/publish/releaseTransports.js

@@ -0,0 +1,42 @@
+"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.releaseTransports = void 0;
+const logger_1 = require("../../logger");
+const inquirer_1 = require("../../inquirer");
+exports.releaseTransports = {
+    name: 'release-transport',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Release transports step', true);
+        const tmpFolder = context.rawInput.contextData.logTemporaryFolder;
+        const releaseTimeout = context.rawInput.systemData.releaseTimeout;
+        context.runtime.systemData.releasedTransports.push(context.runtime.systemData.tadirTransport);
+        if (context.runtime.systemData.langTransport) {
+            context.runtime.systemData.releasedTransports.push(context.runtime.systemData.langTransport);
+        }
+        if (context.runtime.systemData.custTransport) {
+            context.runtime.systemData.releasedTransports.push(context.runtime.systemData.custTransport);
+        }
+        context.runtime.systemData.releasedTransports.push(context.runtime.systemData.devcTransport);
+        var counter = 0;
+        for (const transport of context.runtime.systemData.releasedTransports) {
+            counter++;
+            const prefix = `(${counter}/${context.runtime.systemData.releasedTransports.length}) `;
+            logger_1.Logger.setPrefix(prefix);
+            inquirer_1.Inquirer.setPrefix(prefix);
+            logger_1.Logger.log(`Ready to release transport ${transport.trkorr}, ${transport.trmIdentifier}`, true);
+            logger_1.Logger.loading(`Releasing transport...`);
+            yield transport.release(false, releaseTimeout ? true : false, tmpFolder, releaseTimeout);
+            logger_1.Logger.removePrefix();
+            inquirer_1.Inquirer.removePrefix();
+        }
+    })
+};

package/dist/actions/publish/{buildTrmPackageInstance.d.ts → setCustomizingTransports.d.ts}

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