trm-core 9.10.6 → 10.0.0

package/dist/actions/commons/prompts/setLandscapeTarget.js

@@ -0,0 +1,40 @@
+"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.setLandscapeTarget = setLandscapeTarget;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../../systemConnector");
+const setTransportTarget_1 = require("./setTransportTarget");
+/**
+ * Resolves the landscape target system that receives the transports generated by an action.
+ *
+ * When the connected system has no transport targets and none was supplied, it is treated
+ * as the final system of the landscape and `undefined` is returned.
+ *
+ * @param noInquirer Disable interactive target selection.
+ * @param userInput Explicit target to validate and use.
+ * @param inquirerMessage Prompt label used when interactive selection is required.
+ * @param skippedMessage Warning logged when no target is available, e.g. `Install transport won't be generated.`
+ * @returns The selected, valid transport target, or `undefined` for the final system.
+ */
+function setLandscapeTarget(noInquirer, userInput, inquirerMessage, skippedMessage) {
+    return __awaiter(this, void 0, void 0, function* () {
+        trm_commons_1.Logger.loading(`Checking system target...`);
+        const transportTargets = yield systemConnector_1.SystemConnector.getTransportTargets();
+        if (transportTargets.length === 0 && !userInput) {
+            //no transport targets: system is the last in the landscape?
+            trm_commons_1.Logger.info(`No transport targets in ${systemConnector_1.SystemConnector.getDest()}`);
+            trm_commons_1.Logger.warning(`Is ${systemConnector_1.SystemConnector.getDest()} final system in landscape? ${skippedMessage}`, true);
+            return undefined;
+        }
+        return (0, setTransportTarget_1.setTransportTarget)(noInquirer, transportTargets, userInput, inquirerMessage);
+    });
+}

package/dist/actions/commons/prompts/setTransportTarget.d.ts

@@ -1,2 +1,17 @@
 import { TARSYSTEM } from "../../../client";
+/**
+ * Resolves and validates the target system for a transport.
+ *
+ * A supplied `userInput` is validated against `systemTargets`. Without an explicit
+ * value, the sole available target is selected automatically; otherwise the user is
+ * prompted unless `noInquirer` is enabled.
+ *
+ * @param noInquirer Disable interactive target selection.
+ * @param systemTargets Transport targets available in the connected SAP system.
+ * @param userInput Explicit target to validate and use.
+ * @param inquirerMessage Prompt label used when interactive selection is required.
+ * @returns The selected, valid transport target, trimmed and uppercased.
+ * @throws When no targets are available, the explicit target is invalid, or a required target was
+ * not supplied in non-interactive mode.
+ */
 export declare function setTransportTarget(noInquirer: boolean, systemTargets: TARSYSTEM[], userInput?: TARSYSTEM, inquirerMessage?: string): Promise<TARSYSTEM>;

package/dist/actions/commons/prompts/setTransportTarget.js

@@ -16,10 +16,28 @@ exports.setTransportTarget = setTransportTarget;
 const trm_commons_1 = require("trm-commons");
 const chalk_1 = __importDefault(require("chalk"));
 const validators_1 = require("../../../validators");
+/**
+ * Resolves and validates the target system for a transport.
+ *
+ * A supplied `userInput` is validated against `systemTargets`. Without an explicit
+ * value, the sole available target is selected automatically; otherwise the user is
+ * prompted unless `noInquirer` is enabled.
+ *
+ * @param noInquirer Disable interactive target selection.
+ * @param systemTargets Transport targets available in the connected SAP system.
+ * @param userInput Explicit target to validate and use.
+ * @param inquirerMessage Prompt label used when interactive selection is required.
+ * @returns The selected, valid transport target, trimmed and uppercased.
+ * @throws When no targets are available, the explicit target is invalid, or a required target was
+ * not supplied in non-interactive mode.
+ */
 function setTransportTarget(noInquirer, systemTargets, userInput, inquirerMessage) {
     return __awaiter(this, void 0, void 0, function* () {
+        if (systemTargets.length === 0) {
+            throw new Error(`No transport targets are available in the connected SAP system.`);
+        }
         var needsValidation;
-        var transportTarget = userInput;
+        var transportTarget = userInput === null || userInput === void 0 ? void 0 : userInput.trim().toUpperCase();
         if (transportTarget === undefined) {
             if (systemTargets.length === 1) {
                 transportTarget = systemTargets[0];
@@ -58,6 +76,6 @@ function setTransportTarget(noInquirer, systemTargets, userInput, inquirerMessag
             }
             trm_commons_1.Logger.info(`Target system: ${chalk_1.default.bold(transportTarget)}`);
         }
-        return transportTarget;
+        return transportTarget.trim().toUpperCase();
     });
 }

package/dist/actions/commons/setSystemPackages.d.ts

@@ -1,3 +1,10 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { IActionContext } from "..";
+/**
+ * Workflow step that populates `contextData.systemPackages` from the target system.
+ *
+ * A caller-supplied package list is preserved, allowing workflows to reuse a cached
+ * snapshot and avoid an additional system query.
+ * Local-registry packages are included, so dependencies and dependants published locally are matched.
+ */
 export declare const setSystemPackages: Step<IActionContext>;

package/dist/actions/commons/setSystemPackages.js

@@ -12,13 +12,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSystemPackages = void 0;
 const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
+/**
+ * Workflow step that populates `contextData.systemPackages` from the target system.
+ *
+ * A caller-supplied package list is preserved, allowing workflows to reuse a cached
+ * snapshot and avoid an additional system query.
+ * Local-registry packages are included, so dependencies and dependants published locally are matched.
+ */
 exports.setSystemPackages = {
     name: 'set-system-packages',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Set system packages step', true);
+        //1- set system packages
+        if (!context.rawInput.contextData) { //guard
+            context.rawInput.contextData = {};
+        }
         if (context.rawInput.contextData.systemPackages === undefined) {
             trm_commons_1.Logger.loading(`Reading system data...`);
-            context.rawInput.contextData.systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true);
+            context.rawInput.contextData.systemPackages = yield systemConnector_1.SystemConnector.getInstalledPackages(true, true);
         }
     })
 };

package/dist/actions/commons/utils/actionLocks.d.ts

@@ -0,0 +1,32 @@
+import { AbstractRegistry } from "../../../registry";
+import { ActionLockKey } from "../../../systemConnector";
+export type LockResource = {
+    type: "PACKAGE" | "DEVCLASS" | "OBJECT" | "TRANSPORT" | "NAMESPACE";
+    name: string;
+};
+/** Keep the same canonical key across separate processes and both SAP transports. */
+export declare function actionLockKey(resource: LockResource): ActionLockKey;
+export declare function packageLockResource(registry: AbstractRegistry, name: string): LockResource;
+export declare function objectLockResource(object: {
+    pgmid: string;
+    object: string;
+    objName: string;
+}): LockResource;
+/** One non-expiring SAP lock owner; close only after workflow rollback has finished. */
+export declare class ActionLockScope {
+    private readonly actionName;
+    private readonly ownerToken;
+    private readonly held;
+    constructor(actionName: string);
+    acquire(resources: LockResource[]): Promise<void>;
+    release(): Promise<void>;
+}
+/**
+ * Runs the work, then releases its locks once. A release failure is logged by the lock scope:
+ * after a success it doesn't reject the committed action, after a failure it never masks it.
+ */
+export declare function withLockRelease<T>(release: () => Promise<void>, work: () => Promise<T>): Promise<T>;
+/** Releases locks whose failure was already logged by their {@link ActionLockScope}. */
+export declare function releaseLogged(release: () => Promise<void>): Promise<void>;
+/** Preserve the operation's result or failure while still attempting lock cleanup. */
+export declare function withActionLockScope<T>(scope: ActionLockScope, work: () => Promise<T>): Promise<T>;

package/dist/actions/commons/utils/actionLocks.js

@@ -0,0 +1,135 @@
+"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.ActionLockScope = void 0;
+exports.actionLockKey = actionLockKey;
+exports.packageLockResource = packageLockResource;
+exports.objectLockResource = objectLockResource;
+exports.withLockRelease = withLockRelease;
+exports.releaseLogged = releaseLogged;
+exports.withActionLockScope = withActionLockScope;
+const crypto_1 = require("crypto");
+const trm_commons_1 = require("trm-commons");
+const client_1 = require("../../../client");
+const systemConnector_1 = require("../../../systemConnector");
+/** Keep the same canonical key across separate processes and both SAP transports. */
+function actionLockKey(resource) {
+    const name = resource.type === "PACKAGE"
+        ? resource.name.trim()
+        : resource.name.trim().toUpperCase();
+    if (!name || name.length > 255) {
+        throw new Error(`Invalid ${resource.type} lock resource name.`);
+    }
+    return {
+        resourceType: resource.type,
+        resourceHash: (0, crypto_1.createHash)("sha256").update(resource.type).update("\0").update(name).digest("hex").toUpperCase(),
+        resourceName: name
+    };
+}
+function packageLockResource(registry, name) {
+    return { type: "PACKAGE", name: `${name.trim().toLowerCase()} [${registry.endpoint.trim()}]` };
+}
+function objectLockResource(object) {
+    return { type: "OBJECT", name: `${object.pgmid.trim().toUpperCase()} ${object.object.trim().toUpperCase()} ${object.objName.trim().toUpperCase()}` };
+}
+/** One non-expiring SAP lock owner; close only after workflow rollback has finished. */
+class ActionLockScope {
+    constructor(actionName) {
+        this.actionName = actionName;
+        this.ownerToken = (0, crypto_1.randomUUID)().replace(/-/g, "").toUpperCase();
+        this.held = new Map();
+    }
+    acquire(resources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requested = resources.map(actionLockKey);
+            const fresh = requested.filter(key => !this.held.has(`${key.resourceType}:${key.resourceHash}`));
+            if (fresh.length === 0) {
+                return;
+            }
+            fresh.sort((a, b) => a.resourceType.localeCompare(b.resourceType) || a.resourceHash.localeCompare(b.resourceHash));
+            try {
+                yield systemConnector_1.SystemConnector.acquireActionLocks(fresh, this.ownerToken, this.actionName);
+            }
+            catch (error) {
+                if (error instanceof client_1.ClientError && error.sapMessage) {
+                    // SAP answered and rejected the request: nothing was locked for this owner.
+                    if (/lock held/i.test(error.message)) {
+                        error.message = `${error.message}. If no other TRM action is running, the lock was left by an interrupted action: delete it with transaction /ATRM/LOCK.`;
+                    }
+                    throw error;
+                }
+                // A response can fail after SAP commits. Release only rows owned by this token.
+                try {
+                    yield systemConnector_1.SystemConnector.releaseActionLocks(fresh, this.ownerToken);
+                }
+                catch (cleanupError) {
+                    trm_commons_1.Logger.warning(`Could not clean up uncertain action lock acquisition: ${String(cleanupError)}`, { important: true });
+                }
+                throw error;
+            }
+            for (const key of fresh) {
+                this.held.set(`${key.resourceType}:${key.resourceHash}`, key);
+            }
+        });
+    }
+    release() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.held.size === 0) {
+                return;
+            }
+            const keys = [...this.held.values()];
+            try {
+                yield systemConnector_1.SystemConnector.releaseActionLocks(keys, this.ownerToken);
+            }
+            catch (error) {
+                // Locks never expire: name them so they can be deleted with transaction /ATRM/LOCK.
+                const resources = keys.map(key => `${key.resourceType} ${key.resourceName}`).join(", ");
+                trm_commons_1.Logger.warning(`Could not release ${this.actionName} action locks owned by ${this.ownerToken} (${resources}): ${error instanceof Error ? error.message : String(error)}. Delete them with transaction /ATRM/LOCK.`, { important: true });
+                throw error;
+            }
+            this.held.clear();
+        });
+    }
+}
+exports.ActionLockScope = ActionLockScope;
+/**
+ * Runs the work, then releases its locks once. A release failure is logged by the lock scope:
+ * after a success it doesn't reject the committed action, after a failure it never masks it.
+ */
+function withLockRelease(release, work) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result;
+        try {
+            result = yield work();
+        }
+        catch (error) {
+            yield releaseLogged(release);
+            throw error;
+        }
+        yield releaseLogged(release);
+        return result;
+    });
+}
+/** Releases locks whose failure was already logged by their {@link ActionLockScope}. */
+function releaseLogged(release) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield release();
+        }
+        catch (_a) {
+            // Logged with resources and owner token by ActionLockScope.release.
+        }
+    });
+}
+/** Preserve the operation's result or failure while still attempting lock cleanup. */
+function withActionLockScope(scope, work) {
+    return withLockRelease(() => scope.release(), work);
+}

package/dist/actions/commons/utils/dirtyEntries.d.ts

@@ -0,0 +1,12 @@
+import { ZTRM_DIRTY } from "../../../client";
+/**
+ * Lists the changes made on the target system to an installed package,
+ * so the user can tell what a delete or an overwrite would discard.
+ */
+export declare function logDirtyEntries(entries: ZTRM_DIRTY[]): void;
+/**
+ * Leaves out the entries of transports TRM generated for the package itself (its TRM comment rows name
+ * it): e.g. the landscape transport of a release whose install was rolled back. They aren't changes
+ * made on the system.
+ */
+export declare function withoutOwnTrmTransports(entries: ZTRM_DIRTY[], packageName: string): Promise<ZTRM_DIRTY[]>;

package/dist/actions/commons/utils/dirtyEntries.js

@@ -0,0 +1,54 @@
+"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.logDirtyEntries = logDirtyEntries;
+exports.withoutOwnTrmTransports = withoutOwnTrmTransports;
+const trm_commons_1 = require("trm-commons");
+const transport_1 = require("../../../transport");
+/**
+ * Lists the changes made on the target system to an installed package,
+ * so the user can tell what a delete or an overwrite would discard.
+ */
+function logDirtyEntries(entries) {
+    if (entries.length === 0) {
+        return;
+    }
+    trm_commons_1.Logger.table(['Transport', 'Description', 'Object'], entries.map(o => [
+        o.trkorr,
+        // RFC rows are camel-cased (as4Text), REST rows keep the server field name (as4text)
+        o.as4Text || o.as4text || '',
+        `${o.pgmid} ${o.object} ${o.objName}`
+    ]));
+}
+/**
+ * Leaves out the entries of transports TRM generated for the package itself (its TRM comment rows name
+ * it): e.g. the landscape transport of a release whose install was rolled back. They aren't changes
+ * made on the system.
+ */
+function withoutOwnTrmTransports(entries, packageName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (entries.length === 0) {
+            return entries;
+        }
+        const own = new Set();
+        for (const trkorr of new Set(entries.map(o => o.trkorr))) {
+            try {
+                if ((yield new transport_1.Transport(trkorr).getTrmPackageName()) === packageName) {
+                    own.add(trkorr);
+                }
+            }
+            catch (_a) {
+                //unreadable: keep its entries
+            }
+        }
+        return entries.filter(o => !own.has(o.trkorr));
+    });
+}

package/dist/actions/commons/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./restoreTransport";
+export * from "./releaseDeletionTransport";
+export * from "./retainedWorkflow";
+export * from "./withScopedPrefix";
+export * from "./actionLocks";
+export * from "./packageCleanup";
+export * from "./installedDependency";
+export * from "./installRegistry";
+export * from "./dirtyEntries";
+export * from "./owningInstallation";

package/dist/actions/commons/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./restoreTransport"), exports);
+__exportStar(require("./releaseDeletionTransport"), exports);
+__exportStar(require("./retainedWorkflow"), exports);
+__exportStar(require("./withScopedPrefix"), exports);
+__exportStar(require("./actionLocks"), exports);
+__exportStar(require("./packageCleanup"), exports);
+__exportStar(require("./installedDependency"), exports);
+__exportStar(require("./installRegistry"), exports);
+__exportStar(require("./dirtyEntries"), exports);
+__exportStar(require("./owningInstallation"), exports);

package/dist/actions/commons/utils/installRegistry.d.ts

@@ -0,0 +1,18 @@
+import { AbstractRegistry } from "../../../registry";
+/**
+ * Returns the package an install is recorded under: a local (.trm) artifact is recorded under the
+ * registry it was published to and the name in its manifest, not under the file directory.
+ */
+export declare function resolveInstallPackage(registry: AbstractRegistry, name: string): Promise<{
+    registry: AbstractRegistry;
+    name: string;
+}>;
+/**
+ * Returns the registry an install is recorded under: the registry a local (.trm) artifact was
+ * published to, otherwise the registry itself.
+ */
+export declare function resolveInstallRegistry(registry: AbstractRegistry): Promise<AbstractRegistry>;
+/**
+ * Registry key stored in the TRM install tables for a resolved install registry.
+ */
+export declare function installRegistryKey(registry: AbstractRegistry): string;

package/dist/actions/commons/utils/installRegistry.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInstallPackage = resolveInstallPackage;
+exports.resolveInstallRegistry = resolveInstallRegistry;
+exports.installRegistryKey = installRegistryKey;
+const registry_1 = require("../../../registry");
+/**
+ * Returns the package an install is recorded under: a local (.trm) artifact is recorded under the
+ * registry it was published to and the name in its manifest, not under the file directory.
+ */
+function resolveInstallPackage(registry, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (registry.getRegistryType() !== registry_1.RegistryType.LOCAL) {
+            return { registry, name };
+        }
+        const realPackage = yield registry.getRealPackage();
+        return { registry: realPackage.registry, name: realPackage.packageName };
+    });
+}
+/**
+ * Returns the registry an install is recorded under: the registry a local (.trm) artifact was
+ * published to, otherwise the registry itself.
+ */
+function resolveInstallRegistry(registry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (registry.getRegistryType() !== registry_1.RegistryType.LOCAL) {
+            return registry;
+        }
+        return registry.getRealRegistry();
+    });
+}
+/**
+ * Registry key stored in the TRM install tables for a resolved install registry.
+ */
+function installRegistryKey(registry) {
+    return (0, registry_1.registryKey)(registry);
+}

package/dist/actions/commons/utils/installedDependency.d.ts

@@ -0,0 +1,15 @@
+import type { DependencyCheckStatus } from "../../checkPackageDependencies";
+import { TrmPackage } from "../../../trmPackage";
+/** State of a dependency on the target system, compared with the range it is required in. */
+export type InstalledDependency = {
+    status: DependencyCheckStatus;
+    /** Version on the system; set for `ok` and `versionMismatch`. */
+    installedVersion?: string;
+    /** Why the installed manifest could not be read; set only for `manifestUnreadable`. */
+    error?: unknown;
+};
+/**
+ * Finds `trmPackage` in the system package snapshot and checks the installed version against
+ * `versionRange`. Installed prereleases are matched with `includePrerelease`.
+ */
+export declare function getInstalledDependency(systemPackages: TrmPackage[], trmPackage: TrmPackage, versionRange: string): InstalledDependency;

package/dist/actions/commons/utils/installedDependency.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledDependency = getInstalledDependency;
+const semver_1 = require("semver");
+const trmPackage_1 = require("../../../trmPackage");
+/**
+ * Finds `trmPackage` in the system package snapshot and checks the installed version against
+ * `versionRange`. Installed prereleases are matched with `includePrerelease`.
+ */
+function getInstalledDependency(systemPackages, trmPackage, versionRange) {
+    var _a;
+    const installed = (systemPackages || []).find(o => trmPackage_1.TrmPackage.compare(o, trmPackage));
+    if (!installed) {
+        return { status: 'notFound' };
+    }
+    let installedVersion;
+    try {
+        installedVersion = (_a = installed.manifest) === null || _a === void 0 ? void 0 : _a.get().version;
+    }
+    catch (error) {
+        return { status: 'manifestUnreadable', error };
+    }
+    if (typeof installedVersion !== 'string' || (0, semver_1.valid)(installedVersion) === null) {
+        return { status: 'manifestUnreadable' };
+    }
+    return {
+        status: (0, semver_1.satisfies)(installedVersion, versionRange, { includePrerelease: true }) ? 'ok' : 'versionMismatch',
+        installedVersion
+    };
+}

package/dist/actions/commons/utils/owningInstallation.d.ts

@@ -0,0 +1,6 @@
+import { TrmPackage } from "../../../trmPackage";
+/**
+ * Installed TRM package whose SAP packages contain `devclass`: its root package or one of the
+ * root's subpackages, at any depth. `exclude` (e.g. the package being upgraded) is never returned.
+ */
+export declare function getOwningInstallation(devclass: string, systemPackages: TrmPackage[], exclude?: TrmPackage): Promise<TrmPackage | undefined>;

package/dist/actions/commons/utils/owningInstallation.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOwningInstallation = getOwningInstallation;
+const systemConnector_1 = require("../../../systemConnector");
+function normalize(value) {
+    return value.trim().toUpperCase();
+}
+/**
+ * Installed TRM package whose SAP packages contain `devclass`: its root package or one of the
+ * root's subpackages, at any depth. `exclude` (e.g. the package being upgraded) is never returned.
+ */
+function getOwningInstallation(devclass, systemPackages, exclude) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const excludedDevclass = normalize((exclude === null || exclude === void 0 ? void 0 : exclude.getDevclass()) || '');
+        const roots = new Map();
+        systemPackages.forEach(pkg => {
+            const root = normalize(pkg.getDevclass() || '');
+            if (root && pkg !== exclude && root !== excludedDevclass) {
+                roots.set(root, pkg);
+            }
+        });
+        if (roots.size === 0) {
+            return undefined;
+        }
+        const visited = new Set();
+        let current = devclass;
+        while (current && !visited.has(normalize(current))) {
+            const owner = roots.get(normalize(current));
+            if (owner) {
+                return owner;
+            }
+            visited.add(normalize(current));
+            current = (_a = (yield systemConnector_1.SystemConnector.getDevclass(current))) === null || _a === void 0 ? void 0 : _a.parentcl;
+        }
+        return undefined;
+    });
+}