undici 7.0.0-alpha.3 → 7.0.0-alpha.5

package/lib/dispatcher/client-h2.js

@@ -144,7 +144,7 @@ function resumeH2 (client) {
   const socket = client[kSocket]
 
   if (socket?.destroyed === false) {
-    if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
+    if (client[kSize] === 0 || client[kMaxConcurrentStreams] === 0) {
       socket.unref()
       client[kHTTP2Session].unref()
     } else {
@@ -184,17 +184,19 @@ function onHttp2SessionEnd () {
  * @param {number} errorCode
  */
 function onHttp2SessionGoAway (errorCode) {
-  // We cannot recover, so best to close the session and the socket
+  // TODO(mcollina): Verify if GOAWAY implements the spec correctly:
+  // https://datatracker.ietf.org/doc/html/rfc7540#section-6.8
+  // Specifically, we do not verify the "valid" stream id.
+
   const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${errorCode}`, util.getSocketInfo(this[kSocket]))
   const client = this[kClient]
 
   client[kSocket] = null
   client[kHTTPContext] = null
 
-  if (this[kHTTP2Session] !== null) {
-    this[kHTTP2Session].destroy(err)
-    this[kHTTP2Session] = null
-  }
+  // this is an HTTP2 session
+  this.close()
+  this[kHTTP2Session] = null
 
   util.destroy(this[kSocket], err)
 
@@ -218,7 +220,8 @@ function onHttp2SessionClose () {
 
   const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
 
-  client[kHTTP2Session] = null
+  client[kSocket] = null
+  client[kHTTPContext] = null
 
   if (client.destroyed) {
     assert(client[kPending] === 0)
@@ -238,6 +241,7 @@ function onHttp2SocketClose () {
   const client = this[kHTTP2Session][kClient]
 
   client[kSocket] = null
+  client[kHTTPContext] = null
 
   if (this[kHTTP2Session] !== null) {
     this[kHTTP2Session].destroy(err)
@@ -301,7 +305,7 @@ function writeH2 (client, request) {
   }
 
   /** @type {import('node:http2').ClientHttp2Stream} */
-  let stream
+  let stream = null
 
   const { hostname, port } = client[kUrl]
 
@@ -318,14 +322,21 @@ function writeH2 (client, request) {
     util.errorRequest(client, request, err)
 
     if (stream != null) {
-      util.destroy(stream, err)
+      // Some chunks might still come after abort,
+      // let's ignore them
+      stream.removeAllListeners('data')
+
+      // On Abort, we close the stream to send RST_STREAM frame
+      stream.close()
+
+      // We move the running index to the next request
+      client[kOnError](err)
+      client[kResume]()
     }
 
     // We do not destroy the socket as we can continue using the session
     // the stream gets destroyed and the session remains to create new streams
     util.destroy(body, err)
-    client[kQueue][client[kRunningIdx]++] = null
-    client[kResume]()
   }
 
   try {
@@ -348,7 +359,7 @@ function writeH2 (client, request) {
     // We disabled endStream to allow the user to write to the stream
     stream = session.request(headers, { endStream: false, signal })
 
-    if (stream.id && !stream.pending) {
+    if (!stream.pending) {
       request.onUpgrade(null, null, stream)
       ++session[kOpenStreams]
       client[kQueue][client[kRunningIdx]++] = null
@@ -438,6 +449,7 @@ function writeH2 (client, request) {
       endStream: shouldEndStream,
       signal
     })
+
     writeBodyH2()
   }
 
@@ -454,46 +466,52 @@ function writeH2 (client, request) {
     // for those scenarios, best effort is to destroy the stream immediately
     // as there's no value to keep it open.
     if (request.aborted) {
-      const err = new RequestAbortedError()
-      util.errorRequest(client, request, err)
-      util.destroy(stream, err)
+      stream.removeAllListeners('data')
       return
     }
 
     if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), '') === false) {
       stream.pause()
     }
+  })
 
-    stream.on('data', (chunk) => {
-      if (request.onData(chunk) === false) {
-        stream.pause()
-      }
-    })
+  stream.on('data', (chunk) => {
+    if (request.onData(chunk) === false) {
+      stream.pause()
+    }
   })
 
-  stream.once('end', () => {
+  stream.once('end', (err) => {
+    stream.removeAllListeners('data')
     // When state is null, it means we haven't consumed body and the stream still do not have
     // a state.
     // Present specially when using pipeline or stream
     if (stream.state?.state == null || stream.state.state < 6) {
-      request.onComplete([])
-    }
+      // Do not complete the request if it was aborted
+      if (!request.aborted) {
+        request.onComplete([])
+      }
 
-    if (session[kOpenStreams] === 0) {
+      client[kQueue][client[kRunningIdx]++] = null
+      client[kResume]()
+    } else {
       // Stream is closed or half-closed-remote (6), decrement counter and cleanup
       // It does not have sense to continue working with the stream as we do not
       // have yet RST_STREAM support on client-side
+      --session[kOpenStreams]
+      if (session[kOpenStreams] === 0) {
+        session.unref()
+      }
 
-      session.unref()
+      abort(err ?? new InformationalError('HTTP/2: stream half-closed (remote)'))
+      client[kQueue][client[kRunningIdx]++] = null
+      client[kPendingIdx] = client[kRunningIdx]
+      client[kResume]()
     }
-
-    abort(new InformationalError('HTTP/2: stream half-closed (remote)'))
-    client[kQueue][client[kRunningIdx]++] = null
-    client[kPendingIdx] = client[kRunningIdx]
-    client[kResume]()
   })
 
   stream.once('close', () => {
+    stream.removeAllListeners('data')
     session[kOpenStreams] -= 1
     if (session[kOpenStreams] === 0) {
       session.unref()
@@ -501,16 +519,18 @@ function writeH2 (client, request) {
   })
 
   stream.once('error', function (err) {
+    stream.removeAllListeners('data')
     abort(err)
   })
 
   stream.once('frameError', (type, code) => {
+    stream.removeAllListeners('data')
     abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
   })
 
-  // stream.on('aborted', () => {
-  //   // TODO(HTTP/2): Support aborted
-  // })
+  stream.on('aborted', () => {
+    stream.removeAllListeners('data')
+  })
 
   // stream.on('timeout', () => {
   //   // TODO(HTTP/2): Support timeout

package/lib/handler/cache-handler.js

@@ -4,22 +4,26 @@ const util = require('../core/util')
 const DecoratorHandler = require('../handler/decorator-handler')
 const {
   parseCacheControlHeader,
-  parseVaryHeader
+  parseVaryHeader,
+  isEtagUsable
 } = require('../util/cache')
+const { nowAbsolute } = require('../util/timers.js')
+
+function noop () {}
 
 /**
  * Writes a response to a CacheStore and then passes it on to the next handler
  */
 class CacheHandler extends DecoratorHandler {
   /**
-   * @type {import('../../types/cache-interceptor.d.ts').default.CacheStore}
+   * @type {import('../../types/cache-interceptor.d.ts').default.CacheKey}
    */
-  #store
+  #cacheKey
 
   /**
-   * @type {import('../../types/dispatcher.d.ts').default.RequestOptions}
+   * @type {import('../../types/cache-interceptor.d.ts').default.CacheStore}
    */
-  #requestOptions
+  #store
 
   /**
    * @type {import('../../types/dispatcher.d.ts').default.DispatchHandlers}
@@ -27,25 +31,36 @@ class CacheHandler extends DecoratorHandler {
   #handler
 
   /**
-   * @type {import('../../types/cache-interceptor.d.ts').default.CacheStoreWriteable | undefined}
+   * @type {import('node:stream').Writable | undefined}
    */
   #writeStream
 
   /**
    * @param {import('../../types/cache-interceptor.d.ts').default.CacheOptions} opts
-   * @param {import('../../types/dispatcher.d.ts').default.RequestOptions} requestOptions
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} cacheKey
    * @param {import('../../types/dispatcher.d.ts').default.DispatchHandlers} handler
    */
-  constructor (opts, requestOptions, handler) {
+  constructor (opts, cacheKey, handler) {
     const { store } = opts
 
     super(handler)
 
     this.#store = store
-    this.#requestOptions = requestOptions
+    this.#cacheKey = cacheKey
     this.#handler = handler
   }
 
+  onConnect (abort) {
+    if (this.#writeStream) {
+      this.#writeStream.destroy()
+      this.#writeStream = undefined
+    }
+
+    if (typeof this.#handler.onConnect === 'function') {
+      this.#handler.onConnect(abort)
+    }
+  }
+
   /**
    * @see {DispatchHandlers.onHeaders}
    *
@@ -61,72 +76,71 @@ class CacheHandler extends DecoratorHandler {
     resume,
     statusMessage
   ) {
-    const downstreamOnHeaders = () => this.#handler.onHeaders(
-      statusCode,
-      rawHeaders,
-      resume,
-      statusMessage
-    )
+    const downstreamOnHeaders = () => {
+      if (typeof this.#handler.onHeaders === 'function') {
+        return this.#handler.onHeaders(
+          statusCode,
+          rawHeaders,
+          resume,
+          statusMessage
+        )
+      } else {
+        return true
+      }
+    }
 
     if (
-      !util.safeHTTPMethods.includes(this.#requestOptions.method) &&
+      !util.safeHTTPMethods.includes(this.#cacheKey.method) &&
       statusCode >= 200 &&
       statusCode <= 399
     ) {
-      // https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-respons
-      // Try/catch for if it's synchronous
+      // https://www.rfc-editor.org/rfc/rfc9111.html#name-invalidating-stored-response
       try {
-        const result = this.#store.deleteByOrigin(this.#requestOptions.origin)
-        if (
-          result &&
-          typeof result.catch === 'function' &&
-          typeof this.#handler.onError === 'function'
-        ) {
-          // Fail silently
-          result.catch(_ => {})
-        }
-      } catch (err) {
+        this.#store.delete(this.#cacheKey).catch?.(noop)
+      } catch {
         // Fail silently
       }
-
       return downstreamOnHeaders()
     }
 
-    const headers = util.parseHeaders(rawHeaders)
+    const parsedRawHeaders = util.parseRawHeaders(rawHeaders)
+    const headers = util.parseHeaders(parsedRawHeaders)
 
     const cacheControlHeader = headers['cache-control']
-    const contentLengthHeader = headers['content-length']
+    const isCacheFull = typeof this.#store.isFull !== 'undefined'
+      ? this.#store.isFull
+      : false
 
-    if (!cacheControlHeader || !contentLengthHeader || this.#store.isFull) {
-      // Don't have the headers we need, can't cache
-      return downstreamOnHeaders()
-    }
-
-    const contentLength = Number(contentLengthHeader)
-    if (!Number.isInteger(contentLength)) {
+    if (
+      !cacheControlHeader ||
+      isCacheFull
+    ) {
+      // 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()
     }
 
-    const now = Date.now()
+    const now = nowAbsolute()
     const staleAt = determineStaleAt(now, headers, cacheControlDirectives)
     if (staleAt) {
-      const varyDirectives = headers.vary
-        ? parseVaryHeader(headers.vary, this.#requestOptions.headers)
+      const varyDirectives = this.#cacheKey.headers && headers.vary
+        ? parseVaryHeader(headers.vary, this.#cacheKey.headers)
         : undefined
       const deleteAt = determineDeleteAt(now, cacheControlDirectives, staleAt)
 
       const strippedHeaders = stripNecessaryHeaders(
         rawHeaders,
-        headers,
+        parsedRawHeaders,
         cacheControlDirectives
       )
 
-      this.#writeStream = this.#store.createWriteStream(this.#requestOptions, {
+      /**
+       * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
+       */
+      const value = {
         statusCode,
         statusMessage,
         rawHeaders: strippedHeaders,
@@ -134,21 +148,33 @@ class CacheHandler extends DecoratorHandler {
         cachedAt: now,
         staleAt,
         deleteAt
-      })
+      }
+
+      if (typeof headers.etag === 'string' && isEtagUsable(headers.etag)) {
+        value.etag = headers.etag
+      }
+
+      this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value)
 
       if (this.#writeStream) {
-        this.#writeStream.on('drain', resume)
-        this.#writeStream.on('error', () => {
-          this.#writeStream = undefined
-          resume()
-        })
+        const handler = this
+        this.#writeStream
+          .on('drain', resume)
+          .on('error', function () {
+            // TODO (fix): Make error somehow observable?
+          })
+          .on('close', function () {
+            if (handler.#writeStream === this) {
+              handler.#writeStream = undefined
+            }
+
+            // TODO (fix): Should we resume even if was paused downstream?
+            resume()
+          })
       }
     }
 
-    if (typeof this.#handler.onHeaders === 'function') {
-      return downstreamOnHeaders()
-    }
-    return false
+    return downstreamOnHeaders()
   }
 
   /**
@@ -178,10 +204,6 @@ class CacheHandler extends DecoratorHandler {
    */
   onComplete (rawTrailers) {
     if (this.#writeStream) {
-      if (rawTrailers) {
-        this.#writeStream.rawTrailers = rawTrailers
-      }
-
       this.#writeStream.end()
     }
 
@@ -211,7 +233,7 @@ class CacheHandler extends DecoratorHandler {
  * @see https://www.rfc-editor.org/rfc/rfc9111.html#name-storing-responses-to-authen
  *
  * @param {number} statusCode
- * @param {Record<string, string>} headers
+ * @param {Record<string, string | string[]>} headers
  * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
  */
 function canCacheResponse (statusCode, headers, cacheControlDirectives) {
@@ -223,7 +245,6 @@ function canCacheResponse (statusCode, headers, cacheControlDirectives) {
   }
 
   if (
-    !cacheControlDirectives.public ||
     cacheControlDirectives.private === true ||
     cacheControlDirectives['no-cache'] === true ||
     cacheControlDirectives['no-store']
@@ -237,7 +258,11 @@ function canCacheResponse (statusCode, headers, cacheControlDirectives) {
   }
 
   // https://www.rfc-editor.org/rfc/rfc9111.html#name-storing-responses-to-authen
-  if (headers['authorization']) {
+  if (headers.authorization) {
+    if (!cacheControlDirectives.public || typeof headers.authorization !== 'string') {
+      return false
+    }
+
     if (
       Array.isArray(cacheControlDirectives['no-cache']) &&
       cacheControlDirectives['no-cache'].includes('authorization')
@@ -282,9 +307,12 @@ function determineStaleAt (now, headers, cacheControlDirectives) {
     return now + (maxAge * 1000)
   }
 
-  if (headers.expire) {
+  if (headers.expire && typeof headers.expire === 'string') {
     // https://www.rfc-editor.org/rfc/rfc9111.html#section-5.3
-    return now + (Date.now() - new Date(headers.expire).getTime())
+    const expiresDate = new Date(headers.expire)
+    if (expiresDate instanceof Date && !isNaN(expiresDate)) {
+      return now + (nowAbsolute() - expiresDate.getTime())
+    }
   }
 
   return undefined
@@ -306,11 +334,11 @@ function determineDeleteAt (now, cacheControlDirectives, staleAt) {
 /**
  * Strips headers required to be removed in cached responses
  * @param {Buffer[]} rawHeaders
- * @param {Record<string, string | string[]>} parsedHeaders
+ * @param {string[]} parsedRawHeaders
  * @param {import('../util/cache.js').CacheControlDirectives} cacheControlDirectives
- * @returns {(Buffer|Buffer[])[]}
+ * @returns {Buffer[]}
  */
-function stripNecessaryHeaders (rawHeaders, parsedHeaders, cacheControlDirectives) {
+function stripNecessaryHeaders (rawHeaders, parsedRawHeaders, cacheControlDirectives) {
   const headersToRemove = ['connection']
 
   if (Array.isArray(cacheControlDirectives['no-cache'])) {
@@ -321,39 +349,52 @@ function stripNecessaryHeaders (rawHeaders, parsedHeaders, cacheControlDirective
     headersToRemove.push(...cacheControlDirectives['private'])
   }
 
-  /**
-   * These are the headers that are okay to cache. If this is assigned, we need
-   *  to remake the buffer representation of the headers
-   * @type {Record<string, string | string[]> | undefined}
-   */
   let strippedHeaders
 
-  const headerNames = Object.keys(parsedHeaders)
-  for (let i = 0; i < headerNames.length; i++) {
-    const header = headerNames[i]
+  let offset = 0
+  for (let i = 0; i < parsedRawHeaders.length; i += 2) {
+    const headerName = parsedRawHeaders[i]
 
-    if (headersToRemove.indexOf(header) !== -1) {
-      // We have a at least one header we want to remove
+    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 object
-        //  and backfill the previous headers into it
-        strippedHeaders = {}
-
-        for (let j = 0; j < i; j++) {
-          strippedHeaders[headerNames[j]] = parsedHeaders[headerNames[j]]
+        // 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
     }
 
-    // This header is fine. Let's add it to strippedHeaders if it exists.
+    // We want to keep this header. Let's add it to strippedHeaders if it exists
     if (strippedHeaders) {
-      strippedHeaders[header] = parsedHeaders[header]
+      strippedHeaders[i - offset] = parsedRawHeaders[i]
+      strippedHeaders[i + 1 - offset] = parsedRawHeaders[i + 1]
     }
   }
 
-  return strippedHeaders ? util.encodeHeaders(strippedHeaders) : rawHeaders
+  if (strippedHeaders) {
+    // Trim off the empty values at the end
+    strippedHeaders.length -= offset
+  }
+
+  return strippedHeaders
+    ? util.encodeRawHeaders(strippedHeaders)
+    : rawHeaders
 }
 
 module.exports = CacheHandler

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const assert = require('node:assert')
 const DecoratorHandler = require('../handler/decorator-handler')
 
 /**
@@ -19,29 +20,36 @@ const DecoratorHandler = require('../handler/decorator-handler')
 class CacheRevalidationHandler extends DecoratorHandler {
   #successful = false
   /**
-   * @type {(() => void)}
+   * @type {((boolean) => void) | null}
    */
-  #successCallback
+  #callback
   /**
    * @type {(import('../../types/dispatcher.d.ts').default.DispatchHandlers)}
    */
   #handler
 
+  #abort
+
   /**
-   * @param {() => void} successCallback Function to call if the cached value is valid
+   * @param {(boolean) => void} callback Function to call if the cached value is valid
    * @param {import('../../types/dispatcher.d.ts').default.DispatchHandlers} handler
    */
-  constructor (successCallback, handler) {
-    if (typeof successCallback !== 'function') {
-      throw new TypeError('successCallback must be a function')
+  constructor (callback, handler) {
+    if (typeof callback !== 'function') {
+      throw new TypeError('callback must be a function')
     }
 
     super(handler)
 
-    this.#successCallback = successCallback
+    this.#callback = callback
     this.#handler = handler
   }
 
+  onConnect (abort) {
+    this.#successful = false
+    this.#abort = abort
+  }
+
   /**
    * @see {DispatchHandlers.onHeaders}
    *
@@ -57,13 +65,21 @@ class CacheRevalidationHandler extends DecoratorHandler {
     resume,
     statusMessage
   ) {
+    assert(this.#callback != null)
+
     // https://www.rfc-editor.org/rfc/rfc9111.html#name-handling-a-validation-respo
-    if (statusCode === 304) {
-      this.#successful = true
-      this.#successCallback()
+    this.#successful = statusCode === 304
+    this.#callback(this.#successful)
+    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,
@@ -72,7 +88,8 @@ class CacheRevalidationHandler extends DecoratorHandler {
         statusMessage
       )
     }
-    return false
+
+    return true
   }
 
   /**
@@ -90,7 +107,7 @@ class CacheRevalidationHandler extends DecoratorHandler {
       return this.#handler.onData(chunk)
     }
 
-    return false
+    return true
   }
 
   /**
@@ -99,7 +116,11 @@ class CacheRevalidationHandler extends DecoratorHandler {
    * @param {string[] | null} rawTrailers
    */
   onComplete (rawTrailers) {
-    if (!this.#successful && typeof this.#handler.onComplete === 'function') {
+    if (this.#successful) {
+      return
+    }
+
+    if (typeof this.#handler.onComplete === 'function') {
       this.#handler.onComplete(rawTrailers)
     }
   }
@@ -110,8 +131,19 @@ class CacheRevalidationHandler extends DecoratorHandler {
    * @param {Error} err
    */
   onError (err) {
+    if (this.#successful) {
+      return
+    }
+
+    if (this.#callback) {
+      this.#callback(false)
+      this.#callback = null
+    }
+
     if (typeof this.#handler.onError === 'function') {
       this.#handler.onError(err)
+    } else {
+      throw err
     }
   }
 }