trm-core 4.1.4 → 6.0.0

package/dist/actions/install/installDependencies.js

@@ -1,4 +1,27 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -12,9 +35,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installDependencies = void 0;
 const logger_1 = require("../../logger");
 const Inquirer_1 = require("../../inquirer/Inquirer");
-const installDependency_1 = require("../installDependency");
+const __1 = require("..");
 const registry_1 = require("../../registry");
-const SUBWORKFLOW_NAME = 'install-sub-install-dependency';
+const _ = __importStar(require("lodash"));
+const SUBWORKFLOW_NAME = 'install-dependency-sub-install';
 exports.installDependencies = {
     name: 'install-dependencies',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
@@ -22,62 +46,69 @@ exports.installDependencies = {
             return true;
         }
         else {
-            logger_1.Logger.log(`Skipping dependencies install because there are no dependencies to install`, true);
+            logger_1.Logger.log(`Skipping dependencies install (no packages to install)`, true);
             return false;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const mainPackageName = context.parsedInput.packageName;
-        const dependenciesToInstall = context.runtime.dependenciesToInstall;
-        var continueInstall = false;
-        if (context.parsedInput.installMissingDependencies) {
-            continueInstall = true;
+        logger_1.Logger.log('Install dependencies step', true);
+        if (context.runtime.dependenciesToInstall.length === 1) {
+            logger_1.Logger.info(`There is ${context.runtime.dependenciesToInstall.length} missing dependency to install:`);
         }
         else {
-            if (!context.parsedInput.noInquirer) {
-                const inq1 = yield Inquirer_1.Inquirer.prompt({
-                    type: 'confirm',
-                    name: 'continueInstall',
-                    default: true,
-                    message: `Do you wish to install all of the missing dependencies?`
-                });
-                continueInstall = inq1.continueInstall;
+            logger_1.Logger.info(`There are ${context.runtime.dependenciesToInstall.length} missing dependencies to install:`);
+        }
+        context.runtime.dependenciesToInstall.forEach((o, i) => {
+            logger_1.Logger.info(`  ${i + 1}/${context.runtime.dependenciesToInstall.length} ${o.name} ${o.version}`);
+        });
+        var confirmInstall = true;
+        if (!context.rawInput.contextData.noInquirer) {
+            confirmInstall = (yield Inquirer_1.Inquirer.prompt({
+                type: 'confirm',
+                default: true,
+                message: `Install missing dependencies?`,
+                name: 'confirmInstall'
+            })).confirmInstall;
+        }
+        if (!confirmInstall) {
+            throw new Error(`Install aborted`);
+        }
+        var counter = 0;
+        for (const dependency of context.runtime.dependenciesToInstall) {
+            counter++;
+            logger_1.Logger.loading(`Getting ready to install missing dependency "${dependency.name}"...`);
+            var prefix = `  (${counter}/${context.runtime.dependenciesToInstall.length}) `;
+            if (logger_1.Logger.getPrefix()) {
+                prefix = `${logger_1.Logger.getPrefix()} -> ${prefix}`;
+            }
+            logger_1.Logger.setPrefix(prefix);
+            Inquirer_1.Inquirer.setPrefix(prefix);
+            var registry;
+            var tmpRegistry = new registry_1.Registry(dependency.registry || registry_1.PUBLIC_RESERVED_KEYWORD);
+            if (registry_1.Registry.compare(tmpRegistry, context.rawInput.packageData.registry)) {
+                registry = context.rawInput.packageData.registry;
             }
             else {
-                logger_1.Logger.info(`Dependencies are not being installed: running in silent and no action was taken.`);
-                continueInstall = false;
+                registry = tmpRegistry;
             }
-        }
-        if (continueInstall) {
-            var installCounter = 0;
-            for (const installDependency of dependenciesToInstall) {
-                installCounter++;
-                logger_1.Logger.info(`-> (${installCounter}/${dependenciesToInstall.length}) Dependency "${installDependency.name}" install started.`);
-                var dependencyRegistry;
-                if ((!installDependency.registry || installDependency.registry.trim() === registry_1.PUBLIC_RESERVED_KEYWORD) && context.runtime.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
-                    dependencyRegistry = context.runtime.registry;
-                }
-                else {
-                    dependencyRegistry = new registry_1.Registry(installDependency.registry || registry_1.PUBLIC_RESERVED_KEYWORD);
-                }
-                const inputData = {
-                    packageName: installDependency.name,
-                    versionRange: installDependency.version,
-                    installOptions: context.rawInput,
-                    registry: dependencyRegistry,
-                    integrity: context.parsedInput.safeInstall ? installDependency.integrity : null,
-                    systemPackages: context.parsedInput.systemPackages,
-                    forceInstall: context.parsedInput.skipAlreadyInstalledCheck
-                };
-                logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-                const result = yield (0, installDependency_1.installDependency)(inputData);
-                logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-                logger_1.Logger.info(`   (${installCounter}/${dependenciesToInstall.length}) Dependency "${installDependency.name}" install completed.`);
+            var inputData = {
+                dependencyDataPackage: {
+                    name: dependency.name,
+                    versionRange: dependency.version,
+                    integrity: dependency.integrity,
+                    registry
+                },
+                contextData: _.cloneDeep(context.rawInput.contextData),
+                installData: _.cloneDeep(context.rawInput.installData)
+            };
+            if (inputData.contextData) {
+                inputData.contextData.noR3transInfo = true;
             }
-            logger_1.Logger.success(`-> ${dependenciesToInstall.length}/${dependenciesToInstall.length} dependencies installed, package "${mainPackageName}" install can continue.`);
-        }
-        else {
-            throw new Error(`Package has missing dependencies that need to be installed in order to continue.`);
+            logger_1.Logger.log(`Ready to execute sub-workflow ${SUBWORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+            const result = yield (0, __1.installDependency)(inputData);
+            logger_1.Logger.log(`Workflow ${SUBWORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+            logger_1.Logger.removePrefix();
+            Inquirer_1.Inquirer.removePrefix();
         }
     })
 };

package/dist/actions/install/{setDevclass.d.ts → readDevc.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
-export declare const setDevclass: Step<InstallWorkflowContext>;
+export declare const readDevc: Step<InstallWorkflowContext>;

package/dist/actions/install/readDevc.js

@@ -0,0 +1,29 @@
+"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.readDevc = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+exports.readDevc = {
+    name: 'read-devc',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Read DEVC step', true);
+        logger_1.Logger.loading(`Checking package transports...`);
+        context.runtime.packageTransportsData.tdevc = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.devc.binaries.binaries.data, 'TDEVC'));
+        if (context.runtime.packageTransportsData.tdevc.length === 0) {
+            throw new Error(`Package has no devclass.`);
+        }
+        logger_1.Logger.log(`DEVC TDEVC: ${JSON.stringify(context.runtime.packageTransportsData.tdevc)}`, true);
+        context.runtime.originalData.hierarchy = (0, commons_1.getPackageHierarchy)(context.runtime.packageTransportsData.tdevc);
+        context.runtime.packageTransportsData.tdevct = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.devc.binaries.binaries.data, 'TDEVCT'));
+        logger_1.Logger.log(`DEVC TDEVCT: ${JSON.stringify(context.runtime.packageTransportsData.tdevct)}`, true);
+    })
+};

package/dist/actions/install/{setSystemPackages.d.ts → readTadir.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
-export declare const setSystemPackages: Step<InstallWorkflowContext>;
+export declare const readTadir: Step<InstallWorkflowContext>;

package/dist/actions/install/readTadir.js

@@ -0,0 +1,34 @@
+"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.readTadir = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+const systemConnector_1 = require("../../systemConnector");
+exports.readTadir = {
+    name: 'read-tadir',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Read tadir step', true);
+        logger_1.Logger.loading(`Checking package transports...`);
+        context.runtime.packageTransportsData.tadir = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.tadir.binaries.binaries.data, 'TADIR'));
+        logger_1.Logger.log(`TADIR TADIR: ${JSON.stringify(context.runtime.packageTransportsData.tadir)}`, true);
+        var existingObjects = [];
+        if (!systemConnector_1.SystemConnector.getSupportedBulk().getTransportObjects) {
+            existingObjects = yield systemConnector_1.SystemConnector.getExistingObjects(context.runtime.packageTransportsData.tadir);
+        }
+        else {
+            existingObjects = yield systemConnector_1.SystemConnector.getExistingObjectsBulk(context.runtime.packageTransportsData.tadir);
+        }
+        if (existingObjects.length > 0 && context.runtime.update) {
+            const rootPackage = context.rawInput.contextData.systemPackages.find(o => o.packageName === context.rawInput.packageData.name);
+        }
+    })
+};

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

@@ -0,0 +1,3 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { InstallWorkflowContext } from ".";
+export declare const setInstallDevclass: Step<InstallWorkflowContext>;

package/dist/actions/install/setInstallDevclass.js

@@ -0,0 +1,124 @@
+"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.setInstallDevclass = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+const systemConnector_1 = require("../../systemConnector");
+const inquirer_1 = require("../../inquirer");
+const registry_1 = require("../../registry");
+function _validateDevclass(input, packagesNamespace) {
+    const sInput = input.trim().toUpperCase();
+    if (sInput.length > 30) {
+        return `Package name must not exceede 30 characters limit.`;
+    }
+    if (packagesNamespace.startsWith('/')) {
+        if (!sInput.startsWith(packagesNamespace)) {
+            return `Package name must use namespace "${packagesNamespace}".`;
+        }
+        else {
+            return true;
+        }
+    }
+    else {
+        return true;
+    }
+}
+exports.setInstallDevclass = {
+    name: 'set-install-devclass',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.installDevclass.keepOriginal) {
+            logger_1.Logger.log(`Skipping set devclass replacements (user input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        logger_1.Logger.log('Set install devclass step', true);
+        if (context.rawInput.installData.installDevclass.keepOriginal) {
+            context.rawInput.installData.installDevclass.replacements = context.runtime.packageTransportsData.tdevc.map(o => {
+                return {
+                    originalDevclass: o.devclass,
+                    installDevclass: o.devclass
+                };
+            });
+        }
+        else {
+            if (context.rawInput.installData.installDevclass.replacements.length <= 0) {
+                context.rawInput.installData.installDevclass.replacements = yield systemConnector_1.SystemConnector.getInstallPackages(context.rawInput.packageData.name, context.rawInput.packageData.registry);
+            }
+        }
+        var rootDevclass = (_a = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === context.runtime.originalData.hierarchy.devclass)) === null || _a === void 0 ? void 0 : _a.installDevclass;
+        if (!rootDevclass) {
+            rootDevclass = context.runtime.originalData.hierarchy.devclass;
+        }
+        const packagesNamespace = (0, commons_1.getPackageNamespace)(rootDevclass);
+        var inq1Prompts = [];
+        context.runtime.packageTransportsData.tdevc.forEach(t => {
+            const replacement = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === t.devclass);
+            if (!replacement) {
+                if (context.rawInput.contextData.noInquirer) {
+                    const automaticValue = _validateDevclass(t.devclass, packagesNamespace);
+                    if (automaticValue === true) {
+                        context.rawInput.installData.installDevclass.replacements.push({
+                            originalDevclass: t.devclass,
+                            installDevclass: t.devclass
+                        });
+                    }
+                    else {
+                        throw new Error(automaticValue);
+                    }
+                }
+                else {
+                    inq1Prompts.push({
+                        type: "input",
+                        name: t.devclass,
+                        default: t.devclass,
+                        message: `Input name for package "${t.devclass}"`,
+                        validate: (input) => {
+                            return _validateDevclass(input, packagesNamespace);
+                        }
+                    });
+                }
+            }
+            else {
+                const devclassValid = _validateDevclass(replacement.installDevclass, packagesNamespace);
+                if (devclassValid !== true) {
+                    throw new Error(devclassValid);
+                }
+            }
+        });
+        if (inq1Prompts.length > 0) {
+            const inq1 = yield inquirer_1.Inquirer.prompt(inq1Prompts);
+            Object.keys(inq1).forEach(k => {
+                context.rawInput.installData.installDevclass.replacements = context.rawInput.installData.installDevclass.replacements.filter(o => o.originalDevclass !== k);
+                context.rawInput.installData.installDevclass.replacements.push({
+                    originalDevclass: k,
+                    installDevclass: inq1[k].trim().toUpperCase()
+                });
+            });
+        }
+        logger_1.Logger.loading(`Updating install data...`);
+        var installDevc = [];
+        context.rawInput.installData.installDevclass.replacements.forEach(o => {
+            installDevc.push({
+                package_name: context.rawInput.packageData.name,
+                package_registry: context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : context.rawInput.packageData.registry.endpoint,
+                original_devclass: o.originalDevclass,
+                install_devclass: o.installDevclass
+            });
+        });
+        yield systemConnector_1.SystemConnector.setInstallDevc(installDevc);
+    })
+};

package/dist/actions/install/setPackageIntegrity.js

@@ -16,15 +16,13 @@ const registry_1 = require("../../registry");
 exports.setPackageIntegrity = {
     name: 'set-package-integrity',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const packageName = context.parsedInput.packageName;
-        const registry = context.runtime.registry;
-        const packageRegistry = registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : registry.endpoint;
-        const fetchedIntegrity = context.runtime.fetchedIntegrity;
+        logger_1.Logger.log('Set package integrity step', true);
         logger_1.Logger.loading(`Finalizing install...`);
+        const packageRegistry = context.runtime.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : context.runtime.registry.endpoint;
         yield systemConnector_1.SystemConnector.setPackageIntegrity({
-            package_name: packageName,
+            package_name: context.rawInput.packageData.name,
             package_registry: packageRegistry,
-            integrity: fetchedIntegrity
+            integrity: context.runtime.remotePackageData.integrity
         });
     })
 };

package/dist/actions/install/setR3trans.js

@@ -13,12 +13,16 @@ exports.setR3trans = void 0;
 const logger_1 = require("../../logger");
 const node_r3trans_1 = require("node-r3trans");
 exports.setR3trans = {
-    name: 'set-R3trans',
+    name: 'set-r3trans',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const options = context.parsedInput.r3transOptions;
-        const r3trans = new node_r3trans_1.R3trans(options);
-        const r3transVersion = yield r3trans.getVersion();
-        logger_1.Logger.info(r3transVersion);
-        context.runtime.r3trans = r3trans;
+        logger_1.Logger.log('Set R3trans step', true);
+        logger_1.Logger.loading(`Loading R3Trans...`);
+        const options = context.rawInput.contextData.r3transOptions;
+        logger_1.Logger.log(`Loading R3Trans with options ${JSON.stringify(options)}`, true);
+        context.runtime.r3trans = new node_r3trans_1.R3trans(options);
+        const r3transVersion = yield context.runtime.r3trans.getVersion();
+        const unicode = yield context.runtime.r3trans.isUnicode();
+        logger_1.Logger.info(r3transVersion, context.rawInput.contextData.noR3transInfo);
+        logger_1.Logger.log(`R3Trans unicode?: ${unicode}`, true);
     })
 };

package/dist/actions/installDependency/findInstallRelease.js

@@ -12,48 +12,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findInstallRelease = void 0;
 const logger_1 = require("../../logger");
 const semver_sort_1 = require("semver-sort");
+const trmPackage_1 = require("../../trmPackage");
 const crypto_1 = require("crypto");
 exports.findInstallRelease = {
     name: 'find-install-release',
-    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.skipInstall) {
-            logger_1.Logger.log(`Skipping find install release (skipInstall)`, true);
-            return false;
-        }
-        else {
-            return true;
-        }
-    }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const packageName = context.parsedInput.packageName;
-        const releases = context.runtime.releases;
-        const aPackages = context.runtime.releasePackages;
-        const integrity = context.parsedInput.integrity;
-        var version;
-        const sortedVersions = (0, semver_sort_1.desc)(releases.map(o => o.version));
-        var aSortedPackages = [];
-        for (const v of sortedVersions) {
-            aSortedPackages = aSortedPackages.concat(aPackages.filter(o => o.manifest.get().version === v));
+        logger_1.Logger.log('Find install release step', true);
+        const releases = yield context.rawInput.dependencyDataPackage.registry.getReleases(context.rawInput.dependencyDataPackage.name, context.rawInput.dependencyDataPackage.versionRange);
+        if (releases.length === 0) {
+            throw new Error(`Dependency "${context.rawInput.dependencyDataPackage.name}": releases not found in range ${context.rawInput.dependencyDataPackage.versionRange}.`);
         }
-        if (integrity) {
-            for (const oPackage of aSortedPackages) {
-                if (!version) {
-                    const oArtifact = yield oPackage.fetchRemoteArtifact(oPackage.manifest.get().version);
-                    const fetchedIntegrity = (0, crypto_1.createHash)("sha512").update(oArtifact.binary).digest("hex");
-                    if (integrity === fetchedIntegrity) {
-                        version = oPackage.manifest.get().version;
+        const sortedVersions = (0, semver_sort_1.desc)(releases.map(o => o.version));
+        if (context.rawInput.installData.checks && context.rawInput.installData.checks.safe) {
+            if (context.rawInput.dependencyDataPackage.integrity) {
+                for (const sortedVersion of sortedVersions) {
+                    if (!context.runtime.installVersion) {
+                        const oArtifact = yield new trmPackage_1.TrmPackage(context.rawInput.dependencyDataPackage.name, context.rawInput.dependencyDataPackage.registry).fetchRemoteArtifact(sortedVersion);
+                        const fetchedIntegrity = (0, crypto_1.createHash)("sha512").update(oArtifact.binary).digest("hex");
+                        if (context.rawInput.dependencyDataPackage.integrity === fetchedIntegrity) {
+                            context.runtime.installVersion = sortedVersion;
+                        }
                     }
                 }
             }
-        }
-        else {
-            if (sortedVersions.length > 0) {
-                version = sortedVersions[0];
+            else {
+                throw new Error(`Running in safe mode but no integrity was provided for dependency "${context.rawInput.dependencyDataPackage.name}" install.`);
             }
         }
-        if (!version) {
-            throw new Error(`Couldn't find dependency "${packageName}" on registry. Try manual install.`);
+        else {
+            context.runtime.installVersion = sortedVersions[0];
         }
-        context.output.version = version;
     })
 };

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

@@ -1,39 +1,27 @@
 import { Registry } from "../../registry";
-import { Release } from "trm-registry-types";
-import { TrmPackage } from "../../trmPackage";
-import { InstallActionInput, InstallActionOutput } from "../install";
-export type InstallDependencyActionInput = {
-    packageName: string;
-    versionRange: string;
-    registry: Registry;
-    installOptions: InstallActionInput;
-    forceInstall?: boolean;
-    integrity?: string;
-    systemPackages?: TrmPackage[];
-};
-type WorkflowParsedInput = {
-    packageName?: string;
-    versionRange?: string;
-    forceInstall?: boolean;
-    installOptions?: InstallActionInput;
-    integrity?: string;
-    systemPackages?: TrmPackage[];
-};
+import { IActionContext, InstallActionInputContextData, InstallActionInputInstallData, InstallActionOutput } from "..";
+export interface InstallDependencyActionInput {
+    contextData?: InstallActionInputContextData;
+    dependencyDataPackage: {
+        name: string;
+        versionRange: string;
+        registry: Registry;
+        integrity?: string;
+    };
+    installData?: InstallActionInputInstallData;
+}
 type WorkflowRuntime = {
-    registry?: Registry;
-    releases?: Release[];
-    releasePackages?: TrmPackage[];
-    skipInstall?: boolean;
+    rollback: boolean;
+    installVersion: string;
+    installOutput: InstallActionOutput;
 };
 export type InstallDependencyActionOutput = {
-    version?: string;
-    installOutput?: InstallActionOutput;
+    installOutput: InstallActionOutput;
 };
-export type InstallDependencyWorkflowContext = {
+export interface InstallDependencyWorkflowContext extends IActionContext {
     rawInput: InstallDependencyActionInput;
-    parsedInput: WorkflowParsedInput;
-    runtime: WorkflowRuntime;
+    runtime?: WorkflowRuntime;
     output?: InstallDependencyActionOutput;
-};
+}
 export declare function installDependency(inputData: InstallDependencyActionInput): Promise<InstallDependencyActionOutput>;
 export {};

package/dist/actions/installDependency/index.js

@@ -12,34 +12,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installDependency = void 0;
+exports.installDependency = installDependency;
 const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
+const util_1 = require("util");
 const logger_1 = require("../../logger");
+const __1 = require("..");
 const init_1 = require("./init");
-const getRangeReleases_1 = require("./getRangeReleases");
-const setSystemPackages_1 = require("./setSystemPackages");
-const checkAlreadyInstalled_1 = require("./checkAlreadyInstalled");
 const findInstallRelease_1 = require("./findInstallRelease");
 const installRelease_1 = require("./installRelease");
+;
 const WORKFLOW_NAME = 'install-dependency';
 function installDependency(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
         const workflow = [
             init_1.init,
-            getRangeReleases_1.getRangeReleases,
-            setSystemPackages_1.setSystemPackages,
-            checkAlreadyInstalled_1.checkAlreadyInstalled,
+            __1.setSystemPackages,
             findInstallRelease_1.findInstallRelease,
             installRelease_1.installRelease
         ];
-        logger_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, logger_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
+        logger_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
         const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
-            rawInput: inputData,
-            parsedInput: {},
-            runtime: {}
+            rawInput: inputData
         });
-        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, logger_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        return {};
+        logger_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
+        const installOutput = result.runtime.installOutput;
+        return {
+            installOutput
+        };
     });
 }
-exports.installDependency = installDependency;