undici 7.0.0-alpha.7 → 7.0.0-alpha.9

package/lib/interceptor/cache.js

@@ -10,45 +10,15 @@ const { assertCacheStore, assertCacheMethods, makeCacheKey, parseCacheControlHea
 const { AbortError } = require('../core/errors.js')
 
 /**
- * @param {import('../../types/dispatcher.d.ts').default.DispatchHandler} handler
+ * @typedef {(options: import('../../types/dispatcher.d.ts').default.DispatchOptions, handler: import('../../types/dispatcher.d.ts').default.DispatchHandler) => void} DispatchFn
  */
-function sendGatewayTimeout (handler) {
-  let aborted = false
-  try {
-    if (typeof handler.onConnect === 'function') {
-      handler.onConnect(() => {
-        aborted = true
-      })
-
-      if (aborted) {
-        return
-      }
-    }
-
-    if (typeof handler.onHeaders === 'function') {
-      handler.onHeaders(504, [], () => {}, 'Gateway Timeout')
-      if (aborted) {
-        return
-      }
-    }
-
-    if (typeof handler.onComplete === 'function') {
-      handler.onComplete([])
-    }
-  } catch (err) {
-    if (typeof handler.onError === 'function') {
-      handler.onError(err)
-    }
-  }
-}
 
 /**
  * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
- * @param {number} age
- * @param {import('../util/cache.js').CacheControlDirectives | undefined} cacheControlDirectives
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives | undefined} cacheControlDirectives
  * @returns {boolean}
  */
-function needsRevalidation (result, age, cacheControlDirectives) {
+function needsRevalidation (result, cacheControlDirectives) {
   if (cacheControlDirectives?.['no-cache']) {
     // Always revalidate requests with the no-cache directive
     return true
@@ -81,6 +51,219 @@ function needsRevalidation (result, age, cacheControlDirectives) {
   return false
 }
 
+/**
+ * @param {DispatchFn} dispatch
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions} globalOpts
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
+ * @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.CacheControlDirectives | undefined} reqCacheControl
+ */
+function handleUncachedResponse (
+  dispatch,
+  globalOpts,
+  cacheKey,
+  handler,
+  opts,
+  reqCacheControl
+) {
+  if (reqCacheControl?.['only-if-cached']) {
+    let aborted = false
+    try {
+      if (typeof handler.onConnect === 'function') {
+        handler.onConnect(() => {
+          aborted = true
+        })
+
+        if (aborted) {
+          return
+        }
+      }
+
+      if (typeof handler.onHeaders === 'function') {
+        handler.onHeaders(504, [], () => {}, 'Gateway Timeout')
+        if (aborted) {
+          return
+        }
+      }
+
+      if (typeof handler.onComplete === 'function') {
+        handler.onComplete([])
+      }
+    } catch (err) {
+      if (typeof handler.onError === 'function') {
+        handler.onError(err)
+      }
+    }
+
+    return true
+  }
+
+  return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
+}
+
+/**
+ * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
+ * @param {number} age
+ */
+function sendCachedValue (handler, opts, result, age, context) {
+  // TODO (perf): Readable.from path can be optimized...
+  const stream = util.isStream(result.body)
+    ? result.body
+    : Readable.from(result.body ?? [])
+
+  assert(!stream.destroyed, 'stream should not be destroyed')
+  assert(!stream.readableDidRead, 'stream should not be readableDidRead')
+
+  const controller = {
+    resume () {
+      stream.resume()
+    },
+    pause () {
+      stream.pause()
+    },
+    get paused () {
+      return stream.isPaused()
+    },
+    get aborted () {
+      return stream.destroyed
+    },
+    get reason () {
+      return stream.errored
+    },
+    abort (reason) {
+      stream.destroy(reason ?? new AbortError())
+    }
+  }
+
+  stream
+    .on('error', function (err) {
+      if (!this.readableEnded) {
+        if (typeof handler.onResponseError === 'function') {
+          handler.onResponseError(controller, err)
+        } else {
+          throw err
+        }
+      }
+    })
+    .on('close', function () {
+      if (!this.errored) {
+        handler.onResponseEnd?.(controller, {})
+      }
+    })
+
+  handler.onRequestStart?.(controller, context)
+
+  if (stream.destroyed) {
+    return
+  }
+
+  // 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
+
+  handler.onResponseStart?.(controller, result.statusCode, headers, result.statusMessage)
+
+  if (opts.method === 'HEAD') {
+    stream.destroy()
+  } else {
+    stream.on('data', function (chunk) {
+      handler.onResponseData?.(controller, chunk)
+    })
+  }
+}
+
+/**
+ * @param {DispatchFn} dispatch
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheHandlerOptions} globalOpts
+ * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
+ * @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.CacheControlDirectives | undefined} reqCacheControl
+ * @param {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined} result
+ */
+function handleResult (
+  dispatch,
+  globalOpts,
+  cacheKey,
+  handler,
+  opts,
+  reqCacheControl,
+  result
+) {
+  if (!result) {
+    return handleUncachedResponse(dispatch, globalOpts, cacheKey, handler, opts, reqCacheControl)
+  }
+
+  const now = Date.now()
+  if (now > result.deleteAt) {
+    // Response is expired, cache store shouldn't have given this to us
+    return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
+  }
+
+  const age = Math.round((now - result.cachedAt) / 1000)
+  if (reqCacheControl?.['max-age'] && age >= reqCacheControl['max-age']) {
+    // Response is considered expired for this specific request
+    //  https://www.rfc-editor.org/rfc/rfc9111.html#section-5.2.1.1
+    return dispatch(opts, handler)
+  }
+
+  // Check if the response is stale
+  if (needsRevalidation(result, reqCacheControl)) {
+    if (util.isStream(opts.body) && util.bodyLength(opts.body) !== 0) {
+      // If body is is stream we can't revalidate...
+      // TODO (fix): This could be less strict...
+      return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
+    }
+
+    let withinStaleIfErrorThreshold = false
+    const staleIfErrorExpiry = result.cacheControlDirectives['stale-if-error'] ?? reqCacheControl?.['stale-if-error']
+    if (staleIfErrorExpiry) {
+      withinStaleIfErrorThreshold = now < (result.staleAt + (staleIfErrorExpiry * 1000))
+    }
+
+    let headers = {
+      ...opts.headers,
+      'if-modified-since': new Date(result.cachedAt).toUTCString(),
+      'if-none-match': result.etag
+    }
+
+    if (result.vary) {
+      headers = {
+        ...headers,
+        ...result.vary
+      }
+    }
+
+    // We need to revalidate the response
+    return dispatch(
+      {
+        ...opts,
+        headers
+      },
+      new CacheRevalidationHandler(
+        (success, context) => {
+          if (success) {
+            sendCachedValue(handler, opts, result, age, context)
+          } else if (util.isStream(result.body)) {
+            result.body.on('error', () => {}).destroy()
+          }
+        },
+        new CacheHandler(globalOpts, cacheKey, handler),
+        withinStaleIfErrorThreshold
+      )
+    )
+  }
+
+  // Dump request body.
+  if (util.isStream(opts.body)) {
+    opts.body.on('error', () => {}).destroy()
+  }
+
+  sendCachedValue(handler, opts, result, age, null)
+}
+
 /**
  * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions} [opts]
  * @returns {import('../../types/dispatcher.d.ts').default.DispatcherComposeInterceptor}
@@ -88,7 +271,9 @@ function needsRevalidation (result, age, cacheControlDirectives) {
 module.exports = (opts = {}) => {
   const {
     store = new MemoryCacheStore(),
-    methods = ['GET']
+    methods = ['GET'],
+    cacheByDefault = undefined,
+    type = 'shared'
   } = opts
 
   if (typeof opts !== 'object' || opts === null) {
@@ -98,28 +283,35 @@ module.exports = (opts = {}) => {
   assertCacheStore(store, 'opts.store')
   assertCacheMethods(methods, 'opts.methods')
 
+  if (typeof cacheByDefault !== 'undefined' && typeof cacheByDefault !== 'number') {
+    throw new TypeError(`exepcted opts.cacheByDefault to be number or undefined, got ${typeof cacheByDefault}`)
+  }
+
+  if (typeof type !== 'undefined' && type !== 'shared' && type !== 'private') {
+    throw new TypeError(`exepcted opts.type to be shared, private, or undefined, got ${typeof type}`)
+  }
+
   const globalOpts = {
     store,
-    methods
+    methods,
+    cacheByDefault,
+    type
   }
 
   const safeMethodsToNotCache = util.safeHTTPMethods.filter(method => methods.includes(method) === false)
 
   return dispatch => {
     return (opts, handler) => {
-      // TODO (fix): What if e.g. opts.headers has if-modified-since header? Or other headers
-      // that make things ambigious?
-
       if (!opts.origin || safeMethodsToNotCache.includes(opts.method)) {
         // Not a method we want to cache or we don't have the origin, skip
         return dispatch(opts, handler)
       }
 
-      const requestCacheControl = opts.headers?.['cache-control']
+      const reqCacheControl = opts.headers?.['cache-control']
         ? parseCacheControlHeader(opts.headers['cache-control'])
         : undefined
 
-      if (requestCacheControl?.['no-store']) {
+      if (reqCacheControl?.['no-store']) {
         return dispatch(opts, handler)
       }
 
@@ -127,172 +319,29 @@ module.exports = (opts = {}) => {
        * @type {import('../../types/cache-interceptor.d.ts').default.CacheKey}
        */
       const cacheKey = makeCacheKey(opts)
-
-      // TODO (perf): For small entries support returning a Buffer instead of a stream.
-      // Maybe store should return { staleAt, headers, body, etc... } instead of a stream + stream.value?
-      // Where body can be a Buffer, string, stream or blob?
       const result = store.get(cacheKey)
-      if (!result) {
-        if (requestCacheControl?.['only-if-cached']) {
-          // We only want cached responses
-          //  https://www.rfc-editor.org/rfc/rfc9111.html#name-only-if-cached
-          sendGatewayTimeout(handler)
-          return true
-        }
-
-        return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
-      }
-
-      /**
-       * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
-       * @param {number} age
-       */
-      const respondWithCachedValue = ({ headers, statusCode, statusMessage, body }, age, context) => {
-        const stream = util.isStream(body)
-          ? body
-          : Readable.from(body ?? [])
-
-        assert(!stream.destroyed, 'stream should not be destroyed')
-        assert(!stream.readableDidRead, 'stream should not be readableDidRead')
-
-        const controller = {
-          resume () {
-            stream.resume()
-          },
-          pause () {
-            stream.pause()
-          },
-          get paused () {
-            return stream.isPaused()
-          },
-          get aborted () {
-            return stream.destroyed
-          },
-          get reason () {
-            return stream.errored
-          },
-          abort (reason) {
-            stream.destroy(reason ?? new AbortError())
-          }
-        }
-
-        stream
-          .on('error', function (err) {
-            if (!this.readableEnded) {
-              if (typeof handler.onResponseError === 'function') {
-                handler.onResponseError(controller, err)
-              } else {
-                throw err
-              }
-            }
-          })
-          .on('close', function () {
-            if (!this.errored) {
-              handler.onResponseEnd?.(controller, {})
-            }
-          })
-
-        handler.onRequestStart?.(controller, context)
-
-        if (stream.destroyed) {
-          return
-        }
-
-        // Add the age header
-        // https://www.rfc-editor.org/rfc/rfc9111.html#name-age
-        // TODO (fix): What if headers.age already exists?
-        headers = age != null ? { ...headers, age: String(age) } : headers
-
-        handler.onResponseStart?.(controller, statusCode, statusMessage, headers)
-
-        if (opts.method === 'HEAD') {
-          stream.destroy()
-        } else {
-          stream.on('data', function (chunk) {
-            handler.onResponseData?.(controller, chunk)
-          })
-        }
-      }
-
-      /**
-       * @param {import('../../types/cache-interceptor.d.ts').default.GetResult} result
-       */
-      const handleResult = (result) => {
-        // TODO (perf): Readable.from path can be optimized...
-
-        if (!result.body && opts.method !== 'HEAD') {
-          throw new Error('stream is undefined but method isn\'t HEAD')
-        }
-
-        const age = Math.round((Date.now() - result.cachedAt) / 1000)
-        if (requestCacheControl?.['max-age'] && age >= requestCacheControl['max-age']) {
-          // Response is considered expired for this specific request
-          //  https://www.rfc-editor.org/rfc/rfc9111.html#section-5.2.1.1
-          return dispatch(opts, handler)
-        }
-
-        // Check if the response is stale
-        if (needsRevalidation(result, age, requestCacheControl)) {
-          if (util.isStream(opts.body) && util.bodyLength(opts.body) !== 0) {
-            // If body is is stream we can't revalidate...
-            // TODO (fix): This could be less strict...
-            return dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
-          }
 
-          // We need to revalidate the response
-          return dispatch(
-            {
-              ...opts,
-              headers: {
-                ...opts.headers,
-                'if-modified-since': new Date(result.cachedAt).toUTCString(),
-                etag: result.etag
-              }
-            },
-            new CacheRevalidationHandler(
-              (success, context) => {
-                if (success) {
-                  respondWithCachedValue(result, age, context)
-                } else if (util.isStream(result.body)) {
-                  result.body.on('error', () => {}).destroy()
-                }
-              },
-              new CacheHandler(globalOpts, cacheKey, handler)
-            )
+      if (result && typeof result.then === 'function') {
+        result.then(result => {
+          handleResult(dispatch,
+            globalOpts,
+            cacheKey,
+            handler,
+            opts,
+            reqCacheControl,
+            result
           )
-        }
-
-        // Dump request body.
-        if (util.isStream(opts.body)) {
-          opts.body.on('error', () => {}).destroy()
-        }
-
-        respondWithCachedValue(result, age, null)
-      }
-
-      if (typeof result.then === 'function') {
-        result.then((result) => {
-          if (!result) {
-            if (requestCacheControl?.['only-if-cached']) {
-              // We only want cached responses
-              //  https://www.rfc-editor.org/rfc/rfc9111.html#name-only-if-cached
-              sendGatewayTimeout(handler)
-              return true
-            }
-
-            dispatch(opts, new CacheHandler(globalOpts, cacheKey, handler))
-          } else {
-            handleResult(result)
-          }
-        }, err => {
-          if (typeof handler.onError === 'function') {
-            handler.onError(err)
-          } else {
-            throw err
-          }
         })
       } else {
-        handleResult(result)
+        handleResult(
+          dispatch,
+          globalOpts,
+          cacheKey,
+          handler,
+          opts,
+          reqCacheControl,
+          result
+        )
       }
 
       return true

package/lib/interceptor/response-error.js

@@ -4,7 +4,7 @@ const { parseHeaders } = require('../core/util')
 const DecoratorHandler = require('../handler/decorator-handler')
 const { ResponseError } = require('../core/errors')
 
-class Handler extends DecoratorHandler {
+class ResponseErrorHandler extends DecoratorHandler {
   #handler
   #statusCode
   #contentType
@@ -66,7 +66,7 @@ class Handler extends DecoratorHandler {
       Error.stackTraceLimit = 0
       try {
         err = new ResponseError('Response Error', this.#statusCode, {
-          data: this.#body,
+          body: this.#body,
           headers: this.#headers
         })
       } finally {
@@ -84,6 +84,10 @@ class Handler extends DecoratorHandler {
   }
 }
 
-module.exports = (dispatch) => (opts, handler) => opts.throwOnError
-  ? dispatch(opts, new Handler(opts, { handler }))
-  : dispatch(opts, handler)
+module.exports = () => {
+  return (dispatch) => {
+    return function Intercept (opts, handler) {
+      return dispatch(opts, new ResponseErrorHandler(opts, { handler }))
+    }
+  }
+}

package/lib/util/cache.js

@@ -96,36 +96,27 @@ function assertCacheValue (value) {
 /**
  * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-cache-control
  * @see https://www.iana.org/assignments/http-cache-directives/http-cache-directives.xhtml
- *
- * @typedef {{
- *   'max-stale'?: number;
- *   'min-fresh'?: number;
- *   'max-age'?: number;
- *   's-maxage'?: number;
- *   'stale-while-revalidate'?: number;
- *   'stale-if-error'?: number;
- *   public?: true;
- *   private?: true | string[];
- *   'no-store'?: true;
- *   'no-cache'?: true | string[];
- *   'must-revalidate'?: true;
- *   'proxy-revalidate'?: true;
- *   immutable?: true;
- *   'no-transform'?: true;
- *   'must-understand'?: true;
- *   'only-if-cached'?: true;
- * }} CacheControlDirectives
- *
+
  * @param {string | string[]} header
- * @returns {CacheControlDirectives}
+ * @returns {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives}
  */
 function parseCacheControlHeader (header) {
   /**
-   * @type {import('../util/cache.js').CacheControlDirectives}
+   * @type {import('../../types/cache-interceptor.d.ts').default.CacheControlDirectives}
    */
   const output = {}
 
-  const directives = Array.isArray(header) ? header : header.split(',')
+  let directives
+  if (Array.isArray(header)) {
+    directives = []
+
+    for (const directive of header) {
+      directives.push(...directive.split(','))
+    }
+  } else {
+    directives = header.split(',')
+  }
+
   for (let i = 0; i < directives.length; i++) {
     const directive = directives[i].toLowerCase()
     const keyValueDelimiter = directive.indexOf('=')
@@ -133,10 +124,8 @@ function parseCacheControlHeader (header) {
     let key
     let value
     if (keyValueDelimiter !== -1) {
-      key = directive.substring(0, keyValueDelimiter).trim()
-      value = directive
-        .substring(keyValueDelimiter + 1)
-        .trim()
+      key = directive.substring(0, keyValueDelimiter).trimStart()
+      value = directive.substring(keyValueDelimiter + 1)
     } else {
       key = directive.trim()
     }
@@ -148,16 +137,28 @@ function parseCacheControlHeader (header) {
       case 's-maxage':
       case 'stale-while-revalidate':
       case 'stale-if-error': {
-        if (value === undefined) {
+        if (value === undefined || value[0] === ' ') {
           continue
         }
 
+        if (
+          value.length >= 2 &&
+          value[0] === '"' &&
+          value[value.length - 1] === '"'
+        ) {
+          value = value.substring(1, value.length - 1)
+        }
+
         const parsedValue = parseInt(value, 10)
         // eslint-disable-next-line no-self-compare
         if (parsedValue !== parsedValue) {
           continue
         }
 
+        if (key === 'max-age' && key in output && output[key] >= parsedValue) {
+          continue
+        }
+
         output[key] = parsedValue
 
         break
@@ -206,11 +207,19 @@ function parseCacheControlHeader (header) {
                 headers[headers.length - 1] = lastHeader
               }
 
-              output[key] = headers
+              if (key in output) {
+                output[key] = output[key].concat(headers)
+              } else {
+                output[key] = headers
+              }
             }
           } else {
             // Something like `no-cache=some-header`
-            output[key] = [value]
+            if (key in output) {
+              output[key] = output[key].concat(value)
+            } else {
+              output[key] = [value]
+            }
           }
 
           break
@@ -248,7 +257,7 @@ function parseCacheControlHeader (header) {
  * @returns {Record<string, string | string[]>}
  */
 function parseVaryHeader (varyHeader, headers) {
-  if (typeof varyHeader === 'string' && varyHeader === '*') {
+  if (typeof varyHeader === 'string' && varyHeader.includes('*')) {
     return headers
   }
 
@@ -262,6 +271,8 @@ function parseVaryHeader (varyHeader, headers) {
 
     if (headers[trimmedHeader]) {
       output[trimmedHeader] = headers[trimmedHeader]
+    } else {
+      return undefined
     }
   }