trm-core 9.10.5 → 10.0.0

package/dist/actions/installDependency/confirmDowngrade.js

@@ -0,0 +1,53 @@
+"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.confirmDowngrade = void 0;
+const trm_commons_1 = require("trm-commons");
+const semver_1 = require("semver");
+/**
+ * Workflow step that requires explicit confirmation before a dependency install replaces a newer
+ * installed release. `installData.checks.allowDowngrade` confirms it in advance; otherwise the
+ * user is prompted, and without a prompt the install is aborted.
+ *
+ * 1- confirm downgrade
+ *
+*/
+exports.confirmDowngrade = {
+    name: 'confirm-downgrade',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        return !context.runtime.alreadyInstalled
+            && !!context.runtime.installedVersion
+            && (0, semver_1.lt)(context.runtime.installVersion, context.runtime.installedVersion);
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        //1- confirm downgrade
+        const dependencyName = context.rawInput.dependencyDataPackage.name;
+        const versionRange = context.rawInput.dependencyDataPackage.versionRange;
+        const installedVersion = context.runtime.installedVersion;
+        const installVersion = context.runtime.installVersion;
+        trm_commons_1.Logger.warning(`Dependency "${dependencyName}" v${installedVersion} is installed, but ${versionRange} requires a downgrade to v${installVersion}.`, { important: true });
+        if (context.rawInput.installData.checks.allowDowngrade) {
+            return;
+        }
+        let confirmDowngrade = false;
+        if (!context.rawInput.contextData.noInquirer) {
+            confirmDowngrade = (yield trm_commons_1.Inquirer.prompt({
+                type: 'confirm',
+                default: false,
+                message: `Downgrade "${dependencyName}" from v${installedVersion} to v${installVersion}?`,
+                name: 'confirmDowngrade'
+            })).confirmDowngrade;
+        }
+        if (!confirmDowngrade) {
+            throw new Error(`Install aborted. Dependency "${dependencyName}" v${installedVersion} would be downgraded to v${installVersion}. If you wish to downgrade, rerun install with downgrade allowed.`);
+        }
+    })
+};

package/dist/actions/installDependency/findInstallRelease.d.ts

@@ -1,3 +1,27 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallDependencyWorkflowContext } from ".";
+import { Lock, Lockfile } from "../../lockfile";
+import { AbstractRegistry } from "../../registry";
+import { TrmPackage } from "../../trmPackage";
+/**
+ * Selects the dependency release a dependency install would use: the lockfile entry when the
+ * lockfile has one, otherwise the newest registry release satisfying the range.
+ * The lock integrity is not verified here.
+ * @throws When the lockfile entry is outside the range, or no registry release satisfies it.
+ */
+export declare function selectDependencyRelease(trmPackage: TrmPackage, registry: AbstractRegistry, versionRange: string, lockfile?: Lockfile): Promise<{
+    version: string;
+    lock?: Lock;
+}>;
+/**
+ * Workflow step that selects the dependency release to install.
+ * If a lockfile entry exists, its integrity is verified and its version is used; otherwise,
+ * including when the lockfile has no entry for the dependency, the newest registry release
+ * satisfying the requested semantic-version range is selected.
+ * Registry prereleases are selected only when the range opts in (semver default); installed and
+ * locked prereleases are matched with `includePrerelease`.
+ *
+ * 1- find version
+ *
+*/
 export declare const findInstallRelease: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/findInstallRelease.js

@@ -10,33 +10,56 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findInstallRelease = void 0;
+exports.selectDependencyRelease = selectDependencyRelease;
 const trm_commons_1 = require("trm-commons");
 const semver_sort_1 = require("semver-sort");
 const semver_1 = require("semver");
 const lockfile_1 = require("../../lockfile");
+/**
+ * Selects the dependency release a dependency install would use: the lockfile entry when the
+ * lockfile has one, otherwise the newest registry release satisfying the range.
+ * The lock integrity is not verified here.
+ * @throws When the lockfile entry is outside the range, or no registry release satisfies it.
+ */
+function selectDependencyRelease(trmPackage, registry, versionRange, lockfile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const lock = lockfile === null || lockfile === void 0 ? void 0 : lockfile.getLock(trmPackage, versionRange);
+        if (lock) {
+            return { version: lock.version, lock };
+        }
+        const packageData = yield registry.getPackage(trmPackage.packageName, 'latest');
+        const versions = packageData.versions.filter(v => (0, semver_1.satisfies)(v, versionRange));
+        if (versions.length === 0) {
+            throw new Error(`Dependency "${trmPackage.packageName}": releases not found in range ${versionRange}.`);
+        }
+        return { version: (0, semver_sort_1.desc)(versions)[0] };
+    });
+}
+/**
+ * Workflow step that selects the dependency release to install.
+ * If a lockfile entry exists, its integrity is verified and its version is used; otherwise,
+ * including when the lockfile has no entry for the dependency, the newest registry release
+ * satisfying the requested semantic-version range is selected.
+ * Registry prereleases are selected only when the range opts in (semver default); installed and
+ * locked prereleases are matched with `includePrerelease`.
+ *
+ * 1- find version
+ *
+*/
 exports.findInstallRelease = {
     name: 'find-install-release',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () { return !context.runtime.alreadyInstalled; }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Find install release step', true);
-        const lock = context.rawInput.installData.checks.lockfile ? context.rawInput.installData.checks.lockfile.getLock(context.runtime.trmPackage, context.rawInput.dependencyDataPackage.versionRange) : null;
-        if (lock) {
-            const testLock = yield lockfile_1.Lockfile.testReleaseByLock(lock);
-            if (!testLock) {
-                throw new Error(`Cannot continue due to security issues.`);
-            }
-            else {
-                context.runtime.installVersion = lock.version;
-            }
+        var _a;
+        //1- find version
+        const release = yield selectDependencyRelease(context.runtime.trmPackage, context.rawInput.dependencyDataPackage.registry, context.rawInput.dependencyDataPackage.versionRange, context.rawInput.installData.checks.lockfile);
+        if (context.rawInput.installData.checks.lockfile && !release.lock) {
+            trm_commons_1.Logger.info(`Dependency "${context.rawInput.dependencyDataPackage.name}" not in lockfile, using v${release.version} (${context.rawInput.dependencyDataPackage.versionRange}).`);
         }
-        else {
-            const packageData = yield context.rawInput.dependencyDataPackage.registry.getPackage(context.rawInput.dependencyDataPackage.name, 'latest');
-            const versions = packageData.versions.filter(v => (0, semver_1.satisfies)(v, context.rawInput.dependencyDataPackage.versionRange));
-            if (versions.length === 0) {
-                throw new Error(`Dependency "${context.rawInput.dependencyDataPackage.name}": releases not found in range ${context.rawInput.dependencyDataPackage.versionRange}.`);
-            }
-            else {
-                context.runtime.installVersion = (0, semver_sort_1.desc)(versions)[0];
-            }
+        if (release.lock && !(yield lockfile_1.Lockfile.testReleaseByLock(release.lock))) {
+            throw new Error(`Cannot continue due to security issues.`);
         }
+        context.runtime.installVersion = release.version;
+        context.runtime.installIntegrity = (_a = release.lock) === null || _a === void 0 ? void 0 : _a.integrity;
     })
 };

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

@@ -1,27 +1,88 @@
 import { AbstractRegistry } from "../../registry";
-import { IActionContext, InstallActionInputContextData, InstallActionInputInstallData, InstallActionOutput } from "..";
+import { IActionContext, InstallActionInput, InstallActionInputContextData, InstallActionInputInstallData, InstallActionOutput } from "..";
 import { TrmPackage } from "../../trmPackage";
+/** Input used to resolve and install one TRM package dependency. */
 export interface InstallDependencyActionInput {
+    /** Shared install context, including optional package snapshot and prompt behavior. */
     contextData?: InstallActionInputContextData;
+    /**
+     * Data related to the dependency package being installed.
+     */
     dependencyDataPackage: {
+        /**
+         * Dependency package name.
+         */
         name: string;
+        /**
+         * Semantic-version range the installed release must satisfy.
+         */
         versionRange: string;
+        /**
+         * Registry from which releases and artifacts are fetched.
+         */
         registry: AbstractRegistry;
     };
+    /** Options forwarded to the underlying {@link install} action. */
     installData?: InstallActionInputInstallData;
 }
 type WorkflowRuntime = {
     trmPackage: TrmPackage;
     installVersion: string;
+    /** Integrity of the locked release; the nested install verifies the release it fetches against it. */
+    installIntegrity?: string;
+    /** Version on the system before the install, if the dependency is installed. */
+    installedVersion?: string;
+    /** True when the installed release is kept and nothing is installed. */
+    alreadyInstalled: boolean;
     installOutput: InstallActionOutput;
+    /** Packages installed by the nested install's dependency installs, transitive ones included. */
+    installedPackages?: TrmPackage[];
+    rollback?: () => Promise<void>;
+    release?: () => Promise<void>;
 };
+/** Result returned after a dependency release has been selected and installed, or kept. */
 export type InstallDependencyActionOutput = {
-    installOutput: InstallActionOutput;
+    /** Full result produced by the underlying package installation; unset when `alreadyInstalled`. */
+    installOutput?: InstallActionOutput;
+    /** True when a compatible release was already installed and nothing was installed. */
+    alreadyInstalled: boolean;
+    /** Version on the system before the install, if the dependency was installed. */
+    installedVersion?: string;
 };
+/** Internal state shared by the dependency-install workflow steps. */
 export interface InstallDependencyWorkflowContext extends IActionContext {
+    /** Original action input. */
     rawInput: InstallDependencyActionInput;
+    /** Resolved package, selected version, and nested installation result. */
     runtime?: WorkflowRuntime;
+    /** Dependency-install result. */
     output?: InstallDependencyActionOutput;
+    /** Optional transactional install runner supplied by a parent workflow. */
+    installRunner?: (input: InstallActionInput) => Promise<{
+        output: InstallActionOutput;
+        installedPackages?: TrmPackage[];
+        rollback: () => Promise<void>;
+        release: () => Promise<void>;
+    }>;
 }
-export declare function installDependency(inputData: InstallDependencyActionInput): Promise<InstallDependencyActionOutput>;
+/**
+ * Resolves the highest suitable dependency release and installs it on the target SAP system.
+ *
+ * A release already installed that satisfies `versionRange` is kept and nothing is installed,
+ * unless a lockfile pins the dependency to a different version. Otherwise, a lockfile entry takes
+ * precedence when present and its integrity is verified, or the newest registry release
+ * satisfying `versionRange` is selected. Replacing a newer installed release requires
+ * confirmation (or `installData.checks.allowDowngrade`). Installation is then delegated to
+ * {@link install} with the supplied options.
+ *
+ * @param inputData Dependency identity, version range, registry, and install options.
+ * @returns The nested installation result, or `alreadyInstalled` when nothing was installed.
+ * @throws When no compatible release can be found, a downgrade is not confirmed, or the nested
+ * install fails.
+ */
+export declare function installDependency(inputData: InstallDependencyActionInput, installRunner?: InstallDependencyWorkflowContext['installRunner']): Promise<InstallDependencyActionOutput & {
+    installedPackages?: TrmPackage[];
+    rollback?: () => Promise<void>;
+    release?: () => Promise<void>;
+}>;
 export {};

package/dist/actions/installDependency/index.js

@@ -8,36 +8,53 @@ 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.installDependency = installDependency;
-const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
-const util_1 = require("util");
-const trm_commons_1 = require("trm-commons");
 const __1 = require("..");
 const init_1 = require("./init");
 const findInstallRelease_1 = require("./findInstallRelease");
 const installRelease_1 = require("./installRelease");
+const checkInstalledRelease_1 = require("./checkInstalledRelease");
+const confirmDowngrade_1 = require("./confirmDowngrade");
 ;
 const WORKFLOW_NAME = 'install-dependency';
-function installDependency(inputData) {
+/**
+ * Resolves the highest suitable dependency release and installs it on the target SAP system.
+ *
+ * A release already installed that satisfies `versionRange` is kept and nothing is installed,
+ * unless a lockfile pins the dependency to a different version. Otherwise, a lockfile entry takes
+ * precedence when present and its integrity is verified, or the newest registry release
+ * satisfying `versionRange` is selected. Replacing a newer installed release requires
+ * confirmation (or `installData.checks.allowDowngrade`). Installation is then delegated to
+ * {@link install} with the supplied options.
+ *
+ * @param inputData Dependency identity, version range, registry, and install options.
+ * @returns The nested installation result, or `alreadyInstalled` when nothing was installed.
+ * @throws When no compatible release can be found, a downgrade is not confirmed, or the nested
+ * install fails.
+ */
+function installDependency(inputData, installRunner) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             init_1.init,
             __1.setSystemPackages,
+            checkInstalledRelease_1.checkInstalledRelease,
             findInstallRelease_1.findInstallRelease,
+            confirmDowngrade_1.confirmDowngrade,
             installRelease_1.installRelease
         ];
-        trm_commons_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
-            rawInput: inputData
-        });
-        trm_commons_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const result = yield (0, __1.executeWorkflow)(WORKFLOW_NAME, workflow, {
+            rawInput: inputData,
+            installRunner
+        }, __1.workflowCallbacks);
         const installOutput = result.runtime.installOutput;
         return {
-            installOutput
+            installOutput,
+            alreadyInstalled: result.runtime.alreadyInstalled,
+            installedVersion: result.runtime.installedVersion,
+            installedPackages: result.runtime.installedPackages,
+            rollback: result.runtime.rollback,
+            release: result.runtime.release
         };
     });
 }

package/dist/actions/installDependency/init.d.ts

@@ -1,3 +1,17 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallDependencyWorkflowContext } from ".";
+/**
+ * Workflow step that validates dependency identity/range and initializes resolution state.
+ *
+ * 1- check package name is compliant
+ *
+ * 2- check registry is not local
+ *
+ * 3- validate version range
+ *
+ * 4- fill runtime values
+ *
+ * 5- fill input values
+ *
+*/
 export declare const init: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/init.js

@@ -10,30 +10,48 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = void 0;
-const trm_commons_1 = require("trm-commons");
 const commons_1 = require("../../commons");
 const semver_1 = require("semver");
 const registry_1 = require("../../registry");
 const trmPackage_1 = require("../../trmPackage");
+/**
+ * Workflow step that validates dependency identity/range and initializes resolution state.
+ *
+ * 1- check package name is compliant
+ *
+ * 2- check registry is not local
+ *
+ * 3- validate version range
+ *
+ * 4- fill runtime values
+ *
+ * 5- fill input values
+ *
+*/
 exports.init = {
     name: 'init',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Init step', true);
+        //1- check package name is compliant
         context.rawInput.dependencyDataPackage.name = (0, commons_1.parsePackageName)({
             fullName: context.rawInput.dependencyDataPackage.name
         }).fullName;
+        //2- check registry is not local
         if (context.rawInput.dependencyDataPackage.registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
             throw new Error(`Cannot install local package "${context.rawInput.dependencyDataPackage.name}": TRM package has to be installed manually.`);
         }
+        //3- validate version range
         context.rawInput.dependencyDataPackage.versionRange = (0, semver_1.validRange)(context.rawInput.dependencyDataPackage.versionRange);
         if (!context.rawInput.dependencyDataPackage.versionRange) {
             throw new Error(`Dependency "${context.rawInput.dependencyDataPackage.name}", invalid version range.`);
         }
+        //4- fill runtime values
         context.runtime = {
             trmPackage: new trmPackage_1.TrmPackage(context.rawInput.dependencyDataPackage.name, context.rawInput.dependencyDataPackage.registry),
             installOutput: undefined,
-            installVersion: undefined
+            installVersion: undefined,
+            alreadyInstalled: false
         };
+        //5- fill input values
         if (!context.rawInput.contextData) {
             context.rawInput.contextData = {};
         }
@@ -46,5 +64,8 @@ exports.init = {
         if (!context.rawInput.installData.installDevclass) {
             context.rawInput.installData.installDevclass = {};
         }
+        if (!context.rawInput.installData.checks) {
+            context.rawInput.installData.checks = {};
+        }
     })
 };

package/dist/actions/installDependency/installRelease.d.ts

@@ -1,3 +1,9 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallDependencyWorkflowContext } from ".";
+/**
+ * Workflow step that delegates the selected dependency release to the package install action.
+ *
+ * 1- run install workflow
+ *
+*/
 export declare const installRelease: Step<InstallDependencyWorkflowContext>;

package/dist/actions/installDependency/installRelease.js

@@ -10,29 +10,39 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installRelease = void 0;
-const trm_commons_1 = require("trm-commons");
 const __1 = require("..");
-const SUBWORKFLOW_NAME = 'install-sub-install-dependency';
+/**
+ * Workflow step that delegates the selected dependency release to the package install action.
+ *
+ * 1- run install workflow
+ *
+*/
 exports.installRelease = {
     name: 'install-release',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () { return !context.runtime.alreadyInstalled; }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Install release step', true);
-        if (!context.runtime.installVersion) {
-            throw new Error(`Couldn't find dependency "${context.rawInput.dependencyDataPackage.name}" on registry.`);
-        }
+        //1- run install workflow
         const inputData = {
             packageData: {
                 name: context.rawInput.dependencyDataPackage.name,
                 registry: context.rawInput.dependencyDataPackage.registry,
                 version: context.runtime.installVersion,
+                integrity: context.runtime.installIntegrity,
                 overwrite: false
             },
-            contextData: Object.assign(Object.assign({}, context.rawInput.contextData), { noStopWarning: true }),
-            installData: context.rawInput.installData
+            contextData: context.rawInput.contextData,
+            installData: context.rawInput.installData,
+            dependency: true
         };
-        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.install)(inputData);
-        trm_commons_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, trm_commons_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        context.runtime.installOutput = result;
+        if (context.installRunner) {
+            const result = yield context.installRunner(inputData);
+            context.runtime.installOutput = result.output;
+            context.runtime.installedPackages = result.installedPackages;
+            context.runtime.rollback = result.rollback;
+            context.runtime.release = result.release;
+        }
+        else {
+            context.runtime.installOutput = yield (0, __1.install)(inputData);
+        }
     })
 };

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

@@ -0,0 +1,53 @@
+import { QuestionUiColumn } from "trm-commons";
+import { TrmManifestEngines } from "../../manifest";
+type Row = Record<string, any>;
+/**
+ * Engines sections edited with a UI table.
+ */
+export type EnginesUiSection = 'trm' | 'components' | 'products' | 'notes' | 'tables';
+/**
+ * Engines split in UI table rows (see {@link enginesToUiRows}).
+ */
+export type EnginesUiRows = {
+    trm: Row[];
+    components: Row[];
+    products: Row[];
+    notes: Row[];
+    tables: Row[];
+    /**
+     * edited as JSON
+     */
+    anyOf?: TrmManifestEngines[];
+    /**
+     * checks unknown to this version, kept untouched
+     */
+    other: Record<string, any>;
+};
+/**
+ * Splits an engines declaration in UI table rows.
+ * @param engines engines declaration
+ */
+export declare function enginesToUiRows(engines?: TrmManifestEngines): EnginesUiRows;
+/**
+ * Converts the rows of one UI table to its engines section.
+ * @param section engines section
+ * @param rows table rows
+ */
+export declare function uiRowsToEnginesSection(section: EnginesUiSection, rows: Row[]): any;
+/**
+ * Builds an engines declaration from UI table rows. Empty sections are omitted.
+ * @param rows table rows
+ */
+export declare function uiRowsToEngines(rows: EnginesUiRows): TrmManifestEngines;
+/**
+ * Validates the rows of one UI table: duplicate names and the strict engines validation of the section.
+ * @param section engines section
+ * @param rows normalized table rows
+ * @returns `true` if valid, otherwise the first error
+ */
+export declare function validateEnginesUiSection(section: EnginesUiSection, rows: Row[]): true | string;
+/**
+ * Columns of the UI table of each engines section.
+ */
+export declare const ENGINES_UI_COLUMNS: Record<EnginesUiSection, QuestionUiColumn[]>;
+export {};