undici 7.0.0-alpha.6 → 7.0.0-alpha.7

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,9 +10,9 @@ const {
 function noop () {}
 
 /**
- * Writes a response to a CacheStore and then passes it on to the next handler
+ * @implements {import('../../types/dispatcher.d.ts').default.DispatchHandler}
  */
-class CacheHandler extends DecoratorHandler {
+class CacheHandler {
   /**
    * @type {import('../../types/cache-interceptor.d.ts').default.CacheKey}
    */
@@ -25,7 +24,7 @@ class CacheHandler extends DecoratorHandler {
   #store
 
   /**
-   * @type {import('../../types/dispatcher.d.ts').default.DispatchHandlers}
+   * @type {import('../../types/dispatcher.d.ts').default.DispatchHandler}
    */
   #handler
 
@@ -35,58 +34,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)
-
     this.#store = store
     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,21 +84,12 @@ 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) {
       // Don't have the cache control header or the cache is full
       return downstreamOnHeaders()
     }
+
     const cacheControlDirectives = parseCacheControlHeader(cacheControlHeader)
     if (!canCacheResponse(statusCode, headers, cacheControlDirectives)) {
       return downstreamOnHeaders()
@@ -130,11 +103,7 @@ class CacheHandler extends DecoratorHandler {
         : undefined
       const deleteAt = determineDeleteAt(now, cacheControlDirectives, staleAt)
 
-      const strippedHeaders = stripNecessaryHeaders(
-        rawHeaders,
-        parsedRawHeaders,
-        cacheControlDirectives
-      )
+      const strippedHeaders = stripNecessaryHeaders(headers, cacheControlDirectives)
 
       /**
        * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
@@ -142,7 +111,7 @@ class CacheHandler extends DecoratorHandler {
       const value = {
         statusCode,
         statusMessage,
-        rawHeaders: strippedHeaders,
+        headers: strippedHeaders,
         vary: varyDirectives,
         cachedAt: now,
         staleAt,
@@ -158,7 +127,7 @@ 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?
           })
@@ -168,7 +137,7 @@ class CacheHandler extends DecoratorHandler {
             }
 
             // TODO (fix): Should we resume even if was paused downstream?
-            resume()
+            controller.resume()
           })
       }
     }
@@ -176,55 +145,23 @@ 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
+  onResponseData (controller, chunk) {
+    if (this.#writeStream?.write(chunk) === false) {
+      controller.pause()
     }
 
-    if (typeof this.#handler.onData === 'function') {
-      paused ||= this.#handler.onData(chunk) === false
-    }
-
-    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)
   }
 }
 
@@ -236,10 +173,7 @@ class CacheHandler extends DecoratorHandler {
  * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
  */
 function canCacheResponse (statusCode, headers, cacheControlDirectives) {
-  if (
-    statusCode !== 200 &&
-    statusCode !== 307
-  ) {
+  if (statusCode !== 200 && statusCode !== 307) {
     return false
   }
 
@@ -309,7 +243,7 @@ function determineStaleAt (now, headers, cacheControlDirectives) {
   if (headers.expire && typeof headers.expire === 'string') {
     // https://www.rfc-editor.org/rfc/rfc9111.html#section-5.3
     const expiresDate = new Date(headers.expire)
-    if (expiresDate instanceof Date && !isNaN(expiresDate)) {
+    if (expiresDate instanceof Date && Number.isFinite(expiresDate.valueOf())) {
       return now + (Date.now() - expiresDate.getTime())
     }
   }
@@ -332,12 +266,11 @@ function determineDeleteAt (now, cacheControlDirectives, staleAt) {
 
 /**
  * Strips headers required to be removed in cached responses
- * @param {Buffer[]} rawHeaders
- * @param {string[]} parsedRawHeaders
+ * @param {Record<string, string | string[]>} headers
  * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
- * @returns {Buffer[]}
+ * @returns {Record<string, string | string []>}
  */
-function stripNecessaryHeaders (rawHeaders, parsedRawHeaders, cacheControlDirectives) {
+function stripNecessaryHeaders (headers, cacheControlDirectives) {
   const headersToRemove = ['connection']
 
   if (Array.isArray(cacheControlDirectives['no-cache'])) {
@@ -349,51 +282,13 @@ function stripNecessaryHeaders (rawHeaders, parsedRawHeaders, cacheControlDirect
   }
 
   let strippedHeaders
-
-  let offset = 0
-  for (let i = 0; i < parsedRawHeaders.length; i += 2) {
-    const headerName = parsedRawHeaders[i]
-
+  for (const headerName of Object.keys(headers)) {
     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]
+      strippedHeaders ??= { ...headers }
+      delete headers[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

package/lib/handler/cache-revalidation-handler.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const assert = require('node:assert')
-const DecoratorHandler = require('../handler/decorator-handler')
 
 /**
  * This takes care of revalidation requests we send to the origin. If we get
@@ -14,123 +13,86 @@ const DecoratorHandler = require('../handler/decorator-handler')
  *
  * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-validation
  *
- * @typedef {import('../../types/dispatcher.d.ts').default.DispatchHandlers} DispatchHandlers
- * @implements {DispatchHandlers}
+ * @implements {import('../../types/dispatcher.d.ts').default.DispatchHandler}
  */
-class CacheRevalidationHandler extends DecoratorHandler {
+class CacheRevalidationHandler {
   #successful = false
   /**
-   * @type {((boolean) => void) | null}
+   * @type {((boolean, any) => void) | null}
    */
   #callback
   /**
-   * @type {(import('../../types/dispatcher.d.ts').default.DispatchHandlers)}
+   * @type {(import('../../types/dispatcher.d.ts').default.DispatchHandler)}
    */
   #handler
 
-  #abort
+  #context
 
   /**
-   * @param {(boolean) => void} callback Function to call if the cached value is valid
-   * @param {import('../../types/dispatcher.d.ts').default.DispatchHandlers} handler
+   * @param {(boolean, any) => void} callback Function to call if the cached value is valid
+   * @param {import('../../types/dispatcher.d.ts').default.DispatchHandler} handler
    */
   constructor (callback, handler) {
     if (typeof callback !== 'function') {
       throw new TypeError('callback must be a function')
     }
 
-    super(handler)
-
     this.#callback = callback
     this.#handler = handler
   }
 
-  onConnect (abort) {
+  onRequestStart (controller, context) {
     this.#successful = false
-    this.#abort = abort
+    this.#context = context
   }
 
-  /**
-   * @see {DispatchHandlers.onHeaders}
-   *
-   * @param {number} statusCode
-   * @param {Buffer[]} rawHeaders
-   * @param {() => void} resume
-   * @param {string} statusMessage
-   * @returns {boolean}
-   */
-  onHeaders (
+  onRequestUpgrade (controller, statusCode, headers, socket) {
+    this.#handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
+  }
+
+  onResponseStart (
+    controller,
     statusCode,
-    rawHeaders,
-    resume,
-    statusMessage
+    statusMessage,
+    headers
   ) {
     assert(this.#callback != null)
 
     // https://www.rfc-editor.org/rfc/rfc9111.html#name-handling-a-validation-respo
     this.#successful = statusCode === 304
-    this.#callback(this.#successful)
+    this.#callback(this.#successful, this.#context)
     this.#callback = null
 
     if (this.#successful) {
       return true
     }
 
-    if (typeof this.#handler.onConnect === 'function') {
-      this.#handler.onConnect(this.#abort)
-    }
-
-    if (typeof this.#handler.onHeaders === 'function') {
-      return this.#handler.onHeaders(
-        statusCode,
-        rawHeaders,
-        resume,
-        statusMessage
-      )
-    }
-
-    return true
+    this.#handler.onRequestStart?.(controller, this.#context)
+    this.#handler.onResponseStart?.(
+      controller,
+      statusCode,
+      statusMessage,
+      headers
+    )
   }
 
-  /**
-   * @see {DispatchHandlers.onData}
-   *
-   * @param {Buffer} chunk
-   * @returns {boolean}
-   */
-  onData (chunk) {
+  onResponseData (controller, chunk) {
     if (this.#successful) {
-      return true
-    }
-
-    if (typeof this.#handler.onData === 'function') {
-      return this.#handler.onData(chunk)
+      return
     }
 
-    return true
+    return this.#handler.onResponseData(controller, chunk)
   }
 
-  /**
-   * @see {DispatchHandlers.onComplete}
-   *
-   * @param {string[] | null} rawTrailers
-   */
-  onComplete (rawTrailers) {
+  onResponseEnd (controller, trailers) {
     if (this.#successful) {
       return
     }
 
-    if (typeof this.#handler.onComplete === 'function') {
-      this.#handler.onComplete(rawTrailers)
-    }
+    this.#handler.onResponseEnd?.(controller, trailers)
   }
 
-  /**
-   * @see {DispatchHandlers.onError}
-   *
-   * @param {Error} err
-   */
-  onError (err) {
+  onResponseError (controller, err) {
     if (this.#successful) {
       return
     }
@@ -140,8 +102,8 @@ class CacheRevalidationHandler extends DecoratorHandler {
       this.#callback = null
     }
 
-    if (typeof this.#handler.onError === 'function') {
-      this.#handler.onError(err)
+    if (typeof this.#handler.onResponseError === 'function') {
+      this.#handler.onResponseError(controller, err)
     } else {
       throw err
     }

package/lib/handler/redirect-handler.js

@@ -10,6 +10,8 @@ const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
 
 const kBody = Symbol('body')
 
+const noop = () => {}
+
 class BodyAsyncIterable {
   constructor (body) {
     this[kBody] = body
@@ -38,8 +40,6 @@ class RedirectHandler {
       throw new InvalidArgumentError('maxRedirections must be a positive number')
     }
 
-    util.assertRequestHandler(handler, opts.method, opts.upgrade)
-
     this.dispatch = dispatch
     this.location = null
     this.abort = null
@@ -47,7 +47,6 @@ class RedirectHandler {
     this.maxRedirections = maxRedirections
     this.handler = handler
     this.history = []
-    this.redirectionLimitReached = false
 
     if (util.isStream(this.opts.body)) {
       // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
@@ -97,27 +96,42 @@ class RedirectHandler {
     this.handler.onError(error)
   }
 
-  onHeaders (statusCode, headers, resume, statusText) {
-    this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body)
-      ? null
-      : parseLocation(statusCode, headers)
-
+  onHeaders (statusCode, rawHeaders, resume, statusText) {
     if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
-      if (this.request) {
-        this.request.abort(new Error('max redirects'))
+      throw new Error('max redirects')
+    }
+
+    // https://tools.ietf.org/html/rfc7231#section-6.4.2
+    // https://fetch.spec.whatwg.org/#http-redirect-fetch
+    // In case of HTTP 301 or 302 with POST, change the method to GET
+    if ((statusCode === 301 || statusCode === 302) && this.opts.method === 'POST') {
+      this.opts.method = 'GET'
+      if (util.isStream(this.opts.body)) {
+        util.destroy(this.opts.body.on('error', noop))
       }
+      this.opts.body = null
+    }
 
-      this.redirectionLimitReached = true
-      this.abort(new Error('max redirects'))
-      return
+    // https://tools.ietf.org/html/rfc7231#section-6.4.4
+    // In case of HTTP 303, always replace method to be either HEAD or GET
+    if (statusCode === 303 && this.opts.method !== 'HEAD') {
+      this.opts.method = 'GET'
+      if (util.isStream(this.opts.body)) {
+        util.destroy(this.opts.body.on('error', noop))
+      }
+      this.opts.body = null
     }
 
+    this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body)
+      ? null
+      : parseLocation(statusCode, rawHeaders)
+
     if (this.opts.origin) {
       this.history.push(new URL(this.opts.path, this.opts.origin))
     }
 
     if (!this.location) {
-      return this.handler.onHeaders(statusCode, headers, resume, statusText)
+      return this.handler.onHeaders(statusCode, rawHeaders, resume, statusText)
     }
 
     const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
@@ -131,13 +145,6 @@ class RedirectHandler {
     this.opts.origin = origin
     this.opts.maxRedirections = 0
     this.opts.query = null
-
-    // https://tools.ietf.org/html/rfc7231#section-6.4.4
-    // In case of HTTP 303, always replace method to be either HEAD or GET
-    if (statusCode === 303 && this.opts.method !== 'HEAD') {
-      this.opts.method = 'GET'
-      this.opts.body = null
-    }
   }
 
   onData (chunk) {
@@ -191,14 +198,14 @@ class RedirectHandler {
   }
 }
 
-function parseLocation (statusCode, headers) {
+function parseLocation (statusCode, rawHeaders) {
   if (redirectableStatusCodes.indexOf(statusCode) === -1) {
     return null
   }
 
-  for (let i = 0; i < headers.length; i += 2) {
-    if (headers[i].length === 8 && util.headerNameToString(headers[i]) === 'location') {
-      return headers[i + 1]
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    if (rawHeaders[i].length === 8 && util.headerNameToString(rawHeaders[i]) === 'location') {
+      return rawHeaders[i + 1]
     }
   }
 }

package/lib/handler/retry-handler.js

@@ -37,6 +37,7 @@ class RetryHandler {
     this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) }
     this.abort = null
     this.aborted = false
+    this.connectCalled = false
     this.retryOpts = {
       retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
       retryAfter: retryAfter ?? true,
@@ -68,16 +69,6 @@ class RetryHandler {
     this.end = null
     this.etag = null
     this.resume = null
-
-    // Handle possible onConnect duplication
-    this.handler.onConnect(reason => {
-      this.aborted = true
-      if (this.abort) {
-        this.abort(reason)
-      } else {
-        this.reason = reason
-      }
-    })
   }
 
   onRequestSent () {
@@ -92,11 +83,14 @@ class RetryHandler {
     }
   }
 
-  onConnect (abort) {
-    if (this.aborted) {
-      abort(this.reason)
-    } else {
-      this.abort = abort
+  onConnect (abort, context) {
+    this.abort = abort
+    if (!this.connectCalled) {
+      this.connectCalled = true
+      this.handler.onConnect(reason => {
+        this.aborted = true
+        this.abort(reason)
+      }, context)
     }
   }