trm-core 2.2.2 → 3.0.0

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

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

package/dist/actions/checkPackageDependencies/analizeDependencies.js

@@ -0,0 +1,84 @@
+"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.analizeDependencies = 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.analizeDependencies = {
+    name: 'analize-dependencies',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.systemPackages && context.parsedInput.systemPackages.length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.info(`Package ${context.parsedInput.packageName} has no TRM package dependencies`, context.parsedInput.print);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const dependencies = context.parsedInput.dependencies;
+        const systemPackages = context.parsedInput.systemPackages;
+        logger_1.Logger.info(`Package ${context.parsedInput.packageName} has ${dependencies.length} TRM package dependencies`, context.parsedInput.print);
+        context.runtime.versionOkDependencies = [];
+        context.runtime.versionKoDependencies = [];
+        context.runtime.integrityOkDependencies = [];
+        context.runtime.integrityKoDependencies = [];
+        context.runtime.table = {
+            head: ['Dependency', 'Registry', 'Dependency range', 'Version on system', 'Version status', 'Integrity status'],
+            data: []
+        };
+        var tableData;
+        for (const dependency of dependencies) {
+            tableData = [dependency.name, dependency.registry || 'public', dependency.version];
+            const dependencyTrmPackage = new trmPackage_1.TrmPackage(dependency.name, new registry_1.Registry(dependency.registry || 'public'));
+            const systemInstalledPackage = 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.versionOkDependencies.push(dependency);
+                }
+                else {
+                    tableData.push('ERR!');
+                    context.runtime.versionKoDependencies.push(dependency);
+                }
+            }
+            else {
+                tableData.push('Not found');
+                tableData.push('ERR!');
+                context.runtime.versionKoDependencies.push(dependency);
+            }
+            try {
+                const installedPackageIntegrity = yield systemConnector_1.SystemConnector.getPackageIntegrity(systemInstalledPackage);
+                if (installedPackageIntegrity === dependency.integrity) {
+                    tableData.push('Safe');
+                    context.runtime.integrityOkDependencies.push(dependency);
+                }
+                else {
+                    tableData.push('Unsafe');
+                    context.runtime.integrityKoDependencies.push(dependency);
+                }
+            }
+            catch (e) {
+                tableData.push('Unknown');
+                context.runtime.integrityKoDependencies.push(dependency);
+                logger_1.Logger.error(e.toString(), true);
+                logger_1.Logger.error(`Couldn't retrieve package integrity`, true);
+            }
+            context.runtime.table.data.push(tableData);
+        }
+        logger_1.Logger.table(context.runtime.table.head, context.runtime.table.data, context.parsedInput.print);
+    })
+};

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

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

package/dist/actions/checkPackageDependencies/buildOutput.js

@@ -0,0 +1,82 @@
+"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.buildOutput = void 0;
+exports.buildOutput = {
+    name: 'build-output',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const items = context.runtime.versionOkDependencies.length +
+                context.runtime.versionKoDependencies.length +
+                context.runtime.integrityOkDependencies.length +
+                context.runtime.integrityKoDependencies.length;
+            return items > 0;
+        }
+        catch (e) {
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        context.output.dependencyStatus = [];
+        context.runtime.versionOkDependencies.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.versionKoDependencies.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.integrityOkDependencies.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.integrityKoDependencies.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

@@ -0,0 +1,37 @@
+import { TrmPackage } from "../../trmPackage";
+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[];
+};
+type WorkflowRuntime = {
+    table?: LogTableStruct;
+    versionOkDependencies?: TrmManifestDependency[];
+    versionKoDependencies?: TrmManifestDependency[];
+    integrityOkDependencies?: TrmManifestDependency[];
+    integrityKoDependencies?: TrmManifestDependency[];
+};
+export type CheckPackageDependencyActionOutput = {
+    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 {};

package/dist/actions/checkPackageDependencies/index.js

@@ -0,0 +1,44 @@
+"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.checkPackageDependencies = 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 analizeDependencies_1 = require("./analizeDependencies");
+const buildOutput_1 = require("./buildOutput");
+const WORKFLOW_NAME = 'check-package-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
+        ];
+        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: {}
+        });
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const output = result.output;
+        return output;
+    });
+}
+exports.checkPackageDependencies = checkPackageDependencies;

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

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

package/dist/actions/checkPackageDependencies/init.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.init = void 0;
+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 = [];
+        }
+        context.output = {
+            dependencies: context.parsedInput.dependencies
+        };
+    })
+};

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

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

package/dist/actions/checkPackageDependencies/setSystemPackages.js

@@ -0,0 +1,28 @@
+"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.setSystemPackages = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.setSystemPackages = {
+    name: 'set-system-packages',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        return context.parsedInput.dependencies.length > 0;
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var systemPackages = context.parsedInput.systemPackages;
+        if (systemPackages.length === 0) {
+            logger_1.Logger.loading(`Reading system packages`, true);
+            systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
+        }
+        context.parsedInput.systemPackages = systemPackages;
+    })
+};

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

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

package/dist/actions/checkSapEntries/analizeSapEntries.js

@@ -0,0 +1,120 @@
+"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.analizeSapEntries = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+exports.analizeSapEntries = {
+    name: 'analize-sap-entries',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.sapEntries && Object.keys(context.parsedInput.sapEntries).length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.info(`Package ${context.parsedInput.packageName} has no SAP entries`, context.parsedInput.print);
+            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 = [];
+        var entriesCount = 0;
+        var tableFields = [];
+        Object.keys(sapEntries).forEach(tableName => {
+            var aFields = [];
+            sapEntries[tableName].forEach(o => {
+                entriesCount++;
+                Object.keys(o).forEach(field => {
+                    if (!aFields.includes(field)) {
+                        aFields.push(field);
+                    }
+                });
+            });
+            tableFields.push({
+                tableName,
+                fields: aFields
+            });
+        });
+        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)) {
+            var tableExists;
+            try {
+                tableExists = yield systemConnector_1.SystemConnector.checkSapEntryExists('TADIR', {
+                    pgmid: 'R3TR',
+                    object: 'TABL',
+                    obj_name: table
+                });
+            }
+            catch (e) {
+                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);
+            }
+            else {
+                var printTableHead = ['Table name'];
+                var printTableData = [];
+                var tableData;
+                printTableHead = printTableHead.concat(tableFields.find(o => o.tableName === table).fields);
+                printTableHead.push('Status');
+                for (const tableEntry of sapEntries[table]) {
+                    tableData = [table];
+                    var entryStatus;
+                    try {
+                        const exists = yield systemConnector_1.SystemConnector.checkSapEntryExists(table, tableEntry);
+                        if (exists) {
+                            entryStatus = `OK`;
+                            context.runtime.okEntries.push({
+                                table,
+                                tableEntry
+                            });
+                        }
+                        else {
+                            entryStatus = `NOT FOUND`;
+                            context.runtime.koEntries.push({
+                                table,
+                                tableEntry
+                            });
+                        }
+                    }
+                    catch (e) {
+                        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({
+                            table,
+                            tableEntry
+                        });
+                    }
+                    Object.keys(tableEntry).forEach(field => {
+                        const pushIndex = printTableHead.findIndex(headerName => headerName === field);
+                        tableData.splice(pushIndex, 0, tableEntry[field]);
+                    });
+                    tableData.push(entryStatus);
+                    printTableData.push(tableData);
+                }
+                context.runtime.tables.push({
+                    head: printTableHead,
+                    data: printTableData
+                });
+            }
+        }
+        context.runtime.tables.forEach(t => {
+            logger_1.Logger.table(t.head, t.data, context.parsedInput.print);
+        });
+    })
+};

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

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

package/dist/actions/checkSapEntries/buildOutput.js

@@ -0,0 +1,46 @@
+"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.buildOutput = void 0;
+exports.buildOutput = {
+    name: 'build-output',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const items = context.runtime.okEntries.length +
+                context.runtime.okEntries.length;
+            return items > 0;
+        }
+        catch (e) {
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        context.output.sapEntriesStatus = {};
+        context.runtime.okEntries.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.koEntries.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

@@ -0,0 +1,29 @@
+import { TrmPackage } from "../../trmPackage";
+import { LogTableStruct } from "../../commons";
+export type CheckSapEntriesActionInput = {
+    trmPackage: TrmPackage;
+    print: boolean;
+};
+type WorkflowParsedInput = {
+    packageName?: string;
+    sapEntries?: any;
+    print?: boolean;
+};
+type WorkflowRuntime = {
+    tables?: LogTableStruct[];
+    okEntries?: any;
+    koEntries?: any;
+};
+export type CheckSapEntriesActionOutput = {
+    sapEntries?: any;
+    sapEntriesStatus?: any;
+    unknownTables?: string[];
+};
+export type CheckSapEntriesWorkflowContext = {
+    rawInput: CheckSapEntriesActionInput;
+    parsedInput: WorkflowParsedInput;
+    runtime: WorkflowRuntime;
+    output: CheckSapEntriesActionOutput;
+};
+export declare function checkSapEntries(inputData: CheckSapEntriesActionInput): Promise<CheckSapEntriesActionOutput>;
+export {};

package/dist/actions/checkSapEntries/index.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSapEntries = 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 analizeSapEntries_1 = require("./analizeSapEntries");
+const buildOutput_1 = require("./buildOutput");
+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
+        ];
+        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: {}
+        });
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const output = result.output;
+        return output;
+    });
+}
+exports.checkSapEntries = checkSapEntries;

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

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

package/dist/actions/checkSapEntries/init.js

@@ -0,0 +1,29 @@
+"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;
+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 = {};
+        }
+        context.output = {
+            sapEntries: context.parsedInput.sapEntries
+        };
+    })
+};

package/dist/actions/findDependencies/acknowledgementSize.d.ts

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

package/dist/actions/findDependencies/acknowledgementSize.js

@@ -0,0 +1,36 @@
+"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.acknowledgementSize = void 0;
+const inquirer_1 = require("../../inquirer");
+exports.acknowledgementSize = {
+    name: 'acknowledgement-size',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.tadir.length > 50) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const size = context.parsedInput.tadir.length;
+        const inq1 = yield inquirer_1.Inquirer.prompt({
+            type: 'confirm',
+            name: 'continueDependency',
+            default: true,
+            message: `A total of ${size} objects will be analyzed in order to find dependencies, and it may take a long time. Continue?`
+        });
+        if (!inq1.continueDependency) {
+            throw new Error(`Process aborted by user.`);
+        }
+    })
+};