pnpm 7.9.1 → 7.9.2

package/dist/node_modules/cacache/lib/entry-index.js

@@ -2,13 +2,12 @@
 
 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')
 const uniqueFilename = require('unique-filename')
 
-const { disposer } = require('./util/disposer')
 const contentPath = require('./content/path')
 const fixOwner = require('./util/fix-owner')
 const hashToSegments = require('./util/hash-to-segments')
@@ -18,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}`)
@@ -49,8 +43,9 @@ async function compact (cache, key, matchFn, opts = {}) {
     // 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)
+    if (entry.integrity === null && !opts.validateEntry) {
       break
+    }
 
     // if this entry is valid, and it is either the first entry or
     // the newEntries array doesn't already include an entry that
@@ -58,8 +53,9 @@ async function compact (cache, key, matchFn, opts = {}) {
     // it to the beginning of our list
     if ((!opts.validateEntry || opts.validateEntry(entry) === true) &&
       (newEntries.length === 0 ||
-        !newEntries.find((oldEntry) => matchFn(oldEntry, entry))))
+        !newEntries.find((oldEntry) => matchFn(oldEntry, entry)))) {
       newEntries.unshift(entry)
+    }
   }
 
   const newIndex = '\n' + newEntries.map((entry) => {
@@ -78,12 +74,13 @@ async function compact (cache, key, matchFn, opts = {}) {
   }
 
   const teardown = async (tmp) => {
-    if (!tmp.moved)
+    if (!tmp.moved) {
       return rimraf(tmp.target)
+    }
   }
 
   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
@@ -92,13 +89,19 @@ async function compact (cache, key, matchFn, opts = {}) {
     try {
       await fixOwner.chownr(cache, bucket)
     } catch (err) {
-      if (err.code !== 'ENOENT')
+      if (err.code !== 'ENOENT') {
         throw err
+      }
     }
   }
 
   // write the file atomically
-  await disposer(setup(), teardown, write)
+  const tmp = await setup()
+  try {
+    await write(tmp)
+  } finally {
+    await teardown(tmp)
+  }
 
   // we reverse the list we generated such that the newest
   // entries come first in order to make looping through them easier
@@ -110,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 = {
@@ -120,35 +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
@@ -169,31 +169,33 @@ function insertSync (cache, key, integrity, opts = {}) {
   try {
     fixOwner.chownr.sync(cache, bucket)
   } catch (err) {
-    if (err.code !== 'ENOENT')
+    if (err.code !== 'ENOENT') {
       throw err
+    }
   }
   return formatEntry(cache, entry)
 }
 
 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
-      else
-        throw err
-    })
+  try {
+    const entries = await bucketEntries(bucket)
+    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
+    } else {
+      throw err
+    }
+  }
 }
 
 module.exports.find.sync = findSync
@@ -202,24 +204,27 @@ function findSync (cache, key) {
   const bucket = bucketPath(cache, key)
   try {
     return bucketEntriesSync(bucket).reduce((latest, next) => {
-      if (next && next.key === key)
+      if (next && next.key === key) {
         return formatEntry(cache, next)
-      else
+      } else {
         return latest
+      }
     }, null)
   } catch (err) {
-    if (err.code === 'ENOENT')
+    if (err.code === 'ENOENT') {
       return null
-    else
+    } else {
       throw err
+    }
   }
 }
 
 module.exports.delete = del
 
 function del (cache, key, opts = {}) {
-  if (!opts.removeFully)
+  if (!opts.removeFully) {
     return insert(cache, key, null, opts)
+  }
 
   const bucket = bucketPath(cache, key)
   return rimraf(bucket)
@@ -228,8 +233,9 @@ function del (cache, key, opts = {}) {
 module.exports.delete.sync = delSync
 
 function delSync (cache, key, opts = {}) {
-  if (!opts.removeFully)
+  if (!opts.removeFully) {
     return insertSync(cache, key, null, opts)
+  }
 
   const bucket = bucketPath(cache, key)
   return rimraf.sync(bucket)
@@ -241,65 +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
@@ -312,8 +318,9 @@ function bucketEntriesSync (bucket, filter) {
 function _bucketEntries (data, filter) {
   const entries = []
   data.split('\n').forEach((entry) => {
-    if (!entry)
+    if (!entry) {
       return
+    }
 
     const pieces = entry.split('\t')
     if (!pieces[1] || hashEntry(pieces[1]) !== pieces[0]) {
@@ -328,8 +335,9 @@ function _bucketEntries (data, filter) {
       // Entry is corrupted!
       return
     }
-    if (obj)
+    if (obj) {
       entries.push(obj)
+    }
   })
   return entries
 }
@@ -371,8 +379,9 @@ function hash (str, digest) {
 
 function formatEntry (cache, entry, keepAll) {
   // Treat null digests as deletions. They'll shadow any previous entries.
-  if (!entry.integrity && !keepAll)
+  if (!entry.integrity && !keepAll) {
     return null
+  }
 
   return {
     key: entry.key,
@@ -385,9 +394,10 @@ function formatEntry (cache, entry, keepAll) {
 }
 
 function readdirOrEmpty (dir) {
-  return readdir(dir).catch((err) => {
-    if (err.code === 'ENOENT' || err.code === 'ENOTDIR')
+  return fs.readdir(dir).catch((err) => {
+    if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
       return []
+    }
 
     throw err
   })

package/dist/node_modules/cacache/{get.js → lib/get.js}

@@ -3,57 +3,53 @@
 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('./lib/entry-index')
-const memo = require('./lib/memoization')
-const read = require('./lib/content/read')
+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 = {}) {
+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)
-
-    return read(cache, entry.integrity, { integrity, size }).then((data) => {
-      if (memoize)
-        memo.put(cache, entry, data, opts)
+  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 {
-        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)
+  if (memoized && memoize !== false) {
+    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
 
@@ -70,8 +66,9 @@ function getDataSync (cache, key, opts = {}) {
     }
   }
   const entry = index.find.sync(cache, key, opts)
-  if (!entry)
+  if (!entry) {
     throw new index.NotFoundError(cache, key)
+  }
   const data = read.sync(cache, entry.integrity, {
     integrity: integrity,
     size: size,
@@ -82,8 +79,9 @@ function getDataSync (cache, key, opts = {}) {
     size: entry.size,
     integrity: entry.integrity,
   }
-  if (memoize)
+  if (memoize) {
     memo.put(cache, entry, res.data, opts)
+  }
 
   return res
 }
@@ -94,15 +92,17 @@ function getDataByDigestSync (cache, digest, opts = {}) {
   const { integrity, memoize, size } = opts
   const memoized = memo.get.byDigest(cache, digest, opts)
 
-  if (memoized && memoize !== false)
+  if (memoized && memoize !== false) {
     return memoized
+  }
 
   const res = read.sync(cache, digest, {
     integrity: integrity,
     size: size,
   })
-  if (memoize)
+  if (memoize) {
     memo.put.byDigest(cache, digest, res, opts)
+  }
 
   return res
 }
@@ -122,39 +122,41 @@ const getMemoizedStream = (memoized) => {
 function getStream (cache, key, opts = {}) {
   const { memoize, size } = opts
   const memoized = memo.get(cache, key, opts)
-  if (memoized && memoize !== false)
+  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)
+  // 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
 }
@@ -170,8 +172,9 @@ function getStreamDigest (cache, integrity, opts = {}) {
     return stream
   } else {
     const stream = read.readStream(cache, integrity, opts)
-    if (!memoize)
+    if (!memoize) {
       return stream
+    }
 
     const memoStream = new Collect.PassThrough()
     memoStream.on('collect', data => memo.put.byDigest(
@@ -189,49 +192,34 @@ module.exports.stream.byDigest = getStreamDigest
 function info (cache, key, opts = {}) {
   const { memoize } = opts
   const memoized = memo.get(cache, key, opts)
-  if (memoized && memoize !== false)
+  if (memoized && memoize !== false) {
     return Promise.resolve(memoized.entry)
-  else
+  } 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,
-          }
-        })
-    })
+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,
   }
-
-  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)
+module.exports.copy = copy
 
-  return getDataByDigest(cache, key, opts).then((res) => {
-    return writeFile(dest, res).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