undici 7.0.0-alpha.2 → 7.0.0-alpha.4

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

@@ -0,0 +1,325 @@
+'use strict'
+
+const { Writable } = require('node:stream')
+
+/**
+ * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore
+ * @implements {CacheStore}
+ *
+ * @typedef {{
+ *  locked: boolean
+ *  opts: import('../../types/cache-interceptor.d.ts').default.CachedResponse
+ *  body?: Buffer[]
+ * }} MemoryStoreValue
+ */
+class MemoryCacheStore {
+  #maxCount = Infinity
+
+  #maxEntrySize = Infinity
+
+  #entryCount = 0
+
+  /**
+   * @type {Map<string, Map<string, MemoryStoreValue[]>>}
+   */
+  #data = new Map()
+
+  /**
+   * @param {import('../../types/cache-interceptor.d.ts').default.MemoryCacheStoreOpts | undefined} [opts]
+   */
+  constructor (opts) {
+    if (opts) {
+      if (typeof opts !== 'object') {
+        throw new TypeError('MemoryCacheStore options must be an object')
+      }
+
+      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.maxEntrySize !== undefined) {
+        if (
+          typeof opts.maxEntrySize !== 'number' ||
+          !Number.isInteger(opts.maxEntrySize) ||
+          opts.maxEntrySize < 0
+        ) {
+          throw new TypeError('MemoryCacheStore options.maxEntrySize must be a non-negative integer')
+        }
+        this.#maxEntrySize = opts.maxEntrySize
+      }
+    }
+  }
+
+  get isFull () {
+    return this.#entryCount >= this.#maxCount
+  }
+
+  /**
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @returns {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined}
+   */
+  get (key) {
+    if (typeof key !== 'object') {
+      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
+    }
+
+    return { ...value.opts, body: value.body }
+  }
+
+  /**
+   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key
+   * @param {import('../../types/cache-interceptor.d.ts').default.CachedResponse} opts
+   * @returns {Writable | undefined}
+   */
+  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}`)
+    }
+
+    if (this.isFull) {
+      return undefined
+    }
+
+    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 = []
+    }
+
+    let currentSize = 0
+    /**
+     * @type {Buffer[] | null}
+     */
+    let body = key.method !== 'HEAD' ? [] : null
+    const maxEntrySize = this.#maxEntrySize
+
+    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
+        }
+
+        callback()
+      }
+    })
+
+    return writable
+  }
+
+  /**
+   * @param {import('../../types/cache-interceptor.d.ts').default.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)
+    }
+
+    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
+          }
+        }
+      }
+
+      if (matches) {
+        value = {
+          ...current,
+          index: i
+        }
+        break
+      }
+    }
+
+    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]
+  }
+
+  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/constants.js

@@ -107,6 +107,28 @@ const headerNameLowerCasedRecord = {}
 // Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
 Object.setPrototypeOf(headerNameLowerCasedRecord, null)
 
+/**
+ * @type {Record<Lowercase<typeof wellknownHeaderNames[number]>, Buffer>}
+ */
+const wellknownHeaderNameBuffers = {}
+
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(wellknownHeaderNameBuffers, null)
+
+/**
+ * @param {string} header Lowercased header
+ * @returns {Buffer}
+ */
+function getHeaderNameAsBuffer (header) {
+  let buffer = wellknownHeaderNameBuffers[header]
+
+  if (buffer === undefined) {
+    buffer = Buffer.from(header)
+  }
+
+  return buffer
+}
+
 for (let i = 0; i < wellknownHeaderNames.length; ++i) {
   const key = wellknownHeaderNames[i]
   const lowerCasedKey = key.toLowerCase()
@@ -116,5 +138,6 @@ for (let i = 0; i < wellknownHeaderNames.length; ++i) {
 
 module.exports = {
   wellknownHeaderNames,
-  headerNameLowerCasedRecord
+  headerNameLowerCasedRecord,
+  getHeaderNameAsBuffer
 }

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

@@ -478,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}
@@ -863,6 +874,7 @@ module.exports = {
   removeAllListeners,
   errorRequest,
   parseRawHeaders,
+  encodeRawHeaders,
   parseHeaders,
   parseKeepAliveTimeout,
   destroy,
@@ -885,6 +897,6 @@ module.exports = {
   isHttpOrHttpsPrefixed,
   nodeMajor,
   nodeMinor,
-  safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  safeHTTPMethods: Object.freeze(['GET', 'HEAD', 'OPTIONS', 'TRACE']),
   wrapRequestBody
 }

package/lib/dispatcher/client-h1.js

@@ -49,13 +49,13 @@ const {
   kMaxResponseSize,
   kOnError,
   kResume,
-  kHTTPContext
+  kHTTPContext,
+  kClosed
 } = require('../core/symbols.js')
 
 const constants = require('../llhttp/constants.js')
 const EMPTY_BUF = Buffer.alloc(0)
 const FastBuffer = Buffer[Symbol.species]
-const addListener = util.addListener
 const removeAllListeners = util.removeAllListeners
 
 let extractBody
@@ -779,87 +779,13 @@ async function connectH1 (client, socket) {
   socket[kBlocking] = false
   socket[kParser] = new Parser(client, socket, llhttpInstance)
 
-  addListener(socket, 'error', function (err) {
-    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+  util.addListener(socket, 'error', onHttpSocketError)
+  util.addListener(socket, 'readable', onHttpSocketReadable)
+  util.addListener(socket, 'end', onHttpSocketEnd)
+  util.addListener(socket, 'close', onHttpSocketClose)
 
-    const parser = this[kParser]
-
-    // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
-    // to the user.
-    if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
-      // We treat all incoming data so for as a valid response.
-      parser.onMessageComplete()
-      return
-    }
-
-    this[kError] = err
-
-    this[kClient][kOnError](err)
-  })
-  addListener(socket, 'readable', function () {
-    this[kParser]?.readMore()
-  })
-  addListener(socket, 'end', function () {
-    const parser = this[kParser]
-
-    if (parser.statusCode && !parser.shouldKeepAlive) {
-      // We treat all incoming data so far as a valid response.
-      parser.onMessageComplete()
-      return
-    }
-
-    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
-  })
-  addListener(socket, 'close', function () {
-    const parser = this[kParser]
-
-    if (parser) {
-      if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
-        // We treat all incoming data so far as a valid response.
-        parser.onMessageComplete()
-      }
-
-      this[kParser].destroy()
-      this[kParser] = null
-    }
-
-    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
-
-    const client = this[kClient]
-
-    client[kSocket] = null
-    client[kHTTPContext] = null // TODO (fix): This is hacky...
-
-    if (client.destroyed) {
-      assert(client[kPending] === 0)
-
-      // Fail entire queue.
-      const requests = client[kQueue].splice(client[kRunningIdx])
-      for (let i = 0; i < requests.length; i++) {
-        const request = requests[i]
-        util.errorRequest(client, request, err)
-      }
-    } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
-      // Fail head of pipeline.
-      const request = client[kQueue][client[kRunningIdx]]
-      client[kQueue][client[kRunningIdx]++] = null
-
-      util.errorRequest(client, request, err)
-    }
-
-    client[kPendingIdx] = client[kRunningIdx]
-
-    assert(client[kRunning] === 0)
-
-    client.emit('disconnect', client[kUrl], [client], err)
-
-    client[kResume]()
-  })
-
-  let closed = false
-  socket.on('close', () => {
-    closed = true
-  })
+  socket[kClosed] = false
+  socket.on('close', onSocketClose)
 
   return {
     version: 'h1',
@@ -875,7 +801,7 @@ async function connectH1 (client, socket) {
      * @param {() => void} callback
      */
     destroy (err, callback) {
-      if (closed) {
+      if (socket[kClosed]) {
         queueMicrotask(callback)
       } else {
         socket.on('close', callback)
@@ -931,6 +857,90 @@ async function connectH1 (client, socket) {
   }
 }
 
+function onHttpSocketError (err) {
+  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+  const parser = this[kParser]
+
+  // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
+  // to the user.
+  if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
+    // We treat all incoming data so for as a valid response.
+    parser.onMessageComplete()
+    return
+  }
+
+  this[kError] = err
+
+  this[kClient][kOnError](err)
+}
+
+function onHttpSocketReadable () {
+  this[kParser]?.readMore()
+}
+
+function onHttpSocketEnd () {
+  const parser = this[kParser]
+
+  if (parser.statusCode && !parser.shouldKeepAlive) {
+    // We treat all incoming data so far as a valid response.
+    parser.onMessageComplete()
+    return
+  }
+
+  util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+}
+
+function onHttpSocketClose () {
+  const parser = this[kParser]
+
+  if (parser) {
+    if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
+      // We treat all incoming data so far as a valid response.
+      parser.onMessageComplete()
+    }
+
+    this[kParser].destroy()
+    this[kParser] = null
+  }
+
+  const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+  const client = this[kClient]
+
+  client[kSocket] = null
+  client[kHTTPContext] = null // TODO (fix): This is hacky...
+
+  if (client.destroyed) {
+    assert(client[kPending] === 0)
+
+    // Fail entire queue.
+    const requests = client[kQueue].splice(client[kRunningIdx])
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i]
+      util.errorRequest(client, request, err)
+    }
+  } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
+    // Fail head of pipeline.
+    const request = client[kQueue][client[kRunningIdx]]
+    client[kQueue][client[kRunningIdx]++] = null
+
+    util.errorRequest(client, request, err)
+  }
+
+  client[kPendingIdx] = client[kRunningIdx]
+
+  assert(client[kRunning] === 0)
+
+  client.emit('disconnect', client[kUrl], [client], err)
+
+  client[kResume]()
+}
+
+function onSocketClose () {
+  this[kClosed] = true
+}
+
 /**
  * @param {import('./client.js')} client
  */
@@ -991,7 +1001,10 @@ function writeH1 (client, request) {
   const expectsPayload = (
     method === 'PUT' ||
     method === 'POST' ||
-    method === 'PATCH'
+    method === 'PATCH' ||
+    method === 'QUERY' ||
+    method === 'PROPFIND' ||
+    method === 'PROPPATCH'
   )
 
   if (util.isFormDataLike(body)) {
@@ -1319,7 +1332,7 @@ function writeBuffer (abort, body, client, request, socket, contentLength, heade
       socket.uncork()
       request.onBodySent(body)
 
-      if (!expectsPayload) {
+      if (!expectsPayload && request.reset !== false) {
         socket[kReset] = true
       }
     }
@@ -1360,7 +1373,7 @@ async function writeBlob (abort, body, client, request, socket, contentLength, h
     request.onBodySent(buffer)
     request.onRequestSent()
 
-    if (!expectsPayload) {
+    if (!expectsPayload && request.reset !== false) {
       socket[kReset] = true
     }
 
@@ -1487,7 +1500,7 @@ class AsyncWriter {
     socket.cork()
 
     if (bytesWritten === 0) {
-      if (!expectsPayload) {
+      if (!expectsPayload && request.reset !== false) {
         socket[kReset] = true
       }