npm-check-updates 7.0.4-alpha.2 → 7.1.1

package/README.md

@@ -111,7 +111,7 @@ $ ncu "/^(?!gulp-).*$/" # windows
                          satisfied by the existing version range (v2 behavior).
 -n, --newest             find the newest published versions available instead
                          of the latest stable versions
--p, --packageManager     npm (default: npm)
+-p, --packageManager     npm|yarn (default: npm)
 --packageData            include stringified package file (use stdin instead)
 --packageFile            package file location (default: ./package.json)
 --pre                    include -alpha, -beta, -rc. (default: 0; default

package/lib/logging.js

@@ -33,6 +33,12 @@ function print(options, message, loglevel, method = 'log') {
   }
 }
 
+function printJson(options, object) {
+  if (options.loglevel !== 'silent') {
+    console.log(JSON.stringify(object, null, 2))
+  }
+}
+
 function createDependencyTable() {
   return new Table({
     colAligns: ['left', 'right', 'right', 'right'],
@@ -73,4 +79,4 @@ function toDependencyTable(args) {
   return table
 }
 
-module.exports = { print, toDependencyTable }
+module.exports = { print, printJson, toDependencyTable }

package/lib/npm-check-updates.js

@@ -16,11 +16,12 @@ const { rcFile } = require('rc-config-loader')
 const jph = require('json-parse-helpfulerror')
 const vm = require('./versionmanager')
 const packageManagers = require('./package-managers')
-const { print, toDependencyTable } = require('./logging')
+const { print, printJson, toDependencyTable } = require('./logging')
 
 // maps package managers to package file names
 const packageFileNames = {
-  npm: 'package.json'
+  npm: 'package.json',
+  yarn: 'package.json',
 }
 
 // time to wait for stdin before printing a warning
@@ -41,18 +42,12 @@ function programError(options, message) {
   }
 }
 
-function printJson(options, object) {
-  if (options.loglevel !== 'silent') {
-    console.log(JSON.stringify(object, null, 2))
-  }
-}
-
 /**
  * Gets the name of the package file based on --packageFile or --packageManager.
  */
 function getPackageFileName(options) {
   return options.packageFile ? options.packageFile :
-    packageFileNames[options.packageManager]
+    packageFileNames[options.packageManager] || packageFileNames.npm
 }
 
 const readPackageFile = _.partialRight(promisify(fs.readFile), 'utf8')
@@ -94,17 +89,18 @@ function analyzeGlobalPackages(options) {
             total: upgradedPackageNames.length
           })
 
-          let instruction = '[package]'
-          if (upgraded) {
-            instruction = upgradedPackageNames.map(pkg => pkg + '@' + upgraded[pkg]).join(' ')
-          }
+          const instruction = upgraded
+            ? upgradedPackageNames.map(pkg => pkg + '@' + upgraded[pkg]).join(' ')
+            : '[package]'
 
           if (options.json) {
             // since global packages do not have a package.json, return the upgraded deps directly (no version range replacements)
             printJson(options, upgraded)
           }
           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')
+            const upgradeCmd = options.packageManager === 'yarn' ? 'yarn global upgrade' : 'npm -g install'
+
+            print(options, '\n' + chalk.cyan('ncu') + ' itself cannot upgrade global packages. Run the following to upgrade all global packages: \n\n' + chalk.cyan(`${upgradeCmd} ` + instruction) + '\n')
           }
         })
     })
@@ -387,6 +383,10 @@ async function run(options = {}) {
     options.prefix = await packageManagers.npm.defaultPrefix(options)
   }
 
+  if (options.packageManager === 'yarn' && !options.prefix) {
+    options.prefix = await packageManagers.yarn.defaultPrefix(options)
+  }
+
   let timeout
   let timeoutPromise = new Promise(resolve => resolve)
   if (options.timeout) {

package/lib/package-managers/index.js

@@ -1,5 +1,6 @@
 'use strict'
 
 module.exports = {
-  npm: require('./npm')
+  npm: require('./npm'),
+  yarn: require('./yarn')
 }

package/lib/package-managers/yarn.js

@@ -0,0 +1,336 @@
+'use strict'
+
+// eslint-disable-next-line fp/no-events
+const { once } = require('events')
+
+const _ = require('lodash')
+const cint = require('cint')
+const semver = require('semver')
+const spawn = require('spawn-please')
+const pacote = require('pacote')
+const libnpmconfig = require('libnpmconfig')
+
+const jsonlines = require('jsonlines')
+
+const versionUtil = require('../version-util')
+
+const TIME_FIELDS = ['modified', 'created']
+
+// needed until pacote supports full yarn config compatibility
+// See: https://github.com/zkat/pacote/issues/156
+const yarnConfig = {}
+libnpmconfig.read().forEach((value, key) => {
+  // replace env ${VARS} in strings with the process.env value
+  yarnConfig[key] = typeof value !== 'string' ?
+    value :
+    value.replace(/\${([^}]+)}/, (_, envVar) =>
+      process.env[envVar]
+    )
+})
+yarnConfig.cache = false
+
+/**
+ * @typedef {object} CommandAndPackageName
+ * @property {string} command
+ * @property {string} packageName
+ */
+
+/**
+ * Parse JSON lines and throw an informative error on failure.
+ *
+ * @param result    Output from `yarn list --json` to be parsed
+ */
+async function parseJsonLines(result) {
+
+  const dependencies = {}
+
+  const parser = jsonlines.parse()
+
+  parser.on('data', d => {
+    // only parse info data
+    // ignore error info, e.g. "Visit https://yarnpkg.com/en/docs/cli/list for documentation about this command."
+    if (d.type === 'info' && !d.data.match(/^Visit/)) {
+
+      // parse package name and version number from info data, e.g. "nodemon@2.0.4" has binaries
+      const [, pkgName, pkgVersion] = d.data.match(/"(@?.*)@(.*)"/)
+
+      dependencies[pkgName] = {
+        version: pkgVersion,
+        from: pkgName,
+      }
+
+    }
+    else if (d.type === 'error') {
+      throw new Error(d.data)
+    }
+  })
+
+  parser.write(result)
+
+  parser.end()
+
+  await once(parser, 'end')
+
+  return { dependencies }
+
+}
+
+/**
+ * Returns the value of one of the properties retrieved by yarn view.
+ *
+ * @param packageName   Name of the package
+ * @param field         Field such as "versions" or "dist-tags.latest" are parsed from the pacote result (https://www.yarnjs.com/package/pacote#packument)
+ * @param currentVersion
+ * @returns            Promised result
+ */
+function viewOne(packageName, field, currentVersion, { timeout } = {}) {
+  return viewMany(packageName, [field], currentVersion, { timeout })
+    .then(result => result && result[field])
+}
+
+/**
+ * Returns an object of specified values retrieved by yarn view.
+ *
+ * @param packageName   Name of the package
+ * @param fields      Array of fields like versions, time, version
+ * @param currentVersion
+ * @returns            Promised result
+ */
+function viewMany(packageName, fields, currentVersion, { timeout } = {}) {
+  if (currentVersion && (!semver.validRange(currentVersion) ||
+    versionUtil.isWildCard(currentVersion))) {
+    return Promise.resolve({})
+  }
+
+  yarnConfig.fullMetadata = fields.includes('time')
+
+  return pacote.packument(packageName, { ...yarnConfig, timeout })
+    .then(result =>
+      fields.reduce((accum, field) => ({
+        ...accum,
+        [field]: field.startsWith('dist-tags.') && result.versions ?
+          result.versions[_.get(result, field)] :
+          result[field],
+      }), {})
+    )
+}
+
+/**
+ * @param versions  Array of all available versions
+ * @param pre     Enabled prerelease?
+ * @returns         An array of versions with the release versions filtered out
+ */
+function filterOutPrereleaseVersions(versions, pre) {
+  return pre ? versions : versions.filter(
+    version => !versionUtil.isPre(version))
+}
+
+/**
+ * @param versions    Object with all versions
+ * @param enginesNode Package engines.node range
+ * @returns An array of versions which satisfies engines.node range
+ */
+function doesSatisfyEnginesNode(versions, enginesNode) {
+  if (!versions) {
+    return []
+  }
+  if (!enginesNode) {
+    return Object.keys(versions)
+  }
+  const minVersion = _.get(semver.minVersion(enginesNode), 'version')
+  if (!minVersion) {
+    return Object.keys(versions)
+  }
+  return Object.keys(versions).filter(version => {
+    const versionEnginesNode = _.get(versions[version], 'engines.node')
+    return versionEnginesNode &&
+      semver.satisfies(minVersion, versionEnginesNode)
+  })
+}
+
+/**
+ * Spawn yarn requires a different command on Windows.
+ *
+ * @param args
+ * @param [yarnOptions={}]
+ * @param [spawnOptions={}]
+ * @returns
+ */
+function spawnYarn(args, yarnOptions = {}, spawnOptions = {}) {
+  const cmd = process.platform === 'win32' ? 'yarn.cmd' : 'yarn'
+
+  const fullArgs = [].concat(
+    yarnOptions.global ? 'global' : [],
+    args,
+    '--depth=0',
+    yarnOptions.prefix ? `--prefix=${yarnOptions.prefix}` : [],
+    '--json',
+    '--no-progress'
+  )
+  return spawn(cmd, fullArgs, spawnOptions)
+}
+
+/**
+ * Get platform-specific default prefix to pass on to yarn.
+ *
+ * @param options
+ * @param [options.global]
+ * @param [options.prefix]
+ * @returns
+ */
+function defaultPrefix(options) {
+
+  if (options.prefix) {
+    return Promise.resolve(options.prefix)
+  }
+
+  const cmd = process.platform === 'win32' ? 'yarn.cmd' : 'yarn'
+
+  return spawn(cmd, ['global', 'dir']).then(prefix => {
+    // FIX: for ncu -g doesn't work on homebrew or windows #146
+    // https://github.com/raineorshine/npm-check-updates/issues/146
+
+    return options.global && prefix.match('Cellar') ? '/usr/local' :
+
+      // Workaround: get prefix on windows for global packages
+      // Only needed when using npm api directly
+      process.platform === 'win32' && options.global && !process.env.prefix ?
+        prefix ? prefix.trim() : `${process.env.LOCALAPPDATA}\\Yarn\\Data\\global` :
+        null
+  })
+}
+
+module.exports = {
+
+  /**
+   * @param [options]
+   * @param [options.cwd]
+   * @param [options.global]
+   * @param [options.prefix]
+   * @returns
+   */
+  list(options = {}) {
+
+    return spawnYarn('list', options, options.cwd ? { cwd: options.cwd } : {}).then(async jsonLines => {
+      const json = await parseJsonLines(jsonLines)
+
+      return cint.mapObject(json.dependencies, (name, info) => ({
+        // unmet peer dependencies have a different structure
+        [name]: info.version || (info.required && info.required.version),
+      }))
+    })
+      .catch(async jsonLines => {
+        await parseJsonLines(jsonLines)
+        return {}
+      })
+  },
+
+  /**
+   * @param packageName
+   * @param currentVersion
+   * @param options
+   * @returns
+   */
+  latest(packageName, currentVersion, options = {}) {
+    return viewOne(packageName, 'dist-tags.latest', currentVersion,
+      { timeout: options.timeout }).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 && (!versionUtil.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 viewOne(packageName, 'versions', currentVersion)
+          .then(versions => {
+            versions = doesSatisfyEnginesNode(versions, options.enginesNode)
+            return _.last(filterOutPrereleaseVersions(versions, options.pre))
+          })
+      }
+    })
+  },
+
+  /**
+   * @param packageName
+   * @param currentVersion
+   * @param options
+   * @returns
+   */
+  newest(packageName, currentVersion, options = {}) {
+    return viewMany(packageName, ['time', 'versions'], currentVersion,
+      { timeout: options.timeout }).then(result => {
+      const versions = doesSatisfyEnginesNode(result.versions,
+        options.enginesNode)
+      return Object.keys(result.time || {}).reduce((accum, key) =>
+        accum.concat(
+          TIME_FIELDS.includes(key) || versions.includes(key) ? key : []), []
+      )
+    }).then(_.partialRight(_.pullAll, TIME_FIELDS)).then(versions =>
+      _.last(filterOutPrereleaseVersions(versions,
+        options.pre == null || options.pre))
+    )
+  },
+
+  /**
+   * @param packageName
+   * @param currentVersion
+   * @param options
+   * @returns
+   */
+  greatest(packageName, currentVersion, options = {}) {
+    return viewOne(packageName, 'versions', currentVersion,
+      { timeout: options.timeout }).then(versions =>
+      // eslint-disable-next-line fp/no-mutating-methods
+      _.last(filterOutPrereleaseVersions(
+        doesSatisfyEnginesNode(versions, options.enginesNode),
+        options.pre == null || options.pre).sort(versionUtil.compareVersions)
+      )
+    )
+  },
+
+  /**
+   * @param packageName
+   * @param currentVersion
+   * @param options
+   * @returns
+   */
+  greatestMajor(packageName, currentVersion, options = {}) {
+    return viewOne(packageName, 'versions', currentVersion,
+      { timeout: options.timeout }).then(versions =>
+      versionUtil.findGreatestByLevel(
+        filterOutPrereleaseVersions(
+          doesSatisfyEnginesNode(versions, options.enginesNode),
+          options.pre
+        ),
+        currentVersion,
+        'major'
+      )
+    )
+  },
+
+  /**
+   * @param packageName
+   * @param currentVersion
+   * @param options
+   * @returns
+   */
+  greatestMinor(packageName, currentVersion, options) {
+    return viewOne(packageName, 'versions', currentVersion,
+      { timeout: options.timeout }).then(versions =>
+      versionUtil.findGreatestByLevel(
+        filterOutPrereleaseVersions(
+          doesSatisfyEnginesNode(versions, options.enginesNode),
+          options.pre
+        ),
+        currentVersion,
+        'minor'
+      )
+    )
+  },
+
+  defaultPrefix,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-check-updates",
-  "version": "7.0.4-alpha.2",
+  "version": "7.1.1",
   "author": "Tomas Junnonen <tomas1@gmail.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -31,7 +31,7 @@
     "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives .",
     "lintfix": "npm run lint -- --fix",
     "watch": "chokidar \"lib/**/*.js\" -c \"npm run test\"",
-    "mocha": "mocha && mocha test/individual",
+    "mocha": "mocha test test/package-managers/npm test/package-managers/yarn",
     "test": "npm run lint && npm run mocha"
   },
   "bin": {
@@ -54,6 +54,7 @@
     "find-up": "4.1.0",
     "get-stdin": "^8.0.0",
     "json-parse-helpfulerror": "^1.0.3",
+    "jsonlines": "^0.1.1",
     "libnpmconfig": "^1.2.1",
     "lodash": "^4.17.19",
     "p-map": "^4.0.0",
@@ -82,7 +83,8 @@
     "mocha": "^8.1.1",
     "nyc": "^15.1.0",
     "should": "^13.2.3",
-    "tmp": "0.2.1"
+    "tmp": "0.2.1",
+    "yarn": "^1.22.4"
   },
   "files": [
     "bin",