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

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,97 @@ 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
+
+  /**
+   * @type {boolean}
+   */
+  #allowErrorStatusCodes
 
   /**
    * @param {(boolean) => void} callback Function to call if the cached value is valid
    * @param {import('../../types/dispatcher.d.ts').default.DispatchHandlers} handler
+   * @param {boolean} allowErrorStatusCodes
    */
-  constructor (callback, handler) {
+  constructor (callback, handler, allowErrorStatusCodes) {
     if (typeof callback !== 'function') {
       throw new TypeError('callback must be a function')
     }
 
-    super(handler)
-
     this.#callback = callback
     this.#handler = handler
+    this.#allowErrorStatusCodes = allowErrorStatusCodes
   }
 
-  onConnect (abort) {
+  onRequestStart (_, 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)
+    // https://datatracker.ietf.org/doc/html/rfc5861#section-4
+    this.#successful = statusCode === 304 ||
+      (this.#allowErrorStatusCodes && statusCode >= 500 && statusCode <= 504)
+    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 +113,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/decorator-handler.js

@@ -2,6 +2,9 @@
 
 const assert = require('node:assert')
 
+/**
+ * @deprecated
+ */
 module.exports = class DecoratorHandler {
   #handler
   #onCompleteCalled = false

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,16 +40,12 @@ 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
     this.opts = { ...opts, maxRedirections: 0 } // opts must be a copy
     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
@@ -84,40 +82,51 @@ class RedirectHandler {
     }
   }
 
-  onConnect (abort) {
-    this.abort = abort
-    this.handler.onConnect(abort, { history: this.history })
+  onRequestStart (controller, context) {
+    this.handler.onRequestStart?.(controller, { ...context, history: this.history })
   }
 
-  onUpgrade (statusCode, headers, socket) {
-    this.handler.onUpgrade(statusCode, headers, socket)
+  onRequestUpgrade (controller, statusCode, headers, socket) {
+    this.handler.onRequestUpgrade?.(controller, statusCode, headers, socket)
   }
 
-  onError (error) {
-    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)
-
+  onResponseStart (controller, statusCode, statusMessage, headers) {
     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) || redirectableStatusCodes.indexOf(statusCode) === -1
+      ? null
+      : headers.location
+
     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)
+      this.handler.onResponseStart?.(controller, statusCode, statusMessage, headers)
+      return
     }
 
     const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
@@ -131,16 +140,9 @@ 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) {
+  onResponseData (controller, chunk) {
     if (this.location) {
       /*
         https://tools.ietf.org/html/rfc7231#section-6.4
@@ -160,11 +162,11 @@ class RedirectHandler {
         servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
       */
     } else {
-      return this.handler.onData(chunk)
+      this.handler.onResponseData?.(controller, chunk)
     }
   }
 
-  onComplete (trailers) {
+  onResponseEnd (controller, trailers) {
     if (this.location) {
       /*
         https://tools.ietf.org/html/rfc7231#section-6.4
@@ -174,32 +176,14 @@ class RedirectHandler {
 
         See comment on onData method above for more detailed information.
       */
-
-      this.location = null
-      this.abort = null
-
       this.dispatch(this.opts, this)
     } else {
-      this.handler.onComplete(trailers)
+      this.handler.onResponseEnd(controller, trailers)
     }
   }
 
-  onBodySent (chunk) {
-    if (this.handler.onBodySent) {
-      this.handler.onBodySent(chunk)
-    }
-  }
-}
-
-function parseLocation (statusCode, headers) {
-  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]
-    }
+  onResponseError (controller, error) {
+    this.handler.onResponseError?.(controller, error)
   }
 }
 

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)
     }
   }
 

package/lib/handler/unwrap-handler.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const { parseHeaders } = require('../core/util')
+const { InvalidArgumentError } = require('../core/errors')
+
+const kResume = Symbol('resume')
+
+class UnwrapController {
+  #paused = false
+  #reason = null
+  #aborted = false
+  #abort
+
+  [kResume] = null
+
+  constructor (abort) {
+    this.#abort = abort
+  }
+
+  pause () {
+    this.#paused = true
+  }
+
+  resume () {
+    if (this.#paused) {
+      this.#paused = false
+      this[kResume]?.()
+    }
+  }
+
+  abort (reason) {
+    if (!this.#aborted) {
+      this.#aborted = true
+      this.#reason = reason
+      this.#abort(reason)
+    }
+  }
+
+  get aborted () {
+    return this.#aborted
+  }
+
+  get reason () {
+    return this.#reason
+  }
+
+  get paused () {
+    return this.#paused
+  }
+}
+
+module.exports = class UnwrapHandler {
+  #handler
+  #controller
+
+  constructor (handler) {
+    this.#handler = handler
+  }
+
+  static unwrap (handler) {
+    // TODO (fix): More checks...
+    return !handler.onRequestStart ? handler : new UnwrapHandler(handler)
+  }
+
+  onConnect (abort, context) {
+    this.#controller = new UnwrapController(abort)
+    this.#handler.onRequestStart?.(this.#controller, context)
+  }
+
+  onUpgrade (statusCode, rawHeaders, socket) {
+    this.#handler.onRequestUpgrade?.(this.#controller, statusCode, parseHeaders(rawHeaders), socket)
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    this.#controller[kResume] = resume
+    this.#handler.onResponseStart?.(this.#controller, statusCode, statusMessage, parseHeaders(rawHeaders))
+    return !this.#controller.paused
+  }
+
+  onData (data) {
+    this.#handler.onResponseData?.(this.#controller, data)
+    return !this.#controller.paused
+  }
+
+  onComplete (rawTrailers) {
+    this.#handler.onResponseEnd?.(this.#controller, parseHeaders(rawTrailers))
+  }
+
+  onError (err) {
+    if (!this.#handler.onResponseError) {
+      throw new InvalidArgumentError('invalid onError method')
+    }
+
+    this.#handler.onResponseError?.(this.#controller, err)
+  }
+}

package/lib/handler/wrap-handler.js

@@ -0,0 +1,98 @@
+'use strict'
+
+const { InvalidArgumentError } = require('../core/errors')
+
+module.exports = class WrapHandler {
+  #handler
+
+  constructor (handler) {
+    this.#handler = handler
+  }
+
+  static wrap (handler) {
+    // TODO (fix): More checks...
+    return handler.onRequestStart ? handler : new WrapHandler(handler)
+  }
+
+  // Unwrap Interface
+
+  onConnect (abort, context) {
+    return this.#handler.onConnect?.(abort, context)
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    return this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage)
+  }
+
+  onUpgrade (statusCode, rawHeaders, socket) {
+    return this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
+  onData (data) {
+    return this.#handler.onData?.(data)
+  }
+
+  onComplete (trailers) {
+    return this.#handler.onComplete?.(trailers)
+  }
+
+  onError (err) {
+    if (!this.#handler.onError) {
+      throw new InvalidArgumentError('invalid onError method')
+    }
+
+    return this.#handler.onError?.(err)
+  }
+
+  // Wrap Interface
+
+  onRequestStart (controller, context) {
+    this.#handler.onConnect?.((reason) => controller.abort(reason), context)
+  }
+
+  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))
+    }
+
+    this.#handler.onUpgrade?.(statusCode, rawHeaders, socket)
+  }
+
+  onResponseStart (controller, statusCode, statusMessage, headers) {
+    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))
+    }
+
+    if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
+      controller.pause()
+    }
+  }
+
+  onResponseData (controller, data) {
+    if (this.#handler.onData?.(data) === false) {
+      controller.pause()
+    }
+  }
+
+  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))
+    }
+
+    this.#handler.onComplete?.(rawTrailers)
+  }
+
+  onResponseError (controller, err) {
+    if (!this.#handler.onError) {
+      throw new InvalidArgumentError('invalid onError method')
+    }
+
+    this.#handler.onError?.(err)
+  }
+}