cacache 16.0.7 → 16.1.0

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,35 @@ 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)
+  }).catch((err) => stream.emit('error', err))
 
   return stream
 }
@@ -204,27 +199,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

package/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,47 +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)
+  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
         }
-      } 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)
-        })
       })
+      // file doesn't already exist! let's try a rename -> copy fallback
+      // only delete if it successfully copies
+      return move(src, dest)
     })
+  }
 }

package/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