@npmcli/arborist 2.2.1 → 2.2.2

package/bin/ideal.js

@@ -1,59 +1,11 @@
 const Arborist = require('../')
 
+const { inspect } = require('util')
 const options = require('./lib/options.js')
 const print = require('./lib/print-tree.js')
 require('./lib/logging.js')
 require('./lib/timers.js')
 
-const c = require('chalk')
-
-const whichIsA = (name, dependents, indent = '  ') => {
-  if (!dependents || dependents.length === 0)
-    return ''
-  const str = `\nfor: ` +
-    dependents.map(dep => {
-      return dep.more ? `${dep.more} more (${dep.names.join(', ')})`
-        : `${dep.type} dependency ` +
-          `${c.bold(name)}@"${c.bold(dep.spec)}"` + `\nfrom:` +
-          (dep.from.location ? (dep.from.name
-            ? ` ${c.bold(dep.from.name)}@${c.bold(dep.from.version)} ` +
-              c.dim(`at ${dep.from.location}`)
-            : ' the root project')
-          : ` ${c.bold(dep.from.name)}@${c.bold(dep.from.version)}`) +
-          whichIsA(dep.from.name, dep.from.dependents, '  ')
-    }).join('\nand: ')
-
-  return str.split(/\n/).join(`\n${indent}`)
-}
-
-const explainEresolve = ({ dep, current, peerConflict, fixWithForce }) => {
-  return (!dep.whileInstalling ? '' : `While resolving: ` +
-  `${c.bold(dep.whileInstalling.name)}@${c.bold(dep.whileInstalling.version)}\n`) +
-
-  `Found: ` +
-    `${c.bold(current.name)}@${c.bold(current.version)} ` +
-    c.dim(`at ${current.location}`) +
-    `${whichIsA(current.name, current.dependents)}` +
-
-  `\n\nCould not add conflicting dependency: ` +
-    `${c.bold(dep.name)}@${c.bold(dep.version)} ` +
-    c.dim(`at ${dep.location}`) +
-   `${whichIsA(dep.name, dep.dependents)}\n` +
-
-  (!peerConflict ? '' :
-    `\nConflicting peer dependency: ` +
-      `${c.bold(peerConflict.name)}@${c.bold(peerConflict.version)} ` +
-      c.dim(`at ${peerConflict.location}`) +
-      `${whichIsA(peerConflict.name, peerConflict.dependents)}\n`
-  ) +
-
-  `\nFix the upstream dependency conflict, or
-run this command with  --legacy-peer-deps${
-  fixWithForce ? ' or --force' : ''}
-to accept an incorrect (and potentially broken) dependency resolution.
-`
-}
-
 const start = process.hrtime()
 new Arborist(options).buildIdealTree(options).then(tree => {
   const end = process.hrtime(start)
@@ -62,7 +14,7 @@ new Arborist(options).buildIdealTree(options).then(tree => {
   if (tree.meta && options.save)
     tree.meta.save()
 }).catch(er => {
-  console.error(er)
-  if (er.code === 'ERESOLVE')
-    console.error(explainEresolve(er))
+  const opt = { depth: Infinity, color: true }
+  console.error(er.code === 'ERESOLVE' ? inspect(er, opt) : er)
+  process.exitCode = 1
 })

package/bin/lib/logging.js

@@ -26,7 +26,7 @@ if (loglevel !== 'silent') {
       return
     const pref = `${process.pid} ${level} `
     if (level === 'warn' && args[0] === 'ERESOLVE')
-      args[2] = inspect(args[2], { depth: Infinity })
+      args[2] = inspect(args[2], { depth: 10 })
     const msg = pref + format(...args).trim().split('\n').join(`\n${pref}`)
     console.error(msg)
   })

package/lib/arborist/build-ideal-tree.js

@@ -397,7 +397,7 @@ module.exports = cls => class IdealTreeBuilder extends cls {
     // that they're there, and not reinstall the world unnecessarily.
     if (this[_global] && (this[_updateAll] || this[_updateNames].length)) {
       const nm = resolve(this.path, 'node_modules')
-      for (const name of await readdir(nm)) {
+      for (const name of await readdir(nm).catch(() => [])) {
         tree.package.dependencies = tree.package.dependencies || {}
         if (this[_updateAll] || this[_updateNames].includes(name))
           tree.package.dependencies[name] = '*'
@@ -491,7 +491,8 @@ module.exports = cls => class IdealTreeBuilder extends cls {
     /* istanbul ignore else - should also be covered by realpath failure */
     if (filepath) {
       const { name } = spec
-      spec = npa(`file:${relpath(this.path, filepath)}`, this.path)
+      const tree = this.idealTree.target || this.idealTree
+      spec = npa(`file:${relpath(tree.path, filepath)}`, tree.path)
       spec.name = name
     }
     return spec
@@ -663,6 +664,11 @@ This is a one-time fix-up, please be patient...
       })
     }
     await promiseCallLimit(queue)
+
+    // have to re-calc dep flags, because the nodes don't have edges
+    // until their packages get assigned, so everything looks extraneous
+    calcDepFlags(this.idealTree)
+
     // yes, yes, this isn't the "original" version, but now that it's been
     // upgraded, we need to make sure we don't do the work to upgrade it
     // again, since it's now as new as can be.
@@ -800,6 +806,7 @@ This is a one-time fix-up, please be patient...
       // a virtual root of whatever brought in THIS node.
       // so we VR the node itself if the edge is not a peer
       const source = edge.peer ? peerSource : node
+
       const virtualRoot = this[_virtualRoot](source, true)
       // reuse virtual root if we already have one, but don't
       // try to do the override ahead of time, since we MAY be able
@@ -821,13 +828,17 @@ This is a one-time fix-up, please be patient...
       // +-- z@1
       // But if x and y are loaded in the same virtual root, then they will
       // be forced to agree on a version of z.
+      const required = new Set([edge.from])
+      const parent = edge.peer ? virtualRoot : null
       const dep = vrDep && vrDep.satisfies(edge) ? vrDep
-        : await this[_nodeFromEdge](edge, edge.peer ? virtualRoot : null)
+        : await this[_nodeFromEdge](edge, parent, null, required)
+
       /* istanbul ignore next */
       debug(() => {
         if (!dep)
           throw new Error('no dep??')
       })
+
       tasks.push({edge, dep})
     }
 
@@ -864,7 +875,7 @@ This is a one-time fix-up, please be patient...
 
   // loads a node from an edge, and then loads its peer deps (and their
   // peer deps, on down the line) into a virtual root parent.
-  async [_nodeFromEdge] (edge, parent_, secondEdge = null) {
+  async [_nodeFromEdge] (edge, parent_, secondEdge, required) {
     // create a virtual root node with the same deps as the node that
     // is requesting this one, so that we can get all the peer deps in
     // a context where they're likely to be resolvable.
@@ -895,6 +906,11 @@ This is a one-time fix-up, please be patient...
     // ensure the one we want is the one that's placed
     node.parent = parent
 
+    if (required.has(edge.from) && edge.type !== 'peerOptional' ||
+        secondEdge && (
+          required.has(secondEdge.from) && secondEdge.type !== 'peerOptional'))
+      required.add(node)
+
     // handle otherwise unresolvable dependency nesting loops by
     // creating a symbolic link
     // a1 -> b1 -> a2 -> b2 -> a1 -> ...
@@ -908,7 +924,7 @@ This is a one-time fix-up, please be patient...
     // keep track of the thing that caused this node to be included.
     const src = parent.sourceReference
     this[_peerSetSource].set(node, src)
-    return this[_loadPeerSet](node)
+    return this[_loadPeerSet](node, required)
   }
 
   [_virtualRoot] (node, reuse = false) {
@@ -1053,7 +1069,7 @@ This is a one-time fix-up, please be patient...
   // gets placed first.  In non-strict mode, we behave strictly if the
   // virtual root is based on the root project, and allow non-peer parent
   // deps to override, but throw if no preference can be determined.
-  async [_loadPeerSet] (node) {
+  async [_loadPeerSet] (node, required) {
     const peerEdges = [...node.edgesOut.values()]
       // we typically only install non-optional peers, but we have to
       // factor them into the peerSet so that we can avoid conflicts
@@ -1068,10 +1084,12 @@ This is a one-time fix-up, please be patient...
       const parentEdge = node.parent.edgesOut.get(edge.name)
       const {isProjectRoot, isWorkspace} = node.parent.sourceReference
       const isMine = isProjectRoot || isWorkspace
+      const conflictOK = this[_force] || !isMine && !this[_strictPeerDeps]
+
       if (!edge.to) {
         if (!parentEdge) {
           // easy, just put the thing there
-          await this[_nodeFromEdge](edge, node.parent)
+          await this[_nodeFromEdge](edge, node.parent, null, required)
           continue
         } else {
           // if the parent's edge is very broad like >=1, and the edge in
@@ -1082,14 +1100,16 @@ This is a one-time fix-up, please be patient...
           // a conflict.  this is always a problem in strict mode, never
           // in force mode, and a problem in non-strict mode if this isn't
           // on behalf of our project.  in all such cases, we warn at least.
-          await this[_nodeFromEdge](parentEdge, node.parent, edge)
+          const dep = await this[_nodeFromEdge](parentEdge, node.parent, edge, required)
 
           // hooray! that worked!
           if (edge.valid)
             continue
 
-          // allow it
-          if (this[_force] || !isMine && !this[_strictPeerDeps])
+          // allow it.  either we're overriding, or it's not something
+          // that will be installed by default anyway, and we'll fail when
+          // we get to the point where we need to, if we need to.
+          if (conflictOK || !required.has(dep))
             continue
 
           // problem
@@ -1102,7 +1122,7 @@ This is a one-time fix-up, please be patient...
       // in non-strict mode if it's not our fault.  don't warn here, because
       // we are going to warn again when we place the deps, if we end up
       // overriding for something else.
-      if (this[_force] || !isMine && !this[_strictPeerDeps])
+      if (conflictOK)
         continue
 
       // ok, it's the root, or we're in unforced strict mode, so this is bad
@@ -1198,8 +1218,25 @@ This is a one-time fix-up, please be patient...
         break
     }
 
-    if (!target)
-      this[_failPeerConflict](edge)
+    // if we can't find a target, that means that the last placed checked
+    // (and all the places before it) had a copy already.  if we're in
+    // --force mode, then the user has explicitly said that they're ok
+    // with conflicts.  This can only occur in --force mode in the case
+    // when a node was added to the tree with a peerOptional dep that we
+    // ignored, and then later, that edge became invalid, and we fail to
+    // resolve it.  We will warn about it in a moment.
+    if (!target) {
+      if (this[_force]) {
+        // we know that there is a dep (not the root) which is the target
+        // of this edge, or else it wouldn't have been a conflict.
+        target = edge.to.resolveParent
+        canPlace = KEEP
+      } else
+        this[_failPeerConflict](edge)
+    } else {
+      // it worked, so we clearly have no peer conflicts at this point.
+      this[_peerConflict] = null
+    }
 
     this.log.silly(
       'placeDep',
@@ -1210,9 +1247,6 @@ This is a one-time fix-up, please be patient...
       `want: ${edge.spec || '*'}`
     )
 
-    // it worked, so we clearly have no peer conflicts at this point.
-    this[_peerConflict] = null
-
     // Can only get KEEP here if the original edge was valid,
     // and we're checking for an update but it's already up to date.
     if (canPlace === KEEP) {
@@ -1398,6 +1432,7 @@ This is a one-time fix-up, please be patient...
     })
     const entryEdge = peerEntryEdge || edge
     const source = this[_peerSetSource].get(dep)
+
     isSource = isSource || target === source
     // if we're overriding the source, then we care if the *target* is
     // ours, even if it wasn't actually the original source, since we

package/lib/arborist/load-virtual.js

@@ -24,6 +24,7 @@ const loadWorkspacesVirtual = Symbol.for('loadWorkspacesVirtual')
 const flagsSuspect = Symbol.for('flagsSuspect')
 const reCalcDepFlags = Symbol('reCalcDepFlags')
 const checkRootEdges = Symbol('checkRootEdges')
+const rootOptionProvided = Symbol('rootOptionProvided')
 
 const depsToEdges = (type, deps) =>
   Object.entries(deps).map(d => [type, ...d])
@@ -63,6 +64,8 @@ module.exports = cls => class VirtualLoader extends cls {
       root = await this[loadRoot](s),
     } = options
 
+    this[rootOptionProvided] = options.root
+
     await this[loadFromShrinkwrap](s, root)
     return treeCheck(this.virtualTree)
   }
@@ -74,13 +77,17 @@ module.exports = cls => class VirtualLoader extends cls {
   }
 
   async [loadFromShrinkwrap] (s, root) {
-    // root is never any of these things, but might be a brand new
-    // baby Node object that never had its dep flags calculated.
-    root.extraneous = false
-    root.dev = false
-    root.optional = false
-    root.devOptional = false
-    root.peer = false
+    if (!this[rootOptionProvided]) {
+      // root is never any of these things, but might be a brand new
+      // baby Node object that never had its dep flags calculated.
+      root.extraneous = false
+      root.dev = false
+      root.optional = false
+      root.devOptional = false
+      root.peer = false
+    } else
+      this[flagsSuspect] = true
+
     this[checkRootEdges](s, root)
     root.meta = s
     this.virtualTree = root
@@ -88,20 +95,23 @@ module.exports = cls => class VirtualLoader extends cls {
     await this[resolveLinks](links, nodes)
     this[assignBundles](nodes)
     if (this[flagsSuspect])
-      this[reCalcDepFlags]()
+      this[reCalcDepFlags](nodes.values())
     return root
   }
 
-  [reCalcDepFlags] () {
+  [reCalcDepFlags] (nodes) {
     // reset all dep flags
-    for (const node of this.virtualTree.inventory.values()) {
+    // can't use inventory here, because virtualTree might not be root
+    for (const node of nodes) {
+      if (node.isRoot || node === this[rootOptionProvided])
+        continue
       node.extraneous = true
       node.dev = true
       node.optional = true
       node.devOptional = true
       node.peer = true
     }
-    calcDepFlags(this.virtualTree, true)
+    calcDepFlags(this.virtualTree, !this[rootOptionProvided])
   }
 
   // check the lockfile deps, and see if they match.  if they do not
@@ -237,6 +247,12 @@ module.exports = cls => class VirtualLoader extends cls {
     // shrinkwrap doesn't include package name unless necessary
     if (!sw.name)
       sw.name = nameFromFolder(path)
+
+    const dev = sw.dev
+    const optional = sw.optional
+    const devOptional = dev || optional || sw.devOptional
+    const peer = sw.peer
+
     const node = new Node({
       legacyPeerDeps: this.legacyPeerDeps,
       root: this.virtualTree,
@@ -246,6 +262,10 @@ module.exports = cls => class VirtualLoader extends cls {
       resolved: consistentResolve(sw.resolved, this.path, path),
       pkg: sw,
       hasShrinkwrap: sw.hasShrinkwrap,
+      dev,
+      optional,
+      devOptional,
+      peer,
     })
     // cast to boolean because they're undefined in the lock file when false
     node.extraneous = !!sw.extraneous

package/lib/arborist/reify.js

@@ -442,7 +442,8 @@ module.exports = cls => class Reifier extends cls {
     if (this[_trashList].has(node.path))
       return node
 
-    process.emit('time', `reifyNode:${node.location}`)
+    const timer = `reifyNode:${node.location}`
+    process.emit('time', timer)
     this.addTracker('reify', node.name, node.location)
 
     const p = Promise.resolve()
@@ -454,7 +455,7 @@ module.exports = cls => class Reifier extends cls {
     return this[_handleOptionalFailure](node, p)
       .then(() => {
         this.finishTracker('reify', node.name, node.location)
-        process.emit('timeEnd', `reifyNode:${node.location}`)
+        process.emit('timeEnd', timer)
         return node
       })
   }
@@ -474,9 +475,14 @@ module.exports = cls => class Reifier extends cls {
 
     // no idea what this thing is.  remove it from the tree.
     if (!res) {
-      node.parent = null
+      const warning = 'invalid or damaged lockfile detected\n' +
+        'please re-try this operation once it completes\n' +
+        'so that the damage can be corrected, or perform\n' +
+        'a fresh install with no lockfile if the problem persists.'
+      this.log.warn('reify', warning)
       this.log.verbose('reify', 'unrecognized node in tree', node.path)
       node.parent = null
+      node.fsParent = null
       this[_addNodeToTrashList](node)
       return
     }

package/lib/calc-dep-flags.js

@@ -11,7 +11,7 @@ const calcDepFlags = (tree, resetRoot = true) => {
     tree,
     visit: node => calcDepFlagsStep(node),
     filter: node => node,
-    getChildren: node => [...node.edgesOut.values()].map(edge => edge.to),
+    getChildren: (node, tree) => [...tree.edgesOut.values()].map(edge => edge.to),
   })
   return ret
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npmcli/arborist",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "Manage node_modules trees",
   "dependencies": {
     "@npmcli/installed-package-contents": "^1.0.6",