cacache 12.0.3 → 14.0.0

package/CHANGELOG.md

@@ -2,6 +2,105 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [14.0.0](https://github.com/npm/cacache/compare/v13.0.1...v14.0.0) (2020-01-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* **deps:** bumps engines to >= 10
+
+* **deps:** tar v6 and mkdirp v1 ([5a66e7a](https://github.com/npm/cacache/commit/5a66e7a))
+
+### [13.0.1](https://github.com/npm/cacache/compare/v13.0.0...v13.0.1) (2019-09-30)
+
+
+### Bug Fixes
+
+* **fix-owner:** chownr.sync quits on non-root uid ([08801be](https://github.com/npm/cacache/commit/08801be))
+
+## [13.0.0](https://github.com/npm/cacache/compare/v12.0.3...v13.0.0) (2019-09-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* This subtly changes the streaming interface of
+everything in cacache that streams, which is, well, everything in
+cacache.  Most users will probably not notice, but any code that
+depended on stream behavior always being deferred until next tick will
+need to adjust.
+
+The mississippi methods 'to', 'from', 'through', and so on, have been
+replaced with their Minipass counterparts, and streaming interaction
+with the file system is done via fs-minipass.
+
+The following modules are of interest here:
+
+- [minipass](http://npm.im/minipass) The core stream library.
+
+- [fs-minipass](http://npm.im/fs-minipass)  Note that the 'WriteStream'
+  class from fs-minipass is _not_ a Minipass stream, but rather a plain
+  old EventEmitter that duck types as a Writable.
+
+- [minipass-collect](http://npm.im/minipass-collect) Gather up all the
+  data from a stream.  Cacache only uses Collect.PassThrough, which is a
+  basic Minipass passthrough stream which emits a 'collect' event with
+  the completed data just before the 'end' event.
+
+- [minipass-pipeline](http://npm.im/minipass-pipeline) Connect one or
+  more streams into a pipe chain.  Errors anywhere in the pipeline are
+  proxied down the chain and then up to the Pipeline object itself.
+  Writes go into the head, reads go to the tail.  Used in place of
+  pump() and pumpify().
+
+- [minipass-flush](http://npm.im/minipass-flush) A Minipass passthrough
+  stream that defers its 'end' event until after a flush() method has
+  completed (either calling the supplied callback, or returning a
+  promise.)  Use in place of flush-write-stream (aka mississippi.to).
+
+Streams from through2, concat-stream, and the behavior provided by
+end-of-stream are all implemented in Minipass itself.
+
+Features of interest to cacache, which make Minipass a particularly good
+fit:
+
+- All of the 'endish' events are normalized, so we can just listen on
+  'end' and know that finish, prefinish, and close will be handled as
+  well.
+- Minipass doesn't waste time [containing
+  zalgo](https://blog.izs.me/2013/08/designing-apis-for-asynchrony).
+- Minipass has built-in support for promises that indicate the end or
+  error: stream.promise(), stream.collect(), and stream.concat().
+- With reliable and consistent timing guarantees, much less
+  error-checking logic is required.  We can be more confident that an
+  error is being thrown or emitted in the correct place, rather than in
+  a callback which is deferred, resulting in a hung promise or
+  uncaughtException.
+
+The biggest downside of Minipass is that it lacks some of the internal
+characteristics of node-core streams, which many community modules use
+to identify streams.  They have no _writableState or _readableState
+objects, or _read or _write methods.  As a result, the is-stream module
+(at least, at the time of this commit) doesn't recognize Minipass
+streams as readable or writable streams.
+
+All in all, the changes required of downstream users should be minimal,
+but are unlikely to be zero.  Hence the semver major change.
+
+### Features
+
+* replace all streams with Minipass streams ([f4c0962](https://github.com/npm/cacache/commit/f4c0962))
+* **deps:** Add minipass and minipass-pipeline ([a6545a9](https://github.com/npm/cacache/commit/a6545a9))
+* **promise:** converted .resolve to native promise, converted .map and .reduce to native ([220c56d](https://github.com/npm/cacache/commit/220c56d))
+* **promise:** individually promisifing functions as needed ([74b939e](https://github.com/npm/cacache/commit/74b939e))
+* **promise:** moved .reject from bluebird to native promise ([1d56da1](https://github.com/npm/cacache/commit/1d56da1))
+* **promise:** removed .fromNode, removed .join ([9c457a0](https://github.com/npm/cacache/commit/9c457a0))
+* **promise:** removed .map, replaced with p-map. removed .try ([cc3ee05](https://github.com/npm/cacache/commit/cc3ee05))
+* **promise:** removed .tap ([0260f12](https://github.com/npm/cacache/commit/0260f12))
+* **promise:** removed .using/.disposer ([5d832f3](https://github.com/npm/cacache/commit/5d832f3))
+* **promise:** removed bluebird ([c21298c](https://github.com/npm/cacache/commit/c21298c))
+* **promise:** removed bluebird specific .catch calls ([28aeeac](https://github.com/npm/cacache/commit/28aeeac))
+* **promise:** replaced .reduce and .mapSeries ([478f5cb](https://github.com/npm/cacache/commit/478f5cb))
+
 ### [12.0.3](https://github.com/npm/cacache/compare/v12.0.2...v12.0.3) (2019-08-19)
 
 
@@ -65,7 +164,7 @@ chown everything to root.
 The solution is for the user to create a folder, make it user-owned, and
 use that, rather than relying on cacache to create the root cache folder.
 
-If we decide to restore the uid/gid opts, and use ownership inferrence
+If we decide to restore the uid/gid opts, and use ownership inference
 only when uid/gid are unset, then take care to also make rm take an
 option object, and pass it through to entry-index.js.
 

package/README.md

@@ -12,8 +12,6 @@ when running as `root`.
 It was written to be used as [npm](https://npm.im)'s local cache, but can
 just as easily be used on its own.
 
-_Translations: [español](README.es.md)_
-
 ## Install
 
 `$ npm install --save cacache`
@@ -40,7 +38,6 @@ _Translations: [español](README.es.md)_
     * [`rm.entry`](#rm-entry)
     * [`rm.content`](#rm-content)
   * Utilities
-    * [`setLocale`](#set-locale)
     * [`clearMemoized`](#clear-memoized)
     * [`tmp.mkdir`](#tmp-mkdir)
     * [`tmp.withTmp`](#with-tmp)
@@ -52,7 +49,7 @@ _Translations: [español](README.es.md)_
 ### Example
 
 ```javascript
-const cacache = require('cacache/en')
+const cacache = require('cacache')
 const fs = require('fs')
 
 const tarball = '/path/to/mytar.tgz'
@@ -113,21 +110,6 @@ Happy hacking!
 
 ### API
 
-#### <a name="localized-api"></a> Using localized APIs
-
-cacache includes a complete API in English, with the same features as other
-translations. To use the English API as documented in this README, use
-`require('cacache/en')`. This is also currently the default if you do
-`require('cacache')`, but may change in the future.
-
-cacache also supports other languages! You can find the list of currently
-supported ones by looking in `./locales` in the source directory. You can use
-the API in that language with `require('cacache/<lang>')`.
-
-Want to add support for a new language? Please go ahead! You should be able to
-copy `./locales/en.js` and `./locales/en.json` and fill them in. Translating the
-`README.md` is a bit more work, but also appreciated if you get around to it. 👍🏼
-
 #### <a name="ls"></a> `> cacache.ls(cache) -> Promise<Object>`
 
 Lists info for all entries currently in the cache as a single large object. Each
@@ -478,14 +460,6 @@ cacache.rm.content(cachePath, 'sha512-SoMeDIGest/IN+BaSE64==').then(() => {
 })
 ```
 
-#### <a name="set-locale"></a> `> cacache.setLocale(locale)`
-
-Configure the language/locale used for messages and errors coming from cacache.
-The list of available locales is in the `./locales` directory in the project
-root.
-
-_Interested in contributing more languages! [Submit a PR](CONTRIBUTING.md)!_
-
 #### <a name="clear-memoized"></a> `> cacache.clearMemoized()`
 
 Completely resets the in-memory entry cache.
@@ -537,8 +511,8 @@ cacache.tmp.mkdir(cache).then(dir => {
 
 Creates a temporary directory with [`tmp.mkdir()`](#tmp-mkdir) and calls `cb`
 with it. The created temporary directory will be removed when the return value
-of `cb()` resolves -- that is, if you return a Promise from `cb()`, the tmp
-directory will be automatically deleted once that promise completes.
+of `cb()` resolves, the tmp directory will be automatically deleted once that 
+promise completes.
 
 The same caveats apply when it comes to managing permissions for the tmp dir's
 contents.

package/get.js

@@ -1,15 +1,18 @@
 'use strict'
 
-const BB = require('bluebird')
+const util = require('util')
 
 const figgyPudding = require('figgy-pudding')
 const fs = require('fs')
 const index = require('./lib/entry-index')
 const memo = require('./lib/memoization')
-const pipe = require('mississippi').pipe
-const pipeline = require('mississippi').pipeline
 const read = require('./lib/content/read')
-const through = require('mississippi').through
+
+const Minipass = require('minipass')
+const Collect = require('minipass-collect')
+const Pipeline = require('minipass-pipeline')
+
+const writeFile = util.promisify(fs.writeFile)
 
 const GetOpts = figgyPudding({
   integrity: {},
@@ -23,44 +26,53 @@ module.exports = function get (cache, key, opts) {
 module.exports.byDigest = function getByDigest (cache, digest, opts) {
   return getData(true, cache, digest, opts)
 }
+
 function getData (byDigest, cache, key, opts) {
   opts = GetOpts(opts)
-  const memoized = (
-    byDigest
-      ? memo.get.byDigest(cache, key, opts)
-      : memo.get(cache, key, opts)
-  )
+  const memoized = byDigest
+    ? memo.get.byDigest(cache, key, opts)
+    : memo.get(cache, key, opts)
   if (memoized && opts.memoize !== false) {
-    return BB.resolve(byDigest ? memoized : {
-      metadata: memoized.entry.metadata,
-      data: memoized.data,
-      integrity: memoized.entry.integrity,
-      size: memoized.entry.size
-    })
+    return Promise.resolve(
+      byDigest
+        ? memoized
+        : {
+          metadata: memoized.entry.metadata,
+          data: memoized.data,
+          integrity: memoized.entry.integrity,
+          size: memoized.entry.size
+        }
+    )
   }
-  return (
-    byDigest ? BB.resolve(null) : index.find(cache, key, opts)
-  ).then(entry => {
-    if (!entry && !byDigest) {
-      throw new index.NotFoundError(cache, key)
-    }
-    return read(cache, byDigest ? key : entry.integrity, {
-      integrity: opts.integrity,
-      size: opts.size
-    }).then(data => byDigest ? data : {
-      metadata: entry.metadata,
-      data: data,
-      size: entry.size,
-      integrity: entry.integrity
-    }).then(res => {
-      if (opts.memoize && byDigest) {
-        memo.put.byDigest(cache, key, res, opts)
-      } else if (opts.memoize) {
-        memo.put(cache, entry, res.data, opts)
+  return (byDigest ? Promise.resolve(null) : index.find(cache, key, opts)).then(
+    (entry) => {
+      if (!entry && !byDigest) {
+        throw new index.NotFoundError(cache, key)
       }
-      return res
-    })
-  })
+      return read(cache, byDigest ? key : entry.integrity, {
+        integrity: opts.integrity,
+        size: opts.size
+      })
+        .then((data) =>
+          byDigest
+            ? data
+            : {
+              metadata: entry.metadata,
+              data: data,
+              size: entry.size,
+              integrity: entry.integrity
+            }
+        )
+        .then((res) => {
+          if (opts.memoize && byDigest) {
+            memo.put.byDigest(cache, key, res, opts)
+          } else if (opts.memoize) {
+            memo.put(cache, entry, res.data, opts)
+          }
+          return res
+        })
+    }
+  )
 }
 
 module.exports.sync = function get (cache, key, opts) {
@@ -69,33 +81,30 @@ module.exports.sync = function get (cache, key, opts) {
 module.exports.sync.byDigest = function getByDigest (cache, digest, opts) {
   return getDataSync(true, cache, digest, opts)
 }
+
 function getDataSync (byDigest, cache, key, opts) {
   opts = GetOpts(opts)
-  const memoized = (
-    byDigest
-      ? memo.get.byDigest(cache, key, opts)
-      : memo.get(cache, key, opts)
-  )
+  const memoized = byDigest
+    ? memo.get.byDigest(cache, key, opts)
+    : memo.get(cache, key, opts)
   if (memoized && opts.memoize !== false) {
-    return byDigest ? memoized : {
-      metadata: memoized.entry.metadata,
-      data: memoized.data,
-      integrity: memoized.entry.integrity,
-      size: memoized.entry.size
-    }
+    return byDigest
+      ? memoized
+      : {
+        metadata: memoized.entry.metadata,
+        data: memoized.data,
+        integrity: memoized.entry.integrity,
+        size: memoized.entry.size
+      }
   }
   const entry = !byDigest && index.find.sync(cache, key, opts)
   if (!entry && !byDigest) {
     throw new index.NotFoundError(cache, key)
   }
-  const data = read.sync(
-    cache,
-    byDigest ? key : entry.integrity,
-    {
-      integrity: opts.integrity,
-      size: opts.size
-    }
-  )
+  const data = read.sync(cache, byDigest ? key : entry.integrity, {
+    integrity: opts.integrity,
+    size: opts.size
+  })
   const res = byDigest
     ? data
     : {
@@ -113,97 +122,93 @@ function getDataSync (byDigest, cache, key, opts) {
 }
 
 module.exports.stream = getStream
+
+const getMemoizedStream = (memoized) => {
+  const stream = new Minipass()
+  stream.on('newListener', function (ev, cb) {
+    ev === 'metadata' && cb(memoized.entry.metadata)
+    ev === 'integrity' && cb(memoized.entry.integrity)
+    ev === 'size' && cb(memoized.entry.size)
+  })
+  stream.end(memoized.data)
+  return stream
+}
+
 function getStream (cache, key, opts) {
   opts = GetOpts(opts)
-  let stream = through()
   const memoized = memo.get(cache, key, opts)
   if (memoized && opts.memoize !== false) {
-    stream.on('newListener', function (ev, cb) {
-      ev === 'metadata' && cb(memoized.entry.metadata)
-      ev === 'integrity' && cb(memoized.entry.integrity)
-      ev === 'size' && cb(memoized.entry.size)
-    })
-    stream.write(memoized.data, () => stream.end())
-    return stream
+    return getMemoizedStream(memoized)
   }
-  index.find(cache, key).then(entry => {
-    if (!entry) {
-      return stream.emit(
-        'error', new index.NotFoundError(cache, key)
-      )
-    }
-    let memoStream
-    if (opts.memoize) {
-      let memoData = []
-      let memoLength = 0
-      memoStream = through((c, en, cb) => {
-        memoData && memoData.push(c)
-        memoLength += c.length
-        cb(null, c, en)
-      }, cb => {
-        memoData && memo.put(cache, entry, Buffer.concat(memoData, memoLength), opts)
-        cb()
+
+  const stream = new Pipeline()
+  index
+    .find(cache, key)
+    .then((entry) => {
+      if (!entry) {
+        throw new index.NotFoundError(cache, key)
+      }
+      stream.emit('metadata', entry.metadata)
+      stream.emit('integrity', entry.integrity)
+      stream.emit('size', entry.size)
+      stream.on('newListener', function (ev, cb) {
+        ev === 'metadata' && cb(entry.metadata)
+        ev === 'integrity' && cb(entry.integrity)
+        ev === 'size' && cb(entry.size)
       })
-    } else {
-      memoStream = through()
-    }
-    stream.emit('metadata', entry.metadata)
-    stream.emit('integrity', entry.integrity)
-    stream.emit('size', entry.size)
-    stream.on('newListener', function (ev, cb) {
-      ev === 'metadata' && cb(entry.metadata)
-      ev === 'integrity' && cb(entry.integrity)
-      ev === 'size' && cb(entry.size)
+
+      const src = read.readStream(
+        cache,
+        entry.integrity,
+        opts.concat({
+          size: opts.size == null ? entry.size : opts.size
+        })
+      )
+
+      if (opts.memoize) {
+        const memoStream = new Collect.PassThrough()
+        memoStream.on('collect', data => memo.put(cache, entry, data, opts))
+        stream.unshift(memoStream)
+      }
+      stream.unshift(src)
     })
-    pipe(
-      read.readStream(cache, entry.integrity, opts.concat({
-        size: opts.size == null ? entry.size : opts.size
-      })),
-      memoStream,
-      stream
-    )
-  }).catch(err => stream.emit('error', err))
+    .catch((err) => stream.emit('error', err))
+
   return stream
 }
 
 module.exports.stream.byDigest = getStreamDigest
+
 function getStreamDigest (cache, integrity, opts) {
   opts = GetOpts(opts)
   const memoized = memo.get.byDigest(cache, integrity, opts)
   if (memoized && opts.memoize !== false) {
-    const stream = through()
-    stream.write(memoized, () => stream.end())
+    const stream = new Minipass()
+    stream.end(memoized)
     return stream
   } else {
-    let stream = read.readStream(cache, integrity, opts)
-    if (opts.memoize) {
-      let memoData = []
-      let memoLength = 0
-      const memoStream = through((c, en, cb) => {
-        memoData && memoData.push(c)
-        memoLength += c.length
-        cb(null, c, en)
-      }, cb => {
-        memoData && memo.put.byDigest(
-          cache,
-          integrity,
-          Buffer.concat(memoData, memoLength),
-          opts
-        )
-        cb()
-      })
-      stream = pipeline(stream, memoStream)
+    const stream = read.readStream(cache, integrity, opts)
+    if (!opts.memoize) {
+      return stream
     }
-    return stream
+    const memoStream = new Collect.PassThrough()
+    memoStream.on('collect', data => memo.put.byDigest(
+      cache,
+      integrity,
+      data,
+      opts
+    ))
+    return new Pipeline(stream, memoStream)
   }
 }
 
 module.exports.info = info
+
 function info (cache, key, opts) {
   opts = GetOpts(opts)
   const memoized = memo.get(cache, key, opts)
   if (memoized && opts.memoize !== false) {
-    return BB.resolve(memoized.entry)
+    return Promise.resolve(memoized.entry)
   } else {
     return index.find(cache, key)
   }
@@ -211,37 +216,51 @@ function info (cache, key, opts) {
 
 module.exports.hasContent = read.hasContent
 
-module.exports.copy = function cp (cache, key, dest, opts) {
+function cp (cache, key, dest, opts) {
   return copy(false, cache, key, dest, opts)
 }
-module.exports.copy.byDigest = function cpDigest (cache, digest, dest, opts) {
+
+module.exports.copy = cp
+
+function cpDigest (cache, digest, dest, opts) {
   return copy(true, cache, digest, dest, opts)
 }
+
+module.exports.copy.byDigest = cpDigest
+
 function copy (byDigest, cache, key, dest, opts) {
   opts = GetOpts(opts)
   if (read.copy) {
-    return (
-      byDigest ? BB.resolve(null) : index.find(cache, key, opts)
-    ).then(entry => {
+    return (byDigest
+      ? Promise.resolve(null)
+      : index.find(cache, key, opts)
+    ).then((entry) => {
       if (!entry && !byDigest) {
         throw new index.NotFoundError(cache, key)
       }
-      return read.copy(
-        cache, byDigest ? key : entry.integrity, dest, opts
-      ).then(() => byDigest ? key : {
-        metadata: entry.metadata,
-        size: entry.size,
-        integrity: entry.integrity
-      })
+      return read
+        .copy(cache, byDigest ? key : entry.integrity, dest, opts)
+        .then(() => {
+          return byDigest
+            ? key
+            : {
+              metadata: entry.metadata,
+              size: entry.size,
+              integrity: entry.integrity
+            }
+        })
     })
-  } else {
-    return getData(byDigest, cache, key, opts).then(res => {
-      return fs.writeFileAsync(dest, byDigest ? res : res.data)
-        .then(() => byDigest ? key : {
+  }
+
+  return getData(byDigest, cache, key, opts).then((res) => {
+    return writeFile(dest, byDigest ? res : res.data).then(() => {
+      return byDigest
+        ? key
+        : {
           metadata: res.metadata,
           size: res.size,
           integrity: res.integrity
-        })
+        }
     })
-  }
+  })
 }

package/index.js

@@ -1,3 +1,41 @@
 'use strict'
 
-module.exports = require('./locales/en.js')
+const ls = require('./ls.js')
+const get = require('./get.js')
+const put = require('./put.js')
+const rm = require('./rm.js')
+const verify = require('./verify.js')
+const { clearMemoized } = require('./lib/memoization.js')
+const tmp = require('./lib/util/tmp.js')
+
+module.exports.ls = ls
+module.exports.ls.stream = ls.stream
+
+module.exports.get = get
+module.exports.get.byDigest = get.byDigest
+module.exports.get.sync = get.sync
+module.exports.get.sync.byDigest = get.sync.byDigest
+module.exports.get.stream = get.stream
+module.exports.get.stream.byDigest = get.stream.byDigest
+module.exports.get.copy = get.copy
+module.exports.get.copy.byDigest = get.copy.byDigest
+module.exports.get.info = get.info
+module.exports.get.hasContent = get.hasContent
+module.exports.get.hasContent.sync = get.hasContent.sync
+
+module.exports.put = put
+module.exports.put.stream = put.stream
+
+module.exports.rm = rm.entry
+module.exports.rm.all = rm.all
+module.exports.rm.entry = module.exports.rm
+module.exports.rm.content = rm.content
+
+module.exports.clearMemoized = clearMemoized
+
+module.exports.tmp = {}
+module.exports.tmp.mkdir = tmp.mkdir
+module.exports.tmp.withTmp = tmp.withTmp
+
+module.exports.verify = verify
+module.exports.verify.lastRun = verify.lastRun

package/lib/content/path.js

@@ -11,16 +11,19 @@ const ssri = require('ssri')
 // ~/.my-cache/content-v2/sha512/ba/da/55deadbeefc0ffee
 //
 module.exports = contentPath
+
 function contentPath (cache, integrity) {
   const sri = ssri.parse(integrity, { single: true })
   // contentPath is the *strongest* algo given
-  return path.join.apply(path, [
+  return path.join(
     contentDir(cache),
-    sri.algorithm
-  ].concat(hashToSegments(sri.hexDigest())))
+    sri.algorithm,
+    ...hashToSegments(sri.hexDigest())
+  )
 }
 
-module.exports._contentDir = contentDir
+module.exports.contentDir = contentDir
+
 function contentDir (cache) {
   return path.join(cache, `content-v${contentVer}`)
 }