feat: support npm lockfile v2 (#124)

* feat: support lockfile v2

* test: add test for lockfile v2

* chore: bump deps

* chore: add @types/node

* test: make standard happy

* test: Travis CI => GitHub CI

* chore: add root package info to output

* chore: remove engine requirements

Author: amio

.github/workflows/node.js.yml

@@ -0,0 +1,26 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

.travis.yml

@@ -1,8 +1,10 @@
 #! /usr/bin/env node
 
+const path = require('path')
 const mri = require('mri')
 const kleur = require('kleur')
-const main = require('../cli-main.js')
+
+const { collectReasons, printReasons } = require('../index.js')
 
 const help = `
   ${kleur.bold('npm-why')} - Identifies why a package has been installed.
@@ -38,3 +40,21 @@ if (args.help) {
   const pkg = args._[0]
   main(dir, pkg)
 }
+
+/**
+ * Run npm-why in a directory
+ *
+ * @param {String} dir Workding directory
+ * @param {String} packageName The package to lookup
+ */
+async function main (dir, packageName) {
+  const reasons = await collectReasons(dir, packageName)
+
+  if (!reasons.length) {
+    console.log(`\n  No one requires ${kleur.blue(packageName)}.`)
+  } else {
+    console.log(`\n  Who required ${kleur.blue(packageName)}:\n`)
+    printReasons(reasons, path.parse(dir).name)
+    console.log('\n')
+  }
+}

bin/npm-why

@@ -1,53 +1,69 @@
-const logicalTree = require('npm-logical-tree')
+const kleur = require('kleur')
+const Arborist = require('@npmcli/arborist')
 
 /**
- * Find who depend upon a target package.
+ * Run npm-why in a directory
  *
- * @param {Object} pkg package.json
- * @param {Object} pkgLock package-lock.json
- * @param {String} target target package name to lookup
+ * @param {String} dir Workding directory
+ * @param {String} packageName The package to lookup
  */
-module.exports = function (pkg, pkgLock, name) {
-  const tree = logicalTree(pkg, pkgLock)
-
-  // Find target deps
-  const targets = new Set()
-  tree.forEach((dep, callback) => {
-    dep.name === name && targets.add(dep)
-    callback()
-  })
-
-  // Find requiredBy for those targets
-  const results = []
-  targets.forEach(t => {
-    lookupDependents(t, tree, [], results)
-  })
-  return results
-}
+async function collectReasons (dir, packageName) {
+  const arb = new Arborist({ path: dir })
+  const tree = await arb.loadVirtual()
+  const pkgs = tree.children.keys()
 
-function lookupDependents (target, root, breadcrumb = [], results) {
-  breadcrumb = breadcrumb.concat(target)
+  let reasons = []
 
-  if (target.requiredBy.size === 0) {
-    return results.push(formatBreadcrumb(breadcrumb))
+  // find all versions of <packageName>
+  for (const name of pkgs) {
+    if (name === packageName) {
+      const reasonChain = buildDependentsTree(tree.children.get(name))
+      reasons = reasons.concat(reasonChain.leafs)
+    }
   }
 
-  if (breadcrumb.includes(root)) {
-    return results.push(formatBreadcrumb(breadcrumb))
+  // prepand root package info to every reason chain
+  const root = { name: tree.name, version: tree.version }
+  reasons = reasons.map(chain => chain.concat(root))
+
+  return reasons
+}
+
+function buildDependentsTree (node, paths = [], leafs = []) {
+  const { name, version, edgesIn } = node
+
+  // when leaf node
+  if (edgesIn.size === 0) {
+    leafs.push(paths)
+    return { name, version, leafs }
   }
 
-  if (breadcrumb.slice(0, -1).includes(target)) {
-    return // Recursive dependency
+  // prevent dead loops
+  if (paths.includes(name)) {
+    return { name, version, leafs }
   }
 
-  target.requiredBy.forEach(dependent => {
-    lookupDependents(dependent, root, breadcrumb, results)
+  const dependents = Array.from(edgesIn).map(edge => {
+    const pkg = { name, version }
+    return buildDependentsTree(edge.from, paths.concat(pkg), leafs)
   })
+
+  return { name, version, leafs, dependents }
+}
+
+function printReasons (reasons, rootPackage) {
+  reasons.map(reason => {
+    const versionTag = kleur.dim('@' + reason[0].version)
+
+    const line = reason.reverse().map(pkg => {
+      return kleur.blue(pkg.name || rootPackage)
+    }).join(' > ')
+
+    return line + versionTag
+  }).sort().forEach(line => console.log(' ', line))
 }
 
-function formatBreadcrumb (bc) {
-  return bc.map(piece => ({
-    name: piece.name,
-    version: piece.version
-  }))
+module.exports = {
+  collectReasons,
+  printReasons
 }