pxnpm 5.0.0 → 6.0.0

package/dist/node_modules/cacache/lib/content/read.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const fs = require('@npmcli/fs')
+const fs = require('fs/promises')
 const fsm = require('fs-minipass')
 const ssri = require('ssri')
 const contentPath = require('./path')
@@ -13,18 +13,20 @@ async function read (cache, integrity, opts = {}) {
   const { size } = opts
   const { stat, cpath, sri } = await withContentSri(cache, integrity, async (cpath, sri) => {
     // get size
-    const stat = await fs.stat(cpath)
+    const stat = size ? { size } : await fs.stat(cpath)
     return { stat, cpath, sri }
   })
-  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()
   }
 
   const data = await fs.readFile(cpath, { encoding: null })
+
+  if (stat.size !== data.length) {
+    throw sizeError(stat.size, data.length)
+  }
+
   if (!ssri.checkData(data, sri)) {
     throw integrityError(sri, cpath)
   }
@@ -46,24 +48,6 @@ const readPipeline = (cpath, size, sri, stream) => {
   return stream
 }
 
-module.exports.sync = readSync
-
-function readSync (cache, integrity, opts = {}) {
-  const { size } = opts
-  return withContentSriSync(cache, integrity, (cpath, sri) => {
-    const data = fs.readFileSync(cpath, { encoding: null })
-    if (typeof size === 'number' && size !== data.length) {
-      throw sizeError(size, data.length)
-    }
-
-    if (ssri.checkData(data, sri)) {
-      return data
-    }
-
-    throw integrityError(sri, cpath)
-  })
-}
-
 module.exports.stream = readStream
 module.exports.readStream = readStream
 
@@ -73,13 +57,10 @@ function readStream (cache, integrity, opts = {}) {
   // Set all this up to run on the stream and then just return the stream
   Promise.resolve().then(async () => {
     const { stat, cpath, sri } = await withContentSri(cache, integrity, async (cpath, sri) => {
-      // just stat to ensure it exists
-      const stat = await fs.stat(cpath)
+      // get size
+      const stat = size ? { size } : await fs.stat(cpath)
       return { stat, cpath, sri }
     })
-    if (typeof size === 'number' && size !== stat.size) {
-      return stream.emit('error', sizeError(size, stat.size))
-    }
 
     return readPipeline(cpath, stat.size, sri, stream)
   }).catch(err => stream.emit('error', err))
@@ -88,20 +69,13 @@ function readStream (cache, integrity, opts = {}) {
 }
 
 module.exports.copy = copy
-module.exports.copy.sync = copySync
 
 function copy (cache, integrity, dest) {
-  return withContentSri(cache, integrity, (cpath, sri) => {
+  return withContentSri(cache, integrity, (cpath) => {
     return fs.copyFile(cpath, dest)
   })
 }
 
-function copySync (cache, integrity, dest) {
-  return withContentSriSync(cache, integrity, (cpath, sri) => {
-    return fs.copyFileSync(cpath, dest)
-  })
-}
-
 module.exports.hasContent = hasContent
 
 async function hasContent (cache, integrity) {
@@ -130,34 +104,6 @@ async function hasContent (cache, integrity) {
   }
 }
 
-module.exports.hasContent.sync = hasContentSync
-
-function hasContentSync (cache, integrity) {
-  if (!integrity) {
-    return false
-  }
-
-  return withContentSriSync(cache, integrity, (cpath, sri) => {
-    try {
-      const stat = fs.statSync(cpath)
-      return { size: stat.size, sri, stat }
-    } catch (err) {
-      if (err.code === 'ENOENT') {
-        return false
-      }
-
-      if (err.code === 'EPERM') {
-        /* istanbul ignore else */
-        if (process.platform !== 'win32') {
-          throw err
-        } else {
-          return false
-        }
-      }
-    }
-  })
-}
-
 async function withContentSri (cache, integrity, fn) {
   const sri = ssri.parse(integrity)
   // If `integrity` has multiple entries, pick the first digest
@@ -201,28 +147,6 @@ async function withContentSri (cache, integrity, fn) {
   }
 }
 
-function withContentSriSync (cache, integrity, fn) {
-  const sri = ssri.parse(integrity)
-  // If `integrity` has multiple entries, pick the first digest
-  // with available local data.
-  const algo = sri.pickAlgorithm()
-  const digests = sri[algo]
-  if (digests.length <= 1) {
-    const cpath = contentPath(cache, digests[0])
-    return fn(cpath, digests[0])
-  } else {
-    let lastErr = null
-    for (const meta of digests) {
-      try {
-        return withContentSriSync(cache, meta, fn)
-      } catch (err) {
-        lastErr = err
-      }
-    }
-    throw lastErr
-  }
-}
-
 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`)

package/dist/node_modules/cacache/lib/content/rm.js

@@ -1,10 +1,8 @@
 'use strict'
 
-const util = require('util')
-
+const fs = require('fs/promises')
 const contentPath = require('./path')
 const { hasContent } = require('./read')
-const rimraf = util.promisify(require('rimraf'))
 
 module.exports = rm
 
@@ -12,7 +10,7 @@ async function rm (cache, integrity) {
   const content = await hasContent(cache, integrity)
   // ~pretty~ sure we can't end up with a content lacking sri, but be safe
   if (content && content.sri) {
-    await rimraf(contentPath(cache, content.sri))
+    await fs.rm(contentPath(cache, content.sri), { recursive: true, force: true })
     return true
   } else {
     return false

package/dist/node_modules/cacache/lib/content/write.js

@@ -1,28 +1,25 @@
 'use strict'
 
 const events = require('events')
-const util = require('util')
 
 const contentPath = require('./path')
-const fixOwner = require('../util/fix-owner')
-const fs = require('@npmcli/fs')
-const moveFile = require('../util/move-file')
-const Minipass = require('minipass')
+const fs = require('fs/promises')
+const { moveFile } = require('@npmcli/fs')
+const { Minipass } = require('minipass')
 const Pipeline = require('minipass-pipeline')
 const Flush = require('minipass-flush')
 const path = require('path')
-const rimraf = util.promisify(require('rimraf'))
 const ssri = require('ssri')
 const uniqueFilename = require('unique-filename')
 const fsm = require('fs-minipass')
 
 module.exports = write
 
+// Cache of move operations in process so we don't duplicate
+const moveOperations = new Map()
+
 async function write (cache, data, opts = {}) {
   const { algorithms, size, integrity } = 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) {
     throw sizeError(size, data.length)
@@ -33,16 +30,19 @@ async function write (cache, data, opts = {}) {
     throw checksumError(integrity, sri)
   }
 
-  const tmp = await makeTmp(cache, opts)
-  try {
-    await fs.writeFile(tmp.target, data, { flag: 'wx' })
-    await moveToDestination(tmp, cache, sri, opts)
-    return { integrity: sri, size: data.length }
-  } finally {
-    if (!tmp.moved) {
-      await rimraf(tmp.target)
+  for (const algo in sri) {
+    const tmp = await makeTmp(cache, opts)
+    const hash = sri[algo].toString()
+    try {
+      await fs.writeFile(tmp.target, data, { flag: 'wx' })
+      await moveToDestination(tmp, cache, hash, opts)
+    } finally {
+      if (!tmp.moved) {
+        await fs.rm(tmp.target, { recursive: true, force: true })
+      }
     }
   }
+  return { integrity: sri, size: data.length }
 }
 
 module.exports.stream = writeStream
@@ -67,6 +67,7 @@ class CacacheWriteStream extends Flush {
         this.cache,
         this.opts
       )
+      this.handleContentP.catch(error => this.emit('error', error))
     }
     return this.inputStream.write(chunk, encoding, cb)
   }
@@ -111,7 +112,7 @@ async function handleContent (inputStream, cache, opts) {
     return res
   } finally {
     if (!tmp.moved) {
-      await rimraf(tmp.target)
+      await fs.rm(tmp.target, { recursive: true, force: true })
     }
   }
 }
@@ -152,21 +153,37 @@ async function pipeToTmp (inputStream, cache, tmpTarget, opts) {
 
 async function makeTmp (cache, opts) {
   const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
-  await fixOwner.mkdirfix(cache, path.dirname(tmpTarget))
+  await fs.mkdir(path.dirname(tmpTarget), { recursive: true })
   return {
     target: tmpTarget,
     moved: false,
   }
 }
 
-async function moveToDestination (tmp, cache, sri, opts) {
+async function moveToDestination (tmp, cache, sri) {
   const destination = contentPath(cache, sri)
   const destDir = path.dirname(destination)
-
-  await fixOwner.mkdirfix(cache, destDir)
-  await moveFile(tmp.target, destination)
-  tmp.moved = true
-  await fixOwner.chownr(cache, destination)
+  if (moveOperations.has(destination)) {
+    return moveOperations.get(destination)
+  }
+  moveOperations.set(
+    destination,
+    fs.mkdir(destDir, { recursive: true })
+      .then(async () => {
+        await moveFile(tmp.target, destination, { overwrite: false })
+        tmp.moved = true
+        return tmp.moved
+      })
+      .catch(err => {
+        if (!err.message.startsWith('The destination file exists')) {
+          throw Object.assign(err, { code: 'EEXIST' })
+        }
+      }).finally(() => {
+        moveOperations.delete(destination)
+      })
+
+  )
+  return moveOperations.get(destination)
 }
 
 function sizeError (expected, found) {

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

@@ -1,21 +1,23 @@
 'use strict'
 
-const util = require('util')
 const crypto = require('crypto')
-const fs = require('@npmcli/fs')
-const Minipass = require('minipass')
+const {
+  appendFile,
+  mkdir,
+  readFile,
+  readdir,
+  rm,
+  writeFile,
+} = require('fs/promises')
+const { Minipass } = require('minipass')
 const path = require('path')
 const ssri = require('ssri')
 const uniqueFilename = require('unique-filename')
 
 const contentPath = require('./content/path')
-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 = require('rimraf')
-const rimraf = util.promisify(_rimraf)
-rimraf.sync = _rimraf.sync
+const { moveFile } = require('@npmcli/fs')
 
 module.exports.NotFoundError = class NotFoundError extends Error {
   constructor (cache, key) {
@@ -66,7 +68,7 @@ async function compact (cache, key, matchFn, opts = {}) {
 
   const setup = async () => {
     const target = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
-    await fixOwner.mkdirfix(cache, path.dirname(target))
+    await mkdir(path.dirname(target), { recursive: true })
     return {
       target,
       moved: false,
@@ -75,24 +77,17 @@ async function compact (cache, key, matchFn, opts = {}) {
 
   const teardown = async (tmp) => {
     if (!tmp.moved) {
-      return rimraf(tmp.target)
+      return rm(tmp.target, { recursive: true, force: true })
     }
   }
 
   const write = async (tmp) => {
-    await fs.writeFile(tmp.target, newIndex, { flag: 'wx' })
-    await fixOwner.mkdirfix(cache, path.dirname(bucket))
+    await writeFile(tmp.target, newIndex, { flag: 'wx' })
+    await mkdir(path.dirname(bucket), { recursive: true })
     // we use @npmcli/move-file directly here because we
     // want to overwrite the existing file
     await moveFile(tmp.target, bucket)
     tmp.moved = true
-    try {
-      await fixOwner.chownr(cache, bucket)
-    } catch (err) {
-      if (err.code !== 'ENOENT') {
-        throw err
-      }
-    }
   }
 
   // write the file atomically
@@ -114,17 +109,17 @@ async function compact (cache, key, matchFn, opts = {}) {
 module.exports.insert = insert
 
 async function insert (cache, key, integrity, opts = {}) {
-  const { metadata, size } = opts
+  const { metadata, size, time } = opts
   const bucket = bucketPath(cache, key)
   const entry = {
     key,
     integrity: integrity && ssri.stringify(integrity),
-    time: Date.now(),
+    time: time || Date.now(),
     size,
     metadata,
   }
   try {
-    await fixOwner.mkdirfix(cache, path.dirname(bucket))
+    await mkdir(path.dirname(bucket), { recursive: true })
     const stringified = JSON.stringify(entry)
     // NOTE - Cleverness ahoy!
     //
@@ -134,44 +129,13 @@ async function insert (cache, key, integrity, opts = {}) {
     //
     // 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)
+    await appendFile(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
   } 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.
-  }
-  return formatEntry(cache, entry)
-}
-
-module.exports.insert.sync = insertSync
-
-function insertSync (cache, key, integrity, opts = {}) {
-  const { metadata, size } = opts
-  const bucket = bucketPath(cache, key)
-  const entry = {
-    key,
-    integrity: integrity && ssri.stringify(integrity),
-    time: Date.now(),
-    size,
-    metadata,
-  }
-  fixOwner.mkdirfix.sync(cache, path.dirname(bucket))
-  const stringified = JSON.stringify(entry)
-  fs.appendFileSync(bucket, `\n${hashEntry(stringified)}\t${stringified}`)
-  try {
-    fixOwner.chownr.sync(cache, bucket)
-  } catch (err) {
-    if (err.code !== 'ENOENT') {
-      throw err
-    }
   }
   return formatEntry(cache, entry)
 }
@@ -198,27 +162,6 @@ async function find (cache, key) {
   }
 }
 
-module.exports.find.sync = findSync
-
-function findSync (cache, key) {
-  const bucket = bucketPath(cache, key)
-  try {
-    return bucketEntriesSync(bucket).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.delete = del
 
 function del (cache, key, opts = {}) {
@@ -227,18 +170,7 @@ function del (cache, key, opts = {}) {
   }
 
   const bucket = bucketPath(cache, key)
-  return rimraf(bucket)
-}
-
-module.exports.delete.sync = delSync
-
-function delSync (cache, key, opts = {}) {
-  if (!opts.removeFully) {
-    return insertSync(cache, key, null, opts)
-  }
-
-  const bucket = bucketPath(cache, key)
-  return rimraf.sync(bucket)
+  return rm(bucket, { recursive: true, force: true })
 }
 
 module.exports.lsStream = lsStream
@@ -304,18 +236,11 @@ async function ls (cache) {
 module.exports.bucketEntries = bucketEntries
 
 async function bucketEntries (bucket, filter) {
-  const data = await fs.readFile(bucket, 'utf8')
-  return _bucketEntries(data, filter)
-}
-
-module.exports.bucketEntries.sync = bucketEntriesSync
-
-function bucketEntriesSync (bucket, filter) {
-  const data = fs.readFileSync(bucket, 'utf8')
+  const data = await readFile(bucket, 'utf8')
   return _bucketEntries(data, filter)
 }
 
-function _bucketEntries (data, filter) {
+function _bucketEntries (data) {
   const entries = []
   data.split('\n').forEach((entry) => {
     if (!entry) {
@@ -331,10 +256,11 @@ function _bucketEntries (data, filter) {
     let obj
     try {
       obj = JSON.parse(pieces[1])
-    } catch (e) {
-      // Entry is corrupted!
-      return
+    } catch (_) {
+      // eslint-ignore-next-line no-empty-block
     }
+    // coverage disabled here, no need to test with an entry that parses to something falsey
+    // istanbul ignore else
     if (obj) {
       entries.push(obj)
     }
@@ -394,7 +320,7 @@ function formatEntry (cache, entry, keepAll) {
 }
 
 function readdirOrEmpty (dir) {
-  return fs.readdir(dir).catch((err) => {
+  return readdir(dir).catch((err) => {
     if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
       return []
     }

package/dist/node_modules/cacache/lib/get.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const Collect = require('minipass-collect')
-const Minipass = require('minipass')
+const { Minipass } = require('minipass')
 const Pipeline = require('minipass-pipeline')
 
 const index = require('./entry-index')
@@ -53,61 +53,6 @@ async function getDataByDigest (cache, key, opts = {}) {
 }
 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) {

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

@@ -17,15 +17,12 @@ module.exports.ls.stream = index.lsStream
 
 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

package/dist/node_modules/cacache/lib/memoization.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const LRU = require('lru-cache')
+const { LRUCache } = require('lru-cache')
 
-const MEMOIZED = new LRU({
+const MEMOIZED = new LRUCache({
   max: 500,
   maxSize: 50 * 1024 * 1024, // 50MB
   ttl: 3 * 60 * 1000, // 3 minutes

package/dist/node_modules/cacache/lib/rm.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const util = require('util')
-
+const { rm } = require('fs/promises')
+const glob = require('./util/glob.js')
 const index = require('./entry-index')
 const memo = require('./memoization')
 const path = require('path')
-const rimraf = util.promisify(require('rimraf'))
 const rmContent = require('./content/rm')
 
 module.exports = entry
@@ -25,7 +24,8 @@ function content (cache, integrity) {
 
 module.exports.all = all
 
-function all (cache) {
+async function all (cache) {
   memo.clearMemoized()
-  return rimraf(path.join(cache, '*(content-*|index-*)'))
+  const paths = await glob(path.join(cache, '*(content-*|index-*)'), { silent: true, nosort: true })
+  return Promise.all(paths.map((p) => rm(p, { recursive: true, force: true })))
 }

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

@@ -0,0 +1,7 @@
+'use strict'
+
+const { glob } = require('glob')
+const path = require('path')
+
+const globify = (pattern) => pattern.split(path.win32.sep).join(path.posix.sep)
+module.exports = (path, options) => glob(globify(path), options)

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

@@ -1,8 +1,7 @@
 'use strict'
 
-const fs = require('@npmcli/fs')
-
-const fixOwner = require('./fix-owner')
+const { withTempDir } = require('@npmcli/fs')
+const fs = require('fs/promises')
 const path = require('path')
 
 module.exports.mkdir = mktmpdir
@@ -23,11 +22,5 @@ function withTmp (cache, opts, cb) {
     cb = opts
     opts = {}
   }
-  return fs.withTempDir(path.join(cache, 'tmp'), cb, opts)
-}
-
-module.exports.fix = fixtmpdir
-
-function fixtmpdir (cache) {
-  return fixOwner(cache, path.join(cache, 'tmp'))
+  return withTempDir(path.join(cache, 'tmp'), cb, opts)
 }