pnpm 7.9.1 → 7.9.2

package/dist/node_modules/cacache/{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/dist/node_modules/cacache/lib/memoization.js

@@ -2,13 +2,11 @@
 
 const LRU = require('lru-cache')
 
-const MAX_SIZE = 50 * 1024 * 1024 // 50MB
-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,
+  max: 500,
+  maxSize: 50 * 1024 * 1024, // 50MB
+  ttl: 3 * 60 * 1000, // 3 minutes
+  sizeCalculation: (entry, key) => key.startsWith('key:') ? entry.data.length : entry.length,
 })
 
 module.exports.clearMemoized = clearMemoized
@@ -18,7 +16,7 @@ function clearMemoized () {
   MEMOIZED.forEach((v, k) => {
     old[k] = v
   })
-  MEMOIZED.reset()
+  MEMOIZED.clear()
   return old
 }
 
@@ -62,12 +60,13 @@ class ObjProxy {
 }
 
 function pickMem (opts) {
-  if (!opts || !opts.memoize)
+  if (!opts || !opts.memoize) {
     return MEMOIZED
-  else if (opts.memoize.get && opts.memoize.set)
+  } else if (opts.memoize.get && opts.memoize.set) {
     return opts.memoize
-  else if (typeof opts.memoize === 'object')
+  } else if (typeof opts.memoize === 'object') {
     return new ObjProxy(opts.memoize)
-  else
+  } else {
     return MEMOIZED
+  }
 }

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

@@ -1,8 +1,8 @@
 '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')
@@ -14,19 +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
@@ -36,6 +33,7 @@ function putStream (cache, key, opts = {}) {
   opts = putOpts(opts)
   let integrity
   let size
+  let error
 
   let memoData
   const pipeline = new Pipeline()
@@ -57,25 +55,24 @@ function putStream (cache, key, opts = {}) {
     .on('size', (s) => {
       size = s
     })
+    .on('error', (err) => {
+      error = err
+    })
 
   pipeline.push(contentStream)
 
   // 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 () {
-      return index
-        .insert(cache, key, integrity, { ...opts, size })
-        .then((entry) => {
-          if (memoize && memoData)
-            memo.put(cache, entry, memoData, opts)
-
-          if (integrity)
-            pipeline.emit('integrity', integrity)
-
-          if (size)
-            pipeline.emit('size', size)
-        })
+    async flush () {
+      if (!error) {
+        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/dist/node_modules/cacache/{rm.js → lib/rm.js}

@@ -2,11 +2,11 @@
 
 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

package/dist/node_modules/cacache/lib/util/fix-owner.js

@@ -33,38 +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
-
-    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
-      })
-    )
-  })
+  // 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
+    })
+  )
 }
 
 module.exports.chownr.sync = fixOwnerSync
@@ -93,8 +93,9 @@ function fixOwnerSync (cache, filepath) {
     )
   } catch (err) {
     // only catch ENOENT, any other error is a problem.
-    if (err.code === 'ENOENT')
+    if (err.code === 'ENOENT') {
       return null
+    }
 
     throw err
   }
@@ -102,24 +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
@@ -136,7 +138,8 @@ function mkdirfixSync (cache, p) {
     if (err.code === 'EEXIST') {
       fixOwnerSync(cache, p)
       return null
-    } else
+    } else {
       throw err
+    }
   }
 }

package/dist/node_modules/cacache/lib/util/move-file.js

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

package/dist/node_modules/cacache/lib/util/tmp.js

@@ -7,15 +7,13 @@ const path = require('path')
 
 module.exports.mkdir = mktmpdir
 
-function mktmpdir (cache, opts = {}) {
+async function mktmpdir (cache, opts = {}) {
   const { tmpPrefix } = opts
   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' })
-    })
+  await fs.mkdir(tmpDir, { recursive: true, owner: 'inherit' })
+  // 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