trm-core 9.10.6 → 10.0.1

package/dist/actions/install/addNamespace.js

@@ -10,83 +10,153 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addNamespace = void 0;
+exports.flattenDevclasses = flattenDevclasses;
+exports.getInstallNamespace = getInstallNamespace;
 const trm_commons_1 = require("trm-commons");
 const commons_1 = require("../../commons");
 const systemConnector_1 = require("../../systemConnector");
 const stopWarning_1 = require("../stopWarning");
+function flattenDevclasses(pkg) {
+    return [
+        pkg.devclass,
+        ...pkg.sub.flatMap(flattenDevclasses),
+    ];
+}
+/**
+ * Returns the namespace packages are installed into: the target names, or the original names when
+ * `original` is set or `keepOriginal` is used. See getPackagesNamespace.
+ */
+function getInstallNamespace(context, original = false) {
+    var _a;
+    const hierarchy = context.runtime.package.hierarchy;
+    const originalDevclasses = flattenDevclasses(hierarchy);
+    if (original || context.rawInput.installData.installDevclass.keepOriginal) {
+        return (0, commons_1.getPackagesNamespace)(hierarchy.devclass, originalDevclasses);
+    }
+    //ignore stored mappings of devclasses that are no longer part of the release
+    const replacements = context.rawInput.installData.installDevclass.replacements.filter(o => originalDevclasses.includes(o.originalDevclass));
+    if (replacements.length === 0) {
+        return (0, commons_1.getPackagesNamespace)(hierarchy.devclass, originalDevclasses);
+    }
+    const rootDevclass = ((_a = replacements.find(o => o.originalDevclass === hierarchy.devclass)) === null || _a === void 0 ? void 0 : _a.installDevclass) || hierarchy.devclass;
+    return (0, commons_1.getPackagesNamespace)(rootDevclass, replacements.map(o => o.installDevclass));
+}
+/** Imports `namespace` with the repair license and texts shipped by the package manifest. */
+function createNamespace(context, namespace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let replicense;
+        let aTexts = [];
+        if (context.runtime.package.data.manifest.namespace) {
+            replicense = context.runtime.package.data.manifest.namespace.replicense;
+            aTexts = context.runtime.package.data.manifest.namespace.texts.map(o => {
+                return {
+                    namespace: context.runtime.package.data.manifest.namespace.ns || namespace,
+                    spras: o.language,
+                    descriptn: o.description,
+                    owner: o.owner
+                };
+            });
+        }
+        if (!replicense) {
+            throw new Error(`Cannot use namespace ${namespace}: unknown repair license.`);
+        }
+        if (aTexts.length === 0) {
+            throw new Error(`Cannot use namespace ${namespace}: unknown description.`);
+        }
+        if (!context.runtime.stopWarningShown) {
+            context.runtime.stopWarningShown = true;
+            (0, stopWarning_1.stopWarning)('install');
+        }
+        trm_commons_1.Logger.loading(`Installing namespace ${namespace}...`);
+        // Track before the mutating await: SAP may commit the namespace and the
+        // connector can still fail while returning the response.
+        context.revert.namespace = namespace;
+        yield systemConnector_1.SystemConnector.addNamespace(namespace, replicense, aTexts);
+    });
+}
+/**
+ * Asks to import the namespace of the objects when the packages are installed outside of it.
+ * Declining keeps the previous behavior: the install continues without it.
+ */
+function importObjectsNamespace(context, namespace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (context.rawInput.installData.installDevclass.skipNamespace === undefined && !context.rawInput.contextData.noInquirer) {
+            context.rawInput.installData.installDevclass.skipNamespace = !(yield trm_commons_1.Inquirer.prompt({
+                message: `Package objects use namespace ${namespace}, do you want to import it (repair license)?`,
+                name: 'skipNamespace',
+                type: 'confirm',
+                default: true
+            })).skipNamespace;
+        }
+        if (context.rawInput.installData.installDevclass.skipNamespace) {
+            trm_commons_1.Logger.warning(`Install will continue without importing namespace ${namespace}: its objects might not be assigned to the install packages. Run install with namespace import or manually add namespace in SE03.`, { important: true });
+            return;
+        }
+        yield createNamespace(context, namespace);
+    });
+}
+/**
+ * Workflow step that registers the package namespace for repair when required.
+ *
+ * 1- set namespace
+ *
+ * 2- check if namespace already exists (only if customer namespace)
+ *
+ *
+ * 3- create namespace
+ *
+*/
 exports.addNamespace = {
     name: 'add-namespace',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Add namespace step', true);
-        var originalNamespace = (0, commons_1.getPackageNamespace)(context.runtime.originalData.hierarchy.devclass);
+        var _a;
+        //1- set namespace
+        const originalNamespace = getInstallNamespace(context, true);
         trm_commons_1.Logger.log(`Package original namespace is ${originalNamespace}`, true);
-        if (!context.rawInput.installData.installDevclass.keepOriginal && context.rawInput.installData.installDevclass.replacements.length > 0) {
-            context.runtime.installData.namespace = (0, commons_1.getPackageNamespace)(context.rawInput.installData.installDevclass.replacements[0].installDevclass);
-        }
-        else {
-            context.runtime.installData.namespace = originalNamespace;
-        }
-        if (context.runtime.installData.namespace[0] !== '/') {
-            trm_commons_1.Logger.log(`Package install namespace is ${context.runtime.installData.namespace}, continue`, true);
+        context.runtime.namespace = getInstallNamespace(context);
+        if (context.runtime.namespace[0] !== '/') {
+            trm_commons_1.Logger.log(`Package install namespace is ${context.runtime.namespace}, continue`, true);
+            // Packages renamed out of the original namespace: the objects keep their names, and can only be
+            // assigned to the install packages (and repaired) when their namespace exists.
+            if (originalNamespace[0] === '/' && !((_a = (yield systemConnector_1.SystemConnector.getNamespace(originalNamespace))) === null || _a === void 0 ? void 0 : _a.trnspacet)) {
+                yield importObjectsNamespace(context, originalNamespace);
+            }
             return;
         }
-        trm_commons_1.Logger.loading(`Checking namespace ${context.runtime.installData.namespace} status in system...`);
-        const namespaceCheck = yield systemConnector_1.SystemConnector.getNamespace(context.runtime.installData.namespace);
+        //2- check if namespace already exists (only if customer namespace)
+        trm_commons_1.Logger.loading(`Checking namespace ${context.runtime.namespace}...`);
+        const namespaceCheck = yield systemConnector_1.SystemConnector.getNamespace(context.runtime.namespace);
         if (namespaceCheck && namespaceCheck.trnspacet) {
-            trm_commons_1.Logger.log(`Namespace ${context.runtime.installData.namespace} exists in system, continue`, true);
+            trm_commons_1.Logger.log(`Namespace ${context.runtime.namespace} exists in system, continue`, true);
             return;
         }
         else {
-            if (context.runtime.installData.namespace === originalNamespace) {
-                if (context.rawInput.installData.installDevclass.keepOriginal) {
-                    trm_commons_1.Logger.warning(`Install will continue without importing namespace ${context.runtime.installData.namespace}. Run install with namespace import or manually add namespace in SE03.`, context.runtime.installData.namespace === '/ATRM/');
-                    return;
-                }
+            if (context.runtime.namespace === originalNamespace) {
+                //trying to install with the same namespace provided by package
                 if (context.rawInput.installData.installDevclass.skipNamespace === undefined && !context.rawInput.contextData.noInquirer) {
                     context.rawInput.installData.installDevclass.skipNamespace = !(yield trm_commons_1.Inquirer.prompt({
-                        message: `Package uses namespace ${context.runtime.installData.namespace}, do you want to import it (repair license)?`,
+                        message: `Package uses namespace ${context.runtime.namespace}, do you want to import it (repair license)?`,
                         name: 'skipNamespace',
                         type: 'confirm',
                         default: true
                     })).skipNamespace;
                 }
                 if (context.rawInput.installData.installDevclass.skipNamespace) {
-                    throw new Error(`Cannot generate packages without namespace ${context.runtime.installData.namespace}. Run install with namespace import or avoid renaming packages.`);
+                    if (context.rawInput.installData.installDevclass.keepOriginal) {
+                        //no packages are being generated under this namespace, importing it is optional
+                        trm_commons_1.Logger.warning(`Install will continue without importing namespace ${context.runtime.namespace}. Run install with namespace import or manually add namespace in SE03.`, { debug: context.runtime.namespace === '/ATRM/', important: true });
+                        return;
+                    }
+                    //namespace doesn't exist but packages must be generated, it's mandatory to have the namespace
+                    throw new Error(`Cannot generate packages without namespace ${context.runtime.namespace}. Run install with namespace import or avoid renaming packages.`);
                 }
             }
             else {
-                throw new Error(`Namespace ${context.runtime.installData.namespace} doesn't exist in ${systemConnector_1.SystemConnector.getDest()}. Manually add namespace in SE03.`);
+                //namespace doesn't exist, force user to create it manually
+                throw new Error(`Namespace ${context.runtime.namespace} doesn't exist in ${systemConnector_1.SystemConnector.getDest()}. Manually add namespace in SE03.`);
             }
         }
-        var replicense;
-        var aTexts = [];
-        if (context.runtime.remotePackageData.manifest.namespace) {
-            replicense = context.runtime.remotePackageData.manifest.namespace.replicense;
-            aTexts = context.runtime.remotePackageData.manifest.namespace.texts.map(o => {
-                return {
-                    namespace: context.runtime.remotePackageData.manifest.namespace.ns || context.runtime.installData.namespace,
-                    spras: o.language,
-                    descriptn: o.description,
-                    owner: o.owner
-                };
-            });
-        }
-        if (!replicense) {
-            throw new Error(`Cannot use namespace ${context.runtime.installData.namespace}: unknown repair license.`);
-        }
-        if (aTexts.length === 0) {
-            throw new Error(`Cannot use namespace ${context.runtime.installData.namespace}: unknown description.`);
-        }
-        if (!context.runtime.stopWarningShown) {
-            context.runtime.stopWarningShown = true;
-            (0, stopWarning_1.stopWarning)('install');
-        }
-        trm_commons_1.Logger.loading(`Installing namespace ${context.runtime.installData.namespace}...`);
-        yield systemConnector_1.SystemConnector.addNamespace(context.runtime.installData.namespace, replicense, aTexts);
-        context.runtime.generatedData.namespace = context.runtime.installData.namespace;
-    }),
-    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.generatedData.namespace) {
-        }
+        //3- create namespace
+        yield createNamespace(context, context.runtime.namespace);
     })
 };

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

@@ -0,0 +1,15 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+import { TrmPackage } from "../../trmPackage";
+/** Installed package declaring a dependency on another installed package. */
+export type PackageDependant = {
+    package: TrmPackage;
+    /** Version range the dependant requires. */
+    range: string;
+};
+/** Lists the dependencies on `target` declared by the other installed packages. */
+export declare function getDependants(systemPackages: TrmPackage[], target: TrmPackage): PackageDependant[];
+/**
+ * Prevents an upgrade from breaking the declared ranges of installed dependant packages.
+ */
+export declare const checkDependants: Step<InstallWorkflowContext>;

package/dist/actions/install/checkDependants.js

@@ -0,0 +1,74 @@
+"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.checkDependants = void 0;
+exports.getDependants = getDependants;
+const trm_commons_1 = require("trm-commons");
+const semver_1 = require("semver");
+const registry_1 = require("../../registry");
+const trmPackage_1 = require("../../trmPackage");
+/** Lists the dependencies on `target` declared by the other installed packages. */
+function getDependants(systemPackages, target) {
+    return systemPackages.flatMap(systemPackage => {
+        if (!systemPackage.manifest || trmPackage_1.TrmPackage.compare(systemPackage, target)) {
+            return [];
+        }
+        return (systemPackage.manifest.get().dependencies || [])
+            .filter(dependency => trmPackage_1.TrmPackage.compare(new trmPackage_1.TrmPackage(dependency.name, registry_1.RegistryProvider.getRegistry(dependency.registry)), target))
+            .map(dependency => ({
+            package: systemPackage,
+            range: dependency.version
+        }));
+    });
+}
+/** Explains how to unblock an upgrade rejected by incompatible dependants. */
+function logResolutionGuide(upgradedPackage, upgradedVersion, incompatibleDependants, ranges) {
+    const target = `"${upgradedPackage.packageName}" v${upgradedVersion}`;
+    const names = incompatibleDependants.map(dependant => `"${dependant.package.packageName}"`).join(', ');
+    trm_commons_1.Logger.info(`How to upgrade to ${target}:`, { important: true });
+    trm_commons_1.Logger.info(`  1. Install a newer release of ${names} whose dependency on "${upgradedPackage.packageName}" accepts v${upgradedVersion}; installing it can also upgrade "${upgradedPackage.packageName}" as its dependency.`, { important: true });
+    trm_commons_1.Logger.info(`  2. If ${target} is still not installed, run this install again.`, { important: true });
+    trm_commons_1.Logger.info(`If no compatible release of ${names} is available, keep the current version or install a version of "${upgradedPackage.packageName}" that satisfies all dependant ranges (${[...new Set(ranges)].join(', ')}).`, { important: true });
+}
+/**
+ * Prevents an upgrade from breaking the declared ranges of installed dependant packages.
+ */
+exports.checkDependants = {
+    name: 'check-dependants',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.runtime.update) {
+            trm_commons_1.Logger.log(`Skipping check dependants check (no upgrade/downgrade)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const upgradedPackage = context.runtime.update;
+        const upgradedVersion = context.runtime.package.data.manifest.version;
+        const dependants = getDependants(context.rawInput.contextData.systemPackages, upgradedPackage).map(dependant => (Object.assign(Object.assign({}, dependant), { compatible: (0, semver_1.satisfies)(upgradedVersion, dependant.range, { includePrerelease: true }) })));
+        if (dependants.length === 0) {
+            trm_commons_1.Logger.info(`No installed packages depend on "${upgradedPackage.packageName}".`, true);
+            return;
+        }
+        const incompatibleDependants = dependants.filter(dependant => !dependant.compatible);
+        dependants
+            .filter(dependant => dependant.compatible)
+            .forEach(dependant => trm_commons_1.Logger.info(`Dependant "${dependant.package.packageName}" accepts "${upgradedPackage.packageName}" v${upgradedVersion} (${dependant.range}); no action needed.`));
+        if (incompatibleDependants.length === 0) {
+            return;
+        }
+        incompatibleDependants.forEach(dependant => trm_commons_1.Logger.error(`Dependant "${dependant.package.packageName}" requires "${upgradedPackage.packageName}" ${dependant.range}, which does not accept v${upgradedVersion}.`, { important: true }));
+        logResolutionGuide(upgradedPackage, upgradedVersion, incompatibleDependants, dependants.map(dependant => dependant.range));
+        throw new Error(`Upgrade aborted: incompatible dependant packages must be upgraded first.`);
+    })
+};

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

@@ -1,3 +1,14 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that identifies missing or incompatible dependencies on the target system.
+ * Incompatible dependencies are queued with their installed version, so they are not reported as missing.
+ *
+ * 1- execute check dependencies workflow
+ *
+ * 2- reject installed dependencies with an unreadable manifest
+ *
+ * 3- filter dependencies
+ *
+*/
 export declare const checkDependencies: Step<InstallWorkflowContext>;

package/dist/actions/install/checkDependencies.js

@@ -12,7 +12,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkDependencies = void 0;
 const trm_commons_1 = require("trm-commons");
 const checkPackageDependencies_1 = require("../checkPackageDependencies");
-const SUBWORKFLOW_NAME = 'check-package-dependencies-sub-install';
+/**
+ * Workflow step that identifies missing or incompatible dependencies on the target system.
+ * Incompatible dependencies are queued with their installed version, so they are not reported as missing.
+ *
+ * 1- execute check dependencies workflow
+ *
+ * 2- reject installed dependencies with an unreadable manifest
+ *
+ * 3- filter dependencies
+ *
+*/
 exports.checkDependencies = {
     name: 'check-dependencies',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -25,10 +35,10 @@ exports.checkDependencies = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Check dependencies step', true);
+        //1- execute check dependencies workflow
         const inputData = {
             packageData: {
-                manifest: context.runtime.remotePackageData.manifest
+                manifest: context.runtime.package.data.manifest
             },
             contextData: {
                 systemPackages: context.rawInput.contextData.systemPackages
@@ -38,18 +48,27 @@ exports.checkDependencies = {
                 information: false
             }
         };
-        trm_commons_1.Logger.loading(`Checking dependencies...`);
-        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);
+        trm_commons_1.Logger.loading(`Checking package dependencies...`);
         const result = yield (0, checkPackageDependencies_1.checkPackageDependencies)(inputData);
-        trm_commons_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, trm_commons_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
         if (result.dependencies.length > 0) {
-            if (result.dependencies.length === 1) {
-                trm_commons_1.Logger.info(`"${context.rawInput.packageData.name}" has ${result.dependencies.length} dependency: ${result.dependencyStatus.filter(o => o.match).length} installed, ${result.dependencyStatus.filter(o => !o.match).length} missing.`);
-            }
-            else {
-                trm_commons_1.Logger.info(`"${context.rawInput.packageData.name}" has ${result.dependencies.length} dependencies: ${result.dependencyStatus.filter(o => o.match).length} installed, ${result.dependencyStatus.filter(o => !o.match).length} missing.`);
-            }
+            const installed = result.dependencyStatus.filter(o => o.status === 'ok').length;
+            const missing = result.dependencyStatus.filter(o => o.status === 'notFound').length;
+            const incompatible = result.dependencyStatus.filter(o => o.status === 'versionMismatch').length;
+            const noun = result.dependencies.length === 1 ? 'dependency' : 'dependencies';
+            trm_commons_1.Logger.info(`"${context.rawInput.packageData.name}" has ${result.dependencies.length} ${noun}: ${installed} installed, ${missing} missing, ${incompatible} incompatible.`);
+        }
+        //2- reject installed dependencies with an unreadable manifest
+        const unreadable = result.dependencyStatus.filter(o => o.status === 'manifestUnreadable');
+        if (unreadable.length > 0) {
+            throw new Error(`Cannot verify installed dependencies ${unreadable.map(o => `"${o.dependency.name}"`).join(', ')}: package is installed but its manifest is unreadable.`);
         }
-        context.runtime.dependenciesToInstall = result.dependencyStatus.filter(o => !o.match).map(k => k.dependency);
+        //3- filter dependencies
+        context.runtime.dependencies = result.dependencyStatus
+            .filter(o => o.status === 'notFound' || o.status === 'versionMismatch')
+            .map(o => ({
+            dependency: o.dependency,
+            status: o.status,
+            installedVersion: o.installedVersion
+        }));
     })
 };

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

@@ -0,0 +1,17 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that rejects dependency cycles and version conflicts the install would run into,
+ * before anything is locked or installed. A dependency already installed in a compatible version is
+ * not installed again, so it ends the walk on that branch. Any other dependency is resolved to the
+ * release a dependency install would select (lockfile entry or newest release in range) and walked.
+ * The walk follows the install order: the first package reaching a dependency decides its version,
+ * and a later range that version doesn't satisfy is a conflict, which would otherwise fail midway,
+ * after earlier dependencies were installed.
+ *
+ * 1- walk the dependency graph and abort on the first cycle or version conflict
+ *
+ * 2- abort when a replaced dependency no longer satisfies another installed package
+ *
+*/
+export declare const checkDependencyCycles: Step<InstallWorkflowContext>;

package/dist/actions/install/checkDependencyCycles.js

@@ -0,0 +1,105 @@
+"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.checkDependencyCycles = void 0;
+const trm_commons_1 = require("trm-commons");
+const registry_1 = require("../../registry");
+const trmPackage_1 = require("../../trmPackage");
+const findInstallRelease_1 = require("../installDependency/findInstallRelease");
+const utils_1 = require("../commons/utils");
+const semver_1 = require("semver");
+/**
+ * Workflow step that rejects dependency cycles and version conflicts the install would run into,
+ * before anything is locked or installed. A dependency already installed in a compatible version is
+ * not installed again, so it ends the walk on that branch. Any other dependency is resolved to the
+ * release a dependency install would select (lockfile entry or newest release in range) and walked.
+ * The walk follows the install order: the first package reaching a dependency decides its version,
+ * and a later range that version doesn't satisfy is a conflict, which would otherwise fail midway,
+ * after earlier dependencies were installed.
+ *
+ * 1- walk the dependency graph and abort on the first cycle or version conflict
+ *
+ * 2- abort when a replaced dependency no longer satisfies another installed package
+ *
+*/
+exports.checkDependencyCycles = {
+    name: 'check-dependency-cycles',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.checks.noDependencies) {
+            trm_commons_1.Logger.log(`Skipping dependency cycles check (user input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        //1- walk the dependency graph and abort on the first cycle or version conflict
+        trm_commons_1.Logger.loading(`Checking dependency graph...`);
+        const systemPackages = context.rawInput.contextData.systemPackages || [];
+        const lockfile = context.rawInput.installData.checks.lockfile;
+        const root = new trmPackage_1.TrmPackage(context.rawInput.packageData.name, context.rawInput.packageData.registry);
+        //completely walked dependencies (a dependency still being walked is on the path)
+        const planned = [];
+        const visit = (manifest, path) => __awaiter(void 0, void 0, void 0, function* () {
+            const requiredBy = path[path.length - 1].packageName;
+            for (const dependency of manifest.dependencies || []) {
+                const trmPackage = new trmPackage_1.TrmPackage(dependency.name, registry_1.RegistryProvider.getRegistry(dependency.registry));
+                const plan = planned.find(o => trmPackage_1.TrmPackage.compare(o.trmPackage, trmPackage));
+                if (plan) {
+                    if (!(0, semver_1.satisfies)(plan.version, dependency.version, { includePrerelease: true })) {
+                        throw new Error(`Install aborted: dependency "${trmPackage.packageName}" version conflict: "${plan.requiredBy}" requires ${plan.versionRange} (v${plan.version} ${plan.kept ? 'installed' : 'to install'}), "${requiredBy}" requires ${dependency.version}.`);
+                    }
+                    continue;
+                }
+                const installed = (0, utils_1.getInstalledDependency)(systemPackages, trmPackage, dependency.version);
+                if (installed.status === 'ok') {
+                    //the package being installed changes version: it is not planned
+                    if (!trmPackage_1.TrmPackage.compare(trmPackage, root)) {
+                        planned.push({ trmPackage, version: installed.installedVersion, kept: true, requiredBy, versionRange: dependency.version });
+                    }
+                    continue;
+                }
+                //the same package installed from another registry (e.g. a .trm file) owns the objects: it can't be installed again
+                const otherRegistry = systemPackages.find(o => o.compareName(trmPackage.packageName) && !o.compareRegistry(trmPackage.registry));
+                if (otherRegistry) {
+                    const source = (registry) => registry.getRegistryType() === registry_1.RegistryType.LOCAL ? 'a .trm file' : `registry ${registry.name}`;
+                    throw new Error(`Install aborted: dependency "${trmPackage.packageName}" must be installed from ${source(trmPackage.registry)}, but it's installed from ${source(otherRegistry.registry)}. Delete it, then install again.`);
+                }
+                const cycleStart = path.findIndex(o => trmPackage_1.TrmPackage.compare(o, trmPackage));
+                if (cycleStart >= 0) {
+                    const cycle = [...path.slice(cycleStart), trmPackage].map(o => `"${o.packageName}"`).join(' -> ');
+                    throw new Error(`Install aborted: cyclic dependency detected ${cycle}.`);
+                }
+                const release = yield (0, findInstallRelease_1.selectDependencyRelease)(trmPackage, trmPackage.registry, dependency.version, lockfile);
+                const releaseManifest = (yield trmPackage.registry.getPackage(trmPackage.packageName, release.version)).manifest;
+                yield visit(releaseManifest, [...path, trmPackage]);
+                planned.push({ trmPackage, version: release.version, kept: false, requiredBy, versionRange: dependency.version });
+            }
+        });
+        yield visit(context.runtime.package.data.manifest, [root]);
+        //2- a dependency installed in another version must still satisfy the other installed packages requiring it
+        const changed = planned.filter(plan => !plan.kept);
+        for (const installedPackage of systemPackages) {
+            if (trmPackage_1.TrmPackage.compare(installedPackage, root) || changed.some(plan => trmPackage_1.TrmPackage.compare(plan.trmPackage, installedPackage))) {
+                continue;
+            }
+            for (const dependency of ((_b = (_a = installedPackage.manifest) === null || _a === void 0 ? void 0 : _a.get()) === null || _b === void 0 ? void 0 : _b.dependencies) || []) {
+                const plan = changed.find(o => trmPackage_1.TrmPackage.compare(o.trmPackage, new trmPackage_1.TrmPackage(dependency.name, registry_1.RegistryProvider.getRegistry(dependency.registry))));
+                if (plan && (0, utils_1.getInstalledDependency)(systemPackages, plan.trmPackage, plan.versionRange).status !== 'notFound'
+                    && !(0, semver_1.satisfies)(plan.version, dependency.version, { includePrerelease: true })) {
+                    throw new Error(`Install aborted: dependency "${plan.trmPackage.packageName}" would be replaced with v${plan.version}, but installed package "${installedPackage.packageName}" requires ${dependency.version}. Upgrade "${installedPackage.packageName}" first.`);
+                }
+            }
+        }
+    })
+};

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

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that blocks installation when the manifest engines are not satisfied.
+ *
+ * 1- execute check engines workflow
+ *
+ * 2- check result (detail each alternative of a failed anyOf)
+ *
+*/
+export declare const checkEngines: Step<InstallWorkflowContext>;

package/dist/actions/install/checkEngines.js

@@ -0,0 +1,100 @@
+"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.checkEngines = void 0;
+const trm_commons_1 = require("trm-commons");
+const checkEngines_1 = require("../checkEngines");
+function requirementsError(missingSapEntries, notMetEngines) {
+    const parts = [
+        missingSapEntries > 0 ? `${missingSapEntries} system ${missingSapEntries === 1 ? 'requirement' : 'requirements'}` : '',
+        notMetEngines > 0 ? `${notMetEngines} engine ${notMetEngines === 1 ? 'requirement' : 'requirements'}` : ''
+    ].filter(Boolean);
+    const total = missingSapEntries + notMetEngines;
+    return new Error(`Install aborted. ${parts.join(' and ')} ${total === 1 ? 'is' : 'are'} not met!`);
+}
+function isAnyOf(result) {
+    return result.path === 'anyOf' || result.path.endsWith('.anyOf');
+}
+function describeNotMet(result) {
+    return `expected ${result.requirement}${result.reason ? ` (${result.reason})` : result.actual ? `, found ${result.actual}` : ''}`;
+}
+/** Lists the unmet requirements of a failed `anyOf`, skipping those under a satisfied nested `anyOf`. */
+function getAnyOfDetails(results, anyOf) {
+    const satisfied = results.filter(o => isAnyOf(o) && o.ok).map(o => `${o.path}[`);
+    return results.filter(o => !o.ok && o.path.startsWith(`${anyOf.path}[`) && !satisfied.some(prefix => o.path.startsWith(prefix)));
+}
+/**
+ * Workflow step that blocks installation when the manifest engines are not satisfied.
+ *
+ * 1- execute check engines workflow
+ *
+ * 2- check result (detail each alternative of a failed anyOf)
+ *
+*/
+exports.checkEngines = {
+    name: 'check-engines',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.runtime.missingSapEntries > 0) {
+            // Aborts the install for the missing SAP entries.
+            return true;
+        }
+        else if (context.rawInput.installData.checks.noEngines) {
+            trm_commons_1.Logger.log(`Skipping engines check (user input)`, true);
+            return false;
+        }
+        else if (!context.runtime.package.data.manifest.engines) {
+            trm_commons_1.Logger.log(`Package has no engines, skipping check`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const missingSapEntries = context.runtime.missingSapEntries || 0;
+        if (context.rawInput.installData.checks.noEngines || !context.runtime.package.data.manifest.engines) {
+            throw requirementsError(missingSapEntries, 0);
+        }
+        //1- execute check engines workflow
+        const inputData = {
+            contextData: {
+                coreVersion: (_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.coreVersion
+            },
+            packageData: {
+                manifest: context.runtime.package.data.manifest
+            },
+            printOptions: {
+                enginesStatus: false,
+                information: false
+            }
+        };
+        trm_commons_1.Logger.loading(`Checking engines...`);
+        const result = yield (0, checkEngines_1.checkEngines)(inputData);
+        //2- check result
+        const notMet = result.results.filter(o => o.required && !o.ok);
+        if (!result.passed) {
+            notMet.forEach(o => {
+                trm_commons_1.Logger.error(`Engine requirement ${o.path} not met: ${describeNotMet(o)}`, { important: true });
+                if (isAnyOf(o)) {
+                    getAnyOfDetails(result.results, o).forEach(detail => {
+                        trm_commons_1.Logger.error(`  ${detail.path}: ${describeNotMet(detail)}`, { important: true });
+                    });
+                }
+            });
+            throw requirementsError(missingSapEntries, notMet.length);
+        }
+        trm_commons_1.Logger.success(`Engines checked.`);
+        if (missingSapEntries > 0) {
+            throw requirementsError(missingSapEntries, 0);
+        }
+    })
+};

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

@@ -0,0 +1,24 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+import { DEVCLASS } from "../../client";
+/**
+ * Validates one install package name chosen by the user, so the prompt can ask again: it must be
+ * outside the SAP packages of the other installed TRM packages and, when it exists, contain none of
+ * their root packages. check-install-devclass repeats the check on the final choice.
+ */
+export declare function validateInstallDevclass(context: InstallWorkflowContext, devclass: DEVCLASS): Promise<true | string>;
+/**
+ * Workflow step that rejects an install whose target ABAP packages would nest it with another
+ * installed TRM package, before anything is locked or installed.
+ *
+ * 1- collect the ABAP package trees of the other installed TRM packages
+ *
+ * 2- reject install packages inside one of those trees
+ *
+ * 3- reject existing install packages that contain another TRM package
+ *
+ * On update, the package's own installed tree stays allowed, also when it is already nested
+ * in another TRM package.
+ *
+*/
+export declare const checkInstallDevclass: Step<InstallWorkflowContext>;