cacache 11.3.2 → 12.0.2

package/README.es.md

@@ -287,7 +287,7 @@ entrada si existe.
 
 * `key` - Clave de la entrada. Igual al argumento `clave`.
 * `integrity` - [hacheo de Subresource Integrity](#integrity) del contenido al que se refiere esta entrada.
-* `path` - Dirección del fichero de datos almacenados, relativa al argumento `cache`.
+* `path` - Dirección del fichero de datos almacenados, unida al argumento `cache`.
 * `time` - Hora de creación de la entrada
 * `metadata` - Metadatos asignados a esta entrada por el usuario
 

package/README.md

@@ -1,12 +1,16 @@
-# cacache [![npm version](https://img.shields.io/npm/v/cacache.svg)](https://npm.im/cacache) [![license](https://img.shields.io/npm/l/cacache.svg)](https://npm.im/cacache) [![Travis](https://img.shields.io/travis/zkat/cacache.svg)](https://travis-ci.org/zkat/cacache) [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/zkat/cacache?svg=true)](https://ci.appveyor.com/project/zkat/cacache) [![Coverage Status](https://coveralls.io/repos/github/zkat/cacache/badge.svg?branch=latest)](https://coveralls.io/github/zkat/cacache?branch=latest)
+# cacache [![npm version](https://img.shields.io/npm/v/cacache.svg)](https://npm.im/cacache) [![license](https://img.shields.io/npm/l/cacache.svg)](https://npm.im/cacache) [![Travis](https://img.shields.io/travis/npm/cacache.svg)](https://travis-ci.org/npm/cacache) [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/npm/cacache?svg=true)](https://ci.appveyor.com/project/npm/cacache) [![Coverage Status](https://coveralls.io/repos/github/npm/cacache/badge.svg?branch=latest)](https://coveralls.io/github/npm/cacache?branch=latest)
 
-[`cacache`](https://github.com/zkat/cacache) is a Node.js library for managing
+[`cacache`](https://github.com/npm/cacache) is a Node.js library for managing
 local key and content address caches. It's really fast, really good at
 concurrency, and it will never give you corrupted data, even if cache files
 get corrupted or manipulated.
 
-It was originally written to be used as [npm](https://npm.im)'s local cache, but
-can just as easily be used on its own.
+On systems that support user and group settings on files, cacache will
+match the `uid` and `gid` values to the folder where the cache lives, even
+when running as `root`.
+
+It was written to be used as [npm](https://npm.im)'s local cache, but can
+just as easily be used on its own.
 
 _Translations: [español](README.es.md)_
 
@@ -290,7 +294,7 @@ one exists.
 
 * `key` - Key the entry was looked up under. Matches the `key` argument.
 * `integrity` - [Subresource Integrity hash](#integrity) for the content this entry refers to.
-* `path` - Filesystem path relative to `cache` argument where content is stored.
+* `path` - Filesystem path where content is stored, joined with `cache` argument.
 * `time` - Timestamp the entry was first added on.
 * `metadata` - User-assigned metadata associated with the entry/content.
 
@@ -414,13 +418,6 @@ may also use any anagram of `'modnar'` to use this feature.
 Currently only supports one algorithm at a time (i.e., an array length of
 exactly `1`). Has no effect if `opts.integrity` is present.
 
-##### `opts.uid`/`opts.gid`
-
-If provided, cacache will do its best to make sure any new files added to the
-cache use this particular `uid`/`gid` combination. This can be used,
-for example, to drop permissions when someone uses `sudo`, but cacache makes
-no assumptions about your needs here.
-
 ##### `opts.memoize`
 
 Default: null
@@ -498,10 +495,11 @@ Completely resets the in-memory entry cache.
 Returns a unique temporary directory inside the cache's `tmp` dir. This
 directory will use the same safe user assignment that all the other stuff use.
 
-Once the directory is made, it's the user's responsibility that all files within
-are made according to the same `opts.gid`/`opts.uid` settings that would be
-passed in. If not, you can ask cacache to do it for you by calling
-[`tmp.fix()`](#tmp-fix), which will fix all tmp directory permissions.
+Once the directory is made, it's the user's responsibility that all files
+within are given the appropriate `gid`/`uid` ownership settings to match
+the rest of the cache. If not, you can ask cacache to do it for you by
+calling [`tmp.fix()`](#tmp-fix), which will fix all tmp directory
+permissions.
 
 If you want automatic cleanup of this directory, use
 [`tmp.withTmp()`](#with-tpm)
@@ -514,6 +512,27 @@ cacache.tmp.mkdir(cache).then(dir => {
 })
 ```
 
+#### <a name="tmp-fix"></a> `> tmp.fix(cache) -> Promise`
+
+Sets the `uid` and `gid` properties on all files and folders within the tmp
+folder to match the rest of the cache.
+
+Use this after manually writing files into [`tmp.mkdir`](#tmp-mkdir) or
+[`tmp.withTmp`](#with-tmp).
+
+##### Example
+
+```javascript
+cacache.tmp.mkdir(cache).then(dir => {
+  writeFile(path.join(dir, 'file'), someData).then(() => {
+    // make sure we didn't just put a root-owned file in the cache
+    cacache.tmp.fix().then(() => {
+      // all uids and gids match now
+    })
+  })
+})
+```
+
 #### <a name="with-tmp"></a> `> tmp.withTmp(cache, opts, cb) -> Promise`
 
 Creates a temporary directory with [`tmp.mkdir()`](#tmp-mkdir) and calls `cb`
@@ -591,8 +610,6 @@ of entries removed, etc.
 
 ##### Options
 
-* `opts.uid` - uid to assign to cache and its contents
-* `opts.gid` - gid to assign to cache and its contents
 * `opts.filter` - receives a formatted entry. Return false to remove it.
                   Note: might be called more than once on the same entry.
 

package/lib/content/path.js

@@ -12,7 +12,7 @@ const ssri = require('ssri')
 //
 module.exports = contentPath
 function contentPath (cache, integrity) {
-  const sri = ssri.parse(integrity, {single: true})
+  const sri = ssri.parse(integrity, { single: true })
   // contentPath is the *strongest* algo given
   return path.join.apply(path, [
     contentDir(cache),

package/lib/content/read.js

@@ -54,8 +54,8 @@ function readStream (cache, integrity, opts) {
   opts = ReadOpts(opts)
   const stream = new PassThrough()
   withContentSri(cache, integrity, (cpath, sri) => {
-    return lstatAsync(cpath).then(stat => ({cpath, sri, stat}))
-  }).then(({cpath, sri, stat}) => {
+    return lstatAsync(cpath).then(stat => ({ cpath, sri, stat }))
+  }).then(({ cpath, sri, stat }) => {
     return pipe(
       fs.createReadStream(cpath),
       ssri.integrityStream({
@@ -95,7 +95,7 @@ module.exports.hasContent = hasContent
 function hasContent (cache, integrity) {
   if (!integrity) { return BB.resolve(false) }
   return withContentSri(cache, integrity, (cpath, sri) => {
-    return lstatAsync(cpath).then(stat => ({size: stat.size, sri, stat}))
+    return lstatAsync(cpath).then(stat => ({ size: stat.size, sri, stat }))
   }).catch(err => {
     if (err.code === 'ENOENT') { return false }
     if (err.code === 'EPERM') {
@@ -114,7 +114,7 @@ function hasContentSync (cache, integrity) {
   return withContentSriSync(cache, integrity, (cpath, sri) => {
     try {
       const stat = fs.lstatSync(cpath)
-      return {size: stat.size, sri, stat}
+      return { size: stat.size, sri, stat }
     } catch (err) {
       if (err.code === 'ENOENT') { return false }
       if (err.code === 'EPERM') {
@@ -141,12 +141,12 @@ function withContentSri (cache, integrity, fn) {
     } else {
       return BB.any(sri[sri.pickAlgorithm()].map(meta => {
         return withContentSri(cache, meta, fn)
-      }, {concurrency: 1}))
+      }, { concurrency: 1 }))
         .catch(err => {
           if ([].some.call(err, e => e.code === 'ENOENT')) {
             throw Object.assign(
               new Error('No matching content found for ' + sri.toString()),
-              {code: 'ENOENT'}
+              { code: 'ENOENT' }
             )
           } else {
             throw err[0]

package/lib/content/write.js

@@ -36,11 +36,11 @@ function write (cache, data, opts) {
   }
   return BB.using(makeTmp(cache, opts), tmp => (
     writeFileAsync(
-      tmp.target, data, {flag: 'wx'}
+      tmp.target, data, { flag: 'wx' }
     ).then(() => (
       moveToDestination(tmp, cache, sri, opts)
     ))
-  )).then(() => ({integrity: sri, size: data.length}))
+  )).then(() => ({ integrity: sri, size: data.length }))
 }
 
 module.exports.stream = writeStream
@@ -111,8 +111,8 @@ function pipeToTmp (inputStream, cache, tmpTarget, opts, errCheck) {
     })
     errCheck()
     return pipe(inputStream, hashStream, outStream).then(() => {
-      return {integrity, size}
-    }, err => {
+      return { integrity, size }
+    }).catch(err => {
       return rimraf(tmpTarget).then(() => { throw err })
     })
   })
@@ -121,7 +121,7 @@ function pipeToTmp (inputStream, cache, tmpTarget, opts, errCheck) {
 function makeTmp (cache, opts) {
   const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
   return fixOwner.mkdirfix(
-    path.dirname(tmpTarget), opts.uid, opts.gid
+    cache, path.dirname(tmpTarget)
   ).then(() => ({
     target: tmpTarget,
     moved: false
@@ -134,14 +134,14 @@ function moveToDestination (tmp, cache, sri, opts, errCheck) {
   const destDir = path.dirname(destination)
 
   return fixOwner.mkdirfix(
-    destDir, opts.uid, opts.gid
+    cache, destDir
   ).then(() => {
     errCheck && errCheck()
     return moveFile(tmp.target, destination)
   }).then(() => {
     errCheck && errCheck()
     tmp.moved = true
-    return fixOwner.chownr(destination, opts.uid, opts.gid)
+    return fixOwner.chownr(cache, destination)
   })
 }
 

package/lib/entry-index.js

@@ -32,9 +32,7 @@ module.exports.NotFoundError = class NotFoundError extends Error {
 
 const IndexOpts = figgyPudding({
   metadata: {},
-  size: {},
-  uid: {},
-  gid: {}
+  size: {}
 })
 
 module.exports.insert = insert
@@ -49,7 +47,7 @@ function insert (cache, key, integrity, opts) {
     metadata: opts.metadata
   }
   return fixOwner.mkdirfix(
-    path.dirname(bucket), opts.uid, opts.gid
+    cache, path.dirname(bucket)
   ).then(() => {
     const stringified = JSON.stringify(entry)
     // NOTE - Cleverness ahoy!
@@ -63,8 +61,8 @@ function insert (cache, key, integrity, opts) {
       bucket, `\n${hashEntry(stringified)}\t${stringified}`
     )
   }).then(
-    () => fixOwner.chownr(bucket, opts.uid, opts.gid)
-  ).catch({code: 'ENOENT'}, () => {
+    () => fixOwner.chownr(cache, bucket)
+  ).catch({ code: 'ENOENT' }, () => {
     // There's a class of race conditions that happen when things get deleted
     // during fixOwner, or between the two mkdirfix/chownr calls.
     //
@@ -86,13 +84,13 @@ function insertSync (cache, key, integrity, opts) {
     size: opts.size,
     metadata: opts.metadata
   }
-  fixOwner.mkdirfix.sync(path.dirname(bucket), opts.uid, opts.gid)
+  fixOwner.mkdirfix.sync(cache, path.dirname(bucket))
   const stringified = JSON.stringify(entry)
   fs.appendFileSync(
     bucket, `\n${hashEntry(stringified)}\t${stringified}`
   )
   try {
-    fixOwner.chownr.sync(bucket, opts.uid, opts.gid)
+    fixOwner.chownr.sync(cache, bucket)
   } catch (err) {
     if (err.code !== 'ENOENT') {
       throw err
@@ -178,7 +176,7 @@ function lsStream (cache) {
             const formatted = formatEntry(cache, entry)
             formatted && stream.push(formatted)
           }
-        }).catch({code: 'ENOENT'}, nop)
+        }).catch({ code: 'ENOENT' }, nop)
       })
     })
   }).then(() => {
@@ -282,8 +280,8 @@ function formatEntry (cache, entry) {
 
 function readdirOrEmpty (dir) {
   return readdirAsync(dir)
-    .catch({code: 'ENOENT'}, () => [])
-    .catch({code: 'ENOTDIR'}, () => [])
+    .catch({ code: 'ENOENT' }, () => [])
+    .catch({ code: 'ENOTDIR' }, () => [])
 }
 
 function nop () {

package/lib/util/fix-owner.js

@@ -5,83 +5,115 @@ const BB = require('bluebird')
 const chownr = BB.promisify(require('chownr'))
 const mkdirp = BB.promisify(require('mkdirp'))
 const inflight = require('promise-inflight')
+const inferOwner = require('infer-owner')
+
+// Memoize getuid()/getgid() calls.
+// patch process.setuid/setgid to invalidate cached value on change
+const self = { uid: null, gid: null }
+const getSelf = () => {
+  if (typeof self.uid !== 'number') {
+    self.uid = process.getuid()
+    const setuid = process.setuid
+    process.setuid = (uid) => {
+      self.uid = null
+      process.setuid = setuid
+      return process.setuid(uid)
+    }
+  }
+  if (typeof self.gid !== 'number') {
+    self.gid = process.getgid()
+    const setgid = process.setgid
+    process.setgid = (gid) => {
+      self.gid = null
+      process.setgid = setgid
+      return process.setgid(gid)
+    }
+  }
+}
 
 module.exports.chownr = fixOwner
-function fixOwner (filepath, uid, gid) {
+function fixOwner (cache, filepath) {
   if (!process.getuid) {
     // This platform doesn't need ownership fixing
     return BB.resolve()
   }
-  if (typeof uid !== 'number' && typeof gid !== 'number') {
-    // There's no permissions override. Nothing to do here.
-    return BB.resolve()
-  }
-  if ((typeof uid === 'number' && process.getuid() === uid) &&
-      (typeof gid === 'number' && process.getgid() === gid)) {
+  return BB.resolve(inferOwner(cache)).then(owner => {
+    const { uid, gid } = owner
+    getSelf()
+
     // No need to override if it's already what we used.
-    return BB.resolve()
-  }
-  return inflight(
-    'fixOwner: fixing ownership on ' + filepath,
-    () => chownr(
-      filepath,
-      typeof uid === 'number' ? uid : process.getuid(),
-      typeof gid === 'number' ? gid : process.getgid()
-    ).catch({code: 'ENOENT'}, () => null)
-  )
+    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({ code: 'ENOENT' }, () => null)
+    )
+  })
 }
 
 module.exports.chownr.sync = fixOwnerSync
-function fixOwnerSync (filepath, uid, gid) {
+function fixOwnerSync (cache, filepath) {
   if (!process.getuid) {
     // This platform doesn't need ownership fixing
     return
   }
-  if (typeof uid !== 'number' && typeof gid !== 'number') {
-    // There's no permissions override. Nothing to do here.
-    return
-  }
-  if ((typeof uid === 'number' && process.getuid() === uid) &&
-      (typeof gid === 'number' && process.getgid() === gid)) {
+  const { uid, gid } = inferOwner.sync(cache)
+  getSelf()
+  if (self.uid === uid && self.gid === gid) {
     // No need to override if it's already what we used.
     return
   }
   try {
     chownr.sync(
       filepath,
-      typeof uid === 'number' ? uid : process.getuid(),
-      typeof gid === 'number' ? gid : process.getgid()
+      typeof uid === 'number' ? uid : self.uid,
+      typeof gid === 'number' ? gid : self.gid
     )
   } catch (err) {
+    // only catch ENOENT, any other error is a problem.
     if (err.code === 'ENOENT') {
       return null
     }
+    throw err
   }
 }
 
 module.exports.mkdirfix = mkdirfix
-function mkdirfix (p, uid, gid, cb) {
-  return mkdirp(p).then(made => {
-    if (made) {
-      return fixOwner(made, uid, gid).then(() => made)
-    }
-  }).catch({code: 'EEXIST'}, () => {
-    // There's a race in mkdirp!
-    return fixOwner(p, uid, gid).then(() => null)
+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 BB.resolve(inferOwner(cache)).then(() => {
+    return mkdirp(p).then(made => {
+      if (made) {
+        return fixOwner(cache, made).then(() => made)
+      }
+    }).catch({ code: 'EEXIST' }, () => {
+      // There's a race in mkdirp!
+      return fixOwner(cache, p).then(() => null)
+    })
   })
 }
 
 module.exports.mkdirfix.sync = mkdirfixSync
-function mkdirfixSync (p, uid, gid) {
+function mkdirfixSync (cache, p) {
   try {
+    inferOwner.sync(cache)
     const made = mkdirp.sync(p)
     if (made) {
-      fixOwnerSync(made, uid, gid)
+      fixOwnerSync(cache, made)
       return made
     }
   } catch (err) {
     if (err.code === 'EEXIST') {
-      fixOwnerSync(p, uid, gid)
+      fixOwnerSync(cache, p)
       return null
     } else {
       throw err

package/lib/util/tmp.js

@@ -9,16 +9,14 @@ const rimraf = BB.promisify(require('rimraf'))
 const uniqueFilename = require('unique-filename')
 
 const TmpOpts = figgyPudding({
-  tmpPrefix: {},
-  uid: {},
-  gid: {}
+  tmpPrefix: {}
 })
 
 module.exports.mkdir = mktmpdir
 function mktmpdir (cache, opts) {
   opts = TmpOpts(opts)
   const tmpTarget = uniqueFilename(path.join(cache, 'tmp'), opts.tmpPrefix)
-  return fixOwner.mkdirfix(tmpTarget, opts.uid, opts.gid).then(() => {
+  return fixOwner.mkdirfix(cache, tmpTarget).then(() => {
     return tmpTarget
   })
 }
@@ -34,7 +32,6 @@ function withTmp (cache, opts, cb) {
 }
 
 module.exports.fix = fixtmpdir
-function fixtmpdir (cache, opts) {
-  opts = TmpOpts(opts)
-  return fixOwner(path.join(cache, 'tmp'), opts.uid, opts.gid)
+function fixtmpdir (cache) {
+  return fixOwner(cache, path.join(cache, 'tmp'))
 }

package/lib/verify.js

@@ -22,9 +22,7 @@ const VerifyOpts = figgyPudding({
   filter: {},
   log: {
     default: { silly () {} }
-  },
-  uid: {},
-  gid: {}
+  }
 })
 
 module.exports = verify
@@ -67,9 +65,9 @@ function markEndTime (cache, opts) {
 
 function fixPerms (cache, opts) {
   opts.log.silly('verify', 'fixing cache permissions')
-  return fixOwner.mkdirfix(cache, opts.uid, opts.gid).then(() => {
+  return fixOwner.mkdirfix(cache, cache).then(() => {
     // TODO - fix file permissions too
-    return fixOwner.chownr(cache, opts.uid, opts.gid)
+    return fixOwner.chownr(cache, cache)
   }).then(() => null)
 }
 
@@ -130,7 +128,7 @@ function garbageCollect (cache, opts) {
             })
           })
         }
-      }, {concurrency: opts.concurrency}))
+      }, { concurrency: opts.concurrency }))
     })
   })
 }
@@ -150,7 +148,7 @@ function verifyContent (filepath, sri) {
         contentInfo.valid = false
       })
     }).then(() => contentInfo)
-  }).catch({code: 'ENOENT'}, () => ({size: 0, valid: false}))
+  }).catch({ code: 'ENOENT' }, () => ({ size: 0, valid: false }))
 }
 
 function rebuildIndex (cache, opts) {
@@ -183,7 +181,7 @@ function rebuildIndex (cache, opts) {
     }
     return BB.map(Object.keys(buckets), key => {
       return rebuildBucket(cache, buckets[key], stats, opts)
-    }, {concurrency: opts.concurrency}).then(() => stats)
+    }, { concurrency: opts.concurrency }).then(() => stats)
   })
 }
 
@@ -195,12 +193,10 @@ function rebuildBucket (cache, bucket, stats, opts) {
       const content = contentPath(cache, entry.integrity)
       return fs.statAsync(content).then(() => {
         return index.insert(cache, entry.key, entry.integrity, {
-          uid: opts.uid,
-          gid: opts.gid,
           metadata: entry.metadata,
           size: entry.size
         }).then(() => { stats.totalEntries++ })
-      }).catch({code: 'ENOENT'}, () => {
+      }).catch({ code: 'ENOENT' }, () => {
         stats.rejectedEntries++
         stats.missingContent++
       })
@@ -216,7 +212,11 @@ function cleanTmp (cache, opts) {
 function writeVerifile (cache, opts) {
   const verifile = path.join(cache, '_lastverified')
   opts.log.silly('verify', 'writing verifile to ' + verifile)
-  return fs.writeFileAsync(verifile, '' + (+(new Date())))
+  try {
+    return fs.writeFileAsync(verifile, '' + (+(new Date())))
+  } finally {
+    fixOwner.chownr.sync(cache, verifile)
+  }
 }
 
 module.exports.lastRun = lastRun

package/locales/en.json

@@ -2,5 +2,6 @@
   "No cache entry for `%s` found in `%s`": "No cache entry for %s found in %s",
   "Integrity verification failed for %s (%s)": "Integrity verification failed for %s (%s)",
   "Bad data size: expected inserted data to be %s bytes, but got %s instead": "Bad data size: expected inserted data to be %s bytes, but got %s instead",
-  "Cache input stream was empty": "Cache input stream was empty"
-}
+  "Cache input stream was empty": "Cache input stream was empty",
+  "Integrity check failed:\n  Wanted: %s\n   Found: %s": "Integrity check failed:\n  Wanted: %s\n   Found: %s"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacache",
-  "version": "11.3.2",
+  "version": "12.0.2",
   "cache-version": {
     "content": "2",
     "index": "5"
@@ -23,7 +23,7 @@
     "update-coc": "weallbehave -o . && git add CODE_OF_CONDUCT.md && git commit -m 'docs(coc): updated CODE_OF_CONDUCT.md'",
     "update-contrib": "weallcontribute -o . && git add CONTRIBUTING.md && git commit -m 'docs(contributing): updated CONTRIBUTING.md'"
   },
-  "repository": "https://github.com/zkat/cacache",
+  "repository": "https://github.com/npm/cacache",
   "keywords": [
     "cache",
     "caching",
@@ -58,32 +58,33 @@
   ],
   "license": "ISC",
   "dependencies": {
-    "bluebird": "^3.5.3",
+    "bluebird": "^3.5.5",
     "chownr": "^1.1.1",
     "figgy-pudding": "^3.5.1",
-    "glob": "^7.1.3",
+    "glob": "^7.1.4",
     "graceful-fs": "^4.1.15",
+    "infer-owner": "^1.0.3",
     "lru-cache": "^5.1.1",
     "mississippi": "^3.0.0",
     "mkdirp": "^0.5.1",
     "move-concurrently": "^1.0.1",
     "promise-inflight": "^1.0.1",
-    "rimraf": "^2.6.2",
+    "rimraf": "^2.6.3",
     "ssri": "^6.0.1",
     "unique-filename": "^1.1.1",
     "y18n": "^4.0.0"
   },
   "devDependencies": {
     "benchmark": "^2.1.4",
-    "chalk": "^2.3.2",
+    "chalk": "^2.4.2",
     "cross-env": "^5.1.4",
-    "require-inject": "^1.4.2",
-    "standard": "^11.0.1",
-    "standard-version": "^4.4.0",
-    "tacks": "^1.2.7",
-    "tap": "^12.1.1",
+    "require-inject": "^1.4.4",
+    "standard": "^12.0.1",
+    "standard-version": "^6.0.1",
+    "tacks": "^1.3.0",
+    "tap": "^12.7.0",
     "weallbehave": "^1.2.0",
-    "weallcontribute": "^1.0.8"
+    "weallcontribute": "^1.0.9"
   },
   "config": {
     "nyc": {

package/put.js

@@ -16,10 +16,9 @@ const PutOpts = figgyPudding({
   pickAlgorithm: {},
   size: {},
   tmpPrefix: {},
-  uid: {},
-  gid: {},
   single: {},
   sep: {},
+  error: {},
   strict: {}
 })
 
@@ -28,7 +27,7 @@ function putData (cache, key, data, opts) {
   opts = PutOpts(opts)
   return write(cache, data, opts).then(res => {
     return index.insert(
-      cache, key, res.integrity, opts.concat({size: res.size})
+      cache, key, res.integrity, opts.concat({ size: res.size })
     ).then(entry => {
       if (opts.memoize) {
         memo.put(cache, entry, data, opts)
@@ -63,7 +62,7 @@ function putStream (cache, key, opts) {
     })
   }, cb => {
     contentStream.end(() => {
-      index.insert(cache, key, integrity, opts.concat({size})).then(entry => {
+      index.insert(cache, key, integrity, opts.concat({ size })).then(entry => {
         if (opts.memoize) {
           memo.put(cache, entry, Buffer.concat(memoData, memoTotal), opts)
         }