trm-core 2.2.3 → 3.0.0

package/dist/actions/publish/setCustTransports.js

@@ -0,0 +1,49 @@
+"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.setCustTransports = void 0;
+const logger_1 = require("../../logger");
+const Inquirer_1 = require("../../inquirer/Inquirer");
+const transport_1 = require("../../transport");
+exports.setCustTransports = {
+    name: 'set-cust-transports',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.skipCust) {
+            logger_1.Logger.log(`Skipping set CUST transports (input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var customizingTransports = context.parsedInput.customizingTransports;
+        const inq1 = yield Inquirer_1.Inquirer.prompt({
+            message: `Customizing transports (separated by comma, leave blank for no customizing)`,
+            name: 'transports',
+            type: 'input',
+            when: !context.parsedInput.silent
+        });
+        customizingTransports = customizingTransports.concat((inq1.transports || '').split(',')).filter(o => o);
+        var aTransports = [];
+        if (customizingTransports.length > 0) {
+            logger_1.Logger.loading(`Reading customizing transports...`);
+            for (var trkorr of customizingTransports) {
+                trkorr = trkorr.trim().toUpperCase();
+                const mainTransport = new transport_1.Transport(trkorr);
+                const tasks = yield mainTransport.getTasks();
+                aTransports.push(mainTransport);
+                aTransports = aTransports.concat(tasks);
+            }
+        }
+        context.runtime.inputCustTransports = aTransports;
+    })
+};

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

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

package/dist/actions/publish/setDevclass.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDevclass = void 0;
+const Inquirer_1 = require("../../inquirer/Inquirer");
+const inquirer_1 = require("../../inquirer");
+const logger_1 = require("../../logger");
+exports.setDevclass = {
+    name: 'set-devclass',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var devclass = context.parsedInput.devclass;
+        if (!devclass) {
+            if (context.parsedInput.silent) {
+                throw new Error(`Running in silent mode and devclass was not set.`);
+            }
+            const inq1 = yield Inquirer_1.Inquirer.prompt({
+                type: "input",
+                message: "Package devclass",
+                name: "devclass",
+                validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                    return yield (0, inquirer_1.validateDevclass)(input);
+                })
+            });
+            devclass = inq1.devclass;
+        }
+        devclass = devclass.trim().toUpperCase();
+        const devclassValid = yield (0, inquirer_1.validateDevclass)(devclass);
+        if (devclassValid && devclassValid !== true) {
+            throw new Error(devclassValid);
+        }
+        logger_1.Logger.log(`Publish devclass: ${devclass}`, true);
+        context.parsedInput.devclass = devclass;
+    })
+};

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

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

package/dist/actions/publish/setDevclassObjs.js

@@ -0,0 +1,22 @@
+"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.setDevclassObjs = void 0;
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.setDevclassObjs = {
+    name: 'set-devclass-objs',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const devclass = context.parsedInput.devclass;
+        logger_1.Logger.loading(`Reading package objects...`);
+        context.runtime.tadirObjects = yield systemConnector_1.SystemConnector.getDevclassObjects(devclass, true);
+    })
+};

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

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

package/dist/actions/publish/setManifestValues.js

@@ -0,0 +1,111 @@
+"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.setManifestValues = void 0;
+const logger_1 = require("../../logger");
+const Inquirer_1 = require("../../inquirer/Inquirer");
+exports.setManifestValues = {
+    name: 'set-manifest-values',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.forceManifestInput || (!context.parsedInput.forceManifestInput && !context.runtime.packageExistsOnRegistry)) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skip manifest input values step (force: ${context.parsedInput.forceManifestInput}, already exists: ${context.runtime.packageExistsOnRegistry})`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var defaultAuthors;
+        var defaultKeywords;
+        if (context.runtime.manifest.authors) {
+            if (typeof (context.runtime.manifest.authors) === 'string') {
+                defaultAuthors = context.runtime.manifest.authors;
+            }
+            else {
+                try {
+                    defaultAuthors = context.runtime.manifest.authors.map(o => {
+                        if (o.name) {
+                            if (o.email) {
+                                return `${o.name} <${o.email}>`;
+                            }
+                            else {
+                                return o.name;
+                            }
+                        }
+                        else {
+                            return o.email;
+                        }
+                    }).filter(s => s).join(', ');
+                }
+                catch (e) {
+                    defaultAuthors = '';
+                }
+            }
+        }
+        if (context.runtime.manifest.keywords) {
+            if (typeof (context.runtime.manifest.keywords) === 'string') {
+                defaultKeywords = context.runtime.manifest.keywords;
+            }
+            else {
+                try {
+                    defaultKeywords = context.runtime.manifest.keywords.filter(s => s).join(', ');
+                }
+                catch (e) {
+                    defaultKeywords = '';
+                }
+            }
+        }
+        const inq1 = yield Inquirer_1.Inquirer.prompt([{
+                type: "input",
+                message: "Package short description",
+                name: "description",
+                default: context.runtime.manifest.description,
+                when: !context.parsedInput.silent
+            }, {
+                type: "input",
+                message: "Website",
+                name: "website",
+                default: context.runtime.manifest.website,
+                when: !context.parsedInput.silent
+            }, {
+                type: "input",
+                message: "Package Git repository",
+                name: "git",
+                default: context.runtime.manifest.git,
+                when: !context.parsedInput.silent
+            }, {
+                type: "input",
+                message: "Authors (separated by comma)",
+                name: "authors",
+                when: !context.parsedInput.silent,
+                default: defaultAuthors
+            }, {
+                type: "input",
+                message: "Keywords (separated by comma)",
+                name: "keywords",
+                when: !context.parsedInput.silent,
+                default: defaultKeywords
+            }, {
+                type: "input",
+                message: "License",
+                name: "license",
+                default: context.runtime.manifest.license,
+                when: !context.parsedInput.silent
+            }]);
+        context.runtime.manifest.description = context.runtime.manifest.description || inq1.description;
+        context.runtime.manifest.website = context.runtime.manifest.website || inq1.website;
+        context.runtime.manifest.git = context.runtime.manifest.git || inq1.git;
+        context.runtime.manifest.authors = context.runtime.manifest.authors || inq1.authors;
+        context.runtime.manifest.keywords = context.runtime.manifest.keywords || inq1.keywords;
+        context.runtime.manifest.license = context.runtime.manifest.license || inq1.license;
+    })
+};

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

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

package/dist/actions/publish/setPrivate.js

@@ -0,0 +1,60 @@
+"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.setPrivate = void 0;
+const logger_1 = require("../../logger");
+const Inquirer_1 = require("../../inquirer/Inquirer");
+exports.setPrivate = {
+    name: 'set-private',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var localPrivate;
+        var remotePrivate;
+        try {
+            const latestPublishedManifest = (yield context.runtime.dummyPackage.fetchRemoteManifest('latest')).get();
+            remotePrivate = latestPublishedManifest.private || false;
+        }
+        catch (e) {
+            logger_1.Logger.error(e.toString(), true);
+            logger_1.Logger.error(`Couldn't fetch latest remote version for private prompt`, true);
+        }
+        if (typeof (context.parsedInput.packagePrivate) !== 'boolean') {
+            localPrivate = remotePrivate;
+        }
+        else {
+            localPrivate = context.parsedInput.packagePrivate;
+        }
+        if (typeof (localPrivate) !== 'boolean') {
+            if (context.parsedInput.silent) {
+                throw new Error(`Running in silent mode and private flag was not set.`);
+            }
+            const inq1 = yield Inquirer_1.Inquirer.prompt([{
+                    type: "list",
+                    message: "Package type",
+                    name: "private",
+                    default: false,
+                    choices: [{
+                            name: "Public (Visible to all users)",
+                            value: false
+                        }, {
+                            name: "Private (Visible to you and users in organization, if specified)",
+                            value: true
+                        }]
+                }]);
+            localPrivate = inq1.private;
+        }
+        if (typeof (remotePrivate) === 'boolean' && localPrivate !== remotePrivate) {
+            const localType = localPrivate ? 'private' : 'public';
+            const remoteType = remotePrivate ? 'private' : 'public';
+            logger_1.Logger.warning(`Changing package visibility ${remoteType} -> ${localType}`);
+        }
+        context.runtime.manifest.private = localPrivate;
+    })
+};

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

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

package/dist/actions/publish/setReadme.js

@@ -0,0 +1,47 @@
+"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.setReadme = void 0;
+const Inquirer_1 = require("../../inquirer/Inquirer");
+const logger_1 = require("../../logger");
+exports.setReadme = {
+    name: 'set-readme',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.parsedInput.silent) {
+            logger_1.Logger.log(`Skipping set readme (input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const inq1 = yield Inquirer_1.Inquirer.prompt([{
+                message: 'Write readme?',
+                type: 'confirm',
+                name: 'editReadme',
+                default: false,
+                when: !context.parsedInput.skipReadme
+            }, {
+                message: 'Write readme',
+                type: 'editor',
+                name: 'readme',
+                postfix: '.md',
+                when: (hash) => {
+                    return hash.editReadme;
+                },
+                default: context.parsedInput.readme
+            }]);
+        if (inq1.readme) {
+            context.parsedInput.readme = inq1.readme;
+        }
+    })
+};

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

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

package/dist/actions/publish/setSapEntries.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.setSapEntries = void 0;
+const logger_1 = require("../../logger");
+exports.setSapEntries = {
+    name: 'set-sap-entries',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const sapEntries = context.runtime.dependencies.sapEntries;
+        if (sapEntries.length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping SAP entries search beacuse no SAP entries were found`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const sapEntries = context.runtime.dependencies.sapEntries;
+        var tablesCounter = 0;
+        var recordsCounter = 0;
+        sapEntries.forEach(o => {
+            if (!context.runtime.manifest.sapEntries[o.table]) {
+                context.runtime.manifest.sapEntries[o.table] = [];
+            }
+            tablesCounter++;
+            o.dependencies.forEach(k => {
+                var tableKeys = k.tableDependency;
+                if (o.table === 'TADIR') {
+                    delete tableKeys['DEVCLASS'];
+                }
+                context.runtime.manifest.sapEntries[o.table].push(tableKeys);
+                recordsCounter++;
+            });
+        });
+        logger_1.Logger.info(`Found ${recordsCounter} SAP entries in ${tablesCounter} tables`);
+    })
+};

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

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

package/dist/actions/publish/setTransportTarget.js

@@ -0,0 +1,63 @@
+"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.setTransportTarget = void 0;
+const Inquirer_1 = require("../../inquirer/Inquirer");
+const inquirer_1 = require("../../inquirer");
+const systemConnector_1 = require("../../systemConnector");
+const logger_1 = require("../../logger");
+exports.setTransportTarget = {
+    name: 'set-transport-target',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var trTarget = context.parsedInput.target;
+        var systemTmscsys = yield systemConnector_1.SystemConnector.getTransportTargets();
+        systemTmscsys = systemTmscsys.sort((a, b) => {
+            if (a.systyp === 'V') {
+                return -1;
+            }
+            else if (b.systyp === 'V') {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+        if (!trTarget) {
+            if (context.parsedInput.silent) {
+                throw new Error(`Running in silent mode and transport target was not set.`);
+            }
+            const inq2 = yield Inquirer_1.Inquirer.prompt({
+                type: "list",
+                message: "Transport request target",
+                name: "trTarget",
+                validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                    return yield (0, inquirer_1.validateTransportTarget)(input, systemTmscsys);
+                }),
+                choices: systemTmscsys.map(o => {
+                    return {
+                        name: `${o.sysnam} (${o.systxt})`,
+                        value: o.sysnam
+                    };
+                })
+            });
+            trTarget = inq2.trTarget.trim().toUpperCase();
+        }
+        else {
+            trTarget = trTarget.trim().toUpperCase();
+            const trTargetValid = yield (0, inquirer_1.validateTransportTarget)(trTarget, systemTmscsys);
+            if (trTargetValid && trTargetValid !== true) {
+                throw new Error(trTargetValid);
+            }
+        }
+        logger_1.Logger.log(`Publish target: ${trTarget}`, true);
+        context.parsedInput.trTarget = trTarget;
+    })
+};

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

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

package/dist/actions/publish/setTrmDependencies.js

@@ -0,0 +1,59 @@
+"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.setTrmDependencies = void 0;
+const logger_1 = require("../../logger");
+const registry_1 = require("../../registry");
+exports.setTrmDependencies = {
+    name: 'set-trm-dependencies',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const trmDependencies = context.runtime.dependencies.trmDependencies;
+        if (trmDependencies.length > 0) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping TRM dependencies search beacuse no TRM packages were found`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const trmDependencies = context.runtime.dependencies.trmDependencies;
+        trmDependencies.forEach(d => {
+            const dependencyManifest = d.trmPackage.manifest.get();
+            const dependencyName = dependencyManifest.name;
+            const dependencyVersion = `^${dependencyManifest.version}`;
+            const dependencyIntegrity = d.integrity;
+            const dependencyRegistry = d.trmPackage.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? undefined : d.trmPackage.registry.endpoint;
+            var arrayIndex = context.runtime.manifest.dependencies.findIndex(o => o.name === dependencyName);
+            if (arrayIndex < 0) {
+                arrayIndex = context.runtime.manifest.dependencies.push({
+                    name: dependencyName,
+                    version: dependencyVersion,
+                    integrity: dependencyIntegrity,
+                    registry: dependencyRegistry
+                });
+                arrayIndex--;
+            }
+            context.runtime.manifest.dependencies[arrayIndex].version = dependencyVersion;
+            context.runtime.manifest.dependencies[arrayIndex].integrity = dependencyIntegrity;
+            if (registry_1.Registry.compare(d.trmPackage.registry, context.runtime.registry)) {
+                logger_1.Logger.info(`Found dependency with package "${dependencyName}", version "${dependencyVersion}"`);
+            }
+            else {
+                const dependencyRegistryName = d.trmPackage.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? 'public' : d.trmPackage.registry.endpoint;
+                logger_1.Logger.info(`Found dependency with package "${dependencyName}", version "${dependencyVersion}", registry "${dependencyRegistryName}"`);
+            }
+            if (!dependencyIntegrity) {
+                throw new Error(`Dependency "${dependencyName}", package integrity not found.`);
+            }
+        });
+    })
+};

package/dist/client/IClient.d.ts

@@ -0,0 +1,4 @@
+export interface IClient {
+    open: () => Promise<void>;
+    checkConnection: () => Promise<boolean>;
+}

package/dist/{rfc/client → client}/RFCClient.d.ts

@@ -1,10 +1,12 @@
 /// <reference types="node" />
-import * as components from "../components";
-import * as struct from "../struct";
-export declare class RFCClient {
+import * as components from "./components";
+import * as struct from "./struct";
+import { IClient } from "./IClient";
+export declare class RFCClient implements IClient {
     private _rfcClient;
     constructor(arg1: any, traceDir?: string);
     open(): Promise<void>;
+    checkConnection(): Promise<boolean>;
     private _call;
     readTable(tableName: components.TABNAME, fields: struct.RFC_DB_FLD[], options?: string): Promise<any[]>;
     getFileSystem(): Promise<struct.FILESYS>;
@@ -16,7 +18,7 @@ export declare class RFCClient {
     setTransportDoc(trkorr: components.TRKORR, doc: struct.TLINE[]): Promise<void>;
     getDevclassObjects(devclass: components.DEVCLASS): Promise<struct.TADIR[]>;
     addToTransportRequest(trkorr: components.TRKORR, content: struct.E071[], lock: boolean): Promise<void>;
-    repositoryEnvironment(objectType: components.SEU_OBJ, objectName: components.SOBJ_NAME): Promise<struct.SENVI>;
+    repositoryEnvironment(objectType: components.SEU_OBJ, objectName: components.SOBJ_NAME): Promise<struct.SENVI[]>;
     deleteTrkorr(trkorr: components.TRKORR): Promise<void>;
     releaseTrkorr(trkorr: components.TRKORR, lock: boolean, timeout?: number): Promise<void>;
     addSkipTrkorr(trkorr: components.TRKORR): Promise<void>;

package/dist/{rfc/client → client}/RFCClient.js

@@ -34,15 +34,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RFCClient = void 0;
 const noderfc = __importStar(require("node-rfc"));
-const commons_1 = require("../../commons");
+const commons_1 = require("../commons");
+const logger_1 = require("../logger");
 class RFCClient {
     constructor(arg1, traceDir) {
         process.env["RFC_TRACE_DIR"] = traceDir || process.cwd();
+        logger_1.Logger.log(`RFC_TRACE_DIR: ${process.env["RFC_TRACE_DIR"]}`, true);
         this._rfcClient = new noderfc.Client(arg1);
     }
     open() {
         return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.loading(`Opening RFC connection`, true);
             yield this._rfcClient.open();
+            logger_1.Logger.success(`RFC open`, true);
+        });
+    }
+    checkConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._rfcClient.alive) {
+                logger_1.Logger.success(`RFC open`, true);
+            }
+            else {
+                logger_1.Logger.warning(`RFC closed`, true);
+            }
+            return this._rfcClient.alive;
         });
     }
     _call(fm, arg, timeout) {
@@ -69,8 +84,10 @@ class RFCClient {
                     timeout
                 };
             }
+            logger_1.Logger.loading(`Executing RFC, FM ${fm}, args ${JSON.stringify(argNormalized)}, opts ${JSON.stringify(callOptions)}`, true);
             const response = yield this._rfcClient.call(fm, argNormalized, callOptions);
             const responseNormalized = (0, commons_1.normalize)(response);
+            logger_1.Logger.success(`RFC resonse: ${JSON.stringify(responseNormalized)}`, true);
             return responseNormalized;
         });
     }
@@ -280,8 +297,8 @@ class RFCClient {
             });
         });
     }
-    forwardTransport(trkorr, target, source, importAgain = true) {
-        return __awaiter(this, void 0, void 0, function* () {
+    forwardTransport(trkorr_1, target_1, source_1) {
+        return __awaiter(this, arguments, void 0, function* (trkorr, target, source, importAgain = true) {
             yield this._call("ZTRM_FORWARD_TR", {
                 iv_trkorr: trkorr.trim().toUpperCase(),
                 iv_target: target.trim().toUpperCase(),
@@ -346,8 +363,8 @@ class RFCClient {
             });
         });
     }
-    trCopy(from, to, doc = false) {
-        return __awaiter(this, void 0, void 0, function* () {
+    trCopy(from_1, to_1) {
+        return __awaiter(this, arguments, void 0, function* (from, to, doc = false) {
             yield this._call("ZTRM_TR_COPY", {
                 iv_from: from,
                 iv_to: to,

package/dist/client/components/PNAME.d.ts

@@ -0,0 +1 @@
+export type PNAME = string;

package/dist/client/components/RS38L_FNAME.d.ts

@@ -0,0 +1 @@
+export type RS38L_FNAME = string;

package/dist/{rfc → client}/components/index.d.ts

@@ -37,3 +37,5 @@ export * from "./ZTRM_PACKAGE_INTEGRITY";
 export * from "./DDSIGN";
 export * from "./DDOPTION";
 export * from "./TRPARFLAG";
+export * from "./RS38L_FNAME";
+export * from "./PNAME";