npm-check-updates 3.1.25 → 3.2.2

package/README.md

@@ -90,6 +90,8 @@ Options
     --cwd                    Used as current working directory for `spawn` in npm listing
     --dep                    check only a specific section(s) of dependencies:
                              prod|dev|peer|optional|bundle (comma-delimited)
+    --engines-node           include only packages that satisfy engines.node as
+                             specified in the package file
     -e, --error-level        set the error-level. 1: exits with error code 0 if no
                              errors occur. 2: exits with error code 0 if no
                              packages need updating (useful for continuous
@@ -97,7 +99,8 @@ Options
     -f, --filter             include only package names matching the given string,
                              comma-or-space-delimited list, or /regex/
     -g, --global             check global packages instead of in the current project
-    -i, --interactive        Enable interactive prompts for each dependency
+    -i, --interactive        Enable interactive prompts for each dependency;
+                             Implies -u unless one of the json options are set
     -j, --jsonAll            output new package file instead of human-readable
                              message
     --jsonDeps               Will return output like `jsonAll` but only lists

package/bin/ncu

@@ -23,10 +23,11 @@ program
     .option('--cwd <path>', 'Used as current working directory for `spawn` in npm listing')
     .option('--dep <dep>', 'check only a specific section(s) of dependencies: prod|dev|peer|optional|bundle (comma-delimited)')
     .option('-e, --error-level <n>', 'set the error-level. 1: exits with error code 0 if no errors occur. 2: exits with error code 0 if no packages need updating (useful for continuous integration). Default is 1.', cint.partialAt(parseInt, 1, 10), 1)
+    .option('--engines-node', 'upgrade to version which satisfies engines.node range')
     .option('-f, --filter <matches>', 'include only package names matching the given string, comma-or-space-delimited list, or /regex/')
     .option('-g, --global', 'check global packages instead of in the current project')
     // program.json is set to true in programInit if any options that begin with 'json' are true
-    .option('-i, --interactive', 'Enable interactive prompts for each dependency')
+    .option('-i, --interactive', 'Enable interactive prompts for each dependency; implies -u unless one of the json options are set')
     .option('-j, --jsonAll', 'output new package file instead of human-readable message')
     .option('--jsonDeps', 'Will return output like `jsonAll` but only lists `dependencies`, `devDependencies`, and `optionalDependencies` of the new package data.')
     .option('--jsonUpgraded', 'output upgraded dependencies in json')

package/bin/npm-check-updates

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 'use strict';
 
-require('node-alias')('ncu', __dirname, { message: false });
+require('node-alias')('ncu', __dirname, {message: false});

package/lib/npm-check-updates.js

@@ -100,8 +100,10 @@ function createDependencyTable() {
 }
 
 /**
- * @param args.from
- * @param args.to
+ * @param {object} args
+ * @param {object} args.from
+ * @param {object} args.to
+ * @returns {Table}
  */
 function toDependencyTable(args) {
     const table = createDependencyTable();
@@ -144,7 +146,7 @@ function analyzeGlobalPackages(options) {
                     print(options, latest, 'silly');
 
                     const upgradedPackageNames = Object.keys(upgraded);
-                    const upgradePromise = printUpgrades(options, {
+                    printUpgrades(options, {
                         current: globalPackages,
                         upgraded,
                         latest,
@@ -164,8 +166,6 @@ function analyzeGlobalPackages(options) {
                     } else if (instruction.length) {
                         print(options, '\n' + chalk.cyan('ncu') + ' itself cannot upgrade global packages. Run the following to upgrade all global packages: \n\n' + chalk.cyan('npm -g install ' + instruction) + '\n');
                     }
-
-                    return upgradePromise;
                 });
         });
 }
@@ -188,6 +188,10 @@ function analyzeProjectDependencies(options, pkgData, pkgFile) {
 
     print(options, `Fetching ${vm.getVersionTarget(options)} versions...`, 'verbose');
 
+    if (options.enginesNode) {
+        options.enginesNode = _.get(pkg, 'engines.node');
+    }
+
     return vm.upgradePackageDefinitions(current, options).then(async ([upgraded, latest]) => {
         const {newPkgData, selectedNewDependencies} = await vm.upgradePackageData(pkgData, current, upgraded, latest, options);
 
@@ -255,6 +259,7 @@ function analyzeProjectDependencies(options, pkgData, pkgFile) {
  * @param {Object} args.upgraded - The packages that should be upgraded.
  * @param {number} args.numUpgraded - The number of upgraded packages
  * @param {number} args.total - The total number of all possible upgrades
+ * @returns {void}
  */
 function printUpgrades(options, {current, upgraded, numUpgraded, total}) {
     print(options, '');
@@ -290,6 +295,11 @@ function printUpgrades(options, {current, upgraded, numUpgraded, total}) {
 /** Initializes and consolidates options from the cli. */
 function initOptions(options) {
 
+    const json = _(options)
+        .keys()
+        .filter(_.partial(_.startsWith, _, 'json', 0))
+        .some(_.propertyOf(options));
+
     return Object.assign({}, options, {
         filter: options.args.join(' ') || options.filter,
         // convert silent option to loglevel silent
@@ -298,10 +308,9 @@ function initOptions(options) {
         // default to 0, except when newest or greatest are set
         pre: options.pre ? Boolean(Number(options.pre)) : options.newest || options.greatest,
         // add shortcut for any keys that start with 'json'
-        json: _(options)
-            .keys()
-            .filter(_.partial(_.startsWith, _, 'json', 0))
-            .some(_.propertyOf(options))
+        json,
+        // imply upgrade in interactive mode when json is not specified as the output
+        upgrade: options.interactive && options.upgrade === undefined ? !json : options.upgrade
     });
 }
 
@@ -382,14 +391,13 @@ async function findPackage(options) {
     return Promise.all([pkgData, pkgFile]);
 }
 
-/** main entry point */
-async function run(options={}) {
-
-    // exit with non-zero error code when there is an unhandled promise rejection
-    process.on('unhandledRejection', err => {
-        throw err;
-    });
+// exit with non-zero error code when there is an unhandled promise rejection
+process.on('unhandledRejection', err => {
+    throw err;
+});
 
+/** main entry point */
+async function run(options = {}) {
     // if not executed on the command-line (i.e. executed as a node module), set some defaults
     if (!options.cli) {
         options = _.defaults({}, options, {

package/lib/package-managers/npm.js

@@ -2,10 +2,12 @@
 const _ = require('lodash');
 const cint = require('cint');
 const semver = require('semver');
-const versionUtil  = require('../version-util.js');
-const spawn        = require('spawn-please');
+const versionUtil = require('../version-util.js');
+const spawn = require('spawn-please');
 const pacote = require('pacote');
 
+const TIME_FIELDS = ['modified', 'created'];
+
 // needed until pacote supports full npm config compatibility
 // See: https://github.com/zkat/pacote/issues/156
 const npmConfig = {};
@@ -43,48 +45,78 @@ function parseJson(result, data) {
 }
 
 /**
+ * Returns the value of one of the properties retrieved by npm view.
  * @param {string} packageName   Name of the package
  * @param {string} field         Field such as "versions" or "dist-tags.latest" are parsed from the pacote result (https://www.npmjs.com/package/pacote#packument)
  * @param {string} currentVersion
- * @returns {Promise}             Promised result
+ * @returns {Promise}            Promised result
+ */
+function viewOne(packageName, field, currentVersion) {
+    return viewMany(packageName, [field], currentVersion)
+        .then(result => result && result[field]);
+}
+
+/**
+ * Returns an object of specified values retrieved by npm view.
+ * @param {string} packageName   Name of the package
+ * @param {string[]} fields      Array of fields like versions, time, version
+ * @param {string} currentVersion
+ * @returns {Promise}            Promised result
  */
-function view(packageName, field, currentVersion) {
+function viewMany(packageName, fields, currentVersion) {
     if (currentVersion && (!semver.validRange(currentVersion) || versionUtil.isWildCard(currentVersion))) {
-        return Promise.resolve();
+        return Promise.resolve({});
     }
 
-    npmConfig['full-metadata'] = field === 'time';
+    npmConfig['full-metadata'] = _.includes(fields, 'time');
 
-    return pacote.packument(packageName, npmConfig).then(result => {
-        if (field.startsWith('dist-tags.')) {
-            const [tagName, version] = field.split('.');
-            if (result[tagName]) {
-                return result[tagName][version];
+    return pacote.packument(packageName, npmConfig).then(result =>
+        fields.reduce((accum, field) => Object.assign(
+            accum,
+            {
+                [field]: field.startsWith('dist-tags.') ?
+                    result.versions[_.get(result, field)] :
+                    result[field]
             }
-        } else if (field === 'versions') {
-            return Object.keys(result[field]);
-        } else {
-            return result[field];
-        }
-    });
+        ), {})
+    );
 }
 
 /**
  * @param {Array} versions  Array of all available versions
+ * @param {Boolean} pre     Enabled prerelease?
  * @returns {Array}         An array of versions with the release versions filtered out
  */
-function filterOutPrereleaseVersions(versions) {
-    return _.filter(versions, _.negate(isPre));
+function filterOutPrereleaseVersions(versions, pre) {
+    return _.filter(versions, version => pre || !isPre(version));
 }
 
 /**
- * @param            version
- * @returns {boolean}          True if the version is any kind of prerelease: alpha, beta, rc, pre
+ * @param {String} version
+ * @returns {boolean} True if the version is any kind of prerelease: alpha, beta, rc, pre
  */
 function isPre(version) {
     return versionUtil.getPrecision(version) === 'release';
 }
 
+/**
+ * @param {{}}     versions    Object with all versions
+ * @param {String} enginesNode Package engines.node range
+ * @returns {Array} An array of versions which satisfies engines.node range
+ */
+function doesSatisfyEnginesNode(versions, enginesNode) {
+    if (!enginesNode) {
+        return _.keys(versions);
+    }
+    const minVersion = _.get(semver.minVersion(enginesNode), 'version');
+    if (!minVersion) {
+        return _.keys(versions);
+    }
+    return _.keys(versions).filter(version => {
+        let versionEnginesNode = _.get(versions[version], 'engines.node');
+        return versionEnginesNode && semver.satisfies(minVersion, versionEnginesNode);
+    });
+}
 
 /**
  * Spawn npm requires a different command on Windows.
@@ -159,22 +191,25 @@ module.exports = {
     /**
      * @param {string} packageName
      * @param {string} currentVersion
-     * @param {boolean} pre
+     * @param {{}} options
      * @returns {Promise}
      */
-    latest(packageName, currentVersion, pre) {
-        return view(packageName, 'dist-tags.latest', currentVersion)
-            .then(version => {
-                // if latest is not a prerelease version, return it
-                // if latest is a prerelease version and --pre is specified, return it
-                if (!isPre(version) || pre) {
-                    return version;
+    latest(packageName, currentVersion, options) {
+        return viewOne(packageName, 'dist-tags.latest', currentVersion)
+            .then(latest => {
+                // if latest exists and latest is not a prerelease version, return it
+                // if latest exists and latest is a prerelease version and --pre is specified, return it
+                // if latest exists and latest not satisfies min version of engines.node
+                if (latest && (!isPre(latest.version) || options.pre) && doesSatisfyEnginesNode({[latest.version]: latest}, options.enginesNode).length) {
+                    return latest.version;
                 // if latest is a prerelease version and --pre is not specified, find the next
                 // version that is not a prerelease
                 } else {
-                    return view(packageName, 'versions', currentVersion)
-                        .then(filterOutPrereleaseVersions)
-                        .then(_.last);
+                    return viewOne(packageName, 'versions', currentVersion)
+                        .then(versions => {
+                            versions = doesSatisfyEnginesNode(versions, options.enginesNode);
+                            return _.last(filterOutPrereleaseVersions(versions, options.pre));
+                        });
                 }
             });
     },
@@ -182,55 +217,77 @@ module.exports = {
     /**
      * @param {string} packageName
      * @param {string} currentVersion
-     * @param {boolean} pre
+     * @param {{}} options
      * @returns {Promise}
      */
-    newest(packageName, currentVersion, pre) {
-        return view(packageName, 'time', currentVersion)
-            .then(_.keys)
-            .then(_.partialRight(_.pullAll, ['modified', 'created']))
-            .then(versions => {
-                return _.last(pre ? versions : filterOutPrereleaseVersions(versions));
-            });
+    newest(packageName, currentVersion, options) {
+        return viewMany(packageName, ['time', 'versions'], currentVersion)
+            .then(result => {
+                const versions = doesSatisfyEnginesNode(result.versions, options.enginesNode);
+                return _.keys(result.time).reduce((accum, key) =>
+                    accum.concat(_.includes(TIME_FIELDS, key) || _.includes(versions, key) ? key : []), []
+                );
+            })
+            .then(_.partialRight(_.pullAll, TIME_FIELDS))
+            .then(versions =>
+                _.last(filterOutPrereleaseVersions(versions, options.pre))
+            );
     },
 
     /**
      * @param {string} packageName
      * @param {string} currentVersion
-     * @param {boolean} pre
+     * @param {{}} options
      * @returns {Promise}
      */
-    greatest(packageName, currentVersion, pre) {
-        return view(packageName, 'versions', currentVersion)
-            .then(versions => {
-                return _.last(pre ? versions : filterOutPrereleaseVersions(versions));
-            });
+    greatest(packageName, currentVersion, options) {
+        return viewOne(packageName, 'versions', currentVersion)
+            .then(versions =>
+                _.last(filterOutPrereleaseVersions(
+                    doesSatisfyEnginesNode(versions, options.enginesNode),
+                    options.pre
+                ))
+            );
     },
 
     /**
      * @param {string} packageName
      * @param {string} currentVersion
-     * @param {boolean} pre
+     * @param {{}} options
      * @returns {Promise}
      */
-    greatestMajor(packageName, currentVersion, pre) {
-        return view(packageName, 'versions', currentVersion).then(versions => {
-            const resultVersions = pre ? versions : filterOutPrereleaseVersions(versions);
-            return versionUtil.findGreatestByLevel(resultVersions, currentVersion, 'major');
-        });
+    greatestMajor(packageName, currentVersion, options) {
+        return viewOne(packageName, 'versions', currentVersion)
+            .then(versions =>
+                versionUtil.findGreatestByLevel(
+                    filterOutPrereleaseVersions(
+                        doesSatisfyEnginesNode(versions, options.enginesNode),
+                        options.pre
+                    ),
+                    currentVersion,
+                    'major'
+                )
+            );
     },
 
     /**
      * @param {string} packageName
      * @param {string} currentVersion
-     * @param {boolean} pre
+     * @param {{}} options
      * @returns {Promise}
      */
-    greatestMinor(packageName, currentVersion, pre) {
-        return view(packageName, 'versions', currentVersion).then(versions => {
-            const resultVersions = pre ? versions : filterOutPrereleaseVersions(versions);
-            return versionUtil.findGreatestByLevel(resultVersions, currentVersion, 'minor');
-        });
+    greatestMinor(packageName, currentVersion, options) {
+        return viewOne(packageName, 'versions', currentVersion)
+            .then(versions =>
+                versionUtil.findGreatestByLevel(
+                    filterOutPrereleaseVersions(
+                        doesSatisfyEnginesNode(versions, options.enginesNode),
+                        options.pre
+                    ),
+                    currentVersion,
+                    'minor'
+                )
+            );
     },
 
     defaultPrefix

package/lib/versionmanager.js

@@ -253,7 +253,8 @@ function upgradePackageDefinitions(currentDependencies, options) {
         pre: options.pre,
         packageManager: options.packageManager,
         json: options.json,
-        loglevel: options.loglevel
+        loglevel: options.loglevel,
+        enginesNode: options.enginesNode
     }).then(latestVersions => {
 
         const upgradedDependencies = upgradeDependencies(currentDependencies, latestVersions, {
@@ -422,7 +423,7 @@ function queryVersions(packageMap, options = {}) {
      * @returns {Promise}
      */
     function getPackageVersionProtected(dep) {
-        return getPackageVersion(dep, packageMap[dep], options.pre).catch(err => {
+        return getPackageVersion(dep, packageMap[dep], options).catch(err => {
             if (err && (err.message || err).toString().match(/E404|ENOTFOUND|404 Not Found/i)) {
                 return null;
             } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-check-updates",
-  "version": "3.1.25",
+  "version": "3.2.2",
   "author": "Tomas Junnonen <tomas1@gmail.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -69,11 +69,11 @@
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "chai-string": "^1.5.0",
-    "chokidar-cli": "^2.0.0",
-    "eslint": "^6.5.1",
-    "mocha": "^6.2.1",
+    "chokidar-cli": "^2.1.0",
+    "eslint": "^6.6.0",
+    "mocha": "^6.2.2",
     "should": "^13.2.3",
-    "snyk": "^1.231.0",
+    "snyk": "^1.239.5",
     "tmp": "0.1.0"
   },
   "files": [