undici 7.0.0-alpha.3 → 7.0.0-alpha.4

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

@@ -1,33 +1,26 @@
 'use strict'
 
-const { Writable, Readable } = require('node:stream')
+const { Writable } = require('node:stream')
 
 /**
  * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore
  * @implements {CacheStore}
  *
  * @typedef {{
- *  readers: number
- *  readLock: boolean
- *  writeLock: boolean
- *  opts: import('../../types/cache-interceptor.d.ts').default.CacheStoreValue
- *  body: Buffer[]
+ *  locked: boolean
+ *  opts: import('../../types/cache-interceptor.d.ts').default.CachedResponse
+ *  body?: Buffer[]
  * }} MemoryStoreValue
  */
 class MemoryCacheStore {
-  #maxEntries = Infinity
+  #maxCount = Infinity
 
   #maxEntrySize = Infinity
 
-  /**
-   * @type {((err) => void) | undefined}
-   */
-  #errorCallback = undefined
-
   #entryCount = 0
 
   /**
-   * @type {Map<string, Map<string, MemoryStoreValue>>}
+   * @type {Map<string, Map<string, MemoryStoreValue[]>>}
    */
   #data = new Map()
 
@@ -40,15 +33,15 @@ class MemoryCacheStore {
         throw new TypeError('MemoryCacheStore options must be an object')
       }
 
-      if (opts.maxEntries !== undefined) {
+      if (opts.maxCount !== undefined) {
         if (
-          typeof opts.maxEntries !== 'number' ||
-          !Number.isInteger(opts.maxEntries) ||
-          opts.maxEntries < 0
+          typeof opts.maxCount !== 'number' ||
+          !Number.isInteger(opts.maxCount) ||
+          opts.maxCount < 0
         ) {
-          throw new TypeError('MemoryCacheStore options.maxEntries must be a non-negative integer')
+          throw new TypeError('MemoryCacheStore options.maxCount must be a non-negative integer')
         }
-        this.#maxEntries = opts.maxEntries
+        this.#maxCount = opts.maxCount
       }
 
       if (opts.maxEntrySize !== undefined) {
@@ -61,51 +54,44 @@ 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
+    return this.#entryCount >= this.#maxCount
   }
 
   /**
-   * @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} key
+   * @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}`)
+  get (key) {
+    if (typeof key !== 'object') {
+      throw new TypeError(`expected key to be object, got ${typeof key}`)
     }
 
-    const values = this.#getValuesForRequest(req, false)
+    const values = this.#getValuesForRequest(key, false)
     if (!values) {
       return undefined
     }
 
-    const value = this.#findValue(req, values)
+    const value = this.#findValue(key, values)
 
-    if (!value || value.readLock) {
+    if (!value || value.locked) {
       return undefined
     }
 
-    return new MemoryStoreReadableStream(value)
+    return { ...value.opts, body: value.body }
   }
 
   /**
-   * @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.CachedResponse} opts
+   * @returns {Writable | undefined}
    */
-  createWriteStream (req, opts) {
-    if (typeof req !== 'object') {
-      throw new TypeError(`expected req to be object, got ${typeof req}`)
+  createWriteStream (key, opts) {
+    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}`)
@@ -115,9 +101,13 @@ class MemoryCacheStore {
       return undefined
     }
 
-    const values = this.#getValuesForRequest(req, true)
+    const values = this.#getValuesForRequest(key, true)
 
-    let value = this.#findValue(req, values)
+    /**
+     * @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
@@ -131,11 +121,8 @@ class MemoryCacheStore {
       this.#entryCount++
 
       value = {
-        readers: 0,
-        readLock: false,
-        writeLock: false,
-        opts,
-        body: []
+        locked: true,
+        opts
       }
 
       // We want to sort our responses in decending order by their deleteAt
@@ -147,9 +134,11 @@ class MemoryCacheStore {
         // 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
@@ -165,6 +154,7 @@ class MemoryCacheStore {
           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
@@ -178,7 +168,7 @@ class MemoryCacheStore {
     } else {
       // Check if there's already another request writing to the value or
       //  a request reading from it
-      if (value.writeLock || value.readLock) {
+      if (value.locked) {
         return undefined
       }
 
@@ -186,70 +176,98 @@ class MemoryCacheStore {
       value.body = []
     }
 
-    const writable = new MemoryStoreWritableStream(
-      value,
-      this.#maxEntrySize
-    )
+    let currentSize = 0
+    /**
+     * @type {Buffer[] | null}
+     */
+    let body = key.method !== 'HEAD' ? [] : null
+    const maxEntrySize = 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)
-      }
-    })
+    const writable = 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
+
+        if (currentSize >= maxEntrySize) {
+          body = null
+          this.end()
+          shiftAtIndex(values, valueIndex)
+          return callback()
+        }
+
+        body.push(chunk)
+        callback()
+      },
+      final (callback) {
+        value.locked = false
+        if (body !== null) {
+          value.body = body
+        }
 
-    writable.on('bodyOversized', () => {
-      values.filter(current => value !== current)
+        callback()
+      }
     })
 
     return writable
   }
 
   /**
-   * @param {string} origin
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
    */
-  deleteByOrigin (origin) {
-    this.#data.delete(origin)
+  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/dispatcher.d.ts').default.RequestOptions} req
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
    * @param {boolean} [makeIfDoesntExist=false]
+   * @returns {MemoryStoreValue[] | undefined}
    */
-  #getValuesForRequest (req, makeIfDoesntExist) {
+  #getValuesForRequest (key, makeIfDoesntExist) {
     // https://www.rfc-editor.org/rfc/rfc9111.html#section-2-3
-    let cachedPaths = this.#data.get(req.origin)
+    const topLevelKey = `${key.origin}:${key.path}`
+    let cachedPaths = this.#data.get(topLevelKey)
     if (!cachedPaths) {
       if (!makeIfDoesntExist) {
         return undefined
       }
 
       cachedPaths = new Map()
-      this.#data.set(req.origin, cachedPaths)
+      this.#data.set(topLevelKey, cachedPaths)
     }
 
-    let values = cachedPaths.get(`${req.path}:${req.method}`)
-    if (!values && makeIfDoesntExist) {
-      values = []
-      cachedPaths.set(`${req.path}:${req.method}`, values)
+    let value = cachedPaths.get(key.method)
+    if (!value && makeIfDoesntExist) {
+      value = []
+      cachedPaths.set(key.method, value)
     }
 
-    return values
+    return value
   }
 
   /**
    * 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 {import('../../types/cache-interceptor.d.ts').default.CacheKey} req
    * @param {MemoryStoreValue[]} values
-   * @returns {MemoryStoreValue | undefined}
+   * @returns {(MemoryStoreValue & { index: number }) | undefined}
    */
   #findValue (req, values) {
     /**
-     * @type {MemoryStoreValue}
+     * @type {MemoryStoreValue | undefined}
      */
     let value
     const now = Date.now()
@@ -280,7 +298,10 @@ class MemoryCacheStore {
       }
 
       if (matches) {
-        value = current
+        value = {
+          ...current,
+          index: i
+        }
         break
       }
     }
@@ -289,129 +310,16 @@ class MemoryCacheStore {
   }
 }
 
-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
-      }
-    })
-  }
-
-  get value () {
-    return this.#value.opts
-  }
-
-  /**
-   * @param {number} size
-   */
-  _read (size) {
-    if (this.#chunksToSend.length === 0) {
-      throw new Error('no chunks left to read, stream should have closed')
-    }
-
-    if (size > this.#chunksToSend.length) {
-      size = this.#chunksToSend.length
-    }
-
-    for (let i = 0; i < size; i++) {
-      this.push(this.#chunksToSend.shift())
-    }
-  }
-}
-
-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 {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]
   }
 
-  /**
-   * @param {() => void} callback
-   */
-  _final (callback) {
-    if (this.#currentSize < this.#maxEntrySize) {
-      this.#value.readLock = false
-      this.#value.body = this.#body
-    }
-
-    callback()
-  }
+  array.length--
 }
 
 module.exports = MemoryCacheStore

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,