trm-core 4.1.4 → 6.0.0

package/dist/actions/install/importTadirTransport.js

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

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

@@ -1,95 +1,106 @@
+import { R3trans, R3transOptions } from "node-r3trans";
 import { Registry } from "../../registry";
+import { Transport } from "../../transport";
 import { TransportBinary, TrmArtifact, TrmPackage } from "../../trmPackage";
 import { Manifest, TrmManifest, TrmManifestDependency } from "../../manifest";
-import { R3trans, R3transOptions } from "node-r3trans";
-import { DEVCLASS, E071, TADIR, TDEVC, TDEVCT } from "../../client";
+import { IActionContext } from "..";
+import { DEVCLASS, E071, NAMESPACE, TADIR, TDEVC, TDEVCT } from "../../client";
 import { PackageHierarchy } from "../../commons";
-import { Transport } from "../../transport";
 export type InstallPackageReplacements = {
     originalDevclass: string;
     installDevclass: string;
 };
-export type InstallActionInput = {
-    packageName: string;
-    registry: Registry;
-    version?: string;
-    systemPackages?: TrmPackage[];
-    integrity?: string;
-    r3transOptions?: R3transOptions;
-    transportLayer?: string;
-    force?: boolean;
-    keepOriginalDevclass?: boolean;
-    importTimeout?: number;
-    generateTransport?: boolean;
-    skipSapEntriesCheck?: boolean;
-    skipObjectTypesCheck?: boolean;
-    skipLangImport?: boolean;
-    skipCustImport?: boolean;
-    ignoreDependencies?: boolean;
-    safeInstall?: boolean;
-    wbTrTargetSystem?: string;
-    silent?: boolean;
-    packageReplacements?: InstallPackageReplacements[];
-    allowReplace?: boolean;
-};
-type WorkflowParsedInput = {
-    packageName?: string;
-    version?: string;
-    skipAlreadyInstalledCheck?: boolean;
-    forceInstallSameVersion?: boolean;
-    overwriteInstall?: boolean;
+export type InstallActionInputContextData = {
     systemPackages?: TrmPackage[];
-    checkSapEntries?: boolean;
-    checkDependencies?: boolean;
-    installMissingDependencies?: boolean;
-    installIntegrity?: string;
-    safeInstall?: boolean;
     r3transOptions?: R3transOptions;
-    checkObjectTypes?: boolean;
-    keepOriginalPackages?: boolean;
-    forceDevclassInput?: boolean;
-    transportLayer?: string;
-    importTimeout?: number;
-    skipLangImport?: boolean;
-    skipCustImport?: boolean;
-    skipWbTransportGen?: boolean;
-    wbTrTargetSystem?: string;
-    packageReplacements?: InstallPackageReplacements[];
+    noR3transInfo?: boolean;
     noInquirer?: boolean;
 };
+export type InstallActionInputInstallData = {
+    import?: {
+        timeout?: number;
+        noLang?: boolean;
+        noCust?: boolean;
+    };
+    checks?: {
+        safe?: boolean;
+        noSapEntries?: boolean;
+        noObjectTypes?: boolean;
+        noDependencies?: boolean;
+    };
+    installDevclass?: {
+        keepOriginal?: boolean;
+        transportLayer?: string;
+        replacements?: InstallPackageReplacements[];
+    };
+    installTransport?: {
+        create?: boolean;
+        targetSystem?: string;
+    };
+};
+export interface InstallActionInput {
+    contextData?: InstallActionInputContextData;
+    packageData: {
+        name: string;
+        version?: string;
+        integrity?: string;
+        registry: Registry;
+        overwrite?: boolean;
+    };
+    installData?: InstallActionInputInstallData;
+}
+type TransportRuntime = {
+    binaries?: TransportBinary;
+    instance?: Transport;
+};
 type WorkflowRuntime = {
-    registry?: Registry;
-    trmPackage?: TrmPackage;
-    manifest?: Manifest;
-    trmManifest?: TrmManifest;
-    dependenciesToInstall?: TrmManifestDependency[];
-    trmArtifact?: TrmArtifact;
-    r3trans?: R3trans;
-    devcTransport?: TransportBinary;
-    tadirTransport?: TransportBinary;
-    langTransport?: TransportBinary;
-    custTransport?: TransportBinary;
-    tdevcData?: TDEVC[];
-    tdevctData?: TDEVCT[];
-    tadirData?: TADIR[];
-    workbenchObjects?: E071[];
-    packageReplacements?: InstallPackageReplacements[];
-    generatedDevclass?: DEVCLASS[];
-    originalPackageHierarchy?: PackageHierarchy;
-    trCopy?: string[];
-    fetchedIntegrity?: string;
-    wbTransport?: Transport;
+    registry: Registry;
+    update: boolean;
+    rollback: boolean;
+    remotePackageData: {
+        version: string;
+        trmPackage: TrmPackage;
+        artifact: TrmArtifact;
+        manifest: Manifest;
+        trmManifest: TrmManifest;
+        integrity: string;
+    };
+    packageTransports: {
+        devc: TransportRuntime;
+        tadir: TransportRuntime;
+        lang: TransportRuntime;
+        cust: TransportRuntime;
+    };
+    packageTransportsData: {
+        tdevc: TDEVC[];
+        tdevct: TDEVCT[];
+        tadir: TADIR[];
+        e071: E071[];
+    };
+    dependenciesToInstall: TrmManifestDependency[];
+    r3trans: R3trans;
+    originalData: {
+        hierarchy: PackageHierarchy;
+    };
+    installData: {
+        namespace: string;
+        entries: E071[];
+        transport?: Transport;
+    };
+    generatedData: {
+        devclass: DEVCLASS[];
+        namespace: NAMESPACE;
+    };
 };
 export type InstallActionOutput = {
     trmPackage: TrmPackage;
     registry: Registry;
-    wbTransport?: Transport;
+    installTransport?: Transport;
 };
-export type InstallWorkflowContext = {
+export interface InstallWorkflowContext extends IActionContext {
     rawInput: InstallActionInput;
-    parsedInput: WorkflowParsedInput;
-    runtime: WorkflowRuntime;
+    runtime?: WorkflowRuntime;
     output?: InstallActionOutput;
-};
+}
 export declare function install(inputData: InstallActionInput): Promise<InstallActionOutput>;
 export {};

package/dist/actions/install/index.js

@@ -12,28 +12,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.install = void 0;
+exports.install = install;
 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 setSystemPackages_1 = require("../commons/setSystemPackages");
 const checkAlreadyInstalled_1 = require("./checkAlreadyInstalled");
+const checkIntegrity_1 = require("./checkIntegrity");
 const checkSapEntries_1 = require("./checkSapEntries");
 const checkDependencies_1 = require("./checkDependencies");
-const checkIntegrity_1 = require("./checkIntegrity");
 const installDependencies_1 = require("./installDependencies");
-const checkTransports_1 = require("./checkTransports");
-const readDevcTransport_1 = require("./readDevcTransport");
 const setR3trans_1 = require("./setR3trans");
-const checkTadirContent_1 = require("./checkTadirContent");
-const checkTadirObjectTypes_1 = require("./checkTadirObjectTypes");
-const setDevclass_1 = require("./setDevclass");
+const checkTransports_1 = require("./checkTransports");
+const readDevc_1 = require("./readDevc");
+const setInstallDevclass_1 = require("./setInstallDevclass");
+const checkObjectTypes_1 = require("./checkObjectTypes");
 const generateDevclass_1 = require("./generateDevclass");
+const readTadir_1 = require("./readTadir");
+const importDevcTransport_1 = require("./importDevcTransport");
+const addNamespace_1 = require("./addNamespace");
 const importTadirTransport_1 = require("./importTadirTransport");
 const importLangTransport_1 = require("./importLangTransport");
-const setPackageIntegrity_1 = require("./setPackageIntegrity");
-const generateWbTransport_1 = require("./generateWbTransport");
 const importCustTransport_1 = require("./importCustTransport");
+const setPackageIntegrity_1 = require("./setPackageIntegrity");
+const generateInstallTransport_1 = require("./generateInstallTransport");
+;
 const WORKFLOW_NAME = 'install';
 function install(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -44,35 +48,34 @@ function install(inputData) {
             checkIntegrity_1.checkIntegrity,
             checkSapEntries_1.checkSapEntries,
             checkDependencies_1.checkDependencies,
-            installDependencies_1.installDependencies,
             setR3trans_1.setR3trans,
+            installDependencies_1.installDependencies,
             checkTransports_1.checkTransports,
-            readDevcTransport_1.readDevcTransport,
-            setDevclass_1.setDevclass,
-            checkTadirContent_1.checkTadirContent,
-            checkTadirObjectTypes_1.checkTadirObjectTypes,
+            readDevc_1.readDevc,
+            readTadir_1.readTadir,
+            checkObjectTypes_1.checkObjectTypes,
+            setInstallDevclass_1.setInstallDevclass,
+            addNamespace_1.addNamespace,
             generateDevclass_1.generateDevclass,
+            importDevcTransport_1.importDevcTransport,
             importTadirTransport_1.importTadirTransport,
             importLangTransport_1.importLangTransport,
             importCustTransport_1.importCustTransport,
             setPackageIntegrity_1.setPackageIntegrity,
-            generateWbTransport_1.generateWbTransport
+            generateInstallTransport_1.generateInstallTransport
         ];
-        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: {}
+            rawInput: inputData
         });
-        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        const trmPackage = result.runtime.trmPackage;
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const trmPackage = result.runtime.remotePackageData.trmPackage;
         const registry = result.runtime.registry;
-        const wbTransport = result.runtime.wbTransport;
+        const installTransport = result.runtime.installData.transport;
         return {
             trmPackage,
             registry,
-            wbTransport
+            installTransport
         };
     });
 }
-exports.install = install;

package/dist/actions/install/init.js

@@ -14,68 +14,126 @@ const logger_1 = require("../../logger");
 const trmPackage_1 = require("../../trmPackage");
 const commons_1 = require("../../commons");
 const crypto_1 = require("crypto");
+const systemConnector_1 = require("../../systemConnector");
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var packageName = context.rawInput.packageName;
-        var packageVersion = context.rawInput.version || 'latest';
-        const registry = context.rawInput.registry;
-        packageName = (0, commons_1.parsePackageName)({
-            fullName: packageName
+        logger_1.Logger.log('Init step', true);
+        const registry = context.rawInput.packageData.registry;
+        context.rawInput.packageData.name = (0, commons_1.parsePackageName)({
+            fullName: context.rawInput.packageData.name
         }).fullName;
-        if (packageVersion.trim().toLowerCase() === 'latest') {
-            packageVersion = 'latest';
+        if (!context.rawInput.packageData.version || context.rawInput.packageData.version.trim().toLowerCase() === 'latest') {
+            context.rawInput.packageData.version = 'latest';
         }
         logger_1.Logger.loading(`Searching TRM package in registry ${registry.name}...`);
-        const trmPackage = new trmPackage_1.TrmPackage(packageName, registry);
-        const oArtifact = yield trmPackage.fetchRemoteArtifact(packageVersion);
-        const installIntegrity = (0, crypto_1.createHash)("sha512").update(oArtifact.binary).digest("hex");
-        const oManifest = yield trmPackage.fetchRemoteManifest(packageVersion);
-        const trmManifest = oManifest.get();
+        const trmPackage = new trmPackage_1.TrmPackage(context.rawInput.packageData.name, registry);
+        const artifact = yield trmPackage.fetchRemoteArtifact(context.rawInput.packageData.version);
+        const integrity = (0, crypto_1.createHash)("sha512").update(artifact.binary).digest("hex");
+        const manifest = yield trmPackage.fetchRemoteManifest(context.rawInput.packageData.version);
+        const trmManifest = manifest.get();
         var sVersion = trmManifest.version;
-        if (packageVersion === 'latest') {
+        if (context.rawInput.packageData.version === 'latest') {
             sVersion = `latest -> ${trmManifest.version}`;
         }
-        logger_1.Logger.info(`"${trmManifest.name}" version ${sVersion} found in registry ${registry.name}`);
-        context.runtime.registry = registry;
-        context.runtime.manifest = oManifest;
-        context.runtime.trmManifest = trmManifest;
-        context.runtime.trmPackage = trmPackage;
-        context.runtime.trmArtifact = oArtifact;
-        context.runtime.workbenchObjects = [];
-        context.runtime.trCopy = [];
-        context.runtime.fetchedIntegrity = installIntegrity;
-        context.runtime.dependenciesToInstall = [];
-        context.parsedInput.systemPackages = context.rawInput.systemPackages || [];
-        context.parsedInput.packageName = packageName;
-        context.parsedInput.version = trmManifest.version;
-        context.parsedInput.safeInstall = context.rawInput.safeInstall ? true : false;
-        context.parsedInput.noInquirer = context.rawInput.silent ? true : false;
-        context.parsedInput.forceDevclassInput = context.rawInput.silent ? false : true;
-        if (context.rawInput.force) {
-            context.parsedInput.skipAlreadyInstalledCheck = true;
-            context.parsedInput.checkSapEntries = false;
-            context.parsedInput.checkObjectTypes = false;
-            context.parsedInput.forceInstallSameVersion = true;
-            context.parsedInput.overwriteInstall = true;
-            context.parsedInput.checkDependencies = false;
+        logger_1.Logger.info(`Ready to install "${trmManifest.name}" version ${sVersion} from registry "${registry.name}".`);
+        context.runtime = {
+            registry,
+            update: undefined,
+            rollback: false,
+            remotePackageData: {
+                version: context.rawInput.packageData.version,
+                trmPackage,
+                trmManifest,
+                manifest,
+                artifact,
+                integrity
+            },
+            dependenciesToInstall: [],
+            r3trans: undefined,
+            packageTransports: {
+                devc: {
+                    binaries: undefined,
+                    instance: undefined
+                },
+                tadir: {
+                    binaries: undefined,
+                    instance: undefined
+                },
+                cust: {
+                    binaries: undefined,
+                    instance: undefined
+                },
+                lang: {
+                    binaries: undefined,
+                    instance: undefined
+                }
+            },
+            packageTransportsData: {
+                tdevc: [],
+                tdevct: [],
+                tadir: [],
+                e071: []
+            },
+            installData: {
+                transport: undefined,
+                namespace: undefined,
+                entries: []
+            },
+            originalData: {
+                hierarchy: undefined
+            },
+            generatedData: {
+                devclass: [],
+                namespace: undefined
+            }
+        };
+        if (context.rawInput.packageData.overwrite === undefined) {
+            context.rawInput.packageData.overwrite = false;
+        }
+        if (!context.rawInput.contextData) {
+            context.rawInput.contextData = {};
+        }
+        if (!context.rawInput.installData) {
+            context.rawInput.installData = {};
+        }
+        if (!context.rawInput.installData.checks) {
+            context.rawInput.installData.checks = {};
+        }
+        if (!context.rawInput.installData.import) {
+            context.rawInput.installData.import = {};
+        }
+        if (!context.rawInput.installData.installDevclass) {
+            context.rawInput.installData.installDevclass = {
+                replacements: []
+            };
+        }
+        if (!context.rawInput.installData.installTransport) {
+            context.rawInput.installData.installTransport = {
+                create: true
+            };
+        }
+        logger_1.Logger.loading(`Checking transport layer...`);
+        if (!context.rawInput.installData.installDevclass.transportLayer) {
+            try {
+                context.rawInput.installData.installDevclass.transportLayer = yield systemConnector_1.SystemConnector.getDefaultTransportLayer();
+                logger_1.Logger.log(`Setting transport layer to default: ${context.rawInput.installData.installDevclass.transportLayer}`, true);
+            }
+            catch (e) {
+                logger_1.Logger.error(e.toString(), true);
+                throw new Error(`Couldn't determine system's default transport layer.`);
+            }
         }
         else {
-            context.parsedInput.skipAlreadyInstalledCheck = false;
-            context.parsedInput.checkSapEntries = context.rawInput.skipSapEntriesCheck ? false : true;
-            context.parsedInput.checkObjectTypes = context.rawInput.skipObjectTypesCheck ? false : true;
-            context.parsedInput.forceInstallSameVersion = false;
-            context.parsedInput.overwriteInstall = context.rawInput.allowReplace ? true : false;
-            context.parsedInput.checkDependencies = context.rawInput.ignoreDependencies ? false : true;
+            if (!(yield systemConnector_1.SystemConnector.isTransportLayerExist(context.rawInput.installData.installDevclass.transportLayer))) {
+                throw new Error(`Transport layer "${context.rawInput.installData.installDevclass.transportLayer}" doesn't exist.`);
+            }
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Rollback init step', true);
+        if (context.runtime && context.runtime.rollback) {
+            logger_1.Logger.success(`Rollback executed.`);
         }
-        context.parsedInput.keepOriginalPackages = context.rawInput.keepOriginalDevclass ? true : false;
-        context.parsedInput.installMissingDependencies = context.rawInput.ignoreDependencies ? false : true;
-        context.parsedInput.transportLayer = context.rawInput.transportLayer;
-        context.parsedInput.wbTrTargetSystem = context.rawInput.wbTrTargetSystem;
-        context.parsedInput.installIntegrity = context.rawInput.integrity;
-        context.parsedInput.r3transOptions = context.rawInput.r3transOptions;
-        context.parsedInput.importTimeout = context.rawInput.importTimeout || 180;
-        context.parsedInput.skipWbTransportGen = context.rawInput.generateTransport ? false : true;
-        context.parsedInput.packageReplacements = context.rawInput.packageReplacements || [];
     })
 };