undici 7.0.0-alpha.6 → 7.0.0-alpha.8

package/lib/dispatcher/dispatcher.js

@@ -1,5 +1,8 @@
 'use strict'
 const EventEmitter = require('node:events')
+const WrapHandler = require('../handler/wrap-handler')
+
+const wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler))
 
 class Dispatcher extends EventEmitter {
   dispatch () {
@@ -29,6 +32,7 @@ class Dispatcher extends EventEmitter {
       }
 
       dispatch = interceptor(dispatch)
+      dispatch = wrapInterceptor(dispatch)
 
       if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
         throw new TypeError('invalid interceptor')

package/lib/handler/cache-handler.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const util = require('../core/util')
-const DecoratorHandler = require('../handler/decorator-handler')
 const {
   parseCacheControlHeader,
   parseVaryHeader,
@@ -11,21 +10,33 @@ const {
 function noop () {}
 
 /**
- * Writes a response to a CacheStore and then passes it on to the next handler
+ * @typedef {import('../../types/dispatcher.d.ts').default.DispatchHandler} DispatchHandler
+ *
+ * @implements {DispatchHandler}
  */
-class CacheHandler extends DecoratorHandler {
+class CacheHandler {
   /**
    * @type {import('../../types/cache-interceptor.d.ts').default.CacheKey}
    */
   #cacheKey
 
+  /**
+   * @type {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions['type']}
+   */
+  #cacheType
+
+  /**
+   * @type {number | undefined}
+   */
+  #cacheByDefault
+
   /**
    * @type {import('../../types/cache-interceptor.d.ts').default.CacheStore}
    */
   #store
 
   /**
-   * @type {import('../../types/dispatcher.d.ts').default.DispatchHandlers}
+   * @type {import('../../types/dispatcher.d.ts').default.DispatchHandler}
    */
   #handler
 
@@ -35,58 +46,41 @@ class CacheHandler extends DecoratorHandler {
   #writeStream
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions} opts
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions} opts
    * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
-   * @param {import('../../types/dispatcher.d.ts').default.DispatchHandlers} handler
+   * @param {import('../../types/dispatcher.d.ts').default.DispatchHandler} handler
    */
-  constructor (opts, cacheKey, handler) {
-    const { store } = opts
-
-    super(handler)
-
+  constructor ({ store, type, cacheByDefault }, cacheKey, handler) {
     this.#store = store
+    this.#cacheType = type
+    this.#cacheByDefault = cacheByDefault
     this.#cacheKey = cacheKey
     this.#handler = handler
   }
 
-  onConnect (abort) {
-    if (this.#writeStream) {
-      this.#writeStream.destroy()
-      this.#writeStream = undefined
-    }
+  onRequestStart (controller, context) {
+    this.#writeStream?.destroy()
+    this.#writeStream = undefined
+    this.#handler.onRequestStart?.(controller, context)
+  }
 
-    if (typeof this.#handler.onConnect === 'function') {
-      this.#handler.onConnect(abort)
-    }
+  onRequestUpgrade (controller, statusCode, headers, socket) {
+    this.#handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
   }
 
-  /**
-   * @see {DispatchHandlers.onHeaders}
-   *
-   * @param {number} statusCode
-   * @param {Buffer[]} rawHeaders
-   * @param {() => void} resume
-   * @param {string} statusMessage
-   * @returns {boolean}
-   */
-  onHeaders (
+  onResponseStart (
+    controller,
     statusCode,
-    rawHeaders,
-    resume,
-    statusMessage
+    statusMessage,
+    headers
   ) {
-    const downstreamOnHeaders = () => {
-      if (typeof this.#handler.onHeaders === 'function') {
-        return this.#handler.onHeaders(
-          statusCode,
-          rawHeaders,
-          resume,
-          statusMessage
-        )
-      } else {
-        return true
-      }
-    }
+    const downstreamOnHeaders = () =>
+      this.#handler.onResponseStart?.(
+        controller,
+        statusCode,
+        statusMessage,
+        headers
+      )
 
     if (
       !util.safeHTTPMethods.includes(this.#cacheKey.method) &&
@@ -102,39 +96,49 @@ class CacheHandler extends DecoratorHandler {
       return downstreamOnHeaders()
     }
 
-    const parsedRawHeaders = util.parseRawHeaders(rawHeaders)
-    const headers = util.parseHeaders(parsedRawHeaders)
-
     const cacheControlHeader = headers['cache-control']
-    const isCacheFull = typeof this.#store.isFull !== 'undefined'
-      ? this.#store.isFull
-      : false
-
-    if (
-      !cacheControlHeader ||
-      isCacheFull
-    ) {
+    if (!cacheControlHeader && !headers['expires'] && !this.#cacheByDefault) {
       // Don't have the cache control header or the cache is full
       return downstreamOnHeaders()
     }
-    const cacheControlDirectives = parseCacheControlHeader(cacheControlHeader)
-    if (!canCacheResponse(statusCode, headers, cacheControlDirectives)) {
+
+    const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {}
+    if (!canCacheResponse(this.#cacheType, statusCode, headers, cacheControlDirectives)) {
       return downstreamOnHeaders()
     }
 
+    const age = getAge(headers)
+
     const now = Date.now()
-    const staleAt = determineStaleAt(now, headers, cacheControlDirectives)
+    const staleAt = determineStaleAt(this.#cacheType, now, headers, cacheControlDirectives) ?? this.#cacheByDefault
     if (staleAt) {
-      const varyDirectives = this.#cacheKey.headers && headers.vary
-        ? parseVaryHeader(headers.vary, this.#cacheKey.headers)
-        : undefined
-      const deleteAt = determineDeleteAt(now, cacheControlDirectives, staleAt)
-
-      const strippedHeaders = stripNecessaryHeaders(
-        rawHeaders,
-        parsedRawHeaders,
-        cacheControlDirectives
-      )
+      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 absoluteStaleAt = staleAt + baseTime
+
+      if (now >= absoluteStaleAt || (age && age >= staleAt)) {
+        // Response is already stale
+        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(cacheControlDirectives, absoluteStaleAt)
+      const strippedHeaders = stripNecessaryHeaders(headers, cacheControlDirectives)
 
       /**
        * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
@@ -142,10 +146,11 @@ class CacheHandler extends DecoratorHandler {
       const value = {
         statusCode,
         statusMessage,
-        rawHeaders: strippedHeaders,
+        headers: strippedHeaders,
         vary: varyDirectives,
-        cachedAt: now,
-        staleAt,
+        cacheControlDirectives,
+        cachedAt: age ? now - (age * 1000) : now,
+        staleAt: absoluteStaleAt,
         deleteAt
       }
 
@@ -158,9 +163,10 @@ class CacheHandler extends DecoratorHandler {
       if (this.#writeStream) {
         const handler = this
         this.#writeStream
-          .on('drain', resume)
+          .on('drain', () => controller.resume())
           .on('error', function () {
             // TODO (fix): Make error somehow observable?
+            handler.#writeStream = undefined
           })
           .on('close', function () {
             if (handler.#writeStream === this) {
@@ -168,7 +174,7 @@ class CacheHandler extends DecoratorHandler {
             }
 
             // TODO (fix): Should we resume even if was paused downstream?
-            resume()
+            controller.resume()
           })
       }
     }
@@ -176,83 +182,52 @@ class CacheHandler extends DecoratorHandler {
     return downstreamOnHeaders()
   }
 
-  /**
-   * @see {DispatchHandlers.onData}
-   *
-   * @param {Buffer} chunk
-   * @returns {boolean}
-   */
-  onData (chunk) {
-    let paused = false
-
-    if (this.#writeStream) {
-      paused ||= this.#writeStream.write(chunk) === false
-    }
-
-    if (typeof this.#handler.onData === 'function') {
-      paused ||= this.#handler.onData(chunk) === false
+  onResponseData (controller, chunk) {
+    if (this.#writeStream?.write(chunk) === false) {
+      controller.pause()
     }
 
-    return !paused
+    this.#handler.onResponseData?.(controller, chunk)
   }
 
-  /**
-   * @see {DispatchHandlers.onComplete}
-   *
-   * @param {string[] | null} rawTrailers
-   */
-  onComplete (rawTrailers) {
-    if (this.#writeStream) {
-      this.#writeStream.end()
-    }
-
-    if (typeof this.#handler.onComplete === 'function') {
-      return this.#handler.onComplete(rawTrailers)
-    }
+  onResponseEnd (controller, trailers) {
+    this.#writeStream?.end()
+    this.#handler.onResponseEnd?.(controller, trailers)
   }
 
-  /**
-   * @see {DispatchHandlers.onError}
-   *
-   * @param {Error} err
-   */
-  onError (err) {
-    if (this.#writeStream) {
-      this.#writeStream.destroy(err)
-      this.#writeStream = undefined
-    }
-
-    if (typeof this.#handler.onError === 'function') {
-      this.#handler.onError(err)
-    }
+  onResponseError (controller, err) {
+    this.#writeStream?.destroy(err)
+    this.#writeStream = undefined
+    this.#handler.onResponseError?.(controller, err)
   }
 }
 
 /**
  * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-storing-responses-to-authen
  *
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions['type']} cacheType
  * @param {number} statusCode
  * @param {Record<string, string | string[]>} headers
- * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  */
-function canCacheResponse (statusCode, headers, cacheControlDirectives) {
-  if (
-    statusCode !== 200 &&
-    statusCode !== 307
-  ) {
+function canCacheResponse (cacheType, statusCode, headers, cacheControlDirectives) {
+  if (statusCode !== 200 && statusCode !== 307) {
     return false
   }
 
   if (
-    cacheControlDirectives.private === true ||
     cacheControlDirectives['no-cache'] === true ||
     cacheControlDirectives['no-store']
   ) {
     return false
   }
 
+  if (cacheType === 'shared' && cacheControlDirectives.private === true) {
+    return false
+  }
+
   // https://www.rfc-editor.org/rfc/rfc9111.html#section-4.1-5
-  if (headers.vary === '*') {
+  if (headers.vary?.includes('*')) {
     return false
   }
 
@@ -281,64 +256,120 @@ function canCacheResponse (statusCode, headers, cacheControlDirectives) {
 }
 
 /**
+ * @param {Record<string, string | string[]>} headers
+ * @returns {number | undefined}
+ */
+function getAge (headers) {
+  if (!headers.age) {
+    return undefined
+  }
+
+  const age = parseInt(Array.isArray(headers.age) ? headers.age[0] : headers.age)
+  if (isNaN(age) || age >= 2147483647) {
+    return undefined
+  }
+
+  return age
+}
+
+/**
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions['type']} cacheType
  * @param {number} now
  * @param {Record<string, string | string[]>} headers
- * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
+ * @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
  */
-function determineStaleAt (now, headers, cacheControlDirectives) {
-  // 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 now + (sMaxAge * 1000)
-  }
-
-  if (cacheControlDirectives.immutable) {
-    // https://www.rfc-editor.org/rfc/rfc8246.html#section-2.2
-    return now + 31536000
+function determineStaleAt (cacheType, now, headers, 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
+    }
   }
 
   const maxAge = cacheControlDirectives['max-age']
   if (maxAge) {
-    return now + (maxAge * 1000)
+    return maxAge * 1000
   }
 
-  if (headers.expire && typeof headers.expire === 'string') {
+  if (headers.expires && typeof headers.expires === 'string') {
     // https://www.rfc-editor.org/rfc/rfc9111.html#section-5.3
-    const expiresDate = new Date(headers.expire)
-    if (expiresDate instanceof Date && !isNaN(expiresDate)) {
-      return now + (Date.now() - expiresDate.getTime())
+    const expiresDate = new Date(headers.expires)
+    if (expiresDate instanceof Date && Number.isFinite(expiresDate.valueOf())) {
+      if (now >= expiresDate.getTime()) {
+        return undefined
+      }
+
+      return expiresDate.getTime() - now
     }
   }
 
+  if (cacheControlDirectives.immutable) {
+    // https://www.rfc-editor.org/rfc/rfc8246.html#section-2.2
+    return 31536000
+  }
+
   return undefined
 }
 
 /**
- * @param {number} now
- * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
  * @param {number} staleAt
  */
-function determineDeleteAt (now, cacheControlDirectives, staleAt) {
+function determineDeleteAt (cacheControlDirectives, staleAt) {
+  let staleWhileRevalidate = -Infinity
+  let staleIfError = -Infinity
+  let immutable = -Infinity
+
   if (cacheControlDirectives['stale-while-revalidate']) {
-    return now + (cacheControlDirectives['stale-while-revalidate'] * 1000)
+    staleWhileRevalidate = staleAt + (cacheControlDirectives['stale-while-revalidate'] * 1000)
+  }
+
+  if (cacheControlDirectives['stale-if-error']) {
+    staleIfError = staleAt + (cacheControlDirectives['stale-if-error'] * 1000)
   }
 
-  return staleAt
+  if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
+    immutable = 31536000
+  }
+
+  return Math.max(staleAt, staleWhileRevalidate, staleIfError, immutable)
 }
 
 /**
  * Strips headers required to be removed in cached responses
- * @param {Buffer[]} rawHeaders
- * @param {string[]} parsedRawHeaders
- * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
- * @returns {Buffer[]}
+ * @param {Record<string, string | string[]>} headers
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives} cacheControlDirectives
+ * @returns {Record<string, string | string []>}
  */
-function stripNecessaryHeaders (rawHeaders, parsedRawHeaders, cacheControlDirectives) {
-  const headersToRemove = ['connection']
+function stripNecessaryHeaders (headers, cacheControlDirectives) {
+  const headersToRemove = [
+    'connection',
+    'proxy-authenticate',
+    'proxy-authentication-info',
+    'proxy-authorization',
+    'proxy-connection',
+    'te',
+    'transfer-encoding',
+    'upgrade',
+    // We'll add age back when serving it
+    'age'
+  ]
+
+  if (headers['connection']) {
+    if (Array.isArray(headers['connection'])) {
+      // connection: a
+      // connection: b
+      headersToRemove.push(...headers['connection'].map(header => header.trim()))
+    } else {
+      // connection: a, b
+      headersToRemove.push(...headers['connection'].split(',').map(header => header.trim()))
+    }
+  }
 
   if (Array.isArray(cacheControlDirectives['no-cache'])) {
     headersToRemove.push(...cacheControlDirectives['no-cache'])
@@ -349,51 +380,14 @@ function stripNecessaryHeaders (rawHeaders, parsedRawHeaders, cacheControlDirect
   }
 
   let strippedHeaders
-
-  let offset = 0
-  for (let i = 0; i < parsedRawHeaders.length; i += 2) {
-    const headerName = parsedRawHeaders[i]
-
-    if (headersToRemove.includes(headerName)) {
-      // We have at least one header we want to remove
-      if (!strippedHeaders) {
-        // This is the first header we want to remove, let's create the array
-        // Since we're stripping headers, this will over allocate. We'll trim
-        //  it later.
-        strippedHeaders = new Array(parsedRawHeaders.length)
-
-        // Backfill the previous headers into it
-        for (let j = 0; j < i; j += 2) {
-          strippedHeaders[j] = parsedRawHeaders[j]
-          strippedHeaders[j + 1] = parsedRawHeaders[j + 1]
-        }
-      }
-
-      // We can't map indices 1:1 from stripped headers to rawHeaders without
-      //  creating holes (if we skip a header, we now have two holes where at
-      //  element should be). So, let's keep an offset to keep strippedHeaders
-      //  flattened. We can also use this at the end for trimming the empty
-      //  elements off of strippedHeaders.
-      offset += 2
-
-      continue
-    }
-
-    // We want to keep this header. Let's add it to strippedHeaders if it exists
-    if (strippedHeaders) {
-      strippedHeaders[i - offset] = parsedRawHeaders[i]
-      strippedHeaders[i + 1 - offset] = parsedRawHeaders[i + 1]
+  for (const headerName of headersToRemove) {
+    if (headers[headerName]) {
+      strippedHeaders ??= { ...headers }
+      delete strippedHeaders[headerName]
     }
   }
 
-  if (strippedHeaders) {
-    // Trim off the empty values at the end
-    strippedHeaders.length -= offset
-  }
-
-  return strippedHeaders
-    ? util.encodeRawHeaders(strippedHeaders)
-    : rawHeaders
+  return strippedHeaders ?? headers
 }
 
 module.exports = CacheHandler