undici 7.0.0-alpha.4 → 7.0.0-alpha.5

package/docs/docs/api/api-lifecycle.md

@@ -58,33 +58,33 @@ stateDiagram-v2
 
 ### idle
 
-The **idle** state is the initial state of a `Client` instance. While an `origin` is required for instantiating a `Client` instance, the underlying socket connection will not be established until a request is queued using [`Client.dispatch()`](Client.md#clientdispatchoptions-handlers). By calling `Client.dispatch()` directly or using one of the multiple implementations ([`Client.connect()`](Client.md#clientconnectoptions-callback), [`Client.pipeline()`](Client.md#clientpipelineoptions-handler), [`Client.request()`](Client.md#clientrequestoptions-callback), [`Client.stream()`](Client.md#clientstreamoptions-factory-callback), and [`Client.upgrade()`](Client.md#clientupgradeoptions-callback)), the `Client` instance will transition from **idle** to [**pending**](#pending) and then most likely directly to [**processing**](#processing).
+The **idle** state is the initial state of a `Client` instance. While an `origin` is required for instantiating a `Client` instance, the underlying socket connection will not be established until a request is queued using [`Client.dispatch()`](/docs/docs/api/Client.md#clientdispatchoptions-handlers). By calling `Client.dispatch()` directly or using one of the multiple implementations ([`Client.connect()`](Client.md#clientconnectoptions-callback), [`Client.pipeline()`](Client.md#clientpipelineoptions-handler), [`Client.request()`](Client.md#clientrequestoptions-callback), [`Client.stream()`](Client.md#clientstreamoptions-factory-callback), and [`Client.upgrade()`](/docs/docs/api/Client.md#clientupgradeoptions-callback)), the `Client` instance will transition from **idle** to [**pending**](/docs/docs/api/Client.md#pending) and then most likely directly to [**processing**](/docs/docs/api/Client.md#processing).
 
-Calling [`Client.close()`](Client.md#clientclosecallback) or [`Client.destroy()`](Client.md#clientdestroyerror-callback) transitions directly to the [**destroyed**](#destroyed) state since the `Client` instance will have no queued requests in this state.
+Calling [`Client.close()`](/docs/docs/api/Client.md#clientclosecallback) or [`Client.destroy()`](Client.md#clientdestroyerror-callback) transitions directly to the [**destroyed**](/docs/docs/api/Client.md#destroyed) state since the `Client` instance will have no queued requests in this state.
 
 ### pending
 
-The **pending** state signifies a non-processing `Client`. Upon entering this state, the `Client` establishes a socket connection and emits the [`'connect'`](Client.md#event-connect) event signalling a connection was successfully established with the `origin` provided during `Client` instantiation. The internal queue is initially empty, and requests can start queueing.
+The **pending** state signifies a non-processing `Client`. Upon entering this state, the `Client` establishes a socket connection and emits the [`'connect'`](/docs/docs/api/Client.md#event-connect) event signalling a connection was successfully established with the `origin` provided during `Client` instantiation. The internal queue is initially empty, and requests can start queueing.
 
-Calling [`Client.close()`](Client.md#clientclosecallback) with queued requests, transitions the `Client` to the [**processing**](#processing) state. Without queued requests, it transitions to the [**destroyed**](#destroyed) state.
+Calling [`Client.close()`](/docs/docs/api/Client.md#clientclosecallback) with queued requests, transitions the `Client` to the [**processing**](/docs/docs/api/Client.md#processing) state. Without queued requests, it transitions to the [**destroyed**](/docs/docs/api/Client.md#destroyed) state.
 
-Calling [`Client.destroy()`](Client.md#clientdestroyerror-callback) transitions directly to the [**destroyed**](#destroyed) state regardless of existing requests.
+Calling [`Client.destroy()`](/docs/docs/api/Client.md#clientdestroyerror-callback) transitions directly to the [**destroyed**](/docs/docs/api/Client.md#destroyed) state regardless of existing requests.
 
 ### processing
 
-The **processing** state is a state machine within itself. It initializes to the [**processing.running**](#running) state. The [`Client.dispatch()`](Client.md#clientdispatchoptions-handlers), [`Client.close()`](Client.md#clientclosecallback), and [`Client.destroy()`](Client.md#clientdestroyerror-callback) can be called at any time while the `Client` is in this state. `Client.dispatch()` will add more requests to the queue while existing requests continue to be processed. `Client.close()` will transition to the [**processing.closing**](#closing) state. And `Client.destroy()` will transition to [**destroyed**](#destroyed).
+The **processing** state is a state machine within itself. It initializes to the [**processing.running**](/docs/docs/api/Client.md#running) state. The [`Client.dispatch()`](/docs/docs/api/Client.md#clientdispatchoptions-handlers), [`Client.close()`](Client.md#clientclosecallback), and [`Client.destroy()`](Client.md#clientdestroyerror-callback) can be called at any time while the `Client` is in this state. `Client.dispatch()` will add more requests to the queue while existing requests continue to be processed. `Client.close()` will transition to the [**processing.closing**](/docs/docs/api/Client.md#closing) state. And `Client.destroy()` will transition to [**destroyed**](/docs/docs/api/Client.md#destroyed).
 
 #### running
 
-In the **processing.running** sub-state, queued requests are being processed in a FIFO order. If a request body requires draining, the *needDrain* event transitions to the [**processing.busy**](#busy) sub-state. The *close* event transitions the Client to the [**process.closing**](#closing) sub-state. If all queued requests are processed and neither [`Client.close()`](Client.md#clientclosecallback) nor [`Client.destroy()`](Client.md#clientdestroyerror-callback) are called, then the [**processing**](#processing) machine will trigger a *keepalive* event transitioning the `Client` back to the [**pending**](#pending) state. During this time, the `Client` is waiting for the socket connection to timeout, and once it does, it triggers the *timeout* event and transitions to the [**idle**](#idle) state.
+In the **processing.running** sub-state, queued requests are being processed in a FIFO order. If a request body requires draining, the *needDrain* event transitions to the [**processing.busy**](/docs/docs/api/Client.md#busy) sub-state. The *close* event transitions the Client to the [**process.closing**](/docs/docs/api/Client.md#closing) sub-state. If all queued requests are processed and neither [`Client.close()`](/docs/docs/api/Client.md#clientclosecallback) nor [`Client.destroy()`](Client.md#clientdestroyerror-callback) are called, then the [**processing**](/docs/docs/api/Client.md#processing) machine will trigger a *keepalive* event transitioning the `Client` back to the [**pending**](/docs/docs/api/Client.md#pending) state. During this time, the `Client` is waiting for the socket connection to timeout, and once it does, it triggers the *timeout* event and transitions to the [**idle**](/docs/docs/api/Client.md#idle) state.
 
 #### busy
 
-This sub-state is only entered when a request body is an instance of [Stream](https://nodejs.org/api/stream.html) and requires draining. The `Client` cannot process additional requests while in this state and must wait until the currently processing request body is completely drained before transitioning back to [**processing.running**](#running).
+This sub-state is only entered when a request body is an instance of [Stream](https://nodejs.org/api/stream.html) and requires draining. The `Client` cannot process additional requests while in this state and must wait until the currently processing request body is completely drained before transitioning back to [**processing.running**](/docs/docs/api/Client.md#running).
 
 #### closing
 
-This sub-state is only entered when a `Client` instance has queued requests and the [`Client.close()`](Client.md#clientclosecallback) method is called. In this state, the `Client` instance continues to process requests as usual, with the one exception that no additional requests can be queued. Once all of the queued requests are processed, the `Client` will trigger the *done* event gracefully entering the [**destroyed**](#destroyed) state without an error.
+This sub-state is only entered when a `Client` instance has queued requests and the [`Client.close()`](/docs/docs/api/Client.md#clientclosecallback) method is called. In this state, the `Client` instance continues to process requests as usual, with the one exception that no additional requests can be queued. Once all of the queued requests are processed, the `Client` will trigger the *done* event gracefully entering the [**destroyed**](/docs/docs/api/Client.md#destroyed) state without an error.
 
 ### destroyed
 

package/lib/cache/memory-cache-store.js

@@ -1,28 +1,26 @@
 'use strict'
 
 const { Writable } = require('node:stream')
+const { nowAbsolute } = require('../util/timers.js')
 
 /**
+ * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheKey} CacheKey
+ * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheValue} CacheValue
  * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore
+ * @typedef {import('../../types/cache-interceptor.d.ts').default.GetResult} GetResult
+ */
+
+/**
  * @implements {CacheStore}
- *
- * @typedef {{
- *  locked: boolean
- *  opts: import('../../types/cache-interceptor.d.ts').default.CachedResponse
- *  body?: Buffer[]
- * }} MemoryStoreValue
  */
 class MemoryCacheStore {
   #maxCount = Infinity
-
+  #maxSize = Infinity
   #maxEntrySize = Infinity
 
-  #entryCount = 0
-
-  /**
-   * @type {Map<string, Map<string, MemoryStoreValue[]>>}
-   */
-  #data = new Map()
+  #size = 0
+  #count = 0
+  #entries = new Map()
 
   /**
    * @param {import('../../types/cache-interceptor.d.ts').default.MemoryCacheStoreOpts | undefined} [opts]
@@ -44,6 +42,17 @@ class MemoryCacheStore {
         this.#maxCount = opts.maxCount
       }
 
+      if (opts.maxSize !== undefined) {
+        if (
+          typeof opts.maxSize !== 'number' ||
+          !Number.isInteger(opts.maxSize) ||
+          opts.maxSize < 0
+        ) {
+          throw new TypeError('MemoryCacheStore options.maxSize must be a non-negative integer')
+        }
+        this.#maxSize = opts.maxSize
+      }
+
       if (opts.maxEntrySize !== undefined) {
         if (
           typeof opts.maxEntrySize !== 'number' ||
@@ -57,12 +66,8 @@ class MemoryCacheStore {
     }
   }
 
-  get isFull () {
-    return this.#entryCount >= this.#maxCount
-  }
-
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} req
    * @returns {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined}
    */
   get (key) {
@@ -70,256 +75,107 @@ class MemoryCacheStore {
       throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
 
-    const values = this.#getValuesForRequest(key, false)
-    if (!values) {
-      return undefined
-    }
-
-    const value = this.#findValue(key, values)
-
-    if (!value || value.locked) {
-      return undefined
-    }
+    const topLevelKey = `${key.origin}:${key.path}`
 
-    return { ...value.opts, body: value.body }
+    const now = nowAbsolute()
+    const entry = this.#entries.get(topLevelKey)?.find((entry) => (
+      entry.deleteAt > now &&
+      entry.method === key.method &&
+      (entry.vary == null || Object.keys(entry.vary).every(headerName => entry.vary[headerName] === key.headers?.[headerName]))
+    ))
+
+    return entry == null
+      ? undefined
+      : {
+          statusMessage: entry.statusMessage,
+          statusCode: entry.statusCode,
+          rawHeaders: entry.rawHeaders,
+          body: entry.body,
+          etag: entry.etag,
+          cachedAt: entry.cachedAt,
+          staleAt: entry.staleAt,
+          deleteAt: entry.deleteAt
+        }
   }
 
   /**
    * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
-   * @param {import('../../types/cache-interceptor.d.ts').default.CachedResponse} opts
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheValue} val
    * @returns {Writable | undefined}
    */
-  createWriteStream (key, opts) {
+  createWriteStream (key, val) {
     if (typeof key !== 'object') {
       throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
-    if (typeof opts !== 'object') {
-      throw new TypeError(`expected value to be object, got ${typeof opts}`)
-    }
-
-    if (this.isFull) {
-      return undefined
+    if (typeof val !== 'object') {
+      throw new TypeError(`expected value to be object, got ${typeof val}`)
     }
 
-    const values = this.#getValuesForRequest(key, true)
-
-    /**
-     * @type {(MemoryStoreValue & { index: number }) | undefined}
-     */
-    let value = this.#findValue(key, values)
-    let valueIndex = value?.index
-    if (!value) {
-      // The value doesn't already exist, meaning we haven't cached this
-      //  response before. Let's assign it a value and insert it into our data
-      //  property.
-
-      if (this.isFull) {
-        // Or not, we don't have space to add another response
-        return undefined
-      }
-
-      this.#entryCount++
-
-      value = {
-        locked: true,
-        opts
-      }
-
-      // We want to sort our responses in decending order by their deleteAt
-      //  timestamps so that deleting expired responses is faster
-      if (
-        values.length === 0 ||
-        opts.deleteAt < values[values.length - 1].deleteAt
-      ) {
-        // Our value is either the only response for this path or our deleteAt
-        //  time is sooner than all the other responses
-        values.push(value)
-        valueIndex = values.length - 1
-      } else if (opts.deleteAt >= values[0].deleteAt) {
-        // Our deleteAt is later than everyone elses
-        values.unshift(value)
-        valueIndex = 0
-      } else {
-        // We're neither in the front or the end, let's just binary search to
-        //  find our stop we need to be in
-        let startIndex = 0
-        let endIndex = values.length
-        while (true) {
-          if (startIndex === endIndex) {
-            values.splice(startIndex, 0, value)
-            break
-          }
-
-          const middleIndex = Math.floor((startIndex + endIndex) / 2)
-          const middleValue = values[middleIndex]
-          if (opts.deleteAt === middleIndex) {
-            values.splice(middleIndex, 0, value)
-            valueIndex = middleIndex
-            break
-          } else if (opts.deleteAt > middleValue.opts.deleteAt) {
-            endIndex = middleIndex
-            continue
-          } else {
-            startIndex = middleIndex
-            continue
-          }
-        }
-      }
-    } else {
-      // Check if there's already another request writing to the value or
-      //  a request reading from it
-      if (value.locked) {
-        return undefined
-      }
-
-      // Empty it so we can overwrite it
-      value.body = []
-    }
+    const topLevelKey = `${key.origin}:${key.path}`
 
-    let currentSize = 0
-    /**
-     * @type {Buffer[] | null}
-     */
-    let body = key.method !== 'HEAD' ? [] : null
-    const maxEntrySize = this.#maxEntrySize
+    const store = this
+    const entry = { ...key, ...val, body: [], size: 0 }
 
-    const writable = new Writable({
+    return new Writable({
       write (chunk, encoding, callback) {
-        if (key.method === 'HEAD') {
-          throw new Error('HEAD request shouldn\'t have a body')
-        }
-
-        if (!body) {
-          return callback()
-        }
-
         if (typeof chunk === 'string') {
           chunk = Buffer.from(chunk, encoding)
         }
 
-        currentSize += chunk.byteLength
+        entry.size += chunk.byteLength
 
-        if (currentSize >= maxEntrySize) {
-          body = null
-          this.end()
-          shiftAtIndex(values, valueIndex)
-          return callback()
+        if (entry.size >= store.#maxEntrySize) {
+          this.destroy()
+        } else {
+          entry.body.push(chunk)
         }
 
-        body.push(chunk)
-        callback()
+        callback(null)
       },
       final (callback) {
-        value.locked = false
-        if (body !== null) {
-          value.body = body
+        let entries = store.#entries.get(topLevelKey)
+        if (!entries) {
+          entries = []
+          store.#entries.set(topLevelKey, entries)
+        }
+        entries.push(entry)
+
+        store.#size += entry.size
+        store.#count += 1
+
+        if (store.#size > store.#maxSize || store.#count > store.#maxCount) {
+          for (const [key, entries] of store.#entries) {
+            for (const entry of entries.splice(0, entries.length / 2)) {
+              store.#size -= entry.size
+              store.#count -= 1
+            }
+            if (entries.length === 0) {
+              store.#entries.delete(key)
+            }
+          }
         }
 
-        callback()
+        callback(null)
       }
     })
-
-    return writable
   }
 
   /**
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {CacheKey} key
    */
   delete (key) {
-    this.#data.delete(`${key.origin}:${key.path}`)
-  }
-
-  /**
-   * Gets all of the requests of the same origin, path, and method. Does not
-   *  take the `vary` property into account.
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
-   * @param {boolean} [makeIfDoesntExist=false]
-   * @returns {MemoryStoreValue[] | undefined}
-   */
-  #getValuesForRequest (key, makeIfDoesntExist) {
-    // https://www.rfc-editor.org/rfc/rfc9111.html#section-2-3
-    const topLevelKey = `${key.origin}:${key.path}`
-    let cachedPaths = this.#data.get(topLevelKey)
-    if (!cachedPaths) {
-      if (!makeIfDoesntExist) {
-        return undefined
-      }
-
-      cachedPaths = new Map()
-      this.#data.set(topLevelKey, cachedPaths)
-    }
-
-    let value = cachedPaths.get(key.method)
-    if (!value && makeIfDoesntExist) {
-      value = []
-      cachedPaths.set(key.method, value)
+    if (typeof key !== 'object') {
+      throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
 
-    return value
-  }
-
-  /**
-   * Given a list of values of a certain request, this decides the best value
-   *  to respond with.
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} req
-   * @param {MemoryStoreValue[]} values
-   * @returns {(MemoryStoreValue & { index: number }) | undefined}
-   */
-  #findValue (req, values) {
-    /**
-     * @type {MemoryStoreValue | undefined}
-     */
-    let value
-    const now = Date.now()
-    for (let i = values.length - 1; i >= 0; i--) {
-      const current = values[i]
-      const currentCacheValue = current.opts
-      if (now >= currentCacheValue.deleteAt) {
-        // We've reached expired values, let's delete them
-        this.#entryCount -= values.length - i
-        values.length = i
-        break
-      }
-
-      let matches = true
-
-      if (currentCacheValue.vary) {
-        if (!req.headers) {
-          matches = false
-          break
-        }
-
-        for (const key in currentCacheValue.vary) {
-          if (currentCacheValue.vary[key] !== req.headers[key]) {
-            matches = false
-            break
-          }
-        }
-      }
+    const topLevelKey = `${key.origin}:${key.path}`
 
-      if (matches) {
-        value = {
-          ...current,
-          index: i
-        }
-        break
-      }
+    for (const entry of this.#entries.get(topLevelKey) ?? []) {
+      this.#size -= entry.size
+      this.#count -= 1
     }
-
-    return value
-  }
-}
-
-/**
- * @param {any[]} array Array to modify
- * @param {number} idx Index to delete
- */
-function shiftAtIndex (array, idx) {
-  for (let i = idx + 1; idx < array.length; i++) {
-    array[i - 1] = array[i]
+    this.#entries.delete(topLevelKey)
   }
-
-  array.length--
 }
 
 module.exports = MemoryCacheStore

package/lib/handler/cache-handler.js

@@ -4,8 +4,10 @@ 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 () {}
 
@@ -121,7 +123,7 @@ class CacheHandler extends DecoratorHandler {
       return downstreamOnHeaders()
     }
 
-    const now = Date.now()
+    const now = nowAbsolute()
     const staleAt = determineStaleAt(now, headers, cacheControlDirectives)
     if (staleAt) {
       const varyDirectives = this.#cacheKey.headers && headers.vary
@@ -135,7 +137,10 @@ class CacheHandler extends DecoratorHandler {
         cacheControlDirectives
       )
 
-      this.#writeStream = this.#store.createWriteStream(this.#cacheKey, {
+      /**
+       * @type {import('../../types/cache-interceptor.d.ts').default.CacheValue}
+       */
+      const value = {
         statusCode,
         statusMessage,
         rawHeaders: strippedHeaders,
@@ -143,7 +148,13 @@ 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) {
         const handler = this
@@ -300,7 +311,7 @@ function determineStaleAt (now, headers, cacheControlDirectives) {
     // 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())
+      return now + (nowAbsolute() - expiresDate.getTime())
     }
   }