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

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

@@ -1,35 +1,26 @@
 'use strict'
 
-const { Writable, Readable } = require('node:stream')
+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 {{
- *  readers: number
- *  readLock: boolean
- *  writeLock: boolean
- *  opts: import('../../types/cache-interceptor.d.ts').default.CacheStoreValue
- *  body: Buffer[]
- * }} MemoryStoreValue
  */
 class MemoryCacheStore {
-  #maxEntries = Infinity
-
+  #maxCount = Infinity
+  #maxSize = Infinity
   #maxEntrySize = Infinity
 
-  /**
-   * @type {((err) => void) | undefined}
-   */
-  #errorCallback = undefined
-
-  #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]
@@ -40,15 +31,26 @@ class MemoryCacheStore {
         throw new TypeError('MemoryCacheStore options must be an object')
       }
 
-      if (opts.maxEntries !== undefined) {
+      if (opts.maxCount !== undefined) {
+        if (
+          typeof opts.maxCount !== 'number' ||
+          !Number.isInteger(opts.maxCount) ||
+          opts.maxCount < 0
+        ) {
+          throw new TypeError('MemoryCacheStore options.maxCount must be a non-negative integer')
+        }
+        this.#maxCount = opts.maxCount
+      }
+
+      if (opts.maxSize !== undefined) {
         if (
-          typeof opts.maxEntries !== 'number' ||
-          !Number.isInteger(opts.maxEntries) ||
-          opts.maxEntries < 0
+          typeof opts.maxSize !== 'number' ||
+          !Number.isInteger(opts.maxSize) ||
+          opts.maxSize < 0
         ) {
-          throw new TypeError('MemoryCacheStore options.maxEntries must be a non-negative integer')
+          throw new TypeError('MemoryCacheStore options.maxSize must be a non-negative integer')
         }
-        this.#maxEntries = opts.maxEntries
+        this.#maxSize = opts.maxSize
       }
 
       if (opts.maxEntrySize !== undefined) {
@@ -61,356 +63,118 @@ class MemoryCacheStore {
         }
         this.#maxEntrySize = opts.maxEntrySize
       }
-
-      if (opts.errorCallback !== undefined) {
-        if (typeof opts.errorCallback !== 'function') {
-          throw new TypeError('MemoryCacheStore options.errorCallback must be a function')
-        }
-        this.#errorCallback = opts.errorCallback
-      }
     }
   }
 
-  get isFull () {
-    return this.#entryCount >= this.#maxEntries
-  }
-
   /**
-   * @param {import('../../types/dispatcher.d.ts').default.RequestOptions} req
-   * @returns {import('../../types/cache-interceptor.d.ts').default.CacheStoreReadable | undefined}
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} req
+   * @returns {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined}
    */
-  createReadStream (req) {
-    if (typeof req !== 'object') {
-      throw new TypeError(`expected req to be object, got ${typeof req}`)
-    }
-
-    const values = this.#getValuesForRequest(req, false)
-    if (!values) {
-      return undefined
+  get (key) {
+    if (typeof key !== 'object') {
+      throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
 
-    const value = this.#findValue(req, values)
+    const topLevelKey = `${key.origin}:${key.path}`
 
-    if (!value || value.readLock) {
-      return undefined
-    }
+    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 new MemoryStoreReadableStream(value)
+    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/dispatcher.d.ts').default.RequestOptions} req
-   * @param {import('../../types/cache-interceptor.d.ts').default.CacheStoreValue} opts
-   * @returns {import('../../types/cache-interceptor.d.ts').default.CacheStoreWriteable | undefined}
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheValue} val
+   * @returns {Writable | undefined}
    */
-  createWriteStream (req, opts) {
-    if (typeof req !== 'object') {
-      throw new TypeError(`expected req to be object, got ${typeof req}`)
-    }
-    if (typeof opts !== 'object') {
-      throw new TypeError(`expected value to be object, got ${typeof opts}`)
+  createWriteStream (key, val) {
+    if (typeof key !== 'object') {
+      throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
-
-    if (this.isFull) {
-      return undefined
+    if (typeof val !== 'object') {
+      throw new TypeError(`expected value to be object, got ${typeof val}`)
     }
 
-    const values = this.#getValuesForRequest(req, true)
+    const topLevelKey = `${key.origin}:${key.path}`
 
-    let value = this.#findValue(req, values)
-    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.
+    const store = this
+    const entry = { ...key, ...val, body: [], size: 0 }
 
-      if (this.isFull) {
-        // Or not, we don't have space to add another response
-        return undefined
-      }
-
-      this.#entryCount++
-
-      value = {
-        readers: 0,
-        readLock: false,
-        writeLock: false,
-        opts,
-        body: []
-      }
-
-      // 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)
-      } else if (opts.deleteAt >= values[0].deleteAt) {
-        // Our deleteAt is later than everyone elses
-        values.unshift(value)
-      } 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)
-            break
-          } else if (opts.deleteAt > middleValue.opts.deleteAt) {
-            endIndex = middleIndex
-            continue
-          } else {
-            startIndex = middleIndex
-            continue
-          }
+    return new Writable({
+      write (chunk, encoding, callback) {
+        if (typeof chunk === 'string') {
+          chunk = Buffer.from(chunk, encoding)
         }
-      }
-    } else {
-      // Check if there's already another request writing to the value or
-      //  a request reading from it
-      if (value.writeLock || value.readLock) {
-        return undefined
-      }
-
-      // Empty it so we can overwrite it
-      value.body = []
-    }
-
-    const writable = new MemoryStoreWritableStream(
-      value,
-      this.#maxEntrySize
-    )
-
-    // Remove the value if there was some error
-    writable.on('error', (err) => {
-      values.filter(current => value !== current)
-      if (this.#errorCallback) {
-        this.#errorCallback(err)
-      }
-    })
-
-    writable.on('bodyOversized', () => {
-      values.filter(current => value !== current)
-    })
-
-    return writable
-  }
-
-  /**
-   * @param {string} origin
-   */
-  deleteByOrigin (origin) {
-    this.#data.delete(origin)
-  }
-
-  /**
-   * Gets all of the requests of the same origin, path, and method. Does not
-   *  take the `vary` property into account.
-   * @param {import('../../types/dispatcher.d.ts').default.RequestOptions} req
-   * @param {boolean} [makeIfDoesntExist=false]
-   */
-  #getValuesForRequest (req, makeIfDoesntExist) {
-    // https://www.rfc-editor.org/rfc/rfc9111.html#section-2-3
-    let cachedPaths = this.#data.get(req.origin)
-    if (!cachedPaths) {
-      if (!makeIfDoesntExist) {
-        return undefined
-      }
-
-      cachedPaths = new Map()
-      this.#data.set(req.origin, cachedPaths)
-    }
-
-    let values = cachedPaths.get(`${req.path}:${req.method}`)
-    if (!values && makeIfDoesntExist) {
-      values = []
-      cachedPaths.set(`${req.path}:${req.method}`, values)
-    }
-
-    return values
-  }
-
-  /**
-   * Given a list of values of a certain request, this decides the best value
-   *  to respond with.
-   * @param {import('../../types/dispatcher.d.ts').default.RequestOptions} req
-   * @param {MemoryStoreValue[]} values
-   * @returns {MemoryStoreValue | undefined}
-   */
-  #findValue (req, values) {
-    /**
-     * @type {MemoryStoreValue}
-     */
-    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
+        entry.size += chunk.byteLength
 
-      if (currentCacheValue.vary) {
-        if (!req.headers) {
-          matches = false
-          break
+        if (entry.size >= store.#maxEntrySize) {
+          this.destroy()
+        } else {
+          entry.body.push(chunk)
         }
 
-        for (const key in currentCacheValue.vary) {
-          if (currentCacheValue.vary[key] !== req.headers[key]) {
-            matches = false
-            break
+        callback(null)
+      },
+      final (callback) {
+        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)
+            }
           }
         }
-      }
-
-      if (matches) {
-        value = current
-        break
-      }
-    }
-
-    return value
-  }
-}
-
-class MemoryStoreReadableStream extends Readable {
-  /**
-   * @type {MemoryStoreValue}
-   */
-  #value
-  /**
-   * @type {Buffer[]}
-   */
-  #chunksToSend = []
-
-  /**
-   * @param {MemoryStoreValue} value
-   */
-  constructor (value) {
-    super()
-
-    if (value.readLock) {
-      throw new Error('can\'t read a locked value')
-    }
 
-    this.#value = value
-    this.#chunksToSend = value?.body ? [...value.body, null] : [null]
-
-    this.#value.readers++
-    this.#value.writeLock = true
-
-    this.on('close', () => {
-      this.#value.readers--
-
-      if (this.#value.readers === 0) {
-        this.#value.writeLock = false
+        callback(null)
       }
     })
   }
 
-  get value () {
-    return this.#value.opts
-  }
-
   /**
-   * @param {number} size
+   * @param {CacheKey} key
    */
-  _read (size) {
-    if (this.#chunksToSend.length === 0) {
-      throw new Error('no chunks left to read, stream should have closed')
+  delete (key) {
+    if (typeof key !== 'object') {
+      throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
 
-    if (size > this.#chunksToSend.length) {
-      size = this.#chunksToSend.length
-    }
+    const topLevelKey = `${key.origin}:${key.path}`
 
-    for (let i = 0; i < size; i++) {
-      this.push(this.#chunksToSend.shift())
+    for (const entry of this.#entries.get(topLevelKey) ?? []) {
+      this.#size -= entry.size
+      this.#count -= 1
     }
-  }
-}
-
-class MemoryStoreWritableStream extends Writable {
-  /**
-   * @type {MemoryStoreValue}
-   */
-  #value
-  #currentSize = 0
-  #maxEntrySize = 0
-  /**
-   * @type {Buffer[]|null}
-   */
-  #body = []
-
-  /**
-   * @param {MemoryStoreValue} value
-   * @param {number} maxEntrySize
-   */
-  constructor (value, maxEntrySize) {
-    super()
-    this.#value = value
-    this.#value.readLock = true
-    this.#maxEntrySize = maxEntrySize ?? Infinity
-  }
-
-  get rawTrailers () {
-    return this.#value.opts.rawTrailers
-  }
-
-  /**
-   * @param {string[] | undefined} trailers
-   */
-  set rawTrailers (trailers) {
-    this.#value.opts.rawTrailers = trailers
-  }
-
-  /**
-   * @param {Buffer} chunk
-   * @param {string} encoding
-   * @param {BufferEncoding} encoding
-   */
-  _write (chunk, encoding, callback) {
-    if (typeof chunk === 'string') {
-      chunk = Buffer.from(chunk, encoding)
-    }
-
-    this.#currentSize += chunk.byteLength
-    if (this.#currentSize < this.#maxEntrySize) {
-      this.#body.push(chunk)
-    } else {
-      this.#body = null // release memory as early as possible
-      this.emit('bodyOversized')
-    }
-
-    callback()
-  }
-
-  /**
-   * @param {() => void} callback
-   */
-  _final (callback) {
-    if (this.#currentSize < this.#maxEntrySize) {
-      this.#value.readLock = false
-      this.#value.body = this.#body
-    }
-
-    callback()
+    this.#entries.delete(topLevelKey)
   }
 }
 

package/lib/core/connect.js

@@ -220,6 +220,11 @@ const setupConnectTimeout = process.platform === 'win32'
  * @param {number} opts.port
  */
 function onConnectTimeout (socket, opts) {
+  // The socket could be already garbage collected
+  if (socket == null) {
+    return
+  }
+
   let message = 'Connect Timeout Error'
   if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
     message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`

package/lib/core/request.js

@@ -130,7 +130,6 @@ class Request {
     }
 
     this.completed = false
-
     this.aborted = false
 
     this.upgrade = upgrade || null
@@ -143,7 +142,7 @@ class Request {
       ? method === 'HEAD' || method === 'GET'
       : idempotent
 
-    this.blocking = blocking == null ? false : blocking
+    this.blocking = blocking ?? this.method !== 'HEAD'
 
     this.reset = reset == null ? null : reset
 
@@ -272,6 +271,7 @@ class Request {
     this.onFinally()
 
     assert(!this.aborted)
+    assert(!this.completed)
 
     this.completed = true
     if (channels.trailers.hasSubscribers) {

package/lib/core/util.js

@@ -10,7 +10,7 @@ const nodeUtil = require('node:util')
 const { stringify } = require('node:querystring')
 const { EventEmitter: EE } = require('node:events')
 const { InvalidArgumentError } = require('./errors')
-const { headerNameLowerCasedRecord, getHeaderNameAsBuffer } = require('./constants')
+const { headerNameLowerCasedRecord } = require('./constants')
 const { tree } = require('./tree')
 
 const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
@@ -436,44 +436,6 @@ function parseHeaders (headers, obj) {
   return obj
 }
 
-/**
- * @param {Record<string, string | string[]>} headers
- * @returns {(Buffer | Buffer[])[]}
- */
-function encodeHeaders (headers) {
-  const headerNames = Object.keys(headers)
-
-  /**
-   * @type {Buffer[]|Buffer[][]}
-   */
-  const rawHeaders = new Array(headerNames.length * 2)
-
-  let rawHeadersIndex = 0
-  for (const header of headerNames) {
-    let rawValue
-    const value = headers[header]
-    if (Array.isArray(value)) {
-      rawValue = new Array(value.length)
-
-      for (let i = 0; i < value.length; i++) {
-        rawValue[i] = Buffer.from(value[i])
-      }
-    } else {
-      rawValue = Buffer.from(value)
-    }
-
-    const headerBuffer = getHeaderNameAsBuffer(header)
-
-    rawHeaders[rawHeadersIndex] = headerBuffer
-    rawHeadersIndex++
-
-    rawHeaders[rawHeadersIndex] = rawValue
-    rawHeadersIndex++
-  }
-
-  return rawHeaders
-}
-
 /**
  * @param {Buffer[]} headers
  * @returns {string[]}
@@ -516,6 +478,17 @@ function parseRawHeaders (headers) {
   return ret
 }
 
+/**
+ * @param {string[]} headers
+ * @param {Buffer[]} headers
+ */
+function encodeRawHeaders (headers) {
+  if (!Array.isArray(headers)) {
+    throw new TypeError('expected headers to be an array')
+  }
+  return headers.map(x => Buffer.from(x))
+}
+
 /**
  * @param {*} buffer
  * @returns {buffer is Buffer}
@@ -901,8 +874,8 @@ module.exports = {
   removeAllListeners,
   errorRequest,
   parseRawHeaders,
+  encodeRawHeaders,
   parseHeaders,
-  encodeHeaders,
   parseKeepAliveTimeout,
   destroy,
   bodyLength,