undici 7.1.0 → 7.2.0

package/README.md

@@ -281,17 +281,23 @@ stalls or deadlocks when running out of connections.
 
 ```js
 // Do
-const headers = await fetch(url)
-  .then(async res => {
-    for await (const chunk of res.body) {
-      // force consumption of body
-    }
-    return res.headers
-  })
+const { body, headers } = await fetch(url);
+for await (const chunk of body) {
+  // force consumption of body
+}
 
 // Do not
-const headers = await fetch(url)
-  .then(res => res.headers)
+const { headers } = await fetch(url);
+```
+
+The same applies for `request` too:
+```js
+// Do
+const { body, headers } = await request(url);
+await res.body.dump(); // force consumption of body
+
+// Do not
+const { headers } = await request(url);
 ```
 
 However, if you want to get only headers, it might be better to use `HEAD` request method. Usage of this method will obviate the need for consumption or cancelling of the response body. See [MDN - HTTP - HTTP request methods - HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) for more details.
@@ -445,6 +451,16 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
 * [__Robert Nagy__](https://github.com/ronag), <https://www.npmjs.com/~ronag>
 * [__Matthew Aitken__](https://github.com/KhafraDev), <https://www.npmjs.com/~khaf>
 
+## Long Term Support
+
+Undici aligns with the Node.js LTS schedule. The following table shows the supported versions:
+
+| Version | Node.js     | End of Life |
+|---------|-------------|-------------|
+| 5.x     | v18.x       | 2024-04-30  |
+| 6.x     | v20.x v22.x | 2026-04-30  |
+| 7.x     | v24.x       | 2027-04-30  |
+
 ## License
 
 MIT

package/docs/docs/api/ProxyAgent.md

@@ -15,6 +15,7 @@ Returns: `ProxyAgent`
 ### Parameter: `ProxyAgentOptions`
 
 Extends: [`AgentOptions`](/docs/docs/api/Agent.md#parameter-agentoptions)
+> It ommits `AgentOptions#connect`.
 
 * **uri** `string | URL` (required) - The URI of the proxy server.  This can be provided as a string, as an instance of the URL class, or as an object with a `uri` property of type string.
 If the `uri` is provided as a string or `uri` is an object with an `uri` property of type string, then it will be parsed into a `URL` object according to the [WHATWG URL Specification](https://url.spec.whatwg.org).
@@ -22,8 +23,8 @@ For detailed information on the parsing process and potential validation errors,
 * **token** `string` (optional) - It can be passed by a string of token for authentication.
 * **auth** `string` (**deprecated**) - Use token.
 * **clientFactory** `(origin: URL, opts: Object) => Dispatcher` (optional) - Default: `(origin, opts) => new Pool(origin, opts)`
-* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. See [TLS](https://nodejs.org/api/tls.html#tlsconnectoptions-callback).
-* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. See [TLS](https://nodejs.org/api/tls.html#tlsconnectoptions-callback).
+* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).
+* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).
 
 Examples:
 
@@ -35,6 +36,13 @@ const proxyAgent = new ProxyAgent('my.proxy.server')
 const proxyAgent = new ProxyAgent(new URL('my.proxy.server'))
 // or
 const proxyAgent = new ProxyAgent({ uri: 'my.proxy.server' })
+// or
+const proxyAgent = new ProxyAgent({
+  uri: new URL('my.proxy.server'),
+  proxyTls: {
+    signal: AbortSignal.timeout(1000)
+  }
+})
 ```
 
 #### Example - Basic ProxyAgent instantiation

package/index.js

@@ -49,15 +49,8 @@ module.exports.cacheStores = {
   MemoryCacheStore: require('./lib/cache/memory-cache-store')
 }
 
-try {
-  const SqliteCacheStore = require('./lib/cache/sqlite-cache-store')
-  module.exports.cacheStores.SqliteCacheStore = SqliteCacheStore
-} catch (err) {
-  // Most likely node:sqlite was not present, since SqliteCacheStore is
-  // optional, don't throw. Don't check specific error codes here because while
-  // ERR_UNKNOWN_BUILTIN_MODULE is expected, users have seen other codes like
-  // MODULE_NOT_FOUND
-}
+const SqliteCacheStore = require('./lib/cache/sqlite-cache-store')
+module.exports.cacheStores.SqliteCacheStore = SqliteCacheStore
 
 module.exports.buildConnector = buildConnector
 module.exports.errors = errors

package/lib/cache/sqlite-cache-store.js

@@ -1,9 +1,10 @@
 'use strict'
 
-const { DatabaseSync } = require('node:sqlite')
 const { Writable } = require('stream')
 const { assertCacheKey, assertCacheValue } = require('../util/cache.js')
 
+let DatabaseSync
+
 const VERSION = 3
 
 // 2gb
@@ -101,6 +102,9 @@ module.exports = class SqliteCacheStore {
       }
     }
 
+    if (!DatabaseSync) {
+      DatabaseSync = require('node:sqlite').DatabaseSync
+    }
     this.#db = new DatabaseSync(opts?.location ?? ':memory:')
 
     this.#db.exec(`

package/lib/dispatcher/client-h2.js

@@ -30,6 +30,7 @@ const {
   kClosed,
   kBodyTimeout
 } = require('../core/symbols.js')
+const { channels } = require('../core/diagnostics.js')
 
 const kOpenStreams = Symbol('open streams')
 
@@ -448,6 +449,14 @@ function writeH2 (client, request) {
 
   session.ref()
 
+  if (channels.sendHeaders.hasSubscribers) {
+    let header = ''
+    for (const key in headers) {
+      header += `${key}: ${headers[key]}\r\n`
+    }
+    channels.sendHeaders.publish({ request, headers: header, socket: session[kSocket] })
+  }
+
   // TODO(metcoder95): add support for sending trailers
   const shouldEndStream = method === 'GET' || method === 'HEAD' || body === null
   if (expectContinue) {

package/lib/handler/cache-handler.js

@@ -6,9 +6,17 @@ const {
   parseVaryHeader,
   isEtagUsable
 } = require('../util/cache')
+const { parseHttpDate } = require('../util/date.js')
 
 function noop () {}
 
+// Status codes that we can use some heuristics on to cache
+const HEURISTICALLY_CACHEABLE_STATUS_CODES = [
+  200, 203, 204, 206, 300, 301, 308, 404, 405, 410, 414, 501
+]
+
+const MAX_RESPONSE_AGE = 2147483647000
+
 /**
  * @typedef {import('../../types/dispatcher.d.ts').default.DispatchHandler} DispatchHandler
  *
@@ -68,17 +76,23 @@ class CacheHandler {
     this.#handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
   }
 
+  /**
+   * @param {import('../../types/dispatcher.d.ts').default.DispatchController} controller
+   * @param {number} statusCode
+   * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
+   * @param {string} statusMessage
+   */
   onResponseStart (
     controller,
     statusCode,
-    headers,
+    resHeaders,
     statusMessage
   ) {
     const downstreamOnHeaders = () =>
       this.#handler.onResponseStart?.(
         controller,
         statusCode,
-        headers,
+        resHeaders,
         statusMessage
       )
 
@@ -87,97 +101,113 @@ class CacheHandler {
       statusCode >= 200 &&
       statusCode <= 399
     ) {
-      // https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-response
+      // Successful response to an unsafe method, delete it from cache
+      //  https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-response
       try {
-        this.#store.delete(this.#cacheKey).catch?.(noop)
+        this.#store.delete(this.#cacheKey)?.catch?.(noop)
       } catch {
         // Fail silently
       }
       return downstreamOnHeaders()
     }
 
-    const cacheControlHeader = headers['cache-control']
-    if (!cacheControlHeader && !headers['expires'] && !this.#cacheByDefault) {
-      // Don't have the cache control header or the cache is full
+    const cacheControlHeader = resHeaders['cache-control']
+    const heuristicallyCacheable = resHeaders['last-modified'] && HEURISTICALLY_CACHEABLE_STATUS_CODES.includes(statusCode)
+    if (
+      !cacheControlHeader &&
+      !resHeaders['expires'] &&
+      !heuristicallyCacheable &&
+      !this.#cacheByDefault
+    ) {
+      // Don't have anything to tell us this response is cachable and we're not
+      //  caching by default
       return downstreamOnHeaders()
     }
 
     const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {}
-    if (!canCacheResponse(this.#cacheType, statusCode, headers, cacheControlDirectives)) {
+    if (!canCacheResponse(this.#cacheType, statusCode, resHeaders, cacheControlDirectives)) {
       return downstreamOnHeaders()
     }
 
-    const age = getAge(headers)
-
     const now = Date.now()
-    const staleAt = determineStaleAt(this.#cacheType, now, headers, cacheControlDirectives) ?? this.#cacheByDefault
-    if (staleAt) {
-      let baseTime = now
-      if (headers['date']) {
-        const parsedDate = parseInt(headers['date'])
-        const date = new Date(isNaN(parsedDate) ? headers['date'] : parsedDate)
-        if (date instanceof Date && !isNaN(date)) {
-          baseTime = date.getTime()
-        }
-      }
+    const resAge = resHeaders.age ? getAge(resHeaders.age) : undefined
+    if (resAge && resAge >= MAX_RESPONSE_AGE) {
+      // Response considered stale
+      return downstreamOnHeaders()
+    }
+
+    const resDate = typeof resHeaders.date === 'string'
+      ? parseHttpDate(resHeaders.date)
+      : undefined
+
+    const staleAt =
+      determineStaleAt(this.#cacheType, now, resAge, resHeaders, resDate, cacheControlDirectives) ??
+      this.#cacheByDefault
+    if (staleAt === undefined || (resAge && resAge > staleAt)) {
+      return downstreamOnHeaders()
+    }
 
-      const absoluteStaleAt = staleAt + baseTime
+    const baseTime = resDate ? resDate.getTime() : now
+    const absoluteStaleAt = staleAt + baseTime
+    if (now >= absoluteStaleAt) {
+      // Response is already stale
+      return downstreamOnHeaders()
+    }
 
-      if (now >= absoluteStaleAt || (age && age >= staleAt)) {
-        // Response is already stale
+    let varyDirectives
+    if (this.#cacheKey.headers && resHeaders.vary) {
+      varyDirectives = parseVaryHeader(resHeaders.vary, this.#cacheKey.headers)
+      if (!varyDirectives) {
+        // Parse error
         return downstreamOnHeaders()
       }
+    }
 
-      let varyDirectives
-      if (this.#cacheKey.headers && headers.vary) {
-        varyDirectives = parseVaryHeader(headers.vary, this.#cacheKey.headers)
-        if (!varyDirectives) {
-          // Parse error
-          return downstreamOnHeaders()
-        }
-      }
+    const deleteAt = determineDeleteAt(baseTime, cacheControlDirectives, absoluteStaleAt)
+    const strippedHeaders = stripNecessaryHeaders(resHeaders, cacheControlDirectives)
+
+    /**
+     * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
+     */
+    const value = {
+      statusCode,
+      statusMessage,
+      headers: strippedHeaders,
+      vary: varyDirectives,
+      cacheControlDirectives,
+      cachedAt: resAge ? now - resAge : now,
+      staleAt: absoluteStaleAt,
+      deleteAt
+    }
 
-      const deleteAt = determineDeleteAt(cacheControlDirectives, absoluteStaleAt)
-      const strippedHeaders = stripNecessaryHeaders(headers, cacheControlDirectives)
+    if (typeof resHeaders.etag === 'string' && isEtagUsable(resHeaders.etag)) {
+      value.etag = resHeaders.etag
+    }
 
-      /**
-       * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
-       */
-      const value = {
-        statusCode,
-        statusMessage,
-        headers: strippedHeaders,
-        vary: varyDirectives,
-        cacheControlDirectives,
-        cachedAt: age ? now - (age * 1000) : now,
-        staleAt: absoluteStaleAt,
-        deleteAt
-      }
+    this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value)
+    if (!this.#writeStream) {
+      return downstreamOnHeaders()
+    }
 
-      if (typeof headers.etag === 'string' && isEtagUsable(headers.etag)) {
-        value.etag = headers.etag
-      }
+    const handler = this
+    this.#writeStream
+      .on('drain', () => controller.resume())
+      .on('error', function () {
+        // TODO (fix): Make error somehow observable?
+        handler.#writeStream = undefined
+
+        // Delete the value in case the cache store is holding onto state from
+        //  the call to createWriteStream
+        handler.#store.delete(handler.#cacheKey)
+      })
+      .on('close', function () {
+        if (handler.#writeStream === this) {
+          handler.#writeStream = undefined
+        }
 
-      this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value)
-
-      if (this.#writeStream) {
-        const handler = this
-        this.#writeStream
-          .on('drain', () => controller.resume())
-          .on('error', function () {
-            // TODO (fix): Make error somehow observable?
-            handler.#writeStream = undefined
-          })
-          .on('close', function () {
-            if (handler.#writeStream === this) {
-              handler.#writeStream = undefined
-            }
-
-            // TODO (fix): Should we resume even if was paused downstream?
-            controller.resume()
-          })
-      }
-    }
+        // TODO (fix): Should we resume even if was paused downstream?
+        controller.resume()
+      })
 
     return downstreamOnHeaders()
   }
@@ -207,18 +237,15 @@ class CacheHandler {
  *
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions['type']} cacheType
  * @param {number} statusCode
- * @param {Record<string, string | string[]>} headers
+ * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  */
-function canCacheResponse (cacheType, statusCode, headers, cacheControlDirectives) {
+function canCacheResponse (cacheType, statusCode, resHeaders, cacheControlDirectives) {
   if (statusCode !== 200 && statusCode !== 307) {
     return false
   }
 
-  if (
-    cacheControlDirectives['no-cache'] === true ||
-    cacheControlDirectives['no-store']
-  ) {
+  if (cacheControlDirectives['no-store']) {
     return false
   }
 
@@ -227,13 +254,13 @@ function canCacheResponse (cacheType, statusCode, headers, cacheControlDirective
   }
 
   // https://www.rfc-editor.org/rfc/rfc9111.html#section-4.1-5
-  if (headers.vary?.includes('*')) {
+  if (resHeaders.vary?.includes('*')) {
     return false
   }
 
   // https://www.rfc-editor.org/rfc/rfc9111.html#name-storing-responses-to-authen
-  if (headers.authorization) {
-    if (!cacheControlDirectives.public || typeof headers.authorization !== 'string') {
+  if (resHeaders.authorization) {
+    if (!cacheControlDirectives.public || typeof resHeaders.authorization !== 'string') {
       return false
     }
 
@@ -256,58 +283,77 @@ function canCacheResponse (cacheType, statusCode, headers, cacheControlDirective
 }
 
 /**
- * @param {Record<string, string | string[]>} headers
+ * @param {string | string[]} ageHeader
  * @returns {number | undefined}
  */
-function getAge (headers) {
-  if (!headers.age) {
-    return undefined
-  }
+function getAge (ageHeader) {
+  const age = parseInt(Array.isArray(ageHeader) ? ageHeader[0] : ageHeader)
 
-  const age = parseInt(Array.isArray(headers.age) ? headers.age[0] : headers.age)
-  if (isNaN(age) || age >= 2147483647) {
-    return undefined
-  }
-
-  return age
+  return isNaN(age) ? undefined : age * 1000
 }
 
 /**
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions['type']} cacheType
  * @param {number} now
- * @param {Record<string, string | string[]>} headers
+ * @param {number | undefined} age
+ * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
+ * @param {Date | undefined} responseDate
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  *
- * @returns {number | undefined} time that the value is stale at or undefined if it shouldn't be cached
+ * @returns {number | undefined} time that the value is stale at in seconds or undefined if it shouldn't be cached
  */
-function determineStaleAt (cacheType, now, headers, cacheControlDirectives) {
+function determineStaleAt (cacheType, now, age, resHeaders, responseDate, cacheControlDirectives) {
   if (cacheType === 'shared') {
     // Prioritize s-maxage since we're a shared cache
     //  s-maxage > max-age > Expire
     //  https://www.rfc-editor.org/rfc/rfc9111.html#section-5.2.2.10-3
     const sMaxAge = cacheControlDirectives['s-maxage']
-    if (sMaxAge) {
-      return sMaxAge * 1000
+    if (sMaxAge !== undefined) {
+      return sMaxAge > 0 ? sMaxAge * 1000 : undefined
     }
   }
 
   const maxAge = cacheControlDirectives['max-age']
-  if (maxAge) {
-    return maxAge * 1000
+  if (maxAge !== undefined) {
+    return maxAge > 0 ? maxAge * 1000 : undefined
   }
 
-  if (headers.expires && typeof headers.expires === 'string') {
+  if (typeof resHeaders.expires === 'string') {
     // https://www.rfc-editor.org/rfc/rfc9111.html#section-5.3
-    const expiresDate = new Date(headers.expires)
-    if (expiresDate instanceof Date && Number.isFinite(expiresDate.valueOf())) {
+    const expiresDate = parseHttpDate(resHeaders.expires)
+    if (expiresDate) {
       if (now >= expiresDate.getTime()) {
         return undefined
       }
 
+      if (responseDate) {
+        if (responseDate >= expiresDate) {
+          return undefined
+        }
+
+        if (age !== undefined && age > (expiresDate - responseDate)) {
+          return undefined
+        }
+      }
+
       return expiresDate.getTime() - now
     }
   }
 
+  if (typeof resHeaders['last-modified'] === 'string') {
+    // https://www.rfc-editor.org/rfc/rfc9111.html#name-calculating-heuristic-fresh
+    const lastModified = new Date(resHeaders['last-modified'])
+    if (isValidDate(lastModified)) {
+      if (lastModified.getTime() >= now) {
+        return undefined
+      }
+
+      const responseAge = now - lastModified.getTime()
+
+      return responseAge * 0.1
+    }
+  }
+
   if (cacheControlDirectives.immutable) {
     // https://www.rfc-editor.org/rfc/rfc8246.html#section-2.2
     return 31536000
@@ -317,10 +363,11 @@ function determineStaleAt (cacheType, now, headers, cacheControlDirectives) {
 }
 
 /**
+ * @param {number} now
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  * @param {number} staleAt
  */
-function determineDeleteAt (cacheControlDirectives, staleAt) {
+function determineDeleteAt (now, cacheControlDirectives, staleAt) {
   let staleWhileRevalidate = -Infinity
   let staleIfError = -Infinity
   let immutable = -Infinity
@@ -334,7 +381,7 @@ function determineDeleteAt (cacheControlDirectives, staleAt) {
   }
 
   if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
-    immutable = 31536000
+    immutable = now + 31536000000
   }
 
   return Math.max(staleAt, staleWhileRevalidate, staleIfError, immutable)
@@ -342,11 +389,11 @@ function determineDeleteAt (cacheControlDirectives, staleAt) {
 
 /**
  * Strips headers required to be removed in cached responses
- * @param {Record<string, string | string[]>} headers
+ * @param {import('../../types/header.d.ts').IncomingHttpHeaders} resHeaders
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  * @returns {Record<string, string | string []>}
  */
-function stripNecessaryHeaders (headers, cacheControlDirectives) {
+function stripNecessaryHeaders (resHeaders, cacheControlDirectives) {
   const headersToRemove = [
     'connection',
     'proxy-authenticate',
@@ -360,14 +407,14 @@ function stripNecessaryHeaders (headers, cacheControlDirectives) {
     'age'
   ]
 
-  if (headers['connection']) {
-    if (Array.isArray(headers['connection'])) {
+  if (resHeaders['connection']) {
+    if (Array.isArray(resHeaders['connection'])) {
       // connection: a
       // connection: b
-      headersToRemove.push(...headers['connection'].map(header => header.trim()))
+      headersToRemove.push(...resHeaders['connection'].map(header => header.trim()))
     } else {
       // connection: a, b
-      headersToRemove.push(...headers['connection'].split(',').map(header => header.trim()))
+      headersToRemove.push(...resHeaders['connection'].split(',').map(header => header.trim()))
     }
   }
 
@@ -381,13 +428,21 @@ function stripNecessaryHeaders (headers, cacheControlDirectives) {
 
   let strippedHeaders
   for (const headerName of headersToRemove) {
-    if (headers[headerName]) {
-      strippedHeaders ??= { ...headers }
+    if (resHeaders[headerName]) {
+      strippedHeaders ??= { ...resHeaders }
       delete strippedHeaders[headerName]
     }
   }
 
-  return strippedHeaders ?? headers
+  return strippedHeaders ?? resHeaders
+}
+
+/**
+ * @param {Date} date
+ * @returns {boolean}
+ */
+function isValidDate (date) {
+  return date instanceof Date && Number.isFinite(date.valueOf())
 }
 
 module.exports = CacheHandler

package/lib/handler/wrap-handler.js

@@ -53,8 +53,7 @@ module.exports = class WrapHandler {
   onRequestUpgrade (controller, statusCode, headers, socket) {
     const rawHeaders = []
     for (const [key, val] of Object.entries(headers)) {
-      // TODO (fix): What if val is Array
-      rawHeaders.push(Buffer.from(key), Buffer.from(val))
+      rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map(v => Buffer.from(v)) : Buffer.from(val))
     }
 
     this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
@@ -63,8 +62,7 @@ module.exports = class WrapHandler {
   onResponseStart (controller, statusCode, headers, statusMessage) {
     const rawHeaders = []
     for (const [key, val] of Object.entries(headers)) {
-      // TODO (fix): What if val is Array
-      rawHeaders.push(Buffer.from(key), Buffer.from(val))
+      rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map(v => Buffer.from(v)) : Buffer.from(val))
     }
 
     if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
@@ -81,8 +79,7 @@ module.exports = class WrapHandler {
   onResponseEnd (controller, trailers) {
     const rawTrailers = []
     for (const [key, val] of Object.entries(trailers)) {
-      // TODO (fix): What if val is Array
-      rawTrailers.push(Buffer.from(key), Buffer.from(val))
+      rawTrailers.push(Buffer.from(key), Array.isArray(val) ? val.map(v => Buffer.from(v)) : Buffer.from(val))
     }
 
     this.#handler.onComplete?.(rawTrailers)

package/lib/interceptor/cache.js

@@ -103,10 +103,14 @@ function handleUncachedResponse (
 }
 
 /**
+ * @param {import('../../types/dispatcher.d.ts').default.DispatchHandler} handler
+ * @param {import('../../types/dispatcher.d.ts').default.RequestOptions} opts
  * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
  * @param {number} age
+ * @param {any} context
+ * @param {boolean} isStale
  */
-function sendCachedValue (handler, opts, result, age, context) {
+function sendCachedValue (handler, opts, result, age, context, isStale) {
   // TODO (perf): Readable.from path can be optimized...
   const stream = util.isStream(result.body)
     ? result.body
@@ -160,8 +164,13 @@ function sendCachedValue (handler, opts, result, age, context) {
 
   // Add the age header
   // https://www.rfc-editor.org/rfc/rfc9111.html#name-age
-  // TODO (fix): What if headers.age already exists?
-  const headers = age != null ? { ...result.headers, age: String(age) } : result.headers
+  const headers = { ...result.headers, age: String(age) }
+
+  if (isStale) {
+    // Add warning header
+    //  https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Warning
+    headers.warning = '110 - "response is stale"'
+  }
 
   handler.onResponseStart?.(controller, result.statusCode, headers, result.statusMessage)
 
@@ -225,8 +234,11 @@ function handleResult (
 
     let headers = {
       ...opts.headers,
-      'if-modified-since': new Date(result.cachedAt).toUTCString(),
-      'if-none-match': result.etag
+      'if-modified-since': new Date(result.cachedAt).toUTCString()
+    }
+
+    if (result.etag) {
+      headers['if-none-match'] = result.etag
     }
 
     if (result.vary) {
@@ -245,7 +257,7 @@ function handleResult (
       new CacheRevalidationHandler(
         (success, context) => {
           if (success) {
-            sendCachedValue(handler, opts, result, age, context)
+            sendCachedValue(handler, opts, result, age, context, true)
           } else if (util.isStream(result.body)) {
             result.body.on('error', () => {}).destroy()
           }
@@ -261,7 +273,7 @@ function handleResult (
     opts.body.on('error', () => {}).destroy()
   }
 
-  sendCachedValue(handler, opts, result, age, null)
+  sendCachedValue(handler, opts, result, age, null, false)
 }
 
 /**

package/lib/interceptor/dns.js

@@ -213,6 +213,10 @@ class DNSInstance {
     this.#records.set(origin.hostname, records)
   }
 
+  deleteRecords (origin) {
+    this.#records.delete(origin.hostname)
+  }
+
   getHandler (meta, opts) {
     return new DNSDispatchHandler(this, meta, opts)
   }
@@ -261,7 +265,7 @@ class DNSDispatchHandler extends DecoratorHandler {
         break
       }
       case 'ENOTFOUND':
-        this.#state.deleteRecord(this.#origin)
+        this.#state.deleteRecords(this.#origin)
       // eslint-disable-next-line no-fallthrough
       default:
         super.onResponseError(controller, err)
@@ -358,7 +362,7 @@ module.exports = interceptorOpts => {
           servername: origin.hostname, // For SNI on TLS
           origin: newOrigin,
           headers: {
-            host: origin.hostname,
+            host: origin.host,
             ...origDispatchOpts.headers
           }
         }

package/lib/interceptor/response-error.js

@@ -16,7 +16,7 @@ class ResponseErrorHandler extends DecoratorHandler {
   }
 
   #checkContentType (contentType) {
-    return this.#contentType.indexOf(contentType) === 0
+    return (this.#contentType ?? '').indexOf(contentType) === 0
   }
 
   onRequestStart (controller, context) {
@@ -81,8 +81,8 @@ class ResponseErrorHandler extends DecoratorHandler {
     }
   }
 
-  onResponseError (err) {
-    super.onResponseError(err)
+  onResponseError (controller, err) {
+    super.onResponseError(controller, err)
   }
 }
 

package/lib/util/cache.js

@@ -5,7 +5,6 @@ const {
 } = require('../core/util')
 
 /**
- *
  * @param {import('../../types/dispatcher.d.ts').default.DispatchOptions} opts
  */
 function makeCacheKey (opts) {

package/lib/util/date.js

@@ -0,0 +1,259 @@
+'use strict'
+
+const IMF_DAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
+const IMF_SPACES = [4, 7, 11, 16, 25]
+const IMF_MONTHS = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
+const IMF_COLONS = [19, 22]
+
+const ASCTIME_SPACES = [3, 7, 10, 19]
+
+const RFC850_DAYS = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-date-time-formats
+ *
+ * @param {string} date
+ * @param {Date} [now]
+ * @returns {Date | undefined}
+ */
+function parseHttpDate (date, now) {
+  // Sun, 06 Nov 1994 08:49:37 GMT    ; IMF-fixdate
+  // Sun Nov  6 08:49:37 1994         ; ANSI C's asctime() format
+  // Sunday, 06-Nov-94 08:49:37 GMT   ; obsolete RFC 850 format
+
+  date = date.toLowerCase()
+
+  switch (date[3]) {
+    case ',': return parseImfDate(date)
+    case ' ': return parseAscTimeDate(date)
+    default: return parseRfc850Date(date, now)
+  }
+}
+
+/**
+ * @see https://httpwg.org/specs/rfc9110.html#preferred.date.format
+ *
+ * @param {string} date
+ * @returns {Date | undefined}
+ */
+function parseImfDate (date) {
+  if (date.length !== 29) {
+    return undefined
+  }
+
+  if (!date.endsWith('gmt')) {
+    // Unsupported timezone
+    return undefined
+  }
+
+  for (const spaceInx of IMF_SPACES) {
+    if (date[spaceInx] !== ' ') {
+      return undefined
+    }
+  }
+
+  for (const colonIdx of IMF_COLONS) {
+    if (date[colonIdx] !== ':') {
+      return undefined
+    }
+  }
+
+  const dayName = date.substring(0, 3)
+  if (!IMF_DAYS.includes(dayName)) {
+    return undefined
+  }
+
+  const dayString = date.substring(5, 7)
+  const day = Number.parseInt(dayString)
+  if (isNaN(day) || (day < 10 && dayString[0] !== '0')) {
+    // Not a number, 0, or it's less than 10 and didn't start with a 0
+    return undefined
+  }
+
+  const month = date.substring(8, 11)
+  const monthIdx = IMF_MONTHS.indexOf(month)
+  if (monthIdx === -1) {
+    return undefined
+  }
+
+  const year = Number.parseInt(date.substring(12, 16))
+  if (isNaN(year)) {
+    return undefined
+  }
+
+  const hourString = date.substring(17, 19)
+  const hour = Number.parseInt(hourString)
+  if (isNaN(hour) || (hour < 10 && hourString[0] !== '0')) {
+    return undefined
+  }
+
+  const minuteString = date.substring(20, 22)
+  const minute = Number.parseInt(minuteString)
+  if (isNaN(minute) || (minute < 10 && minuteString[0] !== '0')) {
+    return undefined
+  }
+
+  const secondString = date.substring(23, 25)
+  const second = Number.parseInt(secondString)
+  if (isNaN(second) || (second < 10 && secondString[0] !== '0')) {
+    return undefined
+  }
+
+  return new Date(Date.UTC(year, monthIdx, day, hour, minute, second))
+}
+
+/**
+ * @see https://httpwg.org/specs/rfc9110.html#obsolete.date.formats
+ *
+ * @param {string} date
+ * @returns {Date | undefined}
+ */
+function parseAscTimeDate (date) {
+  // This is assumed to be in UTC
+
+  if (date.length !== 24) {
+    return undefined
+  }
+
+  for (const spaceIdx of ASCTIME_SPACES) {
+    if (date[spaceIdx] !== ' ') {
+      return undefined
+    }
+  }
+
+  const dayName = date.substring(0, 3)
+  if (!IMF_DAYS.includes(dayName)) {
+    return undefined
+  }
+
+  const month = date.substring(4, 7)
+  const monthIdx = IMF_MONTHS.indexOf(month)
+  if (monthIdx === -1) {
+    return undefined
+  }
+
+  const dayString = date.substring(8, 10)
+  const day = Number.parseInt(dayString)
+  if (isNaN(day) || (day < 10 && dayString[0] !== ' ')) {
+    return undefined
+  }
+
+  const hourString = date.substring(11, 13)
+  const hour = Number.parseInt(hourString)
+  if (isNaN(hour) || (hour < 10 && hourString[0] !== '0')) {
+    return undefined
+  }
+
+  const minuteString = date.substring(14, 16)
+  const minute = Number.parseInt(minuteString)
+  if (isNaN(minute) || (minute < 10 && minuteString[0] !== '0')) {
+    return undefined
+  }
+
+  const secondString = date.substring(17, 19)
+  const second = Number.parseInt(secondString)
+  if (isNaN(second) || (second < 10 && secondString[0] !== '0')) {
+    return undefined
+  }
+
+  const year = Number.parseInt(date.substring(20, 24))
+  if (isNaN(year)) {
+    return undefined
+  }
+
+  return new Date(Date.UTC(year, monthIdx, day, hour, minute, second))
+}
+
+/**
+ * @see https://httpwg.org/specs/rfc9110.html#obsolete.date.formats
+ *
+ * @param {string} date
+ * @param {Date} [now]
+ * @returns {Date | undefined}
+ */
+function parseRfc850Date (date, now = new Date()) {
+  if (!date.endsWith('gmt')) {
+    // Unsupported timezone
+    return undefined
+  }
+
+  const commaIndex = date.indexOf(',')
+  if (commaIndex === -1) {
+    return undefined
+  }
+
+  if ((date.length - commaIndex - 1) !== 23) {
+    return undefined
+  }
+
+  const dayName = date.substring(0, commaIndex)
+  if (!RFC850_DAYS.includes(dayName)) {
+    return undefined
+  }
+
+  if (
+    date[commaIndex + 1] !== ' ' ||
+    date[commaIndex + 4] !== '-' ||
+    date[commaIndex + 8] !== '-' ||
+    date[commaIndex + 11] !== ' ' ||
+    date[commaIndex + 14] !== ':' ||
+    date[commaIndex + 17] !== ':' ||
+    date[commaIndex + 20] !== ' '
+  ) {
+    return undefined
+  }
+
+  const dayString = date.substring(commaIndex + 2, commaIndex + 4)
+  const day = Number.parseInt(dayString)
+  if (isNaN(day) || (day < 10 && dayString[0] !== '0')) {
+    // Not a number, or it's less than 10 and didn't start with a 0
+    return undefined
+  }
+
+  const month = date.substring(commaIndex + 5, commaIndex + 8)
+  const monthIdx = IMF_MONTHS.indexOf(month)
+  if (monthIdx === -1) {
+    return undefined
+  }
+
+  // As of this point year is just the decade (i.e. 94)
+  let year = Number.parseInt(date.substring(commaIndex + 9, commaIndex + 11))
+  if (isNaN(year)) {
+    return undefined
+  }
+
+  const currentYear = now.getUTCFullYear()
+  const currentDecade = currentYear % 100
+  const currentCentury = Math.floor(currentYear / 100)
+
+  if (year > currentDecade && year - currentDecade >= 50) {
+    // Over 50 years in future, go to previous century
+    year += (currentCentury - 1) * 100
+  } else {
+    year += currentCentury * 100
+  }
+
+  const hourString = date.substring(commaIndex + 12, commaIndex + 14)
+  const hour = Number.parseInt(hourString)
+  if (isNaN(hour) || (hour < 10 && hourString[0] !== '0')) {
+    return undefined
+  }
+
+  const minuteString = date.substring(commaIndex + 15, commaIndex + 17)
+  const minute = Number.parseInt(minuteString)
+  if (isNaN(minute) || (minute < 10 && minuteString[0] !== '0')) {
+    return undefined
+  }
+
+  const secondString = date.substring(commaIndex + 18, commaIndex + 20)
+  const second = Number.parseInt(secondString)
+  if (isNaN(second) || (second < 10 && secondString[0] !== '0')) {
+    return undefined
+  }
+
+  return new Date(Date.UTC(year, monthIdx, day, hour, minute, second))
+}
+
+module.exports = {
+  parseHttpDate
+}

package/lib/web/fetch/data-url.js

@@ -283,7 +283,7 @@ function parseMIMEType (input) {
 
   // 5. If position is past the end of input, then return
   // failure
-  if (position.position > input.length) {
+  if (position.position >= input.length) {
     return 'failure'
   }
 
@@ -364,7 +364,7 @@ function parseMIMEType (input) {
     }
 
     // 6. If position is past the end of input, then break.
-    if (position.position > input.length) {
+    if (position.position >= input.length) {
       break
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "7.1.0",
+  "version": "7.2.0",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -69,7 +69,7 @@
     "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE=  npm run test:typescript",
     "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:node-fetch && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:fetch && npm run test:cookies && npm run test:eventsource && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp -p \"test/busboy/*.js\"",
     "test:cache": "borp -p \"test/cache/*.js\"",
@@ -96,6 +96,7 @@
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-websockets.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
     "test:wpt:withoutintl": "node test/wpt/start-fetch.mjs && node test/wpt/start-mimesniff.mjs && node test/wpt/start-xhr.mjs && node test/wpt/start-cacheStorage.mjs && node test/wpt/start-eventsource.mjs",
+    "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
     "coverage:clean": "node ./scripts/clean-coverage.js",
@@ -106,7 +107,7 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.0.0",
+    "@fastify/busboy": "3.1.0",
     "@matteo.collina/tspl": "^0.1.1",
     "@sinonjs/fake-timers": "^12.0.0",
     "@types/node": "^18.19.50",
@@ -121,7 +122,7 @@
     "https-pem": "^3.0.0",
     "husky": "^9.0.7",
     "jest": "^29.0.2",
-    "neostandard": "^0.11.2",
+    "neostandard": "^0.12.0",
     "node-forge": "^1.3.1",
     "proxy": "^2.1.1",
     "tsd": "^0.31.2",

package/types/index.d.ts

@@ -64,6 +64,7 @@ declare namespace Undici {
   const caches: typeof import('./cache').caches
   const interceptors: typeof import('./interceptors').default
   const cacheStores: {
-    MemoryCacheStore: typeof import('./cache-interceptor').default.MemoryCacheStore
+    MemoryCacheStore: typeof import('./cache-interceptor').default.MemoryCacheStore,
+    SqliteCacheStore: typeof import('./cache-interceptor').default.SqliteCacheStore
   }
 }