trm-core 4.1.4 → 6.0.0

package/dist/actions/checkPackageDependencies/analyze.d.ts

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

package/dist/actions/checkPackageDependencies/analyze.js

@@ -0,0 +1,131 @@
+"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.analyze = void 0;
+const logger_1 = require("../../logger");
+const trmPackage_1 = require("../../trmPackage");
+const registry_1 = require("../../registry");
+const semver_1 = require("semver");
+const systemConnector_1 = require("../../systemConnector");
+exports.analyze = {
+    name: 'analyze',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.output.dependencies.length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.info(`Package ${context.rawInput.packageData.package.packageName} has no TRM package dependencies`, !context.rawInput.printOptions.information);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Analyze step', true);
+        logger_1.Logger.info(`Package ${context.rawInput.packageData.package.packageName} has ${context.output.dependencies.length} TRM package dependencies`, !context.rawInput.printOptions.information);
+        var table = {
+            header: ['Dependency', 'Registry', 'Dependency range', 'Version on system', 'Version status', 'Integrity status'],
+            data: []
+        };
+        var tableData;
+        for (const dependency of context.output.dependencies) {
+            tableData = [dependency.name, dependency.registry || registry_1.PUBLIC_RESERVED_KEYWORD, dependency.version];
+            const dependencyTrmPackage = new trmPackage_1.TrmPackage(dependency.name, new registry_1.Registry(dependency.registry || registry_1.PUBLIC_RESERVED_KEYWORD));
+            const systemInstalledPackage = context.rawInput.contextData.systemPackages.find(o => trmPackage_1.TrmPackage.compare(o, dependencyTrmPackage));
+            if (systemInstalledPackage && systemInstalledPackage.manifest) {
+                const installedVersion = systemInstalledPackage.manifest.get().version;
+                tableData.push(installedVersion);
+                if ((0, semver_1.satisfies)(installedVersion, dependency.version)) {
+                    tableData.push('OK');
+                    context.runtime.dependenciesStatus.goodVersion.push(dependency);
+                }
+                else {
+                    tableData.push('ERR!');
+                    context.runtime.dependenciesStatus.badVersion.push(dependency);
+                }
+            }
+            else {
+                tableData.push('Not found');
+                tableData.push('ERR!');
+                context.runtime.dependenciesStatus.badVersion.push(dependency);
+            }
+            try {
+                const installedPackageIntegrity = yield systemConnector_1.SystemConnector.getPackageIntegrity(systemInstalledPackage);
+                if (installedPackageIntegrity === dependency.integrity) {
+                    tableData.push('Safe');
+                    context.runtime.dependenciesStatus.goodIntegrity.push(dependency);
+                }
+                else {
+                    tableData.push('Unsafe');
+                    context.runtime.dependenciesStatus.badIntegrity.push(dependency);
+                }
+            }
+            catch (e) {
+                tableData.push('Unknown');
+                context.runtime.dependenciesStatus.badIntegrity.push(dependency);
+                logger_1.Logger.error(e.toString(), true);
+                logger_1.Logger.error(`Couldn't retrieve package integrity`, true);
+            }
+            table.data.push(tableData);
+        }
+        logger_1.Logger.table(table.header, table.data, !context.rawInput.printOptions.dependencyStatus);
+        context.runtime.dependenciesStatus.goodVersion.forEach(o => {
+            const i = context.output.dependencyStatus.findIndex(k => k.dependency.name === o.name && k.dependency.registry === o.registry);
+            if (i >= 0) {
+                context.output.dependencyStatus[i].match = true;
+            }
+            else {
+                context.output.dependencyStatus.push({
+                    dependency: o,
+                    match: true,
+                    safe: null
+                });
+            }
+        });
+        context.runtime.dependenciesStatus.badVersion.forEach(o => {
+            const i = context.output.dependencyStatus.findIndex(k => k.dependency.name === o.name && k.dependency.registry === o.registry);
+            if (i >= 0) {
+                context.output.dependencyStatus[i].match = false;
+            }
+            else {
+                context.output.dependencyStatus.push({
+                    dependency: o,
+                    match: false,
+                    safe: null
+                });
+            }
+        });
+        context.runtime.dependenciesStatus.goodIntegrity.forEach(o => {
+            const i = context.output.dependencyStatus.findIndex(k => k.dependency.name === o.name && k.dependency.registry === o.registry);
+            if (i >= 0) {
+                context.output.dependencyStatus[i].safe = true;
+            }
+            else {
+                context.output.dependencyStatus.push({
+                    dependency: o,
+                    match: null,
+                    safe: true
+                });
+            }
+        });
+        context.runtime.dependenciesStatus.badIntegrity.forEach(o => {
+            const i = context.output.dependencyStatus.findIndex(k => k.dependency.name === o.name && k.dependency.registry === o.registry);
+            if (i >= 0) {
+                context.output.dependencyStatus[i].safe = false;
+            }
+            else {
+                context.output.dependencyStatus.push({
+                    dependency: o,
+                    match: null,
+                    safe: false
+                });
+            }
+        });
+    })
+};

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

@@ -1,37 +1,38 @@
 import { TrmPackage } from "../../trmPackage";
+import { IActionContext } from "../commons";
 import { TrmManifestDependency } from "../../manifest";
-import { LogTableStruct } from "../../commons";
-export type CheckPackageDependencyActionInput = {
-    trmPackage: TrmPackage;
-    print: boolean;
-    systemPackages?: TrmPackage[];
-};
-type WorkflowParsedInput = {
-    print?: boolean;
-    packageName?: string;
-    dependencies?: TrmManifestDependency[];
-    systemPackages?: TrmPackage[];
-};
+export interface CheckPackageDependenciesActionInput {
+    contextData?: {
+        systemPackages?: TrmPackage[];
+    };
+    packageData: {
+        package: TrmPackage;
+    };
+    printOptions?: {
+        dependencyStatus?: boolean;
+        information?: boolean;
+    };
+}
 type WorkflowRuntime = {
-    table?: LogTableStruct;
-    versionOkDependencies?: TrmManifestDependency[];
-    versionKoDependencies?: TrmManifestDependency[];
-    integrityOkDependencies?: TrmManifestDependency[];
-    integrityKoDependencies?: TrmManifestDependency[];
+    dependenciesStatus: {
+        goodVersion: TrmManifestDependency[];
+        badVersion: TrmManifestDependency[];
+        goodIntegrity: TrmManifestDependency[];
+        badIntegrity: TrmManifestDependency[];
+    };
 };
-export type CheckPackageDependencyActionOutput = {
-    dependencies?: TrmManifestDependency[];
-    dependencyStatus?: {
+export type CheckPackageDependenciesActionOutput = {
+    dependencies: TrmManifestDependency[];
+    dependencyStatus: {
         dependency: TrmManifestDependency;
         match: boolean;
         safe: boolean;
     }[];
 };
-export type CheckPackageDependencyWorkflowContext = {
-    rawInput: CheckPackageDependencyActionInput;
-    parsedInput: WorkflowParsedInput;
-    runtime: WorkflowRuntime;
-    output: CheckPackageDependencyActionOutput;
-};
-export declare function checkPackageDependencies(inputData: CheckPackageDependencyActionInput): Promise<CheckPackageDependencyActionOutput>;
+export interface CheckPackageDependenciesWorkflowContext extends IActionContext {
+    rawInput: CheckPackageDependenciesActionInput;
+    runtime?: WorkflowRuntime;
+    output?: CheckPackageDependenciesActionOutput;
+}
+export declare function checkPackageDependencies(inputData: CheckPackageDependenciesActionInput): Promise<CheckPackageDependenciesActionOutput>;
 export {};

package/dist/actions/checkPackageDependencies/index.js

@@ -12,32 +12,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkPackageDependencies = void 0;
+exports.checkPackageDependencies = checkPackageDependencies;
 const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const util_1 = require("util");
 const logger_1 = require("../../logger");
+const commons_1 = require("../commons");
 const init_1 = require("./init");
-const setSystemPackages_1 = require("./setSystemPackages");
-const analizeDependencies_1 = require("./analizeDependencies");
-const buildOutput_1 = require("./buildOutput");
-const WORKFLOW_NAME = 'check-package-dependencies';
+const analyze_1 = require("./analyze");
+;
+const WORKFLOW_NAME = 'check-dependencies';
 function checkPackageDependencies(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             init_1.init,
-            setSystemPackages_1.setSystemPackages,
-            analizeDependencies_1.analizeDependencies,
-            buildOutput_1.buildOutput
+            commons_1.setSystemPackages,
+            analyze_1.analyze
         ];
-        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: {},
-            output: {}
+            rawInput: inputData
         });
-        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        const output = result.output;
-        return output;
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        return result.output;
     });
 }
-exports.checkPackageDependencies = checkPackageDependencies;

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

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

package/dist/actions/checkPackageDependencies/init.js

@@ -10,21 +10,29 @@ 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");
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        context.parsedInput.packageName = context.rawInput.trmPackage.packageName;
-        context.parsedInput.print = !(context.rawInput.print ? true : false);
-        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
-        if (context.rawInput.trmPackage.manifest) {
-            const manifest = context.rawInput.trmPackage.manifest.get();
-            context.parsedInput.dependencies = manifest.dependencies || [];
-        }
-        else {
-            context.parsedInput.dependencies = [];
-        }
+        logger_1.Logger.log('Init step', true);
         context.output = {
-            dependencies: context.parsedInput.dependencies
+            dependencies: [],
+            dependencyStatus: []
+        };
+        context.runtime = {
+            dependenciesStatus: {
+                goodVersion: [],
+                badVersion: [],
+                goodIntegrity: [],
+                badIntegrity: []
+            }
         };
+        if (context.rawInput.packageData.package.manifest) {
+            const manifest = context.rawInput.packageData.package.manifest.get();
+            context.output.dependencies = manifest.dependencies || [];
+        }
+        if (!context.rawInput.printOptions) {
+            context.rawInput.printOptions = {};
+        }
     })
 };

package/dist/actions/checkSapEntries/{buildOutput.d.ts → analyze.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { CheckSapEntriesWorkflowContext } from ".";
-export declare const buildOutput: Step<CheckSapEntriesWorkflowContext>;
+export declare const analyze: Step<CheckSapEntriesWorkflowContext>;

package/dist/actions/checkSapEntries/{analizeSapEntries.js → analyze.js}

@@ -9,30 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analizeSapEntries = void 0;
+exports.analyze = void 0;
 const logger_1 = require("../../logger");
 const systemConnector_1 = require("../../systemConnector");
-exports.analizeSapEntries = {
-    name: 'analize-sap-entries',
+exports.analyze = {
+    name: 'analyze',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.parsedInput.sapEntries && Object.keys(context.parsedInput.sapEntries).length > 0) {
+        if (Object.keys(context.output.sapEntries).length > 0) {
             return true;
         }
         else {
-            logger_1.Logger.info(`Package ${context.parsedInput.packageName} has no SAP entries`, context.parsedInput.print);
+            logger_1.Logger.info(`Package ${context.rawInput.packageData.package.packageName} has no SAP entries`, !context.rawInput.printOptions.information);
             return false;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const sapEntries = context.parsedInput.sapEntries;
-        context.runtime.okEntries = [];
-        context.runtime.koEntries = [];
-        context.runtime.tables = [];
+        logger_1.Logger.log('Analyze step', true);
+        var logTable = [];
         var entriesCount = 0;
         var tableFields = [];
-        Object.keys(sapEntries).forEach(tableName => {
+        Object.keys(context.output.sapEntries).forEach(tableName => {
             var aFields = [];
-            sapEntries[tableName].forEach(o => {
+            context.output.sapEntries[tableName].forEach(o => {
                 entriesCount++;
                 Object.keys(o).forEach(field => {
                     if (!aFields.includes(field)) {
@@ -45,11 +43,11 @@ exports.analizeSapEntries = {
                 fields: aFields
             });
         });
+        logger_1.Logger.info(`Package ${context.rawInput.packageData.package.packageName} has ${entriesCount} SAP entries`, !context.rawInput.printOptions.information);
         if (entriesCount === 0) {
             return;
         }
-        logger_1.Logger.info(`Package ${context.parsedInput.packageName} has ${entriesCount} SAP entries`, context.parsedInput.print);
-        for (const table of Object.keys(sapEntries)) {
+        for (const table of Object.keys(context.output.sapEntries)) {
             var tableExists;
             try {
                 tableExists = yield systemConnector_1.SystemConnector.checkSapEntryExists('TADIR', {
@@ -62,8 +60,8 @@ exports.analizeSapEntries = {
                 tableExists = false;
             }
             if (!tableExists) {
-                context.output.unknownTables.push(table);
-                logger_1.Logger.error(`Required ${sapEntries[table].length} entries in ${table}, but table was not found`, context.parsedInput.print);
+                context.runtime.missingTables.push(table);
+                logger_1.Logger.error(`Required ${context.output.sapEntries[table].length} entries in ${table}, but table was not found`, !context.rawInput.printOptions.information);
             }
             else {
                 var printTableHead = ['Table name'];
@@ -71,21 +69,21 @@ exports.analizeSapEntries = {
                 var tableData;
                 printTableHead = printTableHead.concat(tableFields.find(o => o.tableName === table).fields);
                 printTableHead.push('Status');
-                for (const tableEntry of sapEntries[table]) {
+                for (const tableEntry of context.output.sapEntries[table]) {
                     tableData = [table];
                     var entryStatus;
                     try {
                         const exists = yield systemConnector_1.SystemConnector.checkSapEntryExists(table, tableEntry);
                         if (exists) {
                             entryStatus = `OK`;
-                            context.runtime.okEntries.push({
+                            context.runtime.entriesStatus.good.push({
                                 table,
                                 tableEntry
                             });
                         }
                         else {
                             entryStatus = `NOT FOUND`;
-                            context.runtime.koEntries.push({
+                            context.runtime.entriesStatus.bad.push({
                                 table,
                                 tableEntry
                             });
@@ -95,7 +93,7 @@ exports.analizeSapEntries = {
                         logger_1.Logger.error(e.toString(), true);
                         logger_1.Logger.error(`Error during check of SAP entry ${JSON.stringify(tableEntry)}`, true);
                         entryStatus = `Unknown`;
-                        context.runtime.koEntries.push({
+                        context.runtime.entriesStatus.bad.push({
                             table,
                             tableEntry
                         });
@@ -107,14 +105,33 @@ exports.analizeSapEntries = {
                     tableData.push(entryStatus);
                     printTableData.push(tableData);
                 }
-                context.runtime.tables.push({
-                    head: printTableHead,
+                logTable.push({
+                    header: printTableHead,
                     data: printTableData
                 });
             }
         }
-        context.runtime.tables.forEach(t => {
-            logger_1.Logger.table(t.head, t.data, context.parsedInput.print);
+        logTable.forEach(t => {
+            logger_1.Logger.table(t.header, t.data, !context.rawInput.printOptions.entriesStatus);
+        });
+        context.output.sapEntriesStatus = {};
+        context.runtime.entriesStatus.good.forEach(o => {
+            if (!context.output.sapEntriesStatus[o.table]) {
+                context.output.sapEntriesStatus[o.table] = [];
+            }
+            context.output.sapEntriesStatus[o.table].push({
+                status: true,
+                entry: o.tableEntry
+            });
+        });
+        context.runtime.entriesStatus.bad.forEach(o => {
+            if (!context.output.sapEntriesStatus[o.table]) {
+                context.output.sapEntriesStatus[o.table] = [];
+            }
+            context.output.sapEntriesStatus[o.table].push({
+                status: false,
+                entry: o.tableEntry
+            });
         });
     })
 };

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

@@ -1,29 +1,40 @@
 import { TrmPackage } from "../../trmPackage";
-import { LogTableStruct } from "../../commons";
-export type CheckSapEntriesActionInput = {
-    trmPackage: TrmPackage;
-    print: boolean;
-};
-type WorkflowParsedInput = {
-    packageName?: string;
-    sapEntries?: any;
-    print?: boolean;
-};
+export interface CheckSapEntriesActionInput {
+    packageData: {
+        package: TrmPackage;
+    };
+    printOptions?: {
+        entriesStatus?: boolean;
+        information?: boolean;
+    };
+}
 type WorkflowRuntime = {
-    tables?: LogTableStruct[];
-    okEntries?: any;
-    koEntries?: any;
+    entriesStatus: {
+        good: {
+            table: string;
+            tableEntry: any;
+        }[];
+        bad: {
+            table: string;
+            tableEntry: any;
+        }[];
+    };
+    missingTables: string[];
+};
+export type SapEntriesStatus = {
+    [key: string]: {
+        status: boolean;
+        entry: any;
+    }[];
 };
 export type CheckSapEntriesActionOutput = {
-    sapEntries?: any;
-    sapEntriesStatus?: any;
-    unknownTables?: string[];
+    sapEntries: any;
+    sapEntriesStatus: SapEntriesStatus;
 };
-export type CheckSapEntriesWorkflowContext = {
+export interface CheckSapEntriesWorkflowContext {
     rawInput: CheckSapEntriesActionInput;
-    parsedInput: WorkflowParsedInput;
-    runtime: WorkflowRuntime;
-    output: CheckSapEntriesActionOutput;
-};
+    runtime?: WorkflowRuntime;
+    output?: CheckSapEntriesActionOutput;
+}
 export declare function checkSapEntries(inputData: CheckSapEntriesActionInput): Promise<CheckSapEntriesActionOutput>;
 export {};

package/dist/actions/checkSapEntries/index.js

@@ -12,30 +12,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkSapEntries = void 0;
+exports.checkSapEntries = checkSapEntries;
 const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const util_1 = require("util");
 const logger_1 = require("../../logger");
 const init_1 = require("./init");
-const analizeSapEntries_1 = require("./analizeSapEntries");
-const buildOutput_1 = require("./buildOutput");
+const analyze_1 = require("./analyze");
+;
 const WORKFLOW_NAME = 'check-sap-entries';
 function checkSapEntries(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             init_1.init,
-            analizeSapEntries_1.analizeSapEntries,
-            buildOutput_1.buildOutput
+            analyze_1.analyze
         ];
-        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: {},
-            output: {}
+            rawInput: inputData
         });
-        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        const output = result.output;
-        return output;
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        return result.output;
     });
 }
-exports.checkSapEntries = checkSapEntries;

package/dist/actions/checkSapEntries/init.js

@@ -10,20 +10,28 @@ 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");
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        context.parsedInput.packageName = context.rawInput.trmPackage.packageName;
-        context.parsedInput.print = !(context.rawInput.print ? true : false);
-        if (context.rawInput.trmPackage.manifest) {
-            const manifest = context.rawInput.trmPackage.manifest.get();
-            context.parsedInput.sapEntries = manifest.sapEntries || {};
-        }
-        else {
-            context.parsedInput.sapEntries = {};
-        }
+        logger_1.Logger.log('Init step', true);
         context.output = {
-            sapEntries: context.parsedInput.sapEntries
+            sapEntries: {},
+            sapEntriesStatus: {}
+        };
+        context.runtime = {
+            entriesStatus: {
+                bad: [],
+                good: []
+            },
+            missingTables: []
         };
+        if (context.rawInput.packageData.package.manifest) {
+            const manifest = context.rawInput.packageData.package.manifest.get();
+            context.output.sapEntries = manifest.sapEntries || {};
+        }
+        if (!context.rawInput.printOptions) {
+            context.rawInput.printOptions = {};
+        }
     })
 };

package/dist/actions/commons/IActionContext.d.ts

@@ -0,0 +1,9 @@
+import { TrmPackage } from "../../trmPackage";
+export interface IActionContext {
+    rawInput: {
+        contextData?: {
+            systemPackages?: TrmPackage[];
+            noInquirer?: boolean;
+        };
+    };
+}

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

@@ -0,0 +1,2 @@
+export * from "./IActionContext";
+export * from "./setSystemPackages";

package/dist/actions/commons/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IActionContext"), exports);
+__exportStar(require("./setSystemPackages"), exports);

package/dist/actions/commons/setSystemPackages.d.ts

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

package/dist/actions/{install → commons}/setSystemPackages.js

@@ -10,16 +10,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSystemPackages = void 0;
-const systemConnector_1 = require("../../systemConnector");
 const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
 exports.setSystemPackages = {
-    name: 'set-system-packages',
+    name: 'setSystemPackages',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var systemPackages = context.parsedInput.systemPackages;
-        if (systemPackages.length === 0) {
+        logger_1.Logger.log('Set system packages step', true);
+        if (context.rawInput.contextData.systemPackages === undefined) {
             logger_1.Logger.loading(`Reading system data...`);
-            systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
+            context.rawInput.contextData.systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
         }
-        context.parsedInput.systemPackages = systemPackages;
     })
 };