cacache 16.0.7 → 16.1.2

package/lib/entry-index.js

@@ -2,7 +2,7 @@
 
 const util = require('util')
 const crypto = require('crypto')
-const fs = require('fs')
+const fs = require('@npmcli/fs')
 const Minipass = require('minipass')
 const path = require('path')
 const ssri = require('ssri')
@@ -17,11 +17,6 @@ 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)
-const readdir = util.promisify(fs.readdir)
-const writeFile = util.promisify(fs.writeFile)
-
 module.exports.NotFoundError = class NotFoundError extends Error {
   constructor (cache, key) {
     super(`No cache entry for ${key} found in ${cache}`)
@@ -85,7 +80,7 @@ async function compact (cache, key, matchFn, opts = {}) {
   }
 
   const write = async (tmp) => {
-    await writeFile(tmp.target, newIndex, { flag: 'wx' })
+    await fs.writeFile(tmp.target, newIndex, { flag: 'wx' })
     await fixOwner.mkdirfix(cache, path.dirname(bucket))
     // we use @npmcli/move-file directly here because we
     // want to overwrite the existing file
@@ -118,7 +113,7 @@ async function compact (cache, key, matchFn, opts = {}) {
 
 module.exports.insert = insert
 
-function insert (cache, key, integrity, opts = {}) {
+async function insert (cache, key, integrity, opts = {}) {
   const { metadata, size } = opts
   const bucket = bucketPath(cache, key)
   const entry = {
@@ -128,36 +123,32 @@ function insert (cache, key, integrity, opts = {}) {
     size,
     metadata,
   }
-  return fixOwner
-    .mkdirfix(cache, path.dirname(bucket))
-    .then(() => {
-      const stringified = JSON.stringify(entry)
-      // NOTE - Cleverness ahoy!
-      //
-      // This works because it's tremendously unlikely for an entry to corrupt
-      // 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.
-      return appendFile(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
-    })
-    .then(() => fixOwner.chownr(cache, bucket))
-    .catch((err) => {
-      if (err.code === 'ENOENT') {
-        return undefined
-      }
+  try {
+    await fixOwner.mkdirfix(cache, path.dirname(bucket))
+    const stringified = JSON.stringify(entry)
+    // NOTE - Cleverness ahoy!
+    //
+    // This works because it's tremendously unlikely for an entry to corrupt
+    // 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.
+    await fs.appendFile(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
+    await fixOwner.chownr(cache, bucket)
+  } catch (err) {
+    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.
-      //
-      // It's perfectly fine to just not bother in those cases and lie
-      // that the index entry was written. Because it's a cache.
-    })
-    .then(() => {
-      return formatEntry(cache, entry)
-    })
+    throw err
+    // There's a class of race conditions that happen when things get deleted
+    // during fixOwner, or between the two mkdirfix/chownr calls.
+    //
+    // It's perfectly fine to just not bother in those cases and lie
+    // that the index entry was written. Because it's a cache.
+  }
+  return formatEntry(cache, entry)
 }
 
 module.exports.insert.sync = insertSync
@@ -187,25 +178,24 @@ function insertSync (cache, key, integrity, opts = {}) {
 
 module.exports.find = find
 
-function find (cache, key) {
+async function find (cache, key) {
   const bucket = bucketPath(cache, key)
-  return bucketEntries(bucket)
-    .then((entries) => {
-      return entries.reduce((latest, next) => {
-        if (next && next.key === key) {
-          return formatEntry(cache, next)
-        } else {
-          return latest
-        }
-      }, null)
-    })
-    .catch((err) => {
-      if (err.code === 'ENOENT') {
-        return null
+  try {
+    const entries = await bucketEntries(bucket)
+    return entries.reduce((latest, next) => {
+      if (next && next.key === key) {
+        return formatEntry(cache, next)
       } else {
-        throw err
+        return latest
       }
-    })
+    }, null)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return null
+    } else {
+      throw err
+    }
+  }
 }
 
 module.exports.find.sync = findSync
@@ -257,67 +247,65 @@ function lsStream (cache) {
   const indexDir = bucketDir(cache)
   const stream = new Minipass({ objectMode: true })
 
-  readdirOrEmpty(indexDir).then(buckets => Promise.all(
-    buckets.map(bucket => {
+  // Set all this up to run on the stream and then just return the stream
+  Promise.resolve().then(async () => {
+    const buckets = await readdirOrEmpty(indexDir)
+    await Promise.all(buckets.map(async (bucket) => {
       const bucketPath = path.join(indexDir, bucket)
-      return readdirOrEmpty(bucketPath).then(subbuckets => Promise.all(
-        subbuckets.map(subbucket => {
-          const subbucketPath = path.join(bucketPath, subbucket)
-
-          // "/cachename/<bucket 0xFF>/<bucket 0xFF>./*"
-          return readdirOrEmpty(subbucketPath).then(entries => Promise.all(
-            entries.map(entry => {
-              const entryPath = path.join(subbucketPath, entry)
-              return bucketEntries(entryPath).then(entries =>
-                // using a Map here prevents duplicate keys from
-                // showing up twice, I guess?
-                entries.reduce((acc, entry) => {
-                  acc.set(entry.key, entry)
-                  return acc
-                }, new Map())
-              ).then(reduced => {
-                // reduced is a map of key => entry
-                for (const entry of reduced.values()) {
-                  const formatted = formatEntry(cache, entry)
-                  if (formatted) {
-                    stream.write(formatted)
-                  }
-                }
-              }).catch(err => {
-                if (err.code === 'ENOENT') {
-                  return undefined
-                }
-                throw err
-              })
-            })
-          ))
-        })
-      ))
-    })
-  ))
-    .then(
-      () => stream.end(),
-      err => stream.emit('error', err)
-    )
+      const subbuckets = await readdirOrEmpty(bucketPath)
+      await Promise.all(subbuckets.map(async (subbucket) => {
+        const subbucketPath = path.join(bucketPath, subbucket)
+
+        // "/cachename/<bucket 0xFF>/<bucket 0xFF>./*"
+        const subbucketEntries = await readdirOrEmpty(subbucketPath)
+        await Promise.all(subbucketEntries.map(async (entry) => {
+          const entryPath = path.join(subbucketPath, entry)
+          try {
+            const entries = await bucketEntries(entryPath)
+            // using a Map here prevents duplicate keys from showing up
+            // twice, I guess?
+            const reduced = entries.reduce((acc, entry) => {
+              acc.set(entry.key, entry)
+              return acc
+            }, new Map())
+            // reduced is a map of key => entry
+            for (const entry of reduced.values()) {
+              const formatted = formatEntry(cache, entry)
+              if (formatted) {
+                stream.write(formatted)
+              }
+            }
+          } catch (err) {
+            if (err.code === 'ENOENT') {
+              return undefined
+            }
+            throw err
+          }
+        }))
+      }))
+    }))
+    stream.end()
+    return stream
+  }).catch(err => stream.emit('error', err))
 
   return stream
 }
 
 module.exports.ls = ls
 
-function ls (cache) {
-  return lsStream(cache).collect().then(entries =>
-    entries.reduce((acc, xs) => {
-      acc[xs.key] = xs
-      return acc
-    }, {})
-  )
+async function ls (cache) {
+  const entries = await lsStream(cache).collect()
+  return entries.reduce((acc, xs) => {
+    acc[xs.key] = xs
+    return acc
+  }, {})
 }
 
 module.exports.bucketEntries = bucketEntries
 
-function bucketEntries (bucket, filter) {
-  return readFile(bucket, 'utf8').then((data) => _bucketEntries(data, filter))
+async function bucketEntries (bucket, filter) {
+  const data = await fs.readFile(bucket, 'utf8')
+  return _bucketEntries(data, filter)
 }
 
 module.exports.bucketEntries.sync = bucketEntriesSync
@@ -406,7 +394,7 @@ function formatEntry (cache, entry, keepAll) {
 }
 
 function readdirOrEmpty (dir) {
-  return readdir(dir).catch((err) => {
+  return fs.readdir(dir).catch((err) => {
     if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
       return []
     }

package/lib/get.js

@@ -8,52 +8,48 @@ const index = require('./entry-index')
 const memo = require('./memoization')
 const read = require('./content/read')
 
-function getData (cache, key, opts = {}) {
+async function getData (cache, key, opts = {}) {
   const { integrity, memoize, size } = opts
   const memoized = memo.get(cache, key, opts)
   if (memoized && memoize !== false) {
-    return Promise.resolve({
+    return {
       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)
-    }
+  const entry = await index.find(cache, key, opts)
+  if (!entry) {
+    throw new index.NotFoundError(cache, key)
+  }
+  const data = await read(cache, entry.integrity, { integrity, size })
+  if (memoize) {
+    memo.put(cache, entry, data, opts)
+  }
 
-    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,
-      }
-    })
-  })
+  return {
+    data,
+    metadata: entry.metadata,
+    size: entry.size,
+    integrity: entry.integrity,
+  }
 }
 module.exports = getData
 
-function getDataByDigest (cache, key, opts = {}) {
+async 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 memoized
   }
 
-  return read(cache, key, { integrity, size }).then((res) => {
-    if (memoize) {
-      memo.put.byDigest(cache, key, res, opts)
-    }
-    return res
-  })
+  const res = await read(cache, key, { integrity, size })
+  if (memoize) {
+    memo.put.byDigest(cache, key, res, opts)
+  }
+  return res
 }
 module.exports.byDigest = getDataByDigest
 
@@ -131,36 +127,36 @@ function getStream (cache, key, opts = {}) {
   }
 
   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)
+  // Set all this up to run on the stream and then just return the stream
+  Promise.resolve().then(async () => {
+    const entry = await index.find(cache, key)
+    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)
     })
-    .catch((err) => stream.emit('error', err))
+
+    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)
+    return stream
+  }).catch((err) => stream.emit('error', err))
 
   return stream
 }
@@ -204,27 +200,26 @@ function info (cache, key, opts = {}) {
 }
 module.exports.info = info
 
-function copy (cache, key, dest, opts = {}) {
-  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,
-        }
-      })
-  })
+async function copy (cache, key, dest, opts = {}) {
+  const entry = await index.find(cache, key, opts)
+  if (!entry) {
+    throw new index.NotFoundError(cache, key)
+  }
+  await read.copy(cache, entry.integrity, dest, opts)
+  return {
+    metadata: entry.metadata,
+    size: entry.size,
+    integrity: entry.integrity,
+  }
 }
 
 module.exports.copy = copy
 
-function copyByDigest (cache, key, dest, opts = {}) {
-  return read.copy(cache, key, dest, opts).then(() => key)
+async function copyByDigest (cache, key, dest, opts = {}) {
+  await read.copy(cache, key, dest, opts)
+  return key
 }
+
 module.exports.copy.byDigest = copyByDigest
 
 module.exports.hasContent = read.hasContent

package/lib/put.js

@@ -14,20 +14,16 @@ const putOpts = (opts) => ({
 
 module.exports = putData
 
-function putData (cache, key, data, opts = {}) {
+async function putData (cache, key, data, opts = {}) {
   const { memoize } = opts
   opts = putOpts(opts)
-  return write(cache, data, opts).then((res) => {
-    return index
-      .insert(cache, key, res.integrity, { ...opts, size: res.size })
-      .then((entry) => {
-        if (memoize) {
-          memo.put(cache, entry, data, opts)
-        }
+  const res = await write(cache, data, opts)
+  const entry = await index.insert(cache, key, res.integrity, { ...opts, size: res.size })
+  if (memoize) {
+    memo.put(cache, entry, data, opts)
+  }
 
-        return res.integrity
-      })
-  })
+  return res.integrity
 }
 
 module.exports.stream = putStream
@@ -68,17 +64,14 @@ function putStream (cache, key, opts = {}) {
   // last but not least, we write the index and emit hash and size,
   // and memoize if we're doing that
   pipeline.push(new Flush({
-    flush () {
+    async flush () {
       if (!error) {
-        return index
-          .insert(cache, key, integrity, { ...opts, size })
-          .then((entry) => {
-            if (memoize && memoData) {
-              memo.put(cache, entry, memoData, opts)
-            }
-            pipeline.emit('integrity', integrity)
-            pipeline.emit('size', size)
-          })
+        const entry = await index.insert(cache, key, integrity, { ...opts, size })
+        if (memoize && memoData) {
+          memo.put(cache, entry, memoData, opts)
+        }
+        pipeline.emit('integrity', integrity)
+        pipeline.emit('size', size)
       }
     },
   }))

package/lib/util/fix-owner.js

@@ -33,40 +33,38 @@ const getSelf = () => {
 
 module.exports.chownr = fixOwner
 
-function fixOwner (cache, filepath) {
+async function fixOwner (cache, filepath) {
   if (!process.getuid) {
     // This platform doesn't need ownership fixing
-    return Promise.resolve()
+    return
   }
 
   getSelf()
   if (self.uid !== 0) {
     // almost certainly can't chown anyway
-    return Promise.resolve()
+    return
   }
 
-  return Promise.resolve(inferOwner(cache)).then((owner) => {
-    const { uid, gid } = owner
+  const { uid, gid } = await inferOwner(cache)
 
-    // No need to override if it's already what we used.
-    if (self.uid === uid && self.gid === gid) {
-      return
-    }
+  // No need to override if it's already what we used.
+  if (self.uid === uid && self.gid === gid) {
+    return
+  }
 
-    return inflight('fixOwner: fixing ownership on ' + filepath, () =>
-      chownr(
-        filepath,
-        typeof uid === 'number' ? uid : self.uid,
-        typeof gid === 'number' ? gid : self.gid
-      ).catch((err) => {
-        if (err.code === 'ENOENT') {
-          return null
-        }
-
-        throw err
-      })
-    )
-  })
+  return inflight('fixOwner: fixing ownership on ' + filepath, () =>
+    chownr(
+      filepath,
+      typeof uid === 'number' ? uid : self.uid,
+      typeof gid === 'number' ? gid : self.gid
+    ).catch((err) => {
+      if (err.code === 'ENOENT') {
+        return null
+      }
+
+      throw err
+    })
+  )
 }
 
 module.exports.chownr.sync = fixOwnerSync
@@ -105,26 +103,25 @@ function fixOwnerSync (cache, filepath) {
 
 module.exports.mkdirfix = mkdirfix
 
-function mkdirfix (cache, p, cb) {
+async function mkdirfix (cache, p, cb) {
   // we have to infer the owner _before_ making the directory, even though
   // we aren't going to use the results, since the cache itself might not
   // exist yet.  If we mkdirp it, then our current uid/gid will be assumed
   // to be correct if it creates the cache folder in the process.
-  return Promise.resolve(inferOwner(cache)).then(() => {
-    return mkdirp(p)
-      .then((made) => {
-        if (made) {
-          return fixOwner(cache, made).then(() => made)
-        }
-      })
-      .catch((err) => {
-        if (err.code === 'EEXIST') {
-          return fixOwner(cache, p).then(() => null)
-        }
-
-        throw err
-      })
-  })
+  await inferOwner(cache)
+  try {
+    const made = await mkdirp(p)
+    if (made) {
+      await fixOwner(cache, made)
+      return made
+    }
+  } catch (err) {
+    if (err.code === 'EEXIST') {
+      await fixOwner(cache, p)
+      return null
+    }
+    throw err
+  }
 }
 
 module.exports.mkdirfix.sync = mkdirfixSync