trm-core 2.2.3 → 3.0.0

package/dist/actions/install/importCustTransport.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCustTransport = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+exports.importCustTransport = {
+    name: 'import-cust-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.custTransport) {
+            if (context.parsedInput.skipCustImport) {
+                logger_1.Logger.log(`Skip import CUST transport (input)`, true);
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            logger_1.Logger.log(`Skip import CUST transport (no transport data in package)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const importTimeout = context.parsedInput.importTimeout;
+        const transportData = context.runtime.custTransport;
+        const target = systemConnector_1.SystemConnector.getDest();
+        logger_1.Logger.loading(`Importing transport to ${target}...`);
+        const transport = yield transport_1.Transport.upload({
+            binary: transportData.binaries,
+            trTarget: target
+        });
+        yield transport.import(importTimeout);
+        context.runtime.trCopy.push(transportData.trkorr);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.error(`CUST transport ${context.runtime.langTransport} can't be removed.`);
+    })
+};

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const importLangTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/importLangTransport.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importLangTransport = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+exports.importLangTransport = {
+    name: 'import-lang-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.langTransport) {
+            if (context.parsedInput.skipLangImport) {
+                logger_1.Logger.log(`Skip import LANG transport (input)`, true);
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            logger_1.Logger.log(`Skip import LANG transport (no transport data in package)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const importTimeout = context.parsedInput.importTimeout;
+        const transportData = context.runtime.langTransport;
+        const target = systemConnector_1.SystemConnector.getDest();
+        logger_1.Logger.loading(`Importing transport to ${target}...`);
+        const transport = yield transport_1.Transport.upload({
+            binary: transportData.binaries,
+            trTarget: target
+        });
+        yield transport.import(importTimeout);
+        context.runtime.trCopy.push(transportData.trkorr);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.error(`LANG transport ${context.runtime.langTransport} can't be removed.`);
+    })
+};

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const importTadirTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/importTadirTransport.js

@@ -0,0 +1,66 @@
+"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.importTadirTransport = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+exports.importTadirTransport = {
+    name: 'import-tadir-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.tadirTransport) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skip import TADIR transport (no transport data in package)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const importTimeout = context.parsedInput.importTimeout;
+        const transportData = context.runtime.tadirTransport;
+        const target = systemConnector_1.SystemConnector.getDest();
+        logger_1.Logger.loading(`Importing transport to ${target}...`);
+        const transport = yield transport_1.Transport.upload({
+            binary: transportData.binaries,
+            trTarget: target
+        });
+        yield transport.import(importTimeout);
+        const aTadir = context.runtime.tadirData;
+        const packageReplacements = context.runtime.packageReplacements;
+        logger_1.Logger.loading(`Finalizing TADIR import...`);
+        for (const tadir of aTadir) {
+            const replacementDevclass = packageReplacements.find(o => o.originalDevclass === tadir.devclass).installDevclass;
+            if (replacementDevclass) {
+                var object = tadir;
+                object.devclass = replacementDevclass;
+                object.srcsystem = 'TRM';
+                logger_1.Logger.log(`Running TADIR interface for object ${object.pgmid} ${object.object} ${object.objName}, devclass ${tadir.devclass} -> ${object.devclass}, src system ${tadir.srcsystem} -> ${object.srcsystem}`, true);
+                yield systemConnector_1.SystemConnector.tadirInterface(object);
+            }
+            else {
+                logger_1.Logger.error(`Replacement devclass not found for ${tadir.devclass}!`, true);
+            }
+        }
+        logger_1.Logger.success(`TADIR import finished.`);
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.loading(`Rollback TADIR transport ${context.runtime.tadirTransport.trkorr}...`);
+        try {
+            yield systemConnector_1.SystemConnector.addSkipTrkorr(context.runtime.tadirTransport.trkorr);
+            logger_1.Logger.info(`Executed rollback on transport ${context.runtime.tadirTransport.trkorr}`);
+        }
+        catch (e) {
+            logger_1.Logger.info(`Unable to rollback transport ${context.runtime.tadirTransport.trkorr}`);
+            logger_1.Logger.error(e.toString(), true);
+        }
+    })
+};

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

@@ -0,0 +1,95 @@
+import { Registry } from "../../registry";
+import { TransportBinary, TrmArtifact, TrmPackage } from "../../trmPackage";
+import { Manifest, TrmManifest, TrmManifestDependency } from "../../manifest";
+import { R3trans, R3transOptions } from "node-r3trans";
+import { DEVCLASS, E071, TADIR, TDEVC, TDEVCT } from "../../client";
+import { PackageHierarchy } from "../../commons";
+import { Transport } from "../../transport";
+export type InstallPackageReplacements = {
+    originalDevclass: string;
+    installDevclass: string;
+};
+export type InstallActionInput = {
+    packageName: string;
+    registry: Registry;
+    version?: string;
+    systemPackages?: TrmPackage[];
+    integrity?: string;
+    r3transOptions?: R3transOptions;
+    transportLayer?: string;
+    force?: boolean;
+    keepOriginalDevclass?: boolean;
+    importTimeout?: number;
+    generateTransport?: boolean;
+    skipSapEntriesCheck?: boolean;
+    skipObjectTypesCheck?: boolean;
+    skipLangImport?: boolean;
+    skipCustImport?: boolean;
+    ignoreDependencies?: boolean;
+    safeInstall?: boolean;
+    wbTrTargetSystem?: string;
+    silent?: boolean;
+    packageReplacements?: InstallPackageReplacements[];
+    allowReplace?: boolean;
+};
+type WorkflowParsedInput = {
+    packageName?: string;
+    version?: string;
+    skipAlreadyInstalledCheck?: boolean;
+    forceInstallSameVersion?: boolean;
+    overwriteInstall?: boolean;
+    systemPackages?: TrmPackage[];
+    checkSapEntries?: boolean;
+    checkDependencies?: boolean;
+    installMissingDependencies?: boolean;
+    installIntegrity?: string;
+    safeInstall?: boolean;
+    r3transOptions?: R3transOptions;
+    checkObjectTypes?: boolean;
+    keepOriginalPackages?: boolean;
+    forceDevclassInput?: boolean;
+    transportLayer?: string;
+    importTimeout?: number;
+    skipLangImport?: boolean;
+    skipCustImport?: boolean;
+    skipWbTransportGen?: boolean;
+    wbTrTargetSystem?: string;
+    packageReplacements?: InstallPackageReplacements[];
+    noInquirer?: boolean;
+};
+type WorkflowRuntime = {
+    registry?: Registry;
+    trmPackage?: TrmPackage;
+    manifest?: Manifest;
+    trmManifest?: TrmManifest;
+    dependenciesToInstall?: TrmManifestDependency[];
+    trmArtifact?: TrmArtifact;
+    r3trans?: R3trans;
+    devcTransport?: TransportBinary;
+    tadirTransport?: TransportBinary;
+    langTransport?: TransportBinary;
+    custTransport?: TransportBinary;
+    tdevcData?: TDEVC[];
+    tdevctData?: TDEVCT[];
+    tadirData?: TADIR[];
+    workbenchObjects?: E071[];
+    packageReplacements?: InstallPackageReplacements[];
+    generatedDevclass?: DEVCLASS[];
+    originalPackageHierarchy?: PackageHierarchy;
+    trCopy?: string[];
+    fetchedIntegrity?: string;
+    wbTransport?: Transport;
+};
+export type InstallActionOutput = {
+    trmPackage: TrmPackage;
+    registry: Registry;
+    wbTransport?: Transport;
+};
+export type InstallWorkflowContext = {
+    rawInput: InstallActionInput;
+    parsedInput: WorkflowParsedInput;
+    runtime: WorkflowRuntime;
+    output?: InstallActionOutput;
+};
+export declare function install(inputData: InstallActionInput): Promise<InstallActionOutput>;
+export {};

package/dist/actions/install/index.js

@@ -0,0 +1,79 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = void 0;
+const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const logger_1 = require("../../logger");
+const util_1 = require("util");
+const init_1 = require("./init");
+const setSystemPackages_1 = require("./setSystemPackages");
+const checkAlreadyInstalled_1 = require("./checkAlreadyInstalled");
+const checkSapEntries_1 = require("./checkSapEntries");
+const checkDependencies_1 = require("./checkDependencies");
+const checkIntegrity_1 = require("./checkIntegrity");
+const installDependencies_1 = require("./installDependencies");
+const checkTransports_1 = require("./checkTransports");
+const readDevcTransport_1 = require("./readDevcTransport");
+const setR3trans_1 = require("./setR3trans");
+const checkTadirContent_1 = require("./checkTadirContent");
+const checkTadirObjectTypes_1 = require("./checkTadirObjectTypes");
+const setDevclass_1 = require("./setDevclass");
+const generateDevclass_1 = require("./generateDevclass");
+const importTadirTransport_1 = require("./importTadirTransport");
+const importLangTransport_1 = require("./importLangTransport");
+const setPackageIntegrity_1 = require("./setPackageIntegrity");
+const generateWbTransport_1 = require("./generateWbTransport");
+const importCustTransport_1 = require("./importCustTransport");
+const WORKFLOW_NAME = 'install';
+function install(inputData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflow = [
+            init_1.init,
+            setSystemPackages_1.setSystemPackages,
+            checkAlreadyInstalled_1.checkAlreadyInstalled,
+            checkIntegrity_1.checkIntegrity,
+            checkSapEntries_1.checkSapEntries,
+            checkDependencies_1.checkDependencies,
+            installDependencies_1.installDependencies,
+            setR3trans_1.setR3trans,
+            checkTransports_1.checkTransports,
+            readDevcTransport_1.readDevcTransport,
+            setDevclass_1.setDevclass,
+            checkTadirContent_1.checkTadirContent,
+            checkTadirObjectTypes_1.checkTadirObjectTypes,
+            generateDevclass_1.generateDevclass,
+            importTadirTransport_1.importTadirTransport,
+            importLangTransport_1.importLangTransport,
+            importCustTransport_1.importCustTransport,
+            setPackageIntegrity_1.setPackageIntegrity,
+            generateWbTransport_1.generateWbTransport
+        ];
+        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: {}
+        });
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const trmPackage = result.runtime.trmPackage;
+        const registry = result.runtime.registry;
+        const wbTransport = result.runtime.wbTransport;
+        return {
+            trmPackage,
+            registry,
+            wbTransport
+        };
+    });
+}
+exports.install = install;

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const init: Step<InstallWorkflowContext>;

package/dist/actions/install/init.js

@@ -0,0 +1,80 @@
+"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.init = void 0;
+const logger_1 = require("../../logger");
+const trmPackage_1 = require("../../trmPackage");
+const commons_1 = require("../../commons");
+const crypto_1 = require("crypto");
+exports.init = {
+    name: 'init',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var packageName = context.rawInput.packageName;
+        var packageVersion = context.rawInput.version || 'latest';
+        const registry = context.rawInput.registry;
+        packageName = (0, commons_1.parsePackageName)({
+            fullName: packageName
+        }).fullName;
+        if (packageVersion.trim().toLowerCase() === 'latest') {
+            packageVersion = 'latest';
+        }
+        logger_1.Logger.loading(`Searching TRM package in registry ${registry.name}...`);
+        const trmPackage = new trmPackage_1.TrmPackage(packageName, registry);
+        const oArtifact = yield trmPackage.fetchRemoteArtifact(packageVersion);
+        const installIntegrity = (0, crypto_1.createHash)("sha512").update(oArtifact.binary).digest("hex");
+        const oManifest = yield trmPackage.fetchRemoteManifest(packageVersion);
+        const trmManifest = oManifest.get();
+        var sVersion = trmManifest.version;
+        if (packageVersion === 'latest') {
+            sVersion = `latest -> ${trmManifest.version}`;
+        }
+        logger_1.Logger.info(`"${trmManifest.name}" version ${sVersion} found in registry ${registry.name}`);
+        context.runtime.registry = registry;
+        context.runtime.manifest = oManifest;
+        context.runtime.trmManifest = trmManifest;
+        context.runtime.trmPackage = trmPackage;
+        context.runtime.trmArtifact = oArtifact;
+        context.runtime.workbenchObjects = [];
+        context.runtime.trCopy = [];
+        context.runtime.fetchedIntegrity = installIntegrity;
+        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
+        context.parsedInput.packageName = packageName;
+        context.parsedInput.version = trmManifest.version;
+        context.parsedInput.safeInstall = context.rawInput.safeInstall ? true : false;
+        context.parsedInput.noInquirer = context.rawInput.silent ? true : false;
+        context.parsedInput.forceDevclassInput = context.rawInput.silent ? false : true;
+        if (context.rawInput.force) {
+            context.parsedInput.skipAlreadyInstalledCheck = true;
+            context.parsedInput.checkSapEntries = false;
+            context.parsedInput.checkObjectTypes = false;
+            context.parsedInput.forceInstallSameVersion = true;
+            context.parsedInput.overwriteInstall = true;
+            context.parsedInput.checkDependencies = false;
+        }
+        else {
+            context.parsedInput.skipAlreadyInstalledCheck = false;
+            context.parsedInput.checkSapEntries = context.rawInput.skipSapEntriesCheck ? false : true;
+            context.parsedInput.checkObjectTypes = context.rawInput.skipObjectTypesCheck ? false : true;
+            context.parsedInput.forceInstallSameVersion = false;
+            context.parsedInput.overwriteInstall = context.rawInput.allowReplace ? true : false;
+            context.parsedInput.checkDependencies = context.rawInput.ignoreDependencies ? false : true;
+        }
+        context.parsedInput.keepOriginalPackages = context.rawInput.keepOriginalDevclass ? true : false;
+        context.parsedInput.installMissingDependencies = context.rawInput.ignoreDependencies ? false : true;
+        context.parsedInput.transportLayer = context.rawInput.transportLayer;
+        context.parsedInput.wbTrTargetSystem = context.rawInput.wbTrTargetSystem;
+        context.parsedInput.installIntegrity = context.rawInput.integrity;
+        context.parsedInput.r3transOptions = context.rawInput.r3transOptions;
+        context.parsedInput.importTimeout = context.rawInput.importTimeout || 180;
+        context.parsedInput.skipWbTransportGen = context.rawInput.generateTransport ? false : true;
+        context.parsedInput.packageReplacements = context.rawInput.packageReplacements || [];
+    })
+};

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const installDependencies: Step<InstallWorkflowContext>;

package/dist/actions/install/installDependencies.js

@@ -0,0 +1,77 @@
+"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.installDependencies = void 0;
+const logger_1 = require("../../logger");
+const Inquirer_1 = require("../../inquirer/Inquirer");
+const installDependency_1 = require("../installDependency");
+const util_1 = require("util");
+const registry_1 = require("../../registry");
+const SUBWORKFLOW_NAME = 'install-sub-install-dependency';
+exports.installDependencies = {
+    name: 'install-dependencies',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.dependenciesToInstall.length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping dependencies install because there are no dependencies to install`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const mainPackageName = context.parsedInput.packageName;
+        const dependenciesToInstall = context.runtime.dependenciesToInstall;
+        var continueInstall = false;
+        if (context.parsedInput.installMissingDependencies) {
+            continueInstall = true;
+        }
+        else {
+            if (!context.parsedInput.noInquirer) {
+                const inq1 = yield Inquirer_1.Inquirer.prompt({
+                    type: 'confirm',
+                    name: 'continueInstall',
+                    default: true,
+                    message: `Do you wish to install all of the missing dependencies?`
+                });
+                continueInstall = inq1.continueInstall;
+            }
+            else {
+                logger_1.Logger.info(`Dependencies are not being installed: running in silent and no action was taken.`);
+                continueInstall = false;
+            }
+        }
+        if (continueInstall) {
+            var installCounter = 0;
+            for (const installDependency of dependenciesToInstall) {
+                installCounter++;
+                logger_1.Logger.info(`-> (${installCounter}/${dependenciesToInstall.length}) Dependency "${installDependency.name}" install started.`);
+                const inputData = {
+                    packageName: installDependency.name,
+                    versionRange: installDependency.version,
+                    installOptions: context.rawInput,
+                    registry: new registry_1.Registry(installDependency.registry || 'public'),
+                    integrity: installDependency.integrity,
+                    systemPackages: context.parsedInput.systemPackages,
+                    forceInstall: context.parsedInput.skipAlreadyInstalledCheck
+                };
+                logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+                const result = yield (0, installDependency_1.installDependency)(inputData);
+                logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+                logger_1.Logger.info(`   (${installCounter}/${dependenciesToInstall.length}) Dependency "${installDependency.name}" install completed.`);
+            }
+            logger_1.Logger.success(`-> ${dependenciesToInstall.length}/${dependenciesToInstall.length} dependencies installed, package "${mainPackageName}" install can continue.`);
+        }
+        else {
+            throw new Error(`Package has missing dependencies that need to be installed in order to continue.`);
+        }
+    })
+};

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const readDevcTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/readDevcTransport.js

@@ -0,0 +1,30 @@
+"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.readDevcTransport = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+exports.readDevcTransport = {
+    name: 'read-devc-transport',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const r3trans = context.runtime.r3trans;
+        const devcTransport = context.runtime.devcTransport;
+        const transportData = devcTransport.binaries.data;
+        logger_1.Logger.loading(`Checking package content...`);
+        const tdevc = (0, commons_1.normalize)(yield r3trans.getTableEntries(transportData, 'TDEVC'));
+        const tdevct = (0, commons_1.normalize)(yield r3trans.getTableEntries(transportData, 'TDEVCT'));
+        if (tdevc.length === 0) {
+            throw new Error(`Package has no devclass data.`);
+        }
+        context.runtime.tdevcData = tdevc;
+        context.runtime.tdevctData = tdevct;
+    })
+};

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const setDevclass: Step<InstallWorkflowContext>;