trm-core 4.1.4 → 6.0.0

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

@@ -1,12 +1,26 @@
-import { DEVCLASS, SENVI, TADIR } from "../../client";
 import { TrmPackage } from "../../trmPackage";
-export type TadirObjectSenvi = {
+import { IActionContext } from "..";
+import { DEVCLASS, SENVI, TADIR } from "../../client";
+export interface FindDependenciesActionInput {
+    contextData?: {
+        noInquirer?: boolean;
+    };
+    packageData: {
+        package: DEVCLASS;
+        objects?: TADIR[];
+    };
+    printOptions?: {
+        trmDependencies?: boolean;
+        sapObjectDependencies?: boolean;
+    };
+}
+type ObjectSenvi = {
     tadir: TADIR;
     senvi: SENVI[];
 };
 export type TableDependency = {
-    dependencyIn: TADIR;
-    tableDependency: any;
+    foundIn: TADIR;
+    object: any;
 };
 export type SapEntriesDependency = {
     table: string;
@@ -14,41 +28,39 @@ export type SapEntriesDependency = {
 };
 export type TrmDependency = {
     devclass: DEVCLASS;
-    trmPackage?: TrmPackage;
+    package: TrmPackage;
     integrity?: string;
     sapEntries: SapEntriesDependency[];
 };
-export type FindDependencyActionInput = {
-    devclass: DEVCLASS;
-    tadir?: TADIR[];
-    systemPackages?: TrmPackage[];
-    print?: boolean;
-    printSapEntries?: boolean;
-    silent?: boolean;
-};
-type WorkflowParsedInput = {
-    devclass?: DEVCLASS;
-    tadir?: TADIR[];
-    systemPackages?: TrmPackage[];
-    print?: boolean;
-    printSapEntries?: boolean;
-    silent?: boolean;
-};
 type WorkflowRuntime = {
-    devclassIgnore?: DEVCLASS[];
-    objectsSenvi?: TadirObjectSenvi[];
-    parsedSenvi?: SapEntriesDependency[];
-};
-export type FindDependencyActionOutput = {
-    sapEntries?: SapEntriesDependency[];
-    trmDependencies?: TrmDependency[];
-    unknownDependencies?: TrmDependency[];
+    abort: boolean;
+    packageData: {
+        ignoredTadir: TADIR[];
+    };
+    repositoryEnvironment: {
+        senvi: ObjectSenvi[];
+    };
+    dependencies: {
+        customObjects: SapEntriesDependency[];
+        sapObjects: SapEntriesDependency[];
+        withTrmPackage: TrmDependency[];
+        withoutTrmPackage: TrmDependency[];
+    };
 };
-export type FindDependenciesWorkflowContext = {
-    rawInput: FindDependencyActionInput;
-    parsedInput: WorkflowParsedInput;
-    runtime: WorkflowRuntime;
-    output: FindDependencyActionOutput;
+export type FindDependenciesActionOutput = {
+    trmPackageDependencies: {
+        withTrmPackage: TrmDependency[];
+        withoutTrmPackage: TrmDependency[];
+    };
+    objectDependencies: {
+        customObjects: SapEntriesDependency[];
+        sapObjects: SapEntriesDependency[];
+    };
 };
-export declare function findDependencies(inputData: FindDependencyActionInput): Promise<FindDependencyActionOutput>;
+export interface FindDependenciesWorkflowContext extends IActionContext {
+    rawInput: FindDependenciesActionInput;
+    runtime?: WorkflowRuntime;
+    output?: FindDependenciesActionOutput;
+}
+export declare function findDependencies(inputData: FindDependenciesActionInput): Promise<FindDependenciesActionOutput>;
 export {};

package/dist/actions/findDependencies/index.js

@@ -12,41 +12,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findDependencies = void 0;
+exports.findDependencies = findDependencies;
 const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const util_1 = require("util");
 const logger_1 = require("../../logger");
 const init_1 = require("./init");
-const setSystemPackages_1 = require("./setSystemPackages");
-const readPackageData_1 = require("./readPackageData");
-const readPackageObjects_1 = require("./readPackageObjects");
+const setObjects_1 = require("./setObjects");
 const readRepositoryEnvironment_1 = require("./readRepositoryEnvironment");
 const parseSenvi_1 = require("./parseSenvi");
 const setTrmDependencies_1 = require("./setTrmDependencies");
 const print_1 = require("./print");
-const acknowledgementSize_1 = require("./acknowledgementSize");
+;
 const WORKFLOW_NAME = 'find-dependencies';
 function findDependencies(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             init_1.init,
-            setSystemPackages_1.setSystemPackages,
-            readPackageData_1.readPackageData,
-            readPackageObjects_1.readPackageObjects,
-            acknowledgementSize_1.acknowledgementSize,
+            setObjects_1.setObjects,
             readRepositoryEnvironment_1.readRepositoryEnvironment,
             parseSenvi_1.parseSenvi,
             setTrmDependencies_1.setTrmDependencies,
             print_1.print
         ];
-        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);
-        return result.output;
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        return {
+            trmPackageDependencies: {
+                withTrmPackage: result.runtime.dependencies.withTrmPackage,
+                withoutTrmPackage: result.runtime.dependencies.withoutTrmPackage,
+            },
+            objectDependencies: {
+                customObjects: result.runtime.dependencies.customObjects,
+                sapObjects: result.runtime.dependencies.sapObjects
+            }
+        };
     });
 }
-exports.findDependencies = findDependencies;

package/dist/actions/findDependencies/init.js

@@ -10,28 +10,36 @@ 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 inquirer_1 = require("../../inquirer");
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var devclass = context.rawInput.devclass;
-        const devclassValid = yield (0, inquirer_1.validateDevclass)(devclass, true);
+        logger_1.Logger.log('Init step', true);
+        const devclassValid = yield (0, inquirer_1.validateDevclass)(context.rawInput.packageData.package, true);
         if (devclassValid && devclassValid !== true) {
             throw new Error(devclassValid);
         }
-        context.parsedInput.devclass = devclass;
-        context.parsedInput.print = context.rawInput.print ? true : false;
-        if (context.parsedInput.print) {
-            context.parsedInput.printSapEntries = context.rawInput.printSapEntries ? true : false;
+        context.runtime = {
+            abort: false,
+            packageData: {
+                ignoredTadir: []
+            },
+            repositoryEnvironment: {
+                senvi: []
+            },
+            dependencies: {
+                customObjects: [],
+                sapObjects: [],
+                withTrmPackage: [],
+                withoutTrmPackage: []
+            }
+        };
+        if (!context.rawInput.contextData) {
+            context.rawInput.contextData = {};
         }
-        else {
-            context.parsedInput.printSapEntries = false;
+        if (!context.rawInput.printOptions) {
+            context.rawInput.printOptions = {};
         }
-        context.parsedInput.tadir = context.rawInput.tadir || [];
-        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
-        context.parsedInput.silent = context.rawInput.silent;
-        context.output.trmDependencies = [];
-        context.output.unknownDependencies = [];
-        context.output.sapEntries = [];
     })
 };

package/dist/actions/findDependencies/parseSenvi.js

@@ -1,4 +1,27 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -10,8 +33,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSenvi = void 0;
-const dependency_1 = require("../../dependency");
 const logger_1 = require("../../logger");
+const dependency_1 = require("../../dependency");
+const _ = __importStar(require("lodash"));
 const SAP_SOURCE_SYSTEMS = ['SAP'];
 const SAP_AUTHORS = ['SAP'];
 const _addEntry = (tableName, sapEntries, dependencyIn, dependency) => {
@@ -25,51 +49,61 @@ const _addEntry = (tableName, sapEntries, dependencyIn, dependency) => {
         index--;
     }
     sapEntries[index].dependencies.push({
-        dependencyIn,
-        tableDependency: dependency
+        foundIn: dependencyIn,
+        object: dependency
     });
     return sapEntries;
 };
 exports.parseSenvi = {
     name: 'parse-senvi',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const objectsSenvi = context.runtime.objectsSenvi;
-        const aIgnoredDevclass = context.runtime.devclassIgnore;
+        logger_1.Logger.log('Parse SENVI step', true);
+        const senviObjects = context.runtime.repositoryEnvironment.senvi;
+        const aIgnoredDevclass = context.runtime.packageData.ignoredTadir.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC').map(o => o.devclass);
         const senviParser = new dependency_1.SenviParser();
-        context.runtime.parsedSenvi = [];
-        context.output.sapEntries = [];
         logger_1.Logger.loading(`Reading object dependencies...`);
-        for (const objectSenvi of objectsSenvi) {
-            logger_1.Logger.log(`Parsing SENVI of TADIR object ${objectSenvi.tadir.pgmid} ${objectSenvi.tadir.object} ${objectSenvi.tadir.objName}, ${objectSenvi.senvi} entries`, true);
-            for (const senvi of objectSenvi.senvi) {
+        for (const senviObject of senviObjects) {
+            logger_1.Logger.log(`Parsing SENVI of TADIR object ${senviObject.tadir.pgmid} ${senviObject.tadir.object} ${senviObject.tadir.objName}, ${senviObject.senvi} entries`, true);
+            for (const senvi of senviObject.senvi) {
                 logger_1.Logger.loading(`Parsing SENVI object ${senvi.type} ${senvi.object} ${senvi.enclObj}...`, true);
                 const parsedSenvi = yield senviParser.parse(senvi);
-                logger_1.Logger.log(`Result: ${JSON.stringify(parsedSenvi)}`, true);
                 if (parsedSenvi && !aIgnoredDevclass.includes(parsedSenvi.devclass)) {
-                    var aParsedSenvi;
+                    const dependency = {
+                        pgmid: parsedSenvi.pgmid,
+                        object: parsedSenvi.object,
+                        objName: parsedSenvi.objName,
+                        devclass: parsedSenvi.devclass
+                    };
+                    var subObject;
+                    if (parsedSenvi.subObject) {
+                        if (parsedSenvi.subObject.func) {
+                            subObject = {
+                                table: 'TFDIR',
+                                dependency: {
+                                    'FUNCNAME': parsedSenvi.subObject.func,
+                                    'PNAME': `SAPL${parsedSenvi.objName}`
+                                }
+                            };
+                        }
+                    }
                     if (SAP_SOURCE_SYSTEMS.includes(parsedSenvi.srcsystem) || SAP_AUTHORS.includes(parsedSenvi.author)) {
-                        aParsedSenvi = context.output.sapEntries;
-                        logger_1.Logger.log(`Dependency with SAP object`, true);
+                        logger_1.Logger.log(`Dependency with SAP object ${parsedSenvi.pgmid} ${parsedSenvi.object} ${parsedSenvi.objName}, package ${parsedSenvi.devclass}`, true);
+                        context.runtime.dependencies.sapObjects = _addEntry('TADIR', _.cloneDeep(context.runtime.dependencies.sapObjects), senviObject.tadir, dependency);
+                        if (subObject) {
+                            context.runtime.dependencies.sapObjects = _addEntry(subObject.table, _.cloneDeep(context.runtime.dependencies.sapObjects), senviObject.tadir, subObject.dependency);
+                        }
                     }
                     else {
-                        aParsedSenvi = context.runtime.parsedSenvi;
-                        logger_1.Logger.log(`Dependency with custom object`, true);
-                    }
-                    aParsedSenvi = _addEntry('TADIR', aParsedSenvi, objectSenvi.tadir, {
-                        'PGMID': parsedSenvi.pgmid,
-                        'OBJECT': parsedSenvi.object,
-                        'OBJ_NAME': parsedSenvi.objName,
-                        'DEVCLASS': parsedSenvi.devclass
-                    });
-                    if (parsedSenvi.subObject) {
-                        if (parsedSenvi.subObject.func) {
-                            aParsedSenvi = _addEntry('TFDIR', aParsedSenvi, objectSenvi.tadir, {
-                                'FUNCNAME': parsedSenvi.subObject.func,
-                                'PNAME': `SAPL${parsedSenvi.objName}`
-                            });
+                        logger_1.Logger.log(`Dependency with custom object ${parsedSenvi.pgmid} ${parsedSenvi.object} ${parsedSenvi.objName}, package ${parsedSenvi.devclass}`, true);
+                        context.runtime.dependencies.customObjects = _addEntry('TADIR', _.cloneDeep(context.runtime.dependencies.customObjects), senviObject.tadir, dependency);
+                        if (subObject) {
+                            context.runtime.dependencies.customObjects = _addEntry(subObject.table, _.cloneDeep(context.runtime.dependencies.customObjects), senviObject.tadir, subObject.dependency);
                         }
                     }
                 }
+                else {
+                    logger_1.Logger.log(`Skipping!`, true);
+                }
             }
         }
     })

package/dist/actions/findDependencies/print.js

@@ -8,10 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.print = void 0;
 const logger_1 = require("../../logger");
 const registry_1 = require("../../registry");
+const chalk_1 = __importDefault(require("chalk"));
 const _getTableTreeText = (tableData) => {
     var aValues = [];
     Object.keys(tableData).forEach(k => {
@@ -19,16 +23,16 @@ const _getTableTreeText = (tableData) => {
     });
     return aValues.join(', ');
 };
-const _getSapEntriesTreeChildren = (sapEntries) => {
+const _getSapEntriesTreeChildren = (sapEntries, highlightTable) => {
     var treeChildren = [];
     sapEntries.forEach(k => {
         var referenceTableTree = {
-            text: k.table,
+            text: highlightTable ? chalk_1.default.bold(k.table) : k.table,
             children: []
         };
         k.dependencies.forEach(y => {
-            const tableKey = _getTableTreeText(y.tableDependency);
-            const tadirKey = `${y.dependencyIn.pgmid} ${y.dependencyIn.object} ${y.dependencyIn.objName}`;
+            const tableKey = _getTableTreeText(y.object);
+            const tadirKey = `${y.foundIn.pgmid} ${y.foundIn.object} ${y.foundIn.objName}`;
             const arrayIndex = referenceTableTree.children.findIndex(o => o.text === tableKey);
             const usedByTree = {
                 text: `Used by`,
@@ -58,63 +62,66 @@ const _getSapEntriesTreeChildren = (sapEntries) => {
 exports.print = {
     name: 'print',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.parsedInput.print) {
+        if (context.rawInput.printOptions.trmDependencies || context.rawInput.printOptions.sapObjectDependencies) {
             return true;
         }
         else {
-            logger_1.Logger.log(`Skipping print (input)`, true);
+            logger_1.Logger.log(`Skipping dependency print status (user input)`, true);
             return false;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const sapEntries = context.output.sapEntries;
-        const unknownDependencies = context.output.unknownDependencies;
-        const trmDependencies = context.output.trmDependencies;
+        logger_1.Logger.log('Print step', true);
+        const sapEntries = context.runtime.dependencies.sapObjects;
+        const unknownDependencies = context.runtime.dependencies.withoutTrmPackage;
+        const trmDependencies = context.runtime.dependencies.withTrmPackage;
         var baseTree = {
-            text: context.parsedInput.devclass,
+            text: chalk_1.default.bold(context.rawInput.packageData.package),
             children: []
         };
         var sapEntriesTree = {
-            text: `Required SAP Entries`,
-            children: _getSapEntriesTreeChildren(sapEntries)
+            text: chalk_1.default.underline(`Required SAP Entries (${sapEntries.reduce((sum, o) => sum + o.dependencies.length, 0)})`),
+            children: _getSapEntriesTreeChildren(sapEntries, true)
         };
         var unknownDependenciesTree = {
-            text: `Without TRM Package`,
+            text: chalk_1.default.underline(`Without TRM Package (${unknownDependencies.length})`),
             children: []
         };
         var trmDependenciesTree = {
-            text: `TRM Packages`,
+            text: chalk_1.default.underline(`TRM Packages (${trmDependencies.length})`),
             children: []
         };
         unknownDependencies.forEach(o => {
             unknownDependenciesTree.children.push({
-                text: o.devclass,
+                text: chalk_1.default.bold(o.devclass),
                 children: [{
                         text: `References`,
-                        children: _getSapEntriesTreeChildren(o.sapEntries)
+                        children: _getSapEntriesTreeChildren(o.sapEntries, false)
                     }]
             });
         });
         trmDependencies.forEach(o => {
             trmDependenciesTree.children.push({
-                text: o.trmPackage.packageName,
+                text: chalk_1.default.bold(o.package.packageName),
                 children: [{
-                        text: `Registry: ${o.trmPackage.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : o.trmPackage.registry.endpoint}`,
+                        text: `Registry: ${o.package.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : o.package.registry.endpoint}`,
                         children: []
                     }, {
-                        text: `Version: ${o.trmPackage.manifest.get().version}`,
+                        text: `Version: ${o.package.manifest.get().version}`,
                         children: []
                     }, {
                         text: `References`,
-                        children: _getSapEntriesTreeChildren(o.sapEntries)
+                        children: _getSapEntriesTreeChildren(o.sapEntries, false)
                     }]
             });
         });
-        if (context.parsedInput.printSapEntries) {
+        if (context.rawInput.printOptions.sapObjectDependencies) {
             baseTree.children.push(sapEntriesTree);
         }
-        baseTree.children.push(unknownDependenciesTree);
-        baseTree.children.push(trmDependenciesTree);
+        if (context.rawInput.printOptions.trmDependencies) {
+            baseTree.children.push(unknownDependenciesTree);
+            baseTree.children.push(trmDependenciesTree);
+        }
         logger_1.Logger.tree(baseTree);
     })
 };

package/dist/actions/findDependencies/readRepositoryEnvironment.js

@@ -10,22 +10,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readRepositoryEnvironment = void 0;
-const systemConnector_1 = require("../../systemConnector");
 const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
 exports.readRepositoryEnvironment = {
     name: 'read-repository-environment',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.abort) {
+            logger_1.Logger.log(`Skipping repository environment read (abort)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var aSenvi = [];
-        var tadir = context.parsedInput.tadir;
-        tadir = tadir.filter(o => !(o.pgmid === 'R3TR' && o.object === 'DEVC'));
+        logger_1.Logger.log('Read repository environment step', true);
+        const aTadir = context.rawInput.packageData.objects.filter(o => !context.runtime.packageData.ignoredTadir.find(k => k.pgmid === o.pgmid &&
+            k.object === o.object &&
+            k.objName === o.objName));
         logger_1.Logger.loading(`Reading objects...`);
-        for (const tadirObj of tadir) {
-            const senvi = yield systemConnector_1.SystemConnector.repositoryEnvironment(tadirObj.object, tadirObj.objName);
-            aSenvi.push({
-                tadir: tadirObj,
-                senvi
-            });
+        for (const tadir of aTadir) {
+            const senviEntry = context.runtime.repositoryEnvironment.senvi.find(o => o.tadir.object === tadir.object && o.tadir.objName === tadir.objName);
+            if (senviEntry) {
+                context.runtime.repositoryEnvironment.senvi.push({
+                    tadir: tadir,
+                    senvi: senviEntry.senvi
+                });
+            }
+            else {
+                logger_1.Logger.log(`Running repository environment on object ${tadir.object} ${tadir.objName}...`, true);
+                try {
+                    context.runtime.repositoryEnvironment.senvi.push({
+                        tadir: tadir,
+                        senvi: yield systemConnector_1.SystemConnector.repositoryEnvironment(tadir.object, tadir.objName)
+                    });
+                }
+                catch (e) {
+                    logger_1.Logger.error(e.toString(), true);
+                }
+            }
         }
-        context.runtime.objectsSenvi = aSenvi;
     })
 };

package/dist/actions/findDependencies/{readPackageData.d.ts → setObjects.d.ts}

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

package/dist/actions/findDependencies/setObjects.js

@@ -0,0 +1,50 @@
+"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.setObjects = void 0;
+const logger_1 = require("../../logger");
+const inquirer_1 = require("../../inquirer");
+const systemConnector_1 = require("../../systemConnector");
+exports.setObjects = {
+    name: 'set-objects',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Set objects step', true);
+        logger_1.Logger.loading(`Reading package data...`);
+        const aDevclass = [context.rawInput.packageData.package].concat((yield systemConnector_1.SystemConnector.getSubpackages(context.rawInput.packageData.package)).map(o => o.devclass));
+        context.runtime.packageData.ignoredTadir = context.runtime.packageData.ignoredTadir.concat(aDevclass.map(devclass => {
+            return {
+                pgmid: 'R3TR',
+                object: 'DEVC',
+                objName: devclass,
+                devclass
+            };
+        }));
+        if (context.rawInput.packageData.objects === undefined) {
+            context.rawInput.packageData.objects = yield systemConnector_1.SystemConnector.getDevclassObjects(context.rawInput.packageData.package, true);
+        }
+        const totalSize = context.rawInput.packageData.objects.length - context.runtime.packageData.ignoredTadir.length;
+        logger_1.Logger.log(`Objects to analyze: ${totalSize}`, true);
+        if (totalSize >= 50) {
+            const sMsg = `A total of ${totalSize} objects will be analyzed in order to automatically find dependencies, and it may take a long time.`;
+            if (!context.rawInput.contextData.noInquirer) {
+                context.runtime.abort = !(yield inquirer_1.Inquirer.prompt({
+                    type: 'confirm',
+                    name: 'continue',
+                    default: true,
+                    message: `${sMsg} Continue?`
+                })).continue;
+            }
+            else {
+                logger_1.Logger.warning(sMsg);
+            }
+        }
+    })
+};