cacache 12.0.4 → 15.0.0

package/lib/util/move-file.js

@@ -1,14 +1,19 @@
 'use strict'
 
-const fs = require('graceful-fs')
-const BB = require('bluebird')
-const chmod = BB.promisify(fs.chmod)
-const unlink = BB.promisify(fs.unlink)
-let move
-let pinflight
+const fs = require('fs')
+const util = require('util')
+const chmod = util.promisify(fs.chmod)
+const unlink = util.promisify(fs.unlink)
+const stat = util.promisify(fs.stat)
+const move = require('move-concurrently')
+const pinflight = require('promise-inflight')
 
 module.exports = moveFile
+
 function moveFile (src, dest) {
+  const isWindows = global.__CACACHE_TEST_FAKE_WINDOWS__ ||
+    process.platform === 'win32'
+
   // This isn't quite an fs.rename -- the assumption is that
   // if `dest` already exists, and we get certain errors while
   // trying to move it, we should just not bother.
@@ -18,34 +23,46 @@ function moveFile (src, dest) {
   // content their own way.
   //
   // Note that, as the name suggests, this strictly only supports file moves.
-  return BB.fromNode(cb => {
-    fs.link(src, dest, err => {
+  return new Promise((resolve, reject) => {
+    fs.link(src, dest, (err) => {
       if (err) {
-        if (err.code === 'EEXIST' || err.code === 'EBUSY') {
+        if (isWindows && err.code === 'EPERM') {
+          // XXX This is a really weird way to handle this situation, as it
+          // results in the src file being deleted even though the dest
+          // might not exist.  Since we pretty much always write files to
+          // deterministic locations based on content hash, this is likely
+          // ok (or at worst, just ends in a future cache miss).  But it would
+          // be worth investigating at some time in the future if this is
+          // really what we want to do here.
+          return resolve()
+        } else if (err.code === 'EEXIST' || err.code === 'EBUSY') {
           // file already exists, so whatever
-        } else if (err.code === 'EPERM' && process.platform === 'win32') {
-          // file handle stayed open even past graceful-fs limits
+          return resolve()
         } else {
-          return cb(err)
+          return reject(err)
         }
+      } else {
+        return resolve()
       }
-      return cb()
     })
-  }).then(() => {
-    // content should never change for any reason, so make it read-only
-    return BB.join(unlink(src), process.platform !== 'win32' && chmod(dest, '0444'))
-  }).catch(() => {
-    if (!pinflight) { pinflight = require('promise-inflight') }
-    return pinflight('cacache-move-file:' + dest, () => {
-      return BB.promisify(fs.stat)(dest).catch(err => {
-        if (err.code !== 'ENOENT') {
-          // Something else is wrong here. Bail bail bail
-          throw err
-        }
-        // file doesn't already exist! let's try a rename -> copy fallback
-        if (!move) { move = require('move-concurrently') }
-        return move(src, dest, { BB, fs })
+  })
+    .then(() => {
+      // content should never change for any reason, so make it read-only
+      return Promise.all([
+        unlink(src),
+        !isWindows && chmod(dest, '0444')
+      ])
+    })
+    .catch(() => {
+      return pinflight('cacache-move-file:' + dest, () => {
+        return stat(dest).catch((err) => {
+          if (err.code !== 'ENOENT') {
+            // Something else is wrong here. Bail bail bail
+            throw err
+          }
+          // file doesn't already exist! let's try a rename -> copy fallback
+          return move(src, dest, { Promise, fs })
+        })
       })
     })
-  })
 }

package/lib/util/tmp.js

@@ -1,37 +1,35 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
-const figgyPudding = require('figgy-pudding')
 const fixOwner = require('./fix-owner')
 const path = require('path')
-const rimraf = BB.promisify(require('rimraf'))
+const rimraf = util.promisify(require('rimraf'))
 const uniqueFilename = require('unique-filename')
-
-const TmpOpts = figgyPudding({
-  tmpPrefix: {}
-})
+const { disposer } = require('./disposer')
 
 module.exports.mkdir = mktmpdir
-function mktmpdir (cache, opts) {
-  opts = TmpOpts(opts)
-  const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
+
+function mktmpdir (cache, opts = {}) {
+  const { tmpPrefix } = opts
+  const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), tmpPrefix)
   return fixOwner.mkdirfix(cache, tmpTarget).then(() => {
     return tmpTarget
   })
 }
 
 module.exports.withTmp = withTmp
+
 function withTmp (cache, opts, cb) {
   if (!cb) {
     cb = opts
-    opts = null
+    opts = {}
   }
-  opts = TmpOpts(opts)
-  return BB.using(mktmpdir(cache, opts).disposer(rimraf), cb)
+  return disposer(mktmpdir(cache, opts), rimraf, cb)
 }
 
 module.exports.fix = fixtmpdir
+
 function fixtmpdir (cache) {
   return fixOwner(cache, path.join(cache, 'tmp'))
 }

package/lib/verify.js

@@ -1,35 +1,39 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
+const pMap = require('p-map')
 const contentPath = require('./content/path')
-const figgyPudding = require('figgy-pudding')
-const finished = BB.promisify(require('mississippi').finished)
 const fixOwner = require('./util/fix-owner')
-const fs = require('graceful-fs')
-const glob = BB.promisify(require('glob'))
+const fs = require('fs')
+const fsm = require('fs-minipass')
+const glob = util.promisify(require('glob'))
 const index = require('./entry-index')
 const path = require('path')
-const rimraf = BB.promisify(require('rimraf'))
+const rimraf = util.promisify(require('rimraf'))
 const ssri = require('ssri')
 
-BB.promisifyAll(fs)
+const hasOwnProperty = (obj, key) =>
+  Object.prototype.hasOwnProperty.call(obj, key)
 
-const VerifyOpts = figgyPudding({
-  concurrency: {
-    default: 20
-  },
-  filter: {},
-  log: {
-    default: { silly () {} }
-  }
+const stat = util.promisify(fs.stat)
+const truncate = util.promisify(fs.truncate)
+const writeFile = util.promisify(fs.writeFile)
+const readFile = util.promisify(fs.readFile)
+
+const verifyOpts = (opts) => ({
+  concurrency: 20,
+  log: { silly () {} },
+  ...opts
 })
 
 module.exports = verify
+
 function verify (cache, opts) {
-  opts = VerifyOpts(opts)
+  opts = verifyOpts(opts)
   opts.log.silly('verify', 'verifying cache at', cache)
-  return BB.reduce([
+
+  const steps = [
     markStartTime,
     fixPerms,
     garbageCollect,
@@ -37,38 +41,57 @@ function verify (cache, opts) {
     cleanTmp,
     writeVerifile,
     markEndTime
-  ], (stats, step, i) => {
-    const label = step.name || `step #${i}`
-    const start = new Date()
-    return BB.resolve(step(cache, opts)).then(s => {
-      s && Object.keys(s).forEach(k => {
-        stats[k] = s[k]
+  ]
+
+  return steps
+    .reduce((promise, step, i) => {
+      const label = step.name
+      const start = new Date()
+      return promise.then((stats) => {
+        return step(cache, opts).then((s) => {
+          s &&
+            Object.keys(s).forEach((k) => {
+              stats[k] = s[k]
+            })
+          const end = new Date()
+          if (!stats.runTime) {
+            stats.runTime = {}
+          }
+          stats.runTime[label] = end - start
+          return Promise.resolve(stats)
+        })
       })
-      const end = new Date()
-      if (!stats.runTime) { stats.runTime = {} }
-      stats.runTime[label] = end - start
+    }, Promise.resolve({}))
+    .then((stats) => {
+      stats.runTime.total = stats.endTime - stats.startTime
+      opts.log.silly(
+        'verify',
+        'verification finished for',
+        cache,
+        'in',
+        `${stats.runTime.total}ms`
+      )
       return stats
     })
-  }, {}).tap(stats => {
-    stats.runTime.total = stats.endTime - stats.startTime
-    opts.log.silly('verify', 'verification finished for', cache, 'in', `${stats.runTime.total}ms`)
-  })
 }
 
 function markStartTime (cache, opts) {
-  return { startTime: new Date() }
+  return Promise.resolve({ startTime: new Date() })
 }
 
 function markEndTime (cache, opts) {
-  return { endTime: new Date() }
+  return Promise.resolve({ endTime: new Date() })
 }
 
 function fixPerms (cache, opts) {
   opts.log.silly('verify', 'fixing cache permissions')
-  return fixOwner.mkdirfix(cache, cache).then(() => {
-    // TODO - fix file permissions too
-    return fixOwner.chownr(cache, cache)
-  }).then(() => null)
+  return fixOwner
+    .mkdirfix(cache, cache)
+    .then(() => {
+      // TODO - fix file permissions too
+      return fixOwner.chownr(cache, cache)
+    })
+    .then(() => null)
 }
 
 // Implements a naive mark-and-sweep tracing garbage collector.
@@ -84,85 +107,105 @@ function garbageCollect (cache, opts) {
   opts.log.silly('verify', 'garbage collecting content')
   const indexStream = index.lsStream(cache)
   const liveContent = new Set()
-  indexStream.on('data', entry => {
-    if (opts.filter && !opts.filter(entry)) { return }
+  indexStream.on('data', (entry) => {
+    if (opts.filter && !opts.filter(entry)) {
+      return
+    }
     liveContent.add(entry.integrity.toString())
   })
-  return finished(indexStream).then(() => {
-    const contentDir = contentPath._contentDir(cache)
+  return new Promise((resolve, reject) => {
+    indexStream.on('end', resolve).on('error', reject)
+  }).then(() => {
+    const contentDir = contentPath.contentDir(cache)
     return glob(path.join(contentDir, '**'), {
       follow: false,
       nodir: true,
       nosort: true
-    }).then(files => {
-      return BB.resolve({
+    }).then((files) => {
+      return Promise.resolve({
         verifiedContent: 0,
         reclaimedCount: 0,
         reclaimedSize: 0,
         badContentCount: 0,
         keptSize: 0
-      }).tap((stats) => BB.map(files, (f) => {
-        const split = f.split(/[/\\]/)
-        const digest = split.slice(split.length - 3).join('')
-        const algo = split[split.length - 4]
-        const integrity = ssri.fromHex(digest, algo)
-        if (liveContent.has(integrity.toString())) {
-          return verifyContent(f, integrity).then(info => {
-            if (!info.valid) {
-              stats.reclaimedCount++
-              stats.badContentCount++
-              stats.reclaimedSize += info.size
+      }).then((stats) =>
+        pMap(
+          files,
+          (f) => {
+            const split = f.split(/[/\\]/)
+            const digest = split.slice(split.length - 3).join('')
+            const algo = split[split.length - 4]
+            const integrity = ssri.fromHex(digest, algo)
+            if (liveContent.has(integrity.toString())) {
+              return verifyContent(f, integrity).then((info) => {
+                if (!info.valid) {
+                  stats.reclaimedCount++
+                  stats.badContentCount++
+                  stats.reclaimedSize += info.size
+                } else {
+                  stats.verifiedContent++
+                  stats.keptSize += info.size
+                }
+                return stats
+              })
             } else {
-              stats.verifiedContent++
-              stats.keptSize += info.size
+              // No entries refer to this content. We can delete.
+              stats.reclaimedCount++
+              return stat(f).then((s) => {
+                return rimraf(f).then(() => {
+                  stats.reclaimedSize += s.size
+                  return stats
+                })
+              })
             }
-            return stats
-          })
-        } else {
-          // No entries refer to this content. We can delete.
-          stats.reclaimedCount++
-          return fs.statAsync(f).then(s => {
-            return rimraf(f).then(() => {
-              stats.reclaimedSize += s.size
-              return stats
-            })
-          })
-        }
-      }, { concurrency: opts.concurrency }))
+          },
+          { concurrency: opts.concurrency }
+        ).then(() => stats)
+      )
     })
   })
 }
 
 function verifyContent (filepath, sri) {
-  return fs.statAsync(filepath).then(stat => {
-    const contentInfo = {
-      size: stat.size,
-      valid: true
-    }
-    return ssri.checkStream(
-      fs.createReadStream(filepath),
-      sri
-    ).catch(err => {
-      if (err.code !== 'EINTEGRITY') { throw err }
-      return rimraf(filepath).then(() => {
-        contentInfo.valid = false
-      })
-    }).then(() => contentInfo)
-  }).catch({ code: 'ENOENT' }, () => ({ size: 0, valid: false }))
+  return stat(filepath)
+    .then((s) => {
+      const contentInfo = {
+        size: s.size,
+        valid: true
+      }
+      return ssri
+        .checkStream(new fsm.ReadStream(filepath), sri)
+        .catch((err) => {
+          if (err.code !== 'EINTEGRITY') {
+            throw err
+          }
+          return rimraf(filepath).then(() => {
+            contentInfo.valid = false
+          })
+        })
+        .then(() => contentInfo)
+    })
+    .catch((err) => {
+      if (err.code === 'ENOENT') {
+        return { size: 0, valid: false }
+      }
+      throw err
+    })
 }
 
 function rebuildIndex (cache, opts) {
   opts.log.silly('verify', 'rebuilding index')
-  return index.ls(cache).then(entries => {
+  return index.ls(cache).then((entries) => {
     const stats = {
       missingContent: 0,
       rejectedEntries: 0,
       totalEntries: 0
     }
     const buckets = {}
-    for (let k in entries) {
-      if (entries.hasOwnProperty(k)) {
-        const hashed = index._hashKey(k)
+    for (const k in entries) {
+      /* istanbul ignore else */
+      if (hasOwnProperty(entries, k)) {
+        const hashed = index.hashKey(k)
         const entry = entries[k]
         const excluded = opts.filter && !opts.filter(entry)
         excluded && stats.rejectedEntries++
@@ -172,35 +215,51 @@ function rebuildIndex (cache, opts) {
           // skip
         } else if (excluded) {
           buckets[hashed] = []
-          buckets[hashed]._path = index._bucketPath(cache, k)
+          buckets[hashed]._path = index.bucketPath(cache, k)
         } else {
           buckets[hashed] = [entry]
-          buckets[hashed]._path = index._bucketPath(cache, k)
+          buckets[hashed]._path = index.bucketPath(cache, k)
         }
       }
     }
-    return BB.map(Object.keys(buckets), key => {
-      return rebuildBucket(cache, buckets[key], stats, opts)
-    }, { concurrency: opts.concurrency }).then(() => stats)
+    return pMap(
+      Object.keys(buckets),
+      (key) => {
+        return rebuildBucket(cache, buckets[key], stats, opts)
+      },
+      { concurrency: opts.concurrency }
+    ).then(() => stats)
   })
 }
 
 function rebuildBucket (cache, bucket, stats, opts) {
-  return fs.truncateAsync(bucket._path).then(() => {
+  return truncate(bucket._path).then(() => {
     // This needs to be serialized because cacache explicitly
     // lets very racy bucket conflicts clobber each other.
-    return BB.mapSeries(bucket, entry => {
-      const content = contentPath(cache, entry.integrity)
-      return fs.statAsync(content).then(() => {
-        return index.insert(cache, entry.key, entry.integrity, {
-          metadata: entry.metadata,
-          size: entry.size
-        }).then(() => { stats.totalEntries++ })
-      }).catch({ code: 'ENOENT' }, () => {
-        stats.rejectedEntries++
-        stats.missingContent++
+    return bucket.reduce((promise, entry) => {
+      return promise.then(() => {
+        const content = contentPath(cache, entry.integrity)
+        return stat(content)
+          .then(() => {
+            return index
+              .insert(cache, entry.key, entry.integrity, {
+                metadata: entry.metadata,
+                size: entry.size
+              })
+              .then(() => {
+                stats.totalEntries++
+              })
+          })
+          .catch((err) => {
+            if (err.code === 'ENOENT') {
+              stats.rejectedEntries++
+              stats.missingContent++
+              return
+            }
+            throw err
+          })
       })
-    })
+    }, Promise.resolve())
   })
 }
 
@@ -213,15 +272,16 @@ function writeVerifile (cache, opts) {
   const verifile = path.join(cache, '_lastverified')
   opts.log.silly('verify', 'writing verifile to ' + verifile)
   try {
-    return fs.writeFileAsync(verifile, '' + (+(new Date())))
+    return writeFile(verifile, '' + +new Date())
   } finally {
     fixOwner.chownr.sync(cache, verifile)
   }
 }
 
 module.exports.lastRun = lastRun
+
 function lastRun (cache) {
-  return fs.readFileAsync(
-    path.join(cache, '_lastverified'), 'utf8'
-  ).then(data => new Date(+data))
+  return readFile(path.join(cache, '_lastverified'), 'utf8').then(
+    (data) => new Date(+data)
+  )
 }

package/ls.js

@@ -1,6 +1,6 @@
 'use strict'
 
-var index = require('./lib/entry-index')
+const index = require('./lib/entry-index')
 
 module.exports = index.ls
 module.exports.stream = index.lsStream

package/package.json

@@ -1,9 +1,6 @@
 {
   "name": "cacache",
-  "publishConfig": {
-    "tag": "legacy"
-  },
-  "version": "12.0.4",
+  "version": "15.0.0",
   "cache-version": {
     "content": "2",
     "index": "5"
@@ -12,16 +9,18 @@
   "main": "index.js",
   "files": [
     "*.js",
-    "lib",
-    "locales"
+    "lib"
   ],
   "scripts": {
     "benchmarks": "node test/benchmarks",
+    "lint": "standard",
+    "postrelease": "npm publish",
+    "posttest": "npm run lint",
+    "prepublishOnly": "git push --follow-tags",
     "prerelease": "npm t",
-    "postrelease": "npm publish && git push --follow-tags",
-    "pretest": "standard",
     "release": "standard-version -s",
-    "test": "cross-env CACACHE_UPDATE_LOCALE_FILES=true tap --coverage --nyc-arg=--all -J test/*.js",
+    "test": "tap",
+    "coverage": "tap",
     "test-docker": "docker run -it --rm --name pacotest -v \"$PWD\":/tmp -w /tmp node:latest npm test"
   },
   "repository": "https://github.com/npm/cacache",
@@ -59,38 +58,38 @@
   ],
   "license": "ISC",
   "dependencies": {
-    "bluebird": "^3.5.5",
-    "chownr": "^1.1.1",
-    "figgy-pudding": "^3.5.1",
+    "chownr": "^1.1.2",
+    "fs-minipass": "^2.0.0",
     "glob": "^7.1.4",
-    "graceful-fs": "^4.1.15",
-    "infer-owner": "^1.0.3",
+    "infer-owner": "^1.0.4",
     "lru-cache": "^5.1.1",
-    "mississippi": "^3.0.0",
-    "mkdirp": "^0.5.1",
+    "minipass": "^3.1.1",
+    "minipass-collect": "^1.0.2",
+    "minipass-flush": "^1.0.5",
+    "minipass-pipeline": "^1.2.2",
+    "mkdirp": "^1.0.3",
     "move-concurrently": "^1.0.1",
+    "p-map": "^3.0.0",
     "promise-inflight": "^1.0.1",
-    "rimraf": "^2.6.3",
-    "ssri": "^6.0.1",
-    "unique-filename": "^1.1.1",
-    "y18n": "^4.0.0"
+    "rimraf": "^2.7.1",
+    "ssri": "^8.0.0",
+    "tar": "^6.0.1",
+    "unique-filename": "^1.1.1"
   },
   "devDependencies": {
     "benchmark": "^2.1.4",
     "chalk": "^2.4.2",
-    "cross-env": "^5.1.4",
     "require-inject": "^1.4.4",
-    "standard": "^12.0.1",
-    "standard-version": "^6.0.1",
+    "standard": "^14.3.1",
+    "standard-version": "^7.1.0",
     "tacks": "^1.3.0",
-    "tap": "^12.7.0"
+    "tap": "^14.10.6"
   },
-  "config": {
-    "nyc": {
-      "exclude": [
-        "node_modules/**",
-        "test/**"
-      ]
-    }
+  "tap": {
+    "100": true,
+    "test-regex": "test/[^/]*.js"
+  },
+  "engines": {
+    "node": ">= 10"
   }
 }