pnpm 7.9.1 → 7.9.2

package/dist/node_modules/lru-cache/package.json

@@ -1,34 +1,74 @@
 {
   "name": "lru-cache",
   "description": "A cache object that deletes the least-recently-used items.",
-  "version": "6.0.0",
+  "version": "7.14.0",
   "author": "Isaac Z. Schlueter <i@izs.me>",
   "keywords": [
     "mru",
     "lru",
     "cache"
   ],
+  "sideEffects": false,
   "scripts": {
+    "build": "",
+    "size": "size-limit",
     "test": "tap",
     "snap": "tap",
     "preversion": "npm test",
     "postversion": "npm publish",
-    "prepublishOnly": "git push origin --follow-tags"
+    "prepublishOnly": "git push origin --follow-tags",
+    "format": "prettier --write ."
   },
   "main": "index.js",
   "repository": "git://github.com/isaacs/node-lru-cache.git",
   "devDependencies": {
+    "@size-limit/preset-small-lib": "^7.0.8",
+    "@types/node": "^17.0.31",
+    "@types/tap": "^15.0.6",
     "benchmark": "^2.1.4",
-    "tap": "^14.10.7"
+    "c8": "^7.11.2",
+    "clock-mock": "^1.0.6",
+    "eslint-config-prettier": "^8.5.0",
+    "prettier": "^2.6.2",
+    "size-limit": "^7.0.8",
+    "tap": "^16.0.1",
+    "ts-node": "^10.7.0",
+    "tslib": "^2.4.0",
+    "typescript": "^4.6.4"
   },
   "license": "ISC",
-  "dependencies": {
-    "yallist": "^4.0.0"
-  },
   "files": [
-    "index.js"
+    "index.js",
+    "index.d.ts"
   ],
   "engines": {
-    "node": ">=10"
-  }
+    "node": ">=12"
+  },
+  "prettier": {
+    "semi": false,
+    "printWidth": 70,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
+  },
+  "tap": {
+    "nyc-arg": [
+      "--include=index.js"
+    ],
+    "node-arg": [
+      "--expose-gc",
+      "--require",
+      "ts-node/register"
+    ],
+    "ts": false
+  },
+  "size-limit": [
+    {
+      "path": "./index.js"
+    }
+  ]
 }

package/dist/node_modules/make-fetch-happen/LICENSE

@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) npm, Inc.
+Copyright 2017-2022 (c) npm, Inc.
 
 Permission to use, copy, modify, and/or distribute this software for
 any purpose with or without fee is hereby granted, provided that the

package/dist/node_modules/make-fetch-happen/lib/agent.js

@@ -2,6 +2,7 @@
 const LRU = require('lru-cache')
 const url = require('url')
 const isLambda = require('is-lambda')
+const dns = require('./dns.js')
 
 const AGENT_CACHE = new LRU({ max: 50 })
 const HttpAgent = require('agentkeepalive')
@@ -50,11 +51,13 @@ function getAgent (uri, opts) {
     : isHttps ? require('https').globalAgent
     : require('http').globalAgent
 
-  if (isLambda && !pxuri)
+  if (isLambda && !pxuri) {
     return lambdaAgent
+  }
 
-  if (AGENT_CACHE.peek(key))
+  if (AGENT_CACHE.peek(key)) {
     return AGENT_CACHE.get(key)
+  }
 
   if (pxuri) {
     const pxopts = isLambda ? {
@@ -74,10 +77,14 @@ function getAgent (uri, opts) {
     localAddress: opts.localAddress,
     rejectUnauthorized: opts.rejectUnauthorized,
     timeout: agentTimeout,
+    freeSocketTimeout: 15000,
+    lookup: dns.getLookup(opts.dns),
   }) : new HttpAgent({
     maxSockets: agentMaxSockets,
     localAddress: opts.localAddress,
     timeout: agentTimeout,
+    freeSocketTimeout: 15000,
+    lookup: dns.getLookup(opts.dns),
   })
   AGENT_CACHE.set(key, agent)
   return agent
@@ -86,16 +93,19 @@ function getAgent (uri, opts) {
 function checkNoProxy (uri, opts) {
   const host = new url.URL(uri).hostname.split('.').reverse()
   let noproxy = (opts.noProxy || getProcessEnv('no_proxy'))
-  if (typeof noproxy === 'string')
-    noproxy = noproxy.split(/\s*,\s*/g)
+  if (typeof noproxy === 'string') {
+    noproxy = noproxy.split(',').map(n => n.trim())
+  }
 
   return noproxy && noproxy.some(no => {
     const noParts = no.split('.').filter(x => x).reverse()
-    if (!noParts.length)
+    if (!noParts.length) {
       return false
+    }
     for (let i = 0; i < noParts.length; i++) {
-      if (host[i] !== noParts[i])
+      if (host[i] !== noParts[i]) {
         return false
+      }
     }
     return true
   })
@@ -104,8 +114,9 @@ function checkNoProxy (uri, opts) {
 module.exports.getProcessEnv = getProcessEnv
 
 function getProcessEnv (env) {
-  if (!env)
+  if (!env) {
     return
+  }
 
   let value
 
@@ -114,8 +125,9 @@ function getProcessEnv (env) {
       value = process.env[e] ||
         process.env[e.toUpperCase()] ||
         process.env[e.toLowerCase()]
-      if (typeof value !== 'undefined')
+      if (typeof value !== 'undefined') {
         break
+      }
     }
   }
 
@@ -141,8 +153,9 @@ function getProxyUri (uri, opts) {
       protocol === 'http:' &&
       getProcessEnv(['https_proxy', 'http_proxy', 'proxy'])
     )
-  if (!proxy)
+  if (!proxy) {
     return null
+  }
 
   const parsedProxy = (typeof proxy === 'string') ? new url.URL(proxy) : proxy
 
@@ -158,9 +171,11 @@ const getPath = u => u.pathname + u.search + u.hash
 
 const HttpProxyAgent = require('http-proxy-agent')
 const HttpsProxyAgent = require('https-proxy-agent')
-const SocksProxyAgent = require('socks-proxy-agent')
+const { SocksProxyAgent } = require('socks-proxy-agent')
 module.exports.getProxy = getProxy
 function getProxy (proxyUrl, opts, isHttps) {
+  // our current proxy agents do not support an overridden dns lookup method, so will not
+  // benefit from the dns cache
   const popts = {
     host: proxyUrl.hostname,
     port: proxyUrl.port,
@@ -177,16 +192,21 @@ function getProxy (proxyUrl, opts, isHttps) {
   }
 
   if (proxyUrl.protocol === 'http:' || proxyUrl.protocol === 'https:') {
-    if (!isHttps)
+    if (!isHttps) {
       return new HttpProxyAgent(popts)
-    else
+    } else {
       return new HttpsProxyAgent(popts)
-  } else if (proxyUrl.protocol.startsWith('socks'))
+    }
+  } else if (proxyUrl.protocol.startsWith('socks')) {
+    // socks-proxy-agent uses hostname not host
+    popts.hostname = popts.host
+    delete popts.host
     return new SocksProxyAgent(popts)
-  else {
+  } else {
     throw Object.assign(
       new Error(`unsupported proxy protocol: '${proxyUrl.protocol}'`),
       {
+        code: 'EUNSUPPORTEDPROXY',
         url: proxyUrl.href,
       }
     )

package/dist/node_modules/make-fetch-happen/lib/cache/entry.js

@@ -1,21 +1,16 @@
 const { Request, Response } = require('minipass-fetch')
 const Minipass = require('minipass')
-const MinipassCollect = require('minipass-collect')
 const MinipassFlush = require('minipass-flush')
-const MinipassPipeline = require('minipass-pipeline')
 const cacache = require('cacache')
 const url = require('url')
 
+const CachingMinipassPipeline = require('../pipeline.js')
 const CachePolicy = require('./policy.js')
 const cacheKey = require('./key.js')
 const remote = require('../remote.js')
 
 const hasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop)
 
-// maximum amount of data we will buffer into memory
-// if we'll exceed this, we switch to streaming
-const MAX_MEM_SIZE = 5 * 1024 * 1024 // 5MB
-
 // allow list for request headers that will be written to the cache index
 // note: we will also store any request headers
 // that are named in a response's vary header
@@ -40,6 +35,7 @@ const KEEP_RESPONSE_HEADERS = [
   'etag',
   'expires',
   'last-modified',
+  'link',
   'location',
   'pragma',
   'vary',
@@ -52,23 +48,31 @@ const getMetadata = (request, response, options) => {
     url: request.url,
     reqHeaders: {},
     resHeaders: {},
+
+    // options on which we must match the request and vary the response
+    options: {
+      compress: options.compress != null ? options.compress : request.compress,
+    },
   }
 
   // only save the status if it's not a 200 or 304
-  if (response.status !== 200 && response.status !== 304)
+  if (response.status !== 200 && response.status !== 304) {
     metadata.status = response.status
+  }
 
   for (const name of KEEP_REQUEST_HEADERS) {
-    if (request.headers.has(name))
+    if (request.headers.has(name)) {
       metadata.reqHeaders[name] = request.headers.get(name)
+    }
   }
 
   // if the request's host header differs from the host in the url
   // we need to keep it, otherwise it's just noise and we ignore it
   const host = request.headers.get('host')
   const parsedUrl = new url.URL(request.url)
-  if (host && parsedUrl.host !== host)
+  if (host && parsedUrl.host !== host) {
     metadata.reqHeaders.host = host
+  }
 
   // if the response has a vary header, make sure
   // we store the relevant request headers too
@@ -82,25 +86,17 @@ const getMetadata = (request, response, options) => {
       // copy any other request headers that will vary the response
       const varyHeaders = vary.trim().toLowerCase().split(/\s*,\s*/)
       for (const name of varyHeaders) {
-        // explicitly ignore accept-encoding here
-        if (name !== 'accept-encoding' && request.headers.has(name))
+        if (request.headers.has(name)) {
           metadata.reqHeaders[name] = request.headers.get(name)
+        }
       }
     }
   }
 
   for (const name of KEEP_RESPONSE_HEADERS) {
-    if (response.headers.has(name))
+    if (response.headers.has(name)) {
       metadata.resHeaders[name] = response.headers.get(name)
-  }
-
-  // we only store accept-encoding and content-encoding if the user
-  // has disabled automatic compression and decompression in minipass-fetch
-  // since if it's enabled (the default) then the content will have
-  // already been decompressed making the header a lie
-  if (options.compress === false) {
-    metadata.reqHeaders['accept-encoding'] = request.headers.get('accept-encoding')
-    metadata.resHeaders['content-encoding'] = response.headers.get('content-encoding')
+    }
   }
 
   return metadata
@@ -121,8 +117,9 @@ class CacheEntry {
       // entry timestamp to determine staleness because cacache will update it
       // when it verifies its data
       this.entry.metadata.time = this.entry.metadata.time || this.entry.time
-    } else
+    } else {
       this.key = cacheKey(request)
+    }
 
     this.options = options
 
@@ -143,9 +140,17 @@ class CacheEntry {
         return entryA.policy.satisfies(entryB.request)
       }, {
         validateEntry: (entry) => {
+          // clean out entries with a buggy content-encoding value
+          if (entry.metadata &&
+              entry.metadata.resHeaders &&
+              entry.metadata.resHeaders['content-encoding'] === null) {
+            return false
+          }
+
           // if an integrity is null, it needs to have a status specified
-          if (entry.integrity === null)
+          if (entry.integrity === null) {
             return !!(entry.metadata && entry.metadata.status)
+          }
 
           return true
         },
@@ -158,8 +163,9 @@ class CacheEntry {
     // a cache mode of 'reload' means to behave as though we have no cache
     // on the way to the network. return undefined to allow cacheFetch to
     // create a brand new request no matter what.
-    if (options.cache === 'reload')
+    if (options.cache === 'reload') {
       return
+    }
 
     // find the specific entry that satisfies the request
     let match
@@ -194,6 +200,7 @@ class CacheEntry {
       this[_request] = new Request(this.entry.metadata.url, {
         method: 'GET',
         headers: this.entry.metadata.reqHeaders,
+        ...this.entry.metadata.options,
       })
     }
 
@@ -235,19 +242,22 @@ class CacheEntry {
     // if we got a status other than 200, 301, or 308,
     // or the CachePolicy forbid storage, append the
     // cache status header and return it untouched
-    if (this.request.method !== 'GET' || ![200, 301, 308].includes(this.response.status) || !this.policy.storable()) {
+    if (
+      this.request.method !== 'GET' ||
+      ![200, 301, 308].includes(this.response.status) ||
+      !this.policy.storable()
+    ) {
       this.response.headers.set('x-local-cache-status', 'skip')
       return this.response
     }
 
     const size = this.response.headers.get('content-length')
-    const fitsInMemory = !!size && Number(size) < MAX_MEM_SIZE
-    const shouldBuffer = this.options.memoize !== false && fitsInMemory
     const cacheOpts = {
       algorithms: this.options.algorithms,
       metadata: getMetadata(this.request, this.response, this.options),
       size,
-      memoize: fitsInMemory && this.options.memoize,
+      integrity: this.options.integrity,
+      integrityEmitter: this.response.body.hasIntegrityEmitter && this.response.body,
     }
 
     let body = null
@@ -260,53 +270,35 @@ class CacheEntry {
         cacheWriteReject = reject
       })
 
-      body = new MinipassPipeline(new MinipassFlush({
+      body = new CachingMinipassPipeline({ events: ['integrity', 'size'] }, new MinipassFlush({
         flush () {
           return cacheWritePromise
         },
       }))
-
-      let abortStream, onResume
-      if (shouldBuffer) {
-        // if the result fits in memory, use a collect stream to gather
-        // the response and write it to cacache while also passing it through
-        // to the user
-        onResume = () => {
-          const collector = new MinipassCollect.PassThrough()
-          abortStream = collector
-          collector.on('collect', (data) => {
-            // TODO if the cache write fails, log a warning but return the response anyway
-            cacache.put(this.options.cachePath, this.key, data, cacheOpts).then(cacheWriteResolve, cacheWriteReject)
-          })
-          body.unshift(collector)
-          body.unshift(this.response.body)
-        }
-      } else {
-        // if it does not fit in memory, create a tee stream and use
-        // that to pipe to both the cache and the user simultaneously
-        onResume = () => {
-          const tee = new Minipass()
-          const cacheStream = cacache.put.stream(this.options.cachePath, this.key, cacheOpts)
-          abortStream = cacheStream
-          tee.pipe(cacheStream)
-          // TODO if the cache write fails, log a warning but return the response anyway
-          cacheStream.promise().then(cacheWriteResolve, cacheWriteReject)
-          body.unshift(tee)
-          body.unshift(this.response.body)
-        }
+      // this is always true since if we aren't reusing the one from the remote fetch, we
+      // are using the one from cacache
+      body.hasIntegrityEmitter = true
+
+      const onResume = () => {
+        const tee = new Minipass()
+        const cacheStream = cacache.put.stream(this.options.cachePath, this.key, cacheOpts)
+        // re-emit the integrity and size events on our new response body so they can be reused
+        cacheStream.on('integrity', i => body.emit('integrity', i))
+        cacheStream.on('size', s => body.emit('size', s))
+        // stick a flag on here so downstream users will know if they can expect integrity events
+        tee.pipe(cacheStream)
+        // TODO if the cache write fails, log a warning but return the response anyway
+        // eslint-disable-next-line promise/catch-or-return
+        cacheStream.promise().then(cacheWriteResolve, cacheWriteReject)
+        body.unshift(tee)
+        body.unshift(this.response.body)
       }
 
       body.once('resume', onResume)
       body.once('end', () => body.removeListener('resume', onResume))
-      this.response.body.on('error', (err) => {
-        // the abortStream will either be a MinipassCollect if we buffer
-        // or a cacache write stream, either way be sure to listen for
-        // errors from the actual response and avoid writing data that we
-        // know to be invalid to the cache
-        abortStream.destroy(err)
-      })
-    } else
+    } else {
       await cacache.index.insert(this.options.cachePath, this.key, null, cacheOpts)
+    }
 
     // note: we do not set the x-local-cache-hash header because we do not know
     // the hash value until after the write to the cache completes, which doesn't
@@ -314,7 +306,7 @@ class CacheEntry {
     // the header anyway
     this.response.headers.set('x-local-cache', encodeURIComponent(this.options.cachePath))
     this.response.headers.set('x-local-cache-key', encodeURIComponent(this.key))
-    this.response.headers.set('x-local-cache-mode', shouldBuffer ? 'buffer' : 'stream')
+    this.response.headers.set('x-local-cache-mode', 'stream')
     this.response.headers.set('x-local-cache-status', status)
     this.response.headers.set('x-local-cache-time', new Date().toISOString())
     const newResponse = new Response(body, {
@@ -329,9 +321,6 @@ class CacheEntry {
   // use the cached data to create a response and return it
   async respond (method, options, status) {
     let response
-    const size = Number(this.response.headers.get('content-length'))
-    const fitsInMemory = !!size && size < MAX_MEM_SIZE
-    const shouldBuffer = this.options.memoize !== false && fitsInMemory
     if (method === 'HEAD' || [301, 308].includes(this.response.status)) {
       // if the request is a HEAD, or the response is a redirect,
       // then the metadata in the entry already includes everything
@@ -341,54 +330,44 @@ class CacheEntry {
       // we're responding with a full cached response, so create a body
       // that reads from cacache and attach it to a new Response
       const body = new Minipass()
-      const removeOnResume = () => body.removeListener('resume', onResume)
-      let onResume
-      if (shouldBuffer) {
-        onResume = async () => {
-          removeOnResume()
-          try {
-            const content = await cacache.get.byDigest(this.options.cachePath, this.entry.integrity, { memoize: this.options.memoize })
-            body.end(content)
-          } catch (err) {
-            if (err.code === 'EINTEGRITY')
-              await cacache.rm.content(this.options.cachePath, this.entry.integrity, { memoize: this.options.memoize })
-            if (err.code === 'ENOENT' || err.code === 'EINTEGRITY')
-              await CacheEntry.invalidate(this.request, this.options)
-            body.emit('error', err)
+      const headers = { ...this.policy.responseHeaders() }
+      const onResume = () => {
+        const cacheStream = cacache.get.stream.byDigest(
+          this.options.cachePath, this.entry.integrity, { memoize: this.options.memoize }
+        )
+        cacheStream.on('error', async (err) => {
+          cacheStream.pause()
+          if (err.code === 'EINTEGRITY') {
+            await cacache.rm.content(
+              this.options.cachePath, this.entry.integrity, { memoize: this.options.memoize }
+            )
           }
-        }
-      } else {
-        onResume = () => {
-          const cacheStream = cacache.get.stream.byDigest(this.options.cachePath, this.entry.integrity, { memoize: this.options.memoize })
-          cacheStream.on('error', async (err) => {
-            cacheStream.pause()
-            if (err.code === 'EINTEGRITY')
-              await cacache.rm.content(this.options.cachePath, this.entry.integrity, { memoize: this.options.memoize })
-            if (err.code === 'ENOENT' || err.code === 'EINTEGRITY')
-              await CacheEntry.invalidate(this.request, this.options)
-            body.emit('error', err)
-            cacheStream.resume()
-          })
-          cacheStream.pipe(body)
-        }
+          if (err.code === 'ENOENT' || err.code === 'EINTEGRITY') {
+            await CacheEntry.invalidate(this.request, this.options)
+          }
+          body.emit('error', err)
+          cacheStream.resume()
+        })
+        // emit the integrity and size events based on our metadata so we're consistent
+        body.emit('integrity', this.entry.integrity)
+        body.emit('size', Number(headers['content-length']))
+        cacheStream.pipe(body)
       }
 
       body.once('resume', onResume)
-      body.once('end', removeOnResume)
+      body.once('end', () => body.removeListener('resume', onResume))
       response = new Response(body, {
         url: this.entry.metadata.url,
         counter: options.counter,
         status: 200,
-        headers: {
-          ...this.policy.responseHeaders(),
-        },
+        headers,
       })
     }
 
     response.headers.set('x-local-cache', encodeURIComponent(this.options.cachePath))
     response.headers.set('x-local-cache-hash', encodeURIComponent(this.entry.integrity))
     response.headers.set('x-local-cache-key', encodeURIComponent(this.key))
-    response.headers.set('x-local-cache-mode', shouldBuffer ? 'buffer' : 'stream')
+    response.headers.set('x-local-cache-mode', 'stream')
     response.headers.set('x-local-cache-status', status)
     response.headers.set('x-local-cache-time', new Date(this.entry.metadata.time).toUTCString())
     return response
@@ -415,8 +394,9 @@ class CacheEntry {
       // if the network fetch fails, return the stale
       // cached response unless it has a cache-control
       // of 'must-revalidate'
-      if (!this.policy.mustRevalidate)
+      if (!this.policy.mustRevalidate) {
         return this.respond(request.method, options, 'stale')
+      }
 
       throw err
     }
@@ -429,8 +409,12 @@ class CacheEntry {
       // in the old cache entry to the new one, if the new metadata does not already
       // include that header
       for (const name of KEEP_RESPONSE_HEADERS) {
-        if (!hasOwnProperty(metadata.resHeaders, name) && hasOwnProperty(this.entry.metadata.resHeaders, name))
+        if (
+          !hasOwnProperty(metadata.resHeaders, name) &&
+          hasOwnProperty(this.entry.metadata.resHeaders, name)
+        ) {
           metadata.resHeaders[name] = this.entry.metadata.resHeaders[name]
+        }
       }
 
       try {

package/dist/node_modules/make-fetch-happen/lib/cache/errors.js

@@ -1,5 +1,6 @@
 class NotCachedError extends Error {
   constructor (url) {
+    /* eslint-disable-next-line max-len */
     super(`request to ${url} failed: cache mode is 'only-if-cached' but no cached response is available.`)
     this.code = 'ENOTCACHED'
   }

package/dist/node_modules/make-fetch-happen/lib/cache/index.js

@@ -8,19 +8,21 @@ const cacheFetch = async (request, options) => {
   const entry = await CacheEntry.find(request, options)
   if (!entry) {
     // no cached result, if the cache mode is 'only-if-cached' that's a failure
-    if (options.cache === 'only-if-cached')
+    if (options.cache === 'only-if-cached') {
       throw new NotCachedError(request.url)
+    }
 
     // otherwise, we make a request, store it and return it
     const response = await remote(request, options)
-    const entry = new CacheEntry({ request, response, options })
-    return entry.store('miss')
+    const newEntry = new CacheEntry({ request, response, options })
+    return newEntry.store('miss')
   }
 
   // we have a cached response that satisfies this request, however if the cache
   // mode is 'no-cache' then we send the revalidation request no matter what
-  if (options.cache === 'no-cache')
+  if (options.cache === 'no-cache') {
     return entry.revalidate(request, options)
+  }
 
   // if the cached entry is not stale, or if the cache mode is 'force-cache' or
   // 'only-if-cached' we can respond with the cached entry. set the status
@@ -28,16 +30,18 @@ const cacheFetch = async (request, options) => {
   const _needsRevalidation = entry.policy.needsRevalidation(request)
   if (options.cache === 'force-cache' ||
       options.cache === 'only-if-cached' ||
-      !_needsRevalidation)
+      !_needsRevalidation) {
     return entry.respond(request.method, options, _needsRevalidation ? 'stale' : 'hit')
+  }
 
   // if we got here, the cache entry is stale so revalidate it
   return entry.revalidate(request, options)
 }
 
 cacheFetch.invalidate = async (request, options) => {
-  if (!options.cachePath)
+  if (!options.cachePath) {
     return
+  }
 
   return CacheEntry.invalidate(request, options)
 }