cacache 15.1.0 → 16.0.0

package/README.md

@@ -458,13 +458,17 @@ cacache.rm.all(cachePath).then(() => {
 })
 ```
 
-#### <a name="rm-entry"></a> `> cacache.rm.entry(cache, key) -> Promise`
+#### <a name="rm-entry"></a> `> cacache.rm.entry(cache, key, [opts]) -> Promise`
 
 Alias: `cacache.rm`
 
 Removes the index entry for `key`. Content will still be accessible if
 requested directly by content address ([`get.stream.byDigest`](#get-stream)).
 
+By default, this appends a new entry to the index with an integrity of `null`.
+If `opts.removeFully` is set to `true` then the index file itself will be
+physically deleted rather than appending a `null`.
+
 To remove the content itself (which might still be used by other entries), use
 [`rm.content`](#rm-content). Or, to safely vacuum any unused content, use
 [`verify`](#verify).
@@ -491,12 +495,21 @@ cacache.rm.content(cachePath, 'sha512-SoMeDIGest/IN+BaSE64==').then(() => {
 })
 ```
 
-#### <a name="index-compact"></a> `> cacache.index.compact(cache, key, matchFn) -> Promise`
+#### <a name="index-compact"></a> `> cacache.index.compact(cache, key, matchFn, [opts]) -> Promise`
 
 Uses `matchFn`, which must be a synchronous function that accepts two entries
 and returns a boolean indicating whether or not the two entries match, to
 deduplicate all entries in the cache for the given `key`.
 
+If `opts.validateEntry` is provided, it will be called as a function with the
+only parameter being a single index entry. The function must return a Boolean,
+if it returns `true` the entry is considered valid and will be kept in the index,
+if it returns `false` the entry will be removed from the index.
+
+If `opts.validateEntry` is not provided, however, every entry in the index will
+be deduplicated and kept until the first `null` integrity is reached, removing
+all entries that were written before the `null`.
+
 The deduplicated list of entries is both written to the index, replacing the
 existing content, and returned in the Promise.
 

package/lib/content/read.js

@@ -23,6 +23,7 @@ function read (cache, integrity, opts = {}) {
     if (typeof size === 'number' && stat.size !== size) {
       throw sizeError(size, stat.size)
     }
+
     if (stat.size > MAX_SINGLE_READ_SIZE) {
       return readPipeline(cpath, stat.size, sri, new Pipeline()).concat()
     }
@@ -31,6 +32,7 @@ function read (cache, integrity, opts = {}) {
       if (!ssri.checkData(data, sri)) {
         throw integrityError(sri, cpath)
       }
+
       return data
     })
   })
@@ -40,11 +42,11 @@ const readPipeline = (cpath, size, sri, stream) => {
   stream.push(
     new fsm.ReadStream(cpath, {
       size,
-      readSize: MAX_SINGLE_READ_SIZE
+      readSize: MAX_SINGLE_READ_SIZE,
     }),
     ssri.integrityStream({
       integrity: sri,
-      size
+      size,
     })
   )
   return stream
@@ -81,6 +83,7 @@ function readStream (cache, integrity, opts = {}) {
     if (typeof size === 'number' && size !== stat.size) {
       return stream.emit('error', sizeError(size, stat.size))
     }
+
     readPipeline(cpath, stat.size, sri, stream)
   }, er => stream.emit('error', er))
 
@@ -112,12 +115,14 @@ function hasContent (cache, integrity) {
   if (!integrity) {
     return Promise.resolve(false)
   }
+
   return withContentSri(cache, integrity, (cpath, sri) => {
     return lstat(cpath).then((stat) => ({ size: stat.size, sri, stat }))
   }).catch((err) => {
     if (err.code === 'ENOENT') {
       return false
     }
+
     if (err.code === 'EPERM') {
       /* istanbul ignore else */
       if (process.platform !== 'win32') {
@@ -135,6 +140,7 @@ function hasContentSync (cache, integrity) {
   if (!integrity) {
     return false
   }
+
   return withContentSriSync(cache, integrity, (cpath, sri) => {
     try {
       const stat = fs.lstatSync(cpath)
@@ -143,6 +149,7 @@ function hasContentSync (cache, integrity) {
       if (err.code === 'ENOENT') {
         return false
       }
+
       if (err.code === 'EPERM') {
         /* istanbul ignore else */
         if (process.platform !== 'win32') {
@@ -167,7 +174,8 @@ function withContentSri (cache, integrity, fn) {
       const cpath = contentPath(cache, digests[0])
       return fn(cpath, digests[0])
     } else {
-      // Can't use race here because a generic error can happen before a ENOENT error, and can happen before a valid result
+      // Can't use race here because a generic error can happen before
+      // a ENOENT error, and can happen before a valid result
       return Promise
         .all(digests.map((meta) => {
           return withContentSri(cache, meta, fn)
@@ -234,6 +242,7 @@ function withContentSriSync (cache, integrity, fn) {
 }
 
 function sizeError (expected, found) {
+  /* eslint-disable-next-line max-len */
   const err = new Error(`Bad data size: expected inserted data to be ${expected} bytes, but got ${found} instead`)
   err.expected = expected
   err.found = found

package/lib/content/write.js

@@ -25,9 +25,11 @@ function write (cache, data, opts = {}) {
   if (algorithms && algorithms.length > 1) {
     throw new Error('opts.algorithms only supports a single algorithm for now')
   }
+
   if (typeof size === 'number' && data.length !== size) {
     return Promise.reject(sizeError(size, data.length))
   }
+
   const sri = ssri.fromData(data, algorithms ? { algorithms } : {})
   if (integrity && !ssri.checkData(data, integrity, opts)) {
     return Promise.reject(checksumError(integrity, sri))
@@ -112,13 +114,17 @@ function pipeToTmp (inputStream, cache, tmpTarget, opts) {
   const hashStream = ssri.integrityStream({
     integrity: opts.integrity,
     algorithms: opts.algorithms,
-    size: opts.size
+    size: opts.size,
+  })
+  hashStream.on('integrity', i => {
+    integrity = i
+  })
+  hashStream.on('size', s => {
+    size = s
   })
-  hashStream.on('integrity', i => { integrity = i })
-  hashStream.on('size', s => { size = s })
 
   const outStream = new fsm.WriteStream(tmpTarget, {
-    flags: 'wx'
+    flags: 'wx',
   })
 
   // NB: this can throw if the hashStream has a problem with
@@ -132,14 +138,16 @@ function pipeToTmp (inputStream, cache, tmpTarget, opts) {
 
   return pipeline.promise()
     .then(() => ({ integrity, size }))
-    .catch(er => rimraf(tmpTarget).then(() => { throw er }))
+    .catch(er => rimraf(tmpTarget).then(() => {
+      throw er
+    }))
 }
 
 function makeTmp (cache, opts) {
   const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
   return fixOwner.mkdirfix(cache, path.dirname(tmpTarget)).then(() => ({
     target: tmpTarget,
-    moved: false
+    moved: false,
   }))
 }
 
@@ -147,6 +155,7 @@ function makeTmpDisposer (tmp) {
   if (tmp.moved) {
     return Promise.resolve()
   }
+
   return rimraf(tmp.target)
 }
 
@@ -166,6 +175,7 @@ function moveToDestination (tmp, cache, sri, opts) {
 }
 
 function sizeError (expected, found) {
+  /* eslint-disable-next-line max-len */
   const err = new Error(`Bad data size: expected inserted data to be ${expected} bytes, but got ${found} instead`)
   err.expected = expected
   err.found = found

package/lib/entry-index.js

@@ -14,7 +14,9 @@ const fixOwner = require('./util/fix-owner')
 const hashToSegments = require('./util/hash-to-segments')
 const indexV = require('../package.json')['cache-version'].index
 const moveFile = require('@npmcli/move-file')
-const rimraf = util.promisify(require('rimraf'))
+const _rimraf = require('rimraf')
+const rimraf = util.promisify(_rimraf)
+rimraf.sync = _rimraf.sync
 
 const appendFile = util.promisify(fs.appendFile)
 const readFile = util.promisify(fs.readFile)
@@ -35,15 +37,32 @@ module.exports.compact = compact
 async function compact (cache, key, matchFn, opts = {}) {
   const bucket = bucketPath(cache, key)
   const entries = await bucketEntries(bucket)
-  // reduceRight because the bottom-most result is the newest
+  const newEntries = []
+  // we loop backwards because the bottom-most result is the newest
   // since we add new entries with appendFile
-  const newEntries = entries.reduceRight((acc, newEntry) => {
-    if (!acc.find((oldEntry) => matchFn(oldEntry, newEntry))) {
-      acc.push(newEntry)
+  for (let i = entries.length - 1; i >= 0; --i) {
+    const entry = entries[i]
+    // a null integrity could mean either a delete was appended
+    // or the user has simply stored an index that does not map
+    // to any content. we determine if the user wants to keep the
+    // null integrity based on the validateEntry function passed in options.
+    // if the integrity is null and no validateEntry is provided, we break
+    // as we consider the null integrity to be a deletion of everything
+    // that came before it.
+    if (entry.integrity === null && !opts.validateEntry) {
+      break
     }
 
-    return acc
-  }, [])
+    // if this entry is valid, and it is either the first entry or
+    // the newEntries array doesn't already include an entry that
+    // matches this one based on the provided matchFn, then we add
+    // it to the beginning of our list
+    if ((!opts.validateEntry || opts.validateEntry(entry) === true) &&
+      (newEntries.length === 0 ||
+        !newEntries.find((oldEntry) => matchFn(oldEntry, entry)))) {
+      newEntries.unshift(entry)
+    }
+  }
 
   const newIndex = '\n' + newEntries.map((entry) => {
     const stringified = JSON.stringify(entry)
@@ -56,7 +75,7 @@ async function compact (cache, key, matchFn, opts = {}) {
     await fixOwner.mkdirfix(cache, path.dirname(target))
     return {
       target,
-      moved: false
+      moved: false,
     }
   }
 
@@ -85,7 +104,12 @@ async function compact (cache, key, matchFn, opts = {}) {
   // write the file atomically
   await disposer(setup(), teardown, write)
 
-  return newEntries.map((entry) => formatEntry(cache, entry, true))
+  // we reverse the list we generated such that the newest
+  // entries come first in order to make looping through them easier
+  // the true passed to formatEntry tells it to keep null
+  // integrity values, if they made it this far it's because
+  // validateEntry returned true, and as such we should return it
+  return newEntries.reverse().map((entry) => formatEntry(cache, entry, true))
 }
 
 module.exports.insert = insert
@@ -98,7 +122,7 @@ function insert (cache, key, integrity, opts = {}) {
     integrity: integrity && ssri.stringify(integrity),
     time: Date.now(),
     size,
-    metadata
+    metadata,
   }
   return fixOwner
     .mkdirfix(cache, path.dirname(bucket))
@@ -110,7 +134,8 @@ function insert (cache, key, integrity, opts = {}) {
       // another while still preserving the string length of the JSON in
       // question. So, we just slap the length in there and verify it on read.
       //
-      // Thanks to @isaacs for the whiteboarding session that ended up with this.
+      // Thanks to @isaacs for the whiteboarding session that ended up with
+      // this.
       return appendFile(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
     })
     .then(() => fixOwner.chownr(cache, bucket))
@@ -118,6 +143,7 @@ function insert (cache, key, integrity, opts = {}) {
       if (err.code === 'ENOENT') {
         return undefined
       }
+
       throw err
       // There's a class of race conditions that happen when things get deleted
       // during fixOwner, or between the two mkdirfix/chownr calls.
@@ -140,7 +166,7 @@ function insertSync (cache, key, integrity, opts = {}) {
     integrity: integrity && ssri.stringify(integrity),
     time: Date.now(),
     size,
-    metadata
+    metadata,
   }
   fixOwner.mkdirfix.sync(cache, path.dirname(bucket))
   const stringified = JSON.stringify(entry)
@@ -201,14 +227,24 @@ function findSync (cache, key) {
 
 module.exports.delete = del
 
-function del (cache, key, opts) {
-  return insert(cache, key, null, opts)
+function del (cache, key, opts = {}) {
+  if (!opts.removeFully) {
+    return insert(cache, key, null, opts)
+  }
+
+  const bucket = bucketPath(cache, key)
+  return rimraf(bucket)
 }
 
 module.exports.delete.sync = delSync
 
-function delSync (cache, key, opts) {
-  return insertSync(cache, key, null, opts)
+function delSync (cache, key, opts = {}) {
+  if (!opts.removeFully) {
+    return insertSync(cache, key, null, opts)
+  }
+
+  const bucket = bucketPath(cache, key)
+  return rimraf.sync(bucket)
 }
 
 module.exports.lsStream = lsStream
@@ -244,7 +280,9 @@ function lsStream (cache) {
                   }
                 }
               }).catch(err => {
-                if (err.code === 'ENOENT') { return undefined }
+                if (err.code === 'ENOENT') {
+                  return undefined
+                }
                 throw err
               })
             })
@@ -291,6 +329,7 @@ function _bucketEntries (data, filter) {
     if (!entry) {
       return
     }
+
     const pieces = entry.split('\t')
     if (!pieces[1] || hashEntry(pieces[1]) !== pieces[0]) {
       // Hash is no good! Corruption or malice? Doesn't matter!
@@ -351,13 +390,14 @@ function formatEntry (cache, entry, keepAll) {
   if (!entry.integrity && !keepAll) {
     return null
   }
+
   return {
     key: entry.key,
     integrity: entry.integrity,
     path: entry.integrity ? contentPath(cache, entry.integrity) : undefined,
     size: entry.size,
     time: entry.time,
-    metadata: entry.metadata
+    metadata: entry.metadata,
   }
 }
 

package/lib/get.js

@@ -0,0 +1,251 @@
+'use strict'
+
+const Collect = require('minipass-collect')
+const Minipass = require('minipass')
+const Pipeline = require('minipass-pipeline')
+const fs = require('fs')
+const util = require('util')
+
+const index = require('./entry-index')
+const memo = require('./memoization')
+const read = require('./content/read')
+
+const writeFile = util.promisify(fs.writeFile)
+
+function getData (cache, key, opts = {}) {
+  const { integrity, memoize, size } = opts
+  const memoized = memo.get(cache, key, opts)
+  if (memoized && memoize !== false) {
+    return Promise.resolve({
+      metadata: memoized.entry.metadata,
+      data: memoized.data,
+      integrity: memoized.entry.integrity,
+      size: memoized.entry.size,
+    })
+  }
+
+  return index.find(cache, key, opts).then((entry) => {
+    if (!entry) {
+      throw new index.NotFoundError(cache, key)
+    }
+
+    return read(cache, entry.integrity, { integrity, size }).then((data) => {
+      if (memoize) {
+        memo.put(cache, entry, data, opts)
+      }
+
+      return {
+        data,
+        metadata: entry.metadata,
+        size: entry.size,
+        integrity: entry.integrity,
+      }
+    })
+  })
+}
+module.exports = getData
+
+function getDataByDigest (cache, key, opts = {}) {
+  const { integrity, memoize, size } = opts
+  const memoized = memo.get.byDigest(cache, key, opts)
+  if (memoized && memoize !== false) {
+    return Promise.resolve(memoized)
+  }
+
+  return read(cache, key, { integrity, size }).then((res) => {
+    if (memoize) {
+      memo.put.byDigest(cache, key, res, opts)
+    }
+    return res
+  })
+}
+module.exports.byDigest = getDataByDigest
+
+function getDataSync (cache, key, opts = {}) {
+  const { integrity, memoize, size } = opts
+  const memoized = memo.get(cache, key, opts)
+
+  if (memoized && memoize !== false) {
+    return {
+      metadata: memoized.entry.metadata,
+      data: memoized.data,
+      integrity: memoized.entry.integrity,
+      size: memoized.entry.size,
+    }
+  }
+  const entry = index.find.sync(cache, key, opts)
+  if (!entry) {
+    throw new index.NotFoundError(cache, key)
+  }
+  const data = read.sync(cache, entry.integrity, {
+    integrity: integrity,
+    size: size,
+  })
+  const res = {
+    metadata: entry.metadata,
+    data: data,
+    size: entry.size,
+    integrity: entry.integrity,
+  }
+  if (memoize) {
+    memo.put(cache, entry, res.data, opts)
+  }
+
+  return res
+}
+
+module.exports.sync = getDataSync
+
+function getDataByDigestSync (cache, digest, opts = {}) {
+  const { integrity, memoize, size } = opts
+  const memoized = memo.get.byDigest(cache, digest, opts)
+
+  if (memoized && memoize !== false) {
+    return memoized
+  }
+
+  const res = read.sync(cache, digest, {
+    integrity: integrity,
+    size: size,
+  })
+  if (memoize) {
+    memo.put.byDigest(cache, digest, res, opts)
+  }
+
+  return res
+}
+module.exports.sync.byDigest = getDataByDigestSync
+
+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 = {}) {
+  const { memoize, size } = opts
+  const memoized = memo.get(cache, key, opts)
+  if (memoized && memoize !== false) {
+    return getMemoizedStream(memoized)
+  }
+
+  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)
+      })
+
+      const src = read.readStream(
+        cache,
+        entry.integrity,
+        { ...opts, size: typeof size !== 'number' ? entry.size : size }
+      )
+
+      if (memoize) {
+        const memoStream = new Collect.PassThrough()
+        memoStream.on('collect', data => memo.put(cache, entry, data, opts))
+        stream.unshift(memoStream)
+      }
+      stream.unshift(src)
+    })
+    .catch((err) => stream.emit('error', err))
+
+  return stream
+}
+
+module.exports.stream = getStream
+
+function getStreamDigest (cache, integrity, opts = {}) {
+  const { memoize } = opts
+  const memoized = memo.get.byDigest(cache, integrity, opts)
+  if (memoized && memoize !== false) {
+    const stream = new Minipass()
+    stream.end(memoized)
+    return stream
+  } else {
+    const stream = read.readStream(cache, integrity, opts)
+    if (!memoize) {
+      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.stream.byDigest = getStreamDigest
+
+function info (cache, key, opts = {}) {
+  const { memoize } = opts
+  const memoized = memo.get(cache, key, opts)
+  if (memoized && memoize !== false) {
+    return Promise.resolve(memoized.entry)
+  } else {
+    return index.find(cache, key)
+  }
+}
+module.exports.info = info
+
+function copy (cache, key, dest, opts = {}) {
+  if (read.copy) {
+    return index.find(cache, key, opts).then((entry) => {
+      if (!entry) {
+        throw new index.NotFoundError(cache, key)
+      }
+      return read.copy(cache, entry.integrity, dest, opts)
+        .then(() => {
+          return {
+            metadata: entry.metadata,
+            size: entry.size,
+            integrity: entry.integrity,
+          }
+        })
+    })
+  }
+
+  return getData(cache, key, opts).then((res) => {
+    return writeFile(dest, res.data).then(() => {
+      return {
+        metadata: res.metadata,
+        size: res.size,
+        integrity: res.integrity,
+      }
+    })
+  })
+}
+module.exports.copy = copy
+
+function copyByDigest (cache, key, dest, opts = {}) {
+  if (read.copy) {
+    return read.copy(cache, key, dest, opts).then(() => key)
+  }
+
+  return getDataByDigest(cache, key, opts).then((res) => {
+    return writeFile(dest, res).then(() => key)
+  })
+}
+module.exports.copy.byDigest = copyByDigest
+
+module.exports.hasContent = read.hasContent

package/{index.js → lib/index.js}

@@ -1,20 +1,19 @@
 'use strict'
 
-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')
-const index = require('./lib/entry-index.js')
+const { clearMemoized } = require('./memoization.js')
+const tmp = require('./util/tmp.js')
+const index = require('./entry-index.js')
 
 module.exports.index = {}
 module.exports.index.compact = index.compact
 module.exports.index.insert = index.insert
 
-module.exports.ls = ls
-module.exports.ls.stream = ls.stream
+module.exports.ls = index.ls
+module.exports.ls.stream = index.lsStream
 
 module.exports.get = get
 module.exports.get.byDigest = get.byDigest

package/lib/memoization.js

@@ -8,7 +8,7 @@ const MAX_AGE = 3 * 60 * 1000
 const MEMOIZED = new LRU({
   max: MAX_SIZE,
   maxAge: MAX_AGE,
-  length: (entry, key) => key.startsWith('key:') ? entry.data.length : entry.length
+  length: (entry, key) => key.startsWith('key:') ? entry.data.length : entry.length,
 })
 
 module.exports.clearMemoized = clearMemoized

package/{put.js → lib/put.js}

@@ -1,15 +1,15 @@
 'use strict'
 
-const index = require('./lib/entry-index')
-const memo = require('./lib/memoization')
-const write = require('./lib/content/write')
+const index = require('./entry-index')
+const memo = require('./memoization')
+const write = require('./content/write')
 const Flush = require('minipass-flush')
 const { PassThrough } = require('minipass-collect')
 const Pipeline = require('minipass-pipeline')
 
 const putOpts = (opts) => ({
   algorithms: ['sha512'],
-  ...opts
+  ...opts,
 })
 
 module.exports = putData
@@ -24,6 +24,7 @@ function putData (cache, key, data, opts = {}) {
         if (memoize) {
           memo.put(cache, entry, data, opts)
         }
+
         return res.integrity
       })
   })
@@ -70,14 +71,16 @@ function putStream (cache, key, opts = {}) {
           if (memoize && memoData) {
             memo.put(cache, entry, memoData, opts)
           }
+
           if (integrity) {
             pipeline.emit('integrity', integrity)
           }
+
           if (size) {
             pipeline.emit('size', size)
           }
         })
-    }
+    },
   }))
 
   return pipeline

package/{rm.js → lib/rm.js}

@@ -2,18 +2,18 @@
 
 const util = require('util')
 
-const index = require('./lib/entry-index')
-const memo = require('./lib/memoization')
+const index = require('./entry-index')
+const memo = require('./memoization')
 const path = require('path')
 const rimraf = util.promisify(require('rimraf'))
-const rmContent = require('./lib/content/rm')
+const rmContent = require('./content/rm')
 
 module.exports = entry
 module.exports.entry = entry
 
-function entry (cache, key) {
+function entry (cache, key, opts) {
   memo.clearMemoized()
-  return index.delete(cache, key)
+  return index.delete(cache, key, opts)
 }
 
 module.exports.content = content

package/lib/util/disposer.js

@@ -11,6 +11,7 @@ function disposer (creatorFn, disposerFn, fn) {
           if (shouldThrow) {
             throw result
           }
+
           return result
         },
         // Disposer fn failed, crash process

package/lib/util/fix-owner.js

@@ -62,6 +62,7 @@ function fixOwner (cache, filepath) {
         if (err.code === 'ENOENT') {
           return null
         }
+
         throw err
       })
     )
@@ -97,6 +98,7 @@ function fixOwnerSync (cache, filepath) {
     if (err.code === 'ENOENT') {
       return null
     }
+
     throw err
   }
 }
@@ -119,6 +121,7 @@ function mkdirfix (cache, p, cb) {
         if (err.code === 'EEXIST') {
           return fixOwner(cache, p).then(() => null)
         }
+
         throw err
       })
   })

package/lib/util/move-file.js

@@ -50,7 +50,7 @@ function moveFile (src, dest) {
       // content should never change for any reason, so make it read-only
       return Promise.all([
         unlink(src),
-        !isWindows && chmod(dest, '0444')
+        !isWindows && chmod(dest, '0444'),
       ])
     })
     .catch(() => {

package/lib/util/tmp.js

@@ -1,21 +1,21 @@
 'use strict'
 
-const util = require('util')
+const fs = require('@npmcli/fs')
 
 const fixOwner = require('./fix-owner')
 const path = require('path')
-const rimraf = util.promisify(require('rimraf'))
-const uniqueFilename = require('unique-filename')
-const { disposer } = require('./disposer')
 
 module.exports.mkdir = mktmpdir
 
 function mktmpdir (cache, opts = {}) {
   const { tmpPrefix } = opts
-  const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), tmpPrefix)
-  return fixOwner.mkdirfix(cache, tmpTarget).then(() => {
-    return tmpTarget
-  })
+  const tmpDir = path.join(cache, 'tmp')
+  return fs.mkdir(tmpDir, { recursive: true, owner: 'inherit' })
+    .then(() => {
+      // do not use path.join(), it drops the trailing / if tmpPrefix is unset
+      const target = `${tmpDir}${path.sep}${tmpPrefix || ''}`
+      return fs.mkdtemp(target, { owner: 'inherit' })
+    })
 }
 
 module.exports.withTmp = withTmp
@@ -25,7 +25,7 @@ function withTmp (cache, opts, cb) {
     cb = opts
     opts = {}
   }
-  return disposer(mktmpdir(cache, opts), rimraf, cb)
+  return fs.withTempDir(path.join(cache, 'tmp'), cb, opts)
 }
 
 module.exports.fix = fixtmpdir

package/lib/verify.js

@@ -24,7 +24,7 @@ const readFile = util.promisify(fs.readFile)
 const verifyOpts = (opts) => ({
   concurrency: 20,
   log: { silly () {} },
-  ...opts
+  ...opts,
 })
 
 module.exports = verify
@@ -40,7 +40,7 @@ function verify (cache, opts) {
     rebuildIndex,
     cleanTmp,
     writeVerifile,
-    markEndTime
+    markEndTime,
   ]
 
   return steps
@@ -57,6 +57,7 @@ function verify (cache, opts) {
           if (!stats.runTime) {
             stats.runTime = {}
           }
+
           stats.runTime[label] = end - start
           return Promise.resolve(stats)
         })
@@ -111,6 +112,7 @@ function garbageCollect (cache, opts) {
     if (opts.filter && !opts.filter(entry)) {
       return
     }
+
     liveContent.add(entry.integrity.toString())
   })
   return new Promise((resolve, reject) => {
@@ -120,14 +122,14 @@ function garbageCollect (cache, opts) {
     return glob(path.join(contentDir, '**'), {
       follow: false,
       nodir: true,
-      nosort: true
+      nosort: true,
     }).then((files) => {
       return Promise.resolve({
         verifiedContent: 0,
         reclaimedCount: 0,
         reclaimedSize: 0,
         badContentCount: 0,
-        keptSize: 0
+        keptSize: 0,
       }).then((stats) =>
         pMap(
           files,
@@ -171,7 +173,7 @@ function verifyContent (filepath, sri) {
     .then((s) => {
       const contentInfo = {
         size: s.size,
-        valid: true
+        valid: true,
       }
       return ssri
         .checkStream(new fsm.ReadStream(filepath), sri)
@@ -179,6 +181,7 @@ function verifyContent (filepath, sri) {
           if (err.code !== 'EINTEGRITY') {
             throw err
           }
+
           return rimraf(filepath).then(() => {
             contentInfo.valid = false
           })
@@ -189,6 +192,7 @@ function verifyContent (filepath, sri) {
       if (err.code === 'ENOENT') {
         return { size: 0, valid: false }
       }
+
       throw err
     })
 }
@@ -199,7 +203,7 @@ function rebuildIndex (cache, opts) {
     const stats = {
       missingContent: 0,
       rejectedEntries: 0,
-      totalEntries: 0
+      totalEntries: 0,
     }
     const buckets = {}
     for (const k in entries) {
@@ -244,7 +248,7 @@ function rebuildBucket (cache, bucket, stats, opts) {
             return index
               .insert(cache, entry.key, entry.integrity, {
                 metadata: entry.metadata,
-                size: entry.size
+                size: entry.size,
               })
               .then(() => {
                 stats.totalEntries++

package/package.json

@@ -1,27 +1,32 @@
 {
   "name": "cacache",
-  "version": "15.1.0",
+  "version": "16.0.0",
   "cache-version": {
     "content": "2",
     "index": "5"
   },
   "description": "Fast, fault-tolerant, cross-platform, disk-based, data-agnostic, content-addressable cache.",
-  "main": "index.js",
+  "main": "lib/index.js",
   "files": [
-    "*.js",
+    "bin",
     "lib"
   ],
   "scripts": {
     "benchmarks": "node test/benchmarks",
-    "lint": "standard",
-    "postrelease": "npm publish",
-    "posttest": "npm run lint",
-    "prepublishOnly": "git push --follow-tags",
-    "prerelease": "npm t",
-    "release": "standard-version -s",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
     "test": "tap",
+    "snap": "tap",
     "coverage": "tap",
-    "test-docker": "docker run -it --rm --name pacotest -v \"$PWD\":/tmp -w /tmp node:latest npm test"
+    "test-docker": "docker run -it --rm --name pacotest -v \"$PWD\":/tmp -w /tmp node:latest npm test",
+    "lint": "eslint '**/*.js'",
+    "npmclilint": "npmcli-lint",
+    "lintfix": "npm run lint -- --fix",
+    "postsnap": "npm run lintfix --",
+    "postlint": "npm-template-check",
+    "template-copy": "npm-template-copy --force",
+    "posttest": "npm run lint"
   },
   "repository": "https://github.com/npm/cacache",
   "keywords": [
@@ -39,49 +44,32 @@
     "disk cache",
     "disk storage"
   ],
-  "author": {
-    "name": "Kat Marchán",
-    "email": "kzm@sykosomatic.org",
-    "twitter": "maybekatz"
-  },
-  "contributors": [
-    {
-      "name": "Charlotte Spencer",
-      "email": "charlottelaspencer@gmail.com",
-      "twitter": "charlotteis"
-    },
-    {
-      "name": "Rebecca Turner",
-      "email": "me@re-becca.org",
-      "twitter": "ReBeccaOrg"
-    }
-  ],
   "license": "ISC",
   "dependencies": {
-    "@npmcli/move-file": "^1.0.1",
+    "@npmcli/fs": "^1.0.0",
+    "@npmcli/move-file": "^1.1.2",
     "chownr": "^2.0.0",
-    "fs-minipass": "^2.0.0",
+    "fs-minipass": "^2.1.0",
     "glob": "^7.1.4",
     "infer-owner": "^1.0.4",
     "lru-cache": "^6.0.0",
     "minipass": "^3.1.1",
     "minipass-collect": "^1.0.2",
     "minipass-flush": "^1.0.5",
-    "minipass-pipeline": "^1.2.2",
-    "mkdirp": "^1.0.3",
+    "minipass-pipeline": "^1.2.4",
+    "mkdirp": "^1.0.4",
     "p-map": "^4.0.0",
     "promise-inflight": "^1.0.1",
     "rimraf": "^3.0.2",
     "ssri": "^8.0.1",
-    "tar": "^6.0.2",
+    "tar": "^6.1.11",
     "unique-filename": "^1.1.1"
   },
   "devDependencies": {
+    "@npmcli/template-oss": "^2.9.2",
     "benchmark": "^2.1.4",
     "chalk": "^4.0.0",
     "require-inject": "^1.4.4",
-    "standard": "^14.3.1",
-    "standard-version": "^7.1.0",
     "tacks": "^1.3.0",
     "tap": "^15.0.9"
   },
@@ -90,6 +78,11 @@
     "test-regex": "test/[^/]*.js"
   },
   "engines": {
-    "node": ">= 10"
-  }
+    "node": "^12.13.0 || ^14.15.0 || >=16"
+  },
+  "templateOSS": {
+    "windowsCI": false,
+    "version": "2.9.2"
+  },
+  "author": "GitHub Inc."
 }

package/get.js

@@ -1,255 +0,0 @@
-'use strict'
-
-const util = require('util')
-const fs = require('fs')
-const index = require('./lib/entry-index')
-const memo = require('./lib/memoization')
-const read = require('./lib/content/read')
-
-const Minipass = require('minipass')
-const Collect = require('minipass-collect')
-const Pipeline = require('minipass-pipeline')
-
-const writeFile = util.promisify(fs.writeFile)
-
-module.exports = function get (cache, key, opts) {
-  return getData(false, cache, key, opts)
-}
-module.exports.byDigest = function getByDigest (cache, digest, opts) {
-  return getData(true, cache, digest, opts)
-}
-
-function getData (byDigest, cache, key, opts = {}) {
-  const { integrity, memoize, size } = opts
-  const memoized = byDigest
-    ? memo.get.byDigest(cache, key, opts)
-    : memo.get(cache, key, opts)
-  if (memoized && memoize !== false) {
-    return Promise.resolve(
-      byDigest
-        ? memoized
-        : {
-          metadata: memoized.entry.metadata,
-          data: memoized.data,
-          integrity: memoized.entry.integrity,
-          size: memoized.entry.size
-        }
-    )
-  }
-  return (byDigest ? Promise.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,
-        size
-      })
-        .then((data) =>
-          byDigest
-            ? data
-            : {
-              data,
-              metadata: entry.metadata,
-              size: entry.size,
-              integrity: entry.integrity
-            }
-        )
-        .then((res) => {
-          if (memoize && byDigest) {
-            memo.put.byDigest(cache, key, res, opts)
-          } else if (memoize) {
-            memo.put(cache, entry, res.data, opts)
-          }
-          return res
-        })
-    }
-  )
-}
-
-module.exports.sync = function get (cache, key, opts) {
-  return getDataSync(false, cache, key, opts)
-}
-module.exports.sync.byDigest = function getByDigest (cache, digest, opts) {
-  return getDataSync(true, cache, digest, opts)
-}
-
-function getDataSync (byDigest, cache, key, opts = {}) {
-  const { integrity, memoize, size } = opts
-  const memoized = byDigest
-    ? memo.get.byDigest(cache, key, opts)
-    : memo.get(cache, key, opts)
-  if (memoized && memoize !== false) {
-    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: integrity,
-    size: size
-  })
-  const res = byDigest
-    ? data
-    : {
-      metadata: entry.metadata,
-      data: data,
-      size: entry.size,
-      integrity: entry.integrity
-    }
-  if (memoize && byDigest) {
-    memo.put.byDigest(cache, key, res, opts)
-  } else if (memoize) {
-    memo.put(cache, entry, res.data, opts)
-  }
-  return res
-}
-
-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 = {}) {
-  const { memoize, size } = opts
-  const memoized = memo.get(cache, key, opts)
-  if (memoized && memoize !== false) {
-    return getMemoizedStream(memoized)
-  }
-
-  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)
-      })
-
-      const src = read.readStream(
-        cache,
-        entry.integrity,
-        { ...opts, size: typeof size !== 'number' ? entry.size : size }
-      )
-
-      if (memoize) {
-        const memoStream = new Collect.PassThrough()
-        memoStream.on('collect', data => memo.put(cache, entry, data, opts))
-        stream.unshift(memoStream)
-      }
-      stream.unshift(src)
-    })
-    .catch((err) => stream.emit('error', err))
-
-  return stream
-}
-
-module.exports.stream.byDigest = getStreamDigest
-
-function getStreamDigest (cache, integrity, opts = {}) {
-  const { memoize } = opts
-  const memoized = memo.get.byDigest(cache, integrity, opts)
-  if (memoized && memoize !== false) {
-    const stream = new Minipass()
-    stream.end(memoized)
-    return stream
-  } else {
-    const stream = read.readStream(cache, integrity, opts)
-    if (!memoize) {
-      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 = {}) {
-  const { memoize } = opts
-  const memoized = memo.get(cache, key, opts)
-  if (memoized && memoize !== false) {
-    return Promise.resolve(memoized.entry)
-  } else {
-    return index.find(cache, key)
-  }
-}
-
-module.exports.hasContent = read.hasContent
-
-function cp (cache, key, dest, opts) {
-  return copy(false, cache, key, 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 = {}) {
-  if (read.copy) {
-    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(() => {
-          return byDigest
-            ? key
-            : {
-              metadata: entry.metadata,
-              size: entry.size,
-              integrity: entry.integrity
-            }
-        })
-    })
-  }
-
-  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/ls.js

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

package/verify.js

@@ -1,3 +0,0 @@
-'use strict'
-
-module.exports = require('./lib/verify')