trm-core 9.10.5 → 10.0.0

package/dist/actions/install/init.js

@@ -8,108 +8,182 @@ 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.init = void 0;
 const trm_commons_1 = require("trm-commons");
-const crypto_1 = require("crypto");
 const systemConnector_1 = require("../../systemConnector");
 const registry_1 = require("../../registry");
 const semver_1 = require("semver");
+const manifest_1 = require("../../manifest");
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("../commons/prompts");
+const utils_1 = require("../commons/utils");
+function sameName(a, b) {
+    return a.trim().toUpperCase() === b.trim().toUpperCase();
+}
+/**
+ * Fills the requested release from the lockfile root, before it is fetched: the root version when
+ * none is requested and the root integrity when none is expected.
+ * @throws When the package, the requested version, or the expected integrity conflicts with the lockfile root.
+ */
+function applyRootLock(context, rootLock) {
+    const packageData = context.rawInput.packageData;
+    //the name of a local artifact is only known once it's read
+    if (packageData.registry.getRegistryType() !== registry_1.RegistryType.LOCAL && !sameName(packageData.name, rootLock.name)) {
+        throw new Error(`Lockfile is for package "${rootLock.name}", cannot install "${packageData.name}" with it.`);
+    }
+    if (!packageData.version) {
+        packageData.version = rootLock.version;
+        trm_commons_1.Logger.info(`Using ${rootLock.name} v${rootLock.version} from lockfile.`);
+    }
+    else if ((0, semver_1.valid)(packageData.version) && !(0, semver_1.eq)(packageData.version, rootLock.version)) {
+        throw new Error(`Requested version ${packageData.version} conflicts with lockfile version ${rootLock.version} of "${rootLock.name}". Omit the version or regenerate the lockfile.`);
+    }
+    if (rootLock.integrity) {
+        if (packageData.integrity === undefined) {
+            packageData.integrity = rootLock.integrity;
+        }
+        else if (packageData.integrity !== rootLock.integrity) {
+            throw new Error(`Requested integrity conflicts with lockfile integrity of "${rootLock.name}" v${rootLock.version}.`);
+        }
+    }
+}
+/**
+ * Checks the fetched release against the lockfile root: a distribution tag or a local artifact
+ * may resolve to another package, release, or registry.
+ * @throws When the fetched release is not the lockfile root.
+ */
+function checkRootLock(context, rootLock) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const manifest = context.runtime.package.data.manifest;
+        if (!sameName(manifest.name, rootLock.name)) {
+            throw new Error(`Lockfile is for package "${rootLock.name}", cannot install "${manifest.name}" with it.`);
+        }
+        if (!(0, semver_1.valid)(manifest.version) || !(0, semver_1.eq)(manifest.version, rootLock.version)) {
+            throw new Error(`Release "${manifest.name}" v${manifest.version} (${context.rawInput.packageData.version}) conflicts with lockfile version ${rootLock.version}. Omit the version or regenerate the lockfile.`);
+        }
+        if (rootLock.registry) {
+            const installRegistry = (yield (0, utils_1.resolveInstallPackage)(context.rawInput.packageData.registry, manifest.name)).registry;
+            if (installRegistry.getRegistryType() !== registry_1.RegistryType.LOCAL && installRegistry.endpoint.trim().toLowerCase() !== rootLock.registry.trim().toLowerCase()) {
+                throw new Error(`Lockfile is for package "${rootLock.name}" of registry "${rootLock.registry}", cannot install it from registry "${installRegistry.endpoint}".`);
+            }
+        }
+    });
+}
+/**
+ * Workflow step that fetches the release, validates install settings, and initializes rollback state.
+ *
+ * 1- fill context data
+ *
+ * 2- fill missing input data
+ *
+ * 3- check install transport layer
+ *
+ * 4- check/set system target
+ *
+ * 5- check if already installed
+ *
+*/
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Init step', true);
+        var _a, _b, _c;
         const registry = context.rawInput.packageData.registry;
-        var artifact;
-        var manifest;
-        var packageData;
-        var actualRegistry;
-        if (registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
-            try {
-                artifact = yield registry.downloadArtifact('dummy', 'dummy');
-            }
-            catch (_a) {
-                throw new Error(`Unable to read local package.`);
-            }
-            const oManifest = artifact.getManifest();
-            manifest = oManifest.get();
-            packageData.manifest = manifest;
-            actualRegistry = oManifest.getPackage().registry;
-            context.rawInput.packageData.name = manifest.name;
-        }
-        if (registry.getRegistryType() !== registry_1.RegistryType.LOCAL) {
-            trm_commons_1.Logger.loading(`Fetching package in registry ${registry.name}...`);
-            packageData = yield registry.getPackage(context.rawInput.packageData.name, context.rawInput.packageData.version || 'latest');
-            artifact = yield registry.downloadArtifact(packageData.name, packageData.manifest.version);
-            const checksum = (0, crypto_1.createHash)("sha512").update(artifact.binary).digest("base64");
-            if (checksum !== packageData.checksum) {
-                var ping;
-                try {
-                    ping = yield registry.ping();
-                }
-                catch (_b) { }
-                trm_commons_1.Logger.error(`SECURITY ISSUE! Release integrity does NOT match!`);
-                trm_commons_1.Logger.error(`SECURITY ISSUE! Expected SHA is ${packageData.checksum}, current SHA is ${checksum}`);
-                trm_commons_1.Logger.error(`SECURITY ISSUE! Please, report the issue to ${ping && ping.alert_email ? ping.alert_email : 'registry moderation team'}`);
-                throw new Error(`Cannot continue due to security issues.`);
-            }
-            manifest = artifact.getManifest().get();
-        }
-        trm_commons_1.Logger.info(`Ready to install ${manifest.name} v${manifest.version}${!(0, semver_1.valid)(context.rawInput.packageData.version) ? (' (' + (context.rawInput.packageData.version || 'latest') + ')') : ''}.`);
-        if (!context.rawInput.contextData) {
-            context.rawInput.contextData = {};
-        }
+        //1- fill context data
         context.runtime = {
-            stopWarningShown: context.rawInput.contextData.noStopWarning ? true : false,
-            isTrmServer: false,
             isTrmRest: false,
-            registry: actualRegistry || registry,
-            update: undefined,
-            remotePackageData: {
-                data: packageData,
-                artifact,
-                manifest,
-                contents: false
-            },
-            dependenciesToInstall: [],
-            r3trans: undefined,
-            packageTransports: {
-                devc: {
-                    binaries: undefined,
-                    instance: undefined
-                },
-                tadir: {
-                    binaries: undefined,
-                    instance: undefined
-                },
-                cust: [],
-                lang: {
-                    binaries: undefined,
-                    instance: undefined
-                }
+            isTrmServer: false,
+            isLocal: registry.getRegistryType() === registry_1.RegistryType.LOCAL,
+            update: undefined, //if has value, it's the package from system that we're updating
+            package: {
+                data: undefined,
+                hierarchy: undefined
             },
-            packageTransportsData: {
-                tdevc: [],
-                tdevct: [],
-                tadir: [],
-                e071: []
+            transports: {
+                devc: undefined,
+                tadir: undefined,
+                lang: undefined,
+                cust: []
             },
-            installData: {
-                namespace: undefined,
-                entries: [],
-                transports: []
+            dele: undefined,
+            transportEntries: {
+                tdevct: []
             },
-            originalData: {
-                hierarchy: undefined
+            dependencies: [],
+            namespace: undefined, //will be calculated from either origin devclass or target devclass later
+            installRegistry: undefined,
+            previousInstallPackages: [],
+            previousInstallTransports: [],
+            dependencyRollbacks: [],
+            dependencyReleases: [],
+            installedDependencies: [],
+            stopWarningShown: false
+        };
+        context.output = {
+            manifest: undefined,
+            transport: undefined
+        };
+        context.revert = {
+            transports: {
+                devc: undefined,
+                tadir: undefined,
+                lang: undefined,
+                cust: []
             },
-            generatedData: {
-                devclass: [],
-                namespace: undefined,
-                tmsTxtRefresh: []
-            }
+            cleanupTransport: undefined,
+            cleanupImported: false,
+            cleanupSucceeded: false,
+            importStarted: false,
+            importedEntries: [],
+            importedCustomizing: [],
+            packageHierarchy: [],
+            packageTransportLayers: [],
+            createdTransports: { cust: [] },
+            sapPackages: [],
+            dele: undefined,
+            metadataWriteStarted: false,
+            metadataPackageRegistry: undefined,
+            metadataPackageRow: undefined,
+            metadataPreviousPackageRow: undefined,
+            namespace: undefined
         };
-        context.runtime.isTrmServer = context.runtime.remotePackageData.data.name === systemConnector_1.TRM_SERVER_PACKAGE_NAME && context.runtime.registry.getRegistryType() === registry_1.RegistryType.PUBLIC;
-        context.runtime.isTrmRest = context.runtime.remotePackageData.data.name === systemConnector_1.TRM_REST_PACKAGE_NAME && context.runtime.registry.getRegistryType() === registry_1.RegistryType.PUBLIC;
+        //the lockfile root pins the release (and its integrity) of the package being installed
+        const rootLock = context.rawInput.dependency ? undefined : (_c = (_b = (_a = context.rawInput.installData) === null || _a === void 0 ? void 0 : _a.checks) === null || _b === void 0 ? void 0 : _b.lockfile) === null || _c === void 0 ? void 0 : _c.getRootLock();
+        if (rootLock) {
+            applyRootLock(context, rootLock);
+        }
+        trm_commons_1.Logger.loading(`Fetching package in registry ${registry.name}...`);
+        context.runtime.package.data = yield registry.getPackage(context.rawInput.packageData.name, context.rawInput.packageData.version || 'latest');
+        context.output.manifest = context.runtime.package.data.manifest;
+        if (rootLock) {
+            yield checkRootLock(context, rootLock);
+        }
+        //the release whose transports are imported must be the expected one (e.g. locked)
+        const expectedIntegrity = context.rawInput.packageData.integrity;
+        if (expectedIntegrity !== undefined && context.runtime.package.data.checksum !== expectedIntegrity) {
+            trm_commons_1.Logger.error(`SECURITY ISSUE! Release "${context.rawInput.packageData.name}", registry "${registry.name}", integrity does NOT match!`, { important: true });
+            trm_commons_1.Logger.error(`SECURITY ISSUE! Registry SHA is ${context.runtime.package.data.checksum}`, { important: true });
+            trm_commons_1.Logger.error(`SECURITY ISSUE! Expected SHA is ${expectedIntegrity}`, { important: true });
+            throw new Error(`Cannot continue due to security issues.`);
+        }
+        //only used to validate manifest
+        try {
+            manifest_1.Manifest.normalize(context.runtime.package.data.manifest);
+        }
+        catch (e) {
+            throw new Error(`Package manifest is invalid: ${e.toString()}`);
+        }
+        // replace input name with actual name in manifest: install mappings and transports
+        // are read and written with case-sensitive queries, under the name of the package record
+        context.rawInput.packageData.name = context.runtime.package.data.manifest.name;
+        //install mappings, transports and locks are recorded under the real registry of a local artifact
+        context.runtime.installRegistry = (yield (0, utils_1.resolveInstallPackage)(registry, context.rawInput.packageData.name)).registry;
+        context.runtime.isTrmServer = context.runtime.package.data.name === systemConnector_1.TRM_SERVER_PACKAGE_NAME && registry.getRegistryType() === registry_1.RegistryType.PUBLIC;
+        context.runtime.isTrmRest = context.runtime.package.data.name === systemConnector_1.TRM_REST_PACKAGE_NAME && registry.getRegistryType() === registry_1.RegistryType.PUBLIC;
+        //2- fill missing input data
         if (context.rawInput.packageData.overwrite === undefined) {
             context.rawInput.packageData.overwrite = false;
         }
@@ -128,42 +202,75 @@ exports.init = {
         if (!context.rawInput.installData.installDevclass.replacements) {
             context.rawInput.installData.installDevclass.replacements = [];
         }
-        if (!context.rawInput.installData.installTransport) {
-            context.rawInput.installData.installTransport = {
-                create: true
-            };
+        if (!context.rawInput.installData.landscapeTransport) {
+            context.rawInput.installData.landscapeTransport = {};
         }
         if (!context.rawInput.installData.skipPostActivities) {
             context.rawInput.installData.skipPostActivities = false;
         }
+        //guard
         if (context.runtime.isTrmServer || context.runtime.isTrmRest) {
             context.rawInput.installData.installDevclass.keepOriginal = false;
         }
-        if (context.rawInput.installData.installDevclass.keepOriginal === undefined) {
-            if (!context.rawInput.contextData.noInquirer) {
-                context.rawInput.installData.installDevclass.keepOriginal = (yield trm_commons_1.Inquirer.prompt([{
-                        name: 'keepOriginal',
-                        message: `Keep original ABAP package(s)?`,
-                        type: 'confirm',
-                        default: context.rawInput.installData.installDevclass.keepOriginal ? true : false
-                    }])).keepOriginal;
+        //3- check install transport layer
+        //the system default is resolved by generate-devclass, only when transportable packages are created
+        if (context.rawInput.installData.installDevclass.transportLayer) {
+            trm_commons_1.Logger.loading(`Checking transport layer...`);
+            if (!(yield systemConnector_1.SystemConnector.isTransportLayerExist(context.rawInput.installData.installDevclass.transportLayer))) {
+                throw new Error(`Transport layer "${context.rawInput.installData.installDevclass.transportLayer}" doesn't exist.`);
             }
         }
-        trm_commons_1.Logger.loading(`Checking transport layer...`);
-        if (!context.rawInput.installData.installDevclass.transportLayer) {
-            try {
-                context.rawInput.installData.installDevclass.transportLayer = yield systemConnector_1.SystemConnector.getDefaultTransportLayer();
-                trm_commons_1.Logger.log(`Setting transport layer to default: ${context.rawInput.installData.installDevclass.transportLayer}`, true);
+        //4- check/set system target
+        context.rawInput.installData.landscapeTransport.targetSystem = yield (0, prompts_1.setLandscapeTarget)(context.rawInput.contextData.noInquirer, context.rawInput.installData.landscapeTransport.targetSystem, "Install transport target", "Install transport won't be generated.");
+        //5- check if already installed
+        context.runtime.update = context.rawInput.contextData.systemPackages.find(o => manifest_1.Manifest.compare(o.manifest, new manifest_1.Manifest(context.runtime.package.data.manifest), false));
+        if (context.runtime.update) {
+            context.runtime.previousInstallPackages = yield systemConnector_1.SystemConnector.getInstallPackages(context.rawInput.packageData.name, context.runtime.installRegistry);
+            context.runtime.previousInstallTransports = yield systemConnector_1.SystemConnector.getInstallTransports(context.rawInput.packageData.name, context.runtime.installRegistry);
+            const installVersion = context.runtime.package.data.manifest.version;
+            const installedVersion = context.runtime.update.manifest.get().version;
+            //transports TRM generated for the package (e.g. of a rolled back release) aren't changes made on the system
+            const dirtyEntries = yield (0, utils_1.withoutOwnTrmTransports)(context.runtime.update.getDirtyEntries(), context.runtime.update.packageName);
+            if ((0, semver_1.eq)(installVersion, installedVersion)) {
+                if (context.rawInput.packageData.overwrite) {
+                    if (dirtyEntries.length > 0) {
+                        let ignoreDirty = false;
+                        trm_commons_1.Logger.warning(`${context.rawInput.packageData.name} has changes made on ${systemConnector_1.SystemConnector.getDest()} that will be overwritten!`, { important: true });
+                        (0, utils_1.logDirtyEntries)(dirtyEntries);
+                        if (!context.rawInput.contextData.noInquirer) {
+                            ignoreDirty = (yield trm_commons_1.Inquirer.prompt({
+                                message: `Continue with install?`,
+                                type: 'confirm',
+                                default: false,
+                                name: 'ignoreDirty'
+                            })).ignoreDirty;
+                        }
+                        if (!ignoreDirty) {
+                            throw new Error(`Install aborted.`);
+                        }
+                    }
+                    trm_commons_1.Logger.info(`${context.rawInput.packageData.name} v${installedVersion} already installed in ${systemConnector_1.SystemConnector.getDest()}, overwriting.`);
+                }
+                else {
+                    throw new Error(`Install aborted. ${context.rawInput.packageData.name} v${installedVersion} already installed in ${systemConnector_1.SystemConnector.getDest()}. If you wish to overwrite, rerun install with overwrite feature.`);
+                }
             }
-            catch (e) {
-                trm_commons_1.Logger.error(e.toString(), true);
-                throw new Error(`Couldn't determine system's default transport layer.`);
+            else {
+                if ((0, semver_1.gt)(installVersion, installedVersion)) {
+                    trm_commons_1.Logger.info(`${chalk_1.default.bold('Upgrading')} ${installedVersion} -> ${installVersion}`);
+                }
+                else {
+                    trm_commons_1.Logger.warning(`${chalk_1.default.bold('Downgrading')} ${installedVersion} -> ${installVersion}`);
+                }
+                if (dirtyEntries.length > 0) {
+                    trm_commons_1.Logger.warning(`${context.rawInput.packageData.name} has changes made on ${systemConnector_1.SystemConnector.getDest()} that will be overwritten!`, { important: true });
+                    (0, utils_1.logDirtyEntries)(dirtyEntries);
+                }
             }
         }
         else {
-            if (!(yield systemConnector_1.SystemConnector.isTransportLayerExist(context.rawInput.installData.installDevclass.transportLayer))) {
-                throw new Error(`Transport layer "${context.rawInput.installData.installDevclass.transportLayer}" doesn't exist.`);
-            }
+            trm_commons_1.Logger.info(`Package first install on ${systemConnector_1.SystemConnector.getDest()}`, true);
         }
+        trm_commons_1.Logger.info(`Ready to install ${context.runtime.package.data.manifest.name} v${context.runtime.package.data.manifest.version}${!(0, semver_1.valid)(context.rawInput.packageData.version) ? (' (' + (context.rawInput.packageData.version || 'latest') + ')') : ''}.`);
     })
 };

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

@@ -1,3 +1,17 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that installs each dependency missing from the target system or installed in an
+ * incompatible version. A downgrade is confirmed by the dependency install; a dependency found
+ * already installed there is skipped without a rollback. Every package a dependency install
+ * installed, transitive ones included, is merged into the package snapshot, so a later dependency
+ * sharing it (diamond) finds it installed.
+ *
+ * 1- list dependencies to install
+ *
+ * 2- prompt install
+ *
+ * 3- run install workflow for each dependency
+ *
+*/
 export declare const installDependencies: Step<InstallWorkflowContext>;

package/dist/actions/install/installDependencies.js

@@ -45,13 +45,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installDependencies = void 0;
 const trm_commons_1 = require("trm-commons");
 const __1 = require("..");
+const manifest_1 = require("../../manifest");
 const registry_1 = require("../../registry");
+const trmPackage_1 = require("../../trmPackage");
 const _ = __importStar(require("lodash"));
-const SUBWORKFLOW_NAME = 'install-dependency-sub-install';
+const _1 = require(".");
+/**
+ * Workflow step that installs each dependency missing from the target system or installed in an
+ * incompatible version. A downgrade is confirmed by the dependency install; a dependency found
+ * already installed there is skipped without a rollback. Every package a dependency install
+ * installed, transitive ones included, is merged into the package snapshot, so a later dependency
+ * sharing it (diamond) finds it installed.
+ *
+ * 1- list dependencies to install
+ *
+ * 2- prompt install
+ *
+ * 3- run install workflow for each dependency
+ *
+*/
 exports.installDependencies = {
     name: 'install-dependencies',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.dependenciesToInstall.length > 0) {
+        if (context.runtime.dependencies.length > 0) {
             return true;
         }
         else {
@@ -60,65 +76,126 @@ exports.installDependencies = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Install dependencies step', true);
-        if (context.runtime.dependenciesToInstall.length === 1) {
-            trm_commons_1.Logger.info(`There is ${context.runtime.dependenciesToInstall.length} missing dependency to install:`);
-        }
-        else {
-            trm_commons_1.Logger.info(`There are ${context.runtime.dependenciesToInstall.length} missing dependencies to install:`);
-        }
-        context.runtime.dependenciesToInstall.forEach((o, i) => {
-            trm_commons_1.Logger.info(`  ${i + 1}/${context.runtime.dependenciesToInstall.length} ${o.name} ${o.version}`);
+        //1- list dependencies to install
+        const total = context.runtime.dependencies.length;
+        trm_commons_1.Logger.info(total === 1 ? `There is 1 dependency to install:` : `There are ${total} dependencies to install:`);
+        context.runtime.dependencies.forEach((o, i) => {
+            if (o.status === 'versionMismatch') {
+                trm_commons_1.Logger.info(`  ${i + 1}/${total} ${o.dependency.name} ${o.dependency.version} (incompatible: v${o.installedVersion} installed)`);
+            }
+            else {
+                trm_commons_1.Logger.info(`  ${i + 1}/${total} ${o.dependency.name} ${o.dependency.version} (missing)`);
+            }
         });
-        var confirmInstall = true;
-        if (!context.rawInput.contextData.noInquirer) {
+        //2- prompt install (not again for dependencies a parent install already confirmed)
+        let confirmInstall = true;
+        const approved = context.rawInput.installData.approvedDependencies || [];
+        const alreadyApproved = context.runtime.dependencies.every(o => approved.includes(o.dependency.name));
+        if (alreadyApproved) {
+            trm_commons_1.Logger.log(`Dependencies already confirmed by the parent install`, true);
+        }
+        else if (!context.rawInput.contextData.noInquirer) {
             confirmInstall = (yield trm_commons_1.Inquirer.prompt({
                 type: 'confirm',
                 default: true,
-                message: `Install missing dependencies?`,
+                message: context.runtime.dependencies.some(o => o.status === 'versionMismatch') ? `Install or replace dependencies?` : `Install missing dependencies?`,
                 name: 'confirmInstall'
             })).confirmInstall;
         }
         if (!confirmInstall) {
-            throw new Error(`Install aborted`);
+            throw new Error(`Install aborted.`);
         }
-        var counter = 0;
+        //3- run install workflow for each dependency
+        context.runtime.systemPackagesBeforeDependencies = [...context.rawInput.contextData.systemPackages];
+        let counter = 0;
         const originalLPrefix = trm_commons_1.Logger.getPrefix();
         const originalIPrefix = trm_commons_1.Inquirer.getPrefix();
-        for (const dependency of context.runtime.dependenciesToInstall) {
+        for (const { dependency } of context.runtime.dependencies) {
             counter++;
-            trm_commons_1.Logger.loading(`Getting ready to install missing dependency "${dependency.name}"...`);
-            var prefix = `(${counter}/${context.runtime.dependenciesToInstall.length}) `;
-            if (originalLPrefix) {
-                trm_commons_1.Logger.setPrefix(`${originalLPrefix}-> ${prefix}`);
+            trm_commons_1.Logger.loading(`Getting ready to install dependency "${dependency.name}"...`);
+            const prefix = `(${counter}/${context.runtime.dependencies.length}) `;
+            try {
+                if (originalLPrefix) {
+                    trm_commons_1.Logger.setPrefix(`${originalLPrefix}-> ${prefix}`);
+                }
+                else {
+                    trm_commons_1.Logger.setPrefix(`  ${prefix}`);
+                }
+                if (originalIPrefix) {
+                    trm_commons_1.Inquirer.setPrefix(`${originalIPrefix}-> ${prefix}`);
+                }
+                else {
+                    trm_commons_1.Inquirer.setPrefix(`  ${prefix}`);
+                }
+                const dependencyRegistry = registry_1.RegistryProvider.getRegistry(dependency.registry);
+                const inputData = {
+                    dependencyDataPackage: {
+                        name: dependency.name,
+                        versionRange: dependency.version,
+                        registry: dependencyRegistry
+                    },
+                    contextData: _.cloneDeep(context.rawInput.contextData),
+                    installData: _.cloneDeep(context.rawInput.installData)
+                };
+                inputData.installData.approvedDependencies = [...new Set([...approved, ...context.runtime.dependencies.map(o => o.dependency.name)])];
+                delete inputData.installData.installDevclass.keepOriginal; //force input value if inquirer allows
+                //the parent's mappings were resolved for its own devclasses: the dependency resolves its own
+                inputData.installData.installDevclass.replacements = [];
+                //on upgrade, the dependency must see the parent's new requirements, not the installed ones
+                if (context.runtime.update) {
+                    const parentPackage = inputData.contextData.systemPackages.find(systemPackage => trmPackage_1.TrmPackage.compare(systemPackage, context.runtime.update));
+                    if (parentPackage) {
+                        parentPackage.manifest = new manifest_1.Manifest(_.cloneDeep(context.runtime.package.data.manifest));
+                    }
+                }
+                const result = yield (0, __1.installDependency)(inputData, input => (0, _1.installWithRollback)(input, context.runtime.lockedNamespaces || []));
+                if (result.alreadyInstalled) {
+                    continue;
+                }
+                if (!result.rollback) {
+                    throw new Error(`Dependency install did not return its rollback journal.`);
+                }
+                context.runtime.dependencyRollbacks.push(result.rollback);
+                if (result.release) {
+                    context.runtime.dependencyReleases.push(result.release);
+                }
+                const installedPackage = new trmPackage_1.TrmPackage(result.installOutput.manifest.name, dependencyRegistry, new manifest_1.Manifest(result.installOutput.manifest));
+                //the dependency install only updated its own copy of the snapshot
+                for (const installed of [...(result.installedPackages || []), installedPackage]) {
+                    const installedIndex = context.rawInput.contextData.systemPackages.findIndex(systemPackage => trmPackage_1.TrmPackage.compare(systemPackage, installed));
+                    if (installedIndex === -1) {
+                        context.rawInput.contextData.systemPackages.push(installed);
+                    }
+                    else {
+                        context.rawInput.contextData.systemPackages.splice(installedIndex, 1, installed);
+                    }
+                    context.runtime.installedDependencies.push(installed);
+                }
             }
-            else {
-                trm_commons_1.Logger.setPrefix(`  ${prefix}`);
-            }
-            if (originalIPrefix) {
-                trm_commons_1.Inquirer.setPrefix(`${originalIPrefix}-> ${prefix}`);
+            finally {
+                trm_commons_1.Logger.setPrefix(originalLPrefix);
+                trm_commons_1.Inquirer.setPrefix(originalIPrefix);
             }
-            else {
-                trm_commons_1.Inquirer.setPrefix(`  ${prefix}`);
+        }
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        let firstError;
+        for (const rollback of [...context.runtime.dependencyRollbacks].reverse()) {
+            try {
+                yield rollback();
             }
-            var inputData = {
-                dependencyDataPackage: {
-                    name: dependency.name,
-                    versionRange: dependency.version,
-                    registry: registry_1.RegistryProvider.getRegistry(dependency.registry)
-                },
-                contextData: _.cloneDeep(context.rawInput.contextData),
-                installData: _.cloneDeep(context.rawInput.installData)
-            };
-            if (inputData.contextData) {
-                inputData.contextData.noR3transInfo = true;
+            catch (error) {
+                firstError || (firstError = error);
             }
-            delete inputData.installData.installDevclass.keepOriginal;
-            trm_commons_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, trm_commons_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-            const result = yield (0, __1.installDependency)(inputData);
-            trm_commons_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, trm_commons_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-            trm_commons_1.Logger.setPrefix(originalLPrefix);
-            trm_commons_1.Inquirer.setPrefix(originalIPrefix);
         }
+        if (firstError) {
+            throw firstError;
+        }
+        //the rolled back packages are no longer installed
+        const before = context.runtime.systemPackagesBeforeDependencies;
+        if (before) {
+            context.rawInput.contextData.systemPackages.splice(0, context.rawInput.contextData.systemPackages.length, ...before);
+        }
+        context.runtime.installedDependencies = [];
     })
 };

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

@@ -0,0 +1,8 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Lock the selected import payload, its resolved target packages and its custom namespace before
+ * dependencies mutate SAP, then repeat the safety checks of check-transports that another action
+ * could have invalidated before the locks were held.
+ */
+export declare const lockResources: Step<InstallWorkflowContext>;