@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/undici/lib/core/connect.js

@@ -4,6 +4,9 @@ const net = require('node:net')
 const assert = require('node:assert')
 const util = require('./util')
 const { InvalidArgumentError, ConnectTimeoutError } = require('./errors')
+const timers = require('../util/timers')
+
+function noop () {}
 
 let tls // include tls conditionally since it is not always available
 
@@ -12,54 +15,68 @@ let tls // include tls conditionally since it is not always available
 // resolve the same servername multiple times even when
 // re-use is enabled.
 
-const SessionCache = class WeakSessionCache {
-  constructor (maxCachedSessions) {
-    this._maxCachedSessions = maxCachedSessions
-    this._sessionCache = new Map()
-    this._sessionRegistry = new FinalizationRegistry((key) => {
-      if (this._sessionCache.size < this._maxCachedSessions) {
-        return
-      }
+let SessionCache
+// FIXME: remove workaround when the Node bug is fixed
+// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
+if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) {
+  SessionCache = class WeakSessionCache {
+    constructor (maxCachedSessions) {
+      this._maxCachedSessions = maxCachedSessions
+      this._sessionCache = new Map()
+      this._sessionRegistry = new global.FinalizationRegistry((key) => {
+        if (this._sessionCache.size < this._maxCachedSessions) {
+          return
+        }
+
+        const ref = this._sessionCache.get(key)
+        if (ref !== undefined && ref.deref() === undefined) {
+          this._sessionCache.delete(key)
+        }
+      })
+    }
+
+    get (sessionKey) {
+      const ref = this._sessionCache.get(sessionKey)
+      return ref ? ref.deref() : null
+    }
 
-      const ref = this._sessionCache.get(key)
-      if (ref !== undefined && ref.deref() === undefined) {
-        this._sessionCache.delete(key)
+    set (sessionKey, session) {
+      if (this._maxCachedSessions === 0) {
+        return
       }
-    })
-  }
 
-  get (sessionKey) {
-    const ref = this._sessionCache.get(sessionKey)
-    return ref ? ref.deref() : null
+      this._sessionCache.set(sessionKey, new WeakRef(session))
+      this._sessionRegistry.register(session, sessionKey)
+    }
   }
+} else {
+  SessionCache = class SimpleSessionCache {
+    constructor (maxCachedSessions) {
+      this._maxCachedSessions = maxCachedSessions
+      this._sessionCache = new Map()
+    }
 
-  set (sessionKey, session) {
-    if (this._maxCachedSessions === 0) {
-      return
+    get (sessionKey) {
+      return this._sessionCache.get(sessionKey)
     }
 
-    if (this._sessionCache.has(sessionKey)) {
-      this._sessionCache.delete(sessionKey)
-    } else if (this._sessionCache.size >= this._maxCachedSessions) {
-      for (const [key, ref] of this._sessionCache) {
-        if (ref.deref() === undefined) {
-          this._sessionCache.delete(key)
-          return
-        }
+    set (sessionKey, session) {
+      if (this._maxCachedSessions === 0) {
+        return
       }
 
-      const oldest = this._sessionCache.keys().next()
-      if (!oldest.done) {
-        this._sessionCache.delete(oldest.value)
+      if (this._sessionCache.size >= this._maxCachedSessions) {
+        // remove the oldest session
+        const { value: oldestKey } = this._sessionCache.keys().next()
+        this._sessionCache.delete(oldestKey)
       }
-    }
 
-    this._sessionCache.set(sessionKey, new WeakRef(session))
-    this._sessionRegistry.register(session, sessionKey)
+      this._sessionCache.set(sessionKey, session)
+    }
   }
 }
 
-function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
+function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
   if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
     throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero')
   }
@@ -67,7 +84,7 @@ function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketP
   const options = { path: socketPath, ...opts }
   const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions)
   timeout = timeout == null ? 10e3 : timeout
-  allowH2 = allowH2 != null ? allowH2 : true
+  allowH2 = allowH2 != null ? allowH2 : false
   return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
     let socket
     if (protocol === 'https:') {
@@ -89,7 +106,8 @@ function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketP
         servername,
         session,
         localAddress,
-        ALPNProtocols: allowH2 ? (preferH2 ? ['h2', 'http/1.1'] : ['http/1.1', 'h2']) : ['http/1.1'],
+        // TODO(HTTP/2): Add support for h2c
+        ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'],
         socket: httpSocket, // upgrade socket connection
         port,
         host: hostname
@@ -105,30 +123,13 @@ function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketP
 
       port = port || 80
 
-      const connectOptions = {
+      socket = net.connect({
         highWaterMark: 64 * 1024, // Same as nodejs fs streams.
         ...options,
         localAddress,
         port,
         host: hostname
-      }
-
-      const family = net.isIP(hostname)
-      if (family !== 0 && servername && servername !== hostname) {
-        connectOptions.host = servername
-        connectOptions.lookup = (_hostname, lookupOptions, cb) => {
-          if (lookupOptions.all) {
-            cb(null, [{ address: hostname, family }])
-          } else {
-            cb(null, hostname, family)
-          }
-        }
-      }
-
-      socket = net.connect(connectOptions)
-      if (useH2c === true) {
-        socket.alpnProtocol = 'h2'
-      }
+      })
     }
 
     // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket
@@ -137,7 +138,7 @@ function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketP
       socket.setKeepAlive(true, keepAliveInitialDelay)
     }
 
-    const clearConnectTimeout = util.setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
+    const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
 
     socket
       .setNoDelay(true)
@@ -156,7 +157,7 @@ function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketP
         if (callback) {
           const cb = callback
           callback = null
-          cb(maybeNormalizeConnectError(err, this, { timeout, hostname, port }))
+          cb(err)
         }
       })
 
@@ -164,29 +165,76 @@ function buildConnector ({ allowH2, preferH2, useH2c, maxCachedSessions, socketP
   }
 }
 
-// `net.connect` with `autoSelectFamily` raises an `AggregateError` when every
-// attempted address fails. If any of those failures is a timeout, surface the
-// error as a `ConnectTimeoutError` so callers see the same error regardless of
-// which timer (Node's internal one or undici's `connectTimeout`) wins the race.
-// The original `AggregateError` is preserved on `.cause`.
-function maybeNormalizeConnectError (err, socket, opts) {
-  if (
-    err instanceof AggregateError &&
-    (err.code === 'ETIMEDOUT' || err.errors.some((e) => e != null && e.code === 'ETIMEDOUT'))
-  ) {
-    let message = 'Connect Timeout Error'
-    if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
-      message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`
-    } else {
-      message += ` (attempted address: ${opts.hostname}:${opts.port},`
+/**
+ * @param {WeakRef<net.Socket>} socketWeakRef
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ * @returns {() => void}
+ */
+const setupConnectTimeout = process.platform === 'win32'
+  ? (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
+
+      let s1 = null
+      let s2 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+        // Windows needs an extra setImmediate probably due to implementation differences in the socket logic
+          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts))
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+        clearImmediate(s2)
+      }
+    }
+  : (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
+
+      let s1 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+          onConnectTimeout(socketWeakRef.deref(), opts)
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+      }
     }
-    message += ` timeout: ${opts.timeout}ms)`
 
-    const wrapped = new ConnectTimeoutError(message)
-    wrapped.cause = err
-    return wrapped
+/**
+ * @param {net.Socket} socket
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @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(', ')},`
+  } else {
+    message += ` (attempted address: ${opts.hostname}:${opts.port},`
   }
-  return err
+
+  message += ` timeout: ${opts.timeout}ms)`
+
+  util.destroy(socket, new ConnectTimeoutError(message))
 }
 
 module.exports = buildConnector

package/node_modules/undici/lib/core/constants.js

@@ -1,9 +1,10 @@
 'use strict'
 
-/**
- * @see https://developer.mozilla.org/docs/Web/HTTP/Headers
- */
-const wellknownHeaderNames = /** @type {const} */ ([
+/** @type {Record<string, string | undefined>} */
+const headerNameLowerCasedRecord = {}
+
+// https://developer.mozilla.org/docs/Web/HTTP/Headers
+const wellknownHeaderNames = [
   'Accept',
   'Accept-Encoding',
   'Accept-Language',
@@ -99,13 +100,7 @@ const wellknownHeaderNames = /** @type {const} */ ([
   'X-Powered-By',
   'X-Requested-With',
   'X-XSS-Protection'
-])
-
-/** @type {Record<typeof wellknownHeaderNames[number]|Lowercase<typeof wellknownHeaderNames[number]>, string>} */
-const headerNameLowerCasedRecord = {}
-
-// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
-Object.setPrototypeOf(headerNameLowerCasedRecord, null)
+]
 
 for (let i = 0; i < wellknownHeaderNames.length; ++i) {
   const key = wellknownHeaderNames[i]
@@ -114,6 +109,9 @@ for (let i = 0; i < wellknownHeaderNames.length; ++i) {
     lowerCasedKey
 }
 
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(headerNameLowerCasedRecord, null)
+
 module.exports = {
   wellknownHeaderNames,
   headerNameLowerCasedRecord

package/node_modules/undici/lib/core/diagnostics.js

@@ -1,12 +1,11 @@
 'use strict'
-
 const diagnosticsChannel = require('node:diagnostics_channel')
 const util = require('node:util')
 
 const undiciDebugLog = util.debuglog('undici')
 const fetchDebuglog = util.debuglog('fetch')
 const websocketDebuglog = util.debuglog('websocket')
-
+let isClientSet = false
 const channels = {
   // Client
   beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'),
@@ -16,8 +15,6 @@ const channels = {
   // Request
   create: diagnosticsChannel.channel('undici:request:create'),
   bodySent: diagnosticsChannel.channel('undici:request:bodySent'),
-  bodyChunkSent: diagnosticsChannel.channel('undici:request:bodyChunkSent'),
-  bodyChunkReceived: diagnosticsChannel.channel('undici:request:bodyChunkReceived'),
   headers: diagnosticsChannel.channel('undici:request:headers'),
   trailers: diagnosticsChannel.channel('undici:request:trailers'),
   error: diagnosticsChannel.channel('undici:request:error'),
@@ -26,34 +23,105 @@ const channels = {
   close: diagnosticsChannel.channel('undici:websocket:close'),
   socketError: diagnosticsChannel.channel('undici:websocket:socket_error'),
   ping: diagnosticsChannel.channel('undici:websocket:ping'),
-  pong: diagnosticsChannel.channel('undici:websocket:pong'),
-  // ProxyAgent
-  proxyConnected: diagnosticsChannel.channel('undici:proxy:connected')
+  pong: diagnosticsChannel.channel('undici:websocket:pong')
 }
 
-let isTrackingClientEvents = false
-
-function trackClientEvents (debugLog = undiciDebugLog) {
-  if (isTrackingClientEvents) {
-    return
-  }
-
-  // Check if any of the channels already have subscribers to prevent duplicate subscriptions
-  // This can happen when both Node.js built-in undici and undici as a dependency are present
-  if (channels.beforeConnect.hasSubscribers || channels.connected.hasSubscribers ||
-      channels.connectError.hasSubscribers || channels.sendHeaders.hasSubscribers) {
-    isTrackingClientEvents = true
-    return
-  }
-
-  isTrackingClientEvents = true
+if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
+  const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog
+
+  // Track all Client events
+  diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connecting to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connected to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host },
+      error
+    } = evt
+    debuglog(
+      'connection to %s using %s%s errored - %s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version,
+      error.message
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('sending request to %s %s/%s', method, origin, path)
+  })
+
+  // Track Request events
+  diagnosticsChannel.channel('undici:request:headers').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      response: { statusCode }
+    } = evt
+    debuglog(
+      'received response to %s %s/%s - HTTP %d',
+      method,
+      origin,
+      path,
+      statusCode
+    )
+  })
+
+  diagnosticsChannel.channel('undici:request:trailers').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('trailers received from %s %s/%s', method, origin, path)
+  })
+
+  diagnosticsChannel.channel('undici:request:error').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      error
+    } = evt
+    debuglog(
+      'request to %s %s/%s errored - %s',
+      method,
+      origin,
+      path,
+      error.message
+    )
+  })
+
+  isClientSet = true
+}
 
-  diagnosticsChannel.subscribe('undici:client:beforeConnect',
-    evt => {
+if (websocketDebuglog.enabled) {
+  if (!isClientSet) {
+    const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog
+    diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
       const {
         connectParams: { version, protocol, port, host }
       } = evt
-      debugLog(
+      debuglog(
         'connecting to %s%s using %s%s',
         host,
         port ? `:${port}` : '',
@@ -62,12 +130,11 @@ function trackClientEvents (debugLog = undiciDebugLog) {
       )
     })
 
-  diagnosticsChannel.subscribe('undici:client:connected',
-    evt => {
+    diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
       const {
         connectParams: { version, protocol, port, host }
       } = evt
-      debugLog(
+      debuglog(
         'connected to %s%s using %s%s',
         host,
         port ? `:${port}` : '',
@@ -76,13 +143,12 @@ function trackClientEvents (debugLog = undiciDebugLog) {
       )
     })
 
-  diagnosticsChannel.subscribe('undici:client:connectError',
-    evt => {
+    diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
       const {
         connectParams: { version, protocol, port, host },
         error
       } = evt
-      debugLog(
+      debuglog(
         'connection to %s%s using %s%s errored - %s',
         host,
         port ? `:${port}` : '',
@@ -92,134 +158,43 @@ function trackClientEvents (debugLog = undiciDebugLog) {
       )
     })
 
-  diagnosticsChannel.subscribe('undici:client:sendHeaders',
-    evt => {
-      const {
-        request: { method, path, origin }
-      } = evt
-      debugLog('sending request to %s %s%s', method, origin, path)
-    })
-}
-
-let isTrackingRequestEvents = false
-
-function trackRequestEvents (debugLog = undiciDebugLog) {
-  if (isTrackingRequestEvents) {
-    return
-  }
-
-  // Check if any of the channels already have subscribers to prevent duplicate subscriptions
-  // This can happen when both Node.js built-in undici and undici as a dependency are present
-  if (channels.headers.hasSubscribers || channels.trailers.hasSubscribers ||
-      channels.error.hasSubscribers) {
-    isTrackingRequestEvents = true
-    return
-  }
-
-  isTrackingRequestEvents = true
-
-  diagnosticsChannel.subscribe('undici:request:headers',
-    evt => {
-      const {
-        request: { method, path, origin },
-        response: { statusCode }
-      } = evt
-      debugLog(
-        'received response to %s %s%s - HTTP %d',
-        method,
-        origin,
-        path,
-        statusCode
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:request:trailers',
-    evt => {
+    diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
       const {
         request: { method, path, origin }
       } = evt
-      debugLog('trailers received from %s %s%s', method, origin, path)
-    })
-
-  diagnosticsChannel.subscribe('undici:request:error',
-    evt => {
-      const {
-        request: { method, path, origin },
-        error
-      } = evt
-      debugLog(
-        'request to %s %s%s errored - %s',
-        method,
-        origin,
-        path,
-        error.message
-      )
+      debuglog('sending request to %s %s/%s', method, origin, path)
     })
-}
-
-let isTrackingWebSocketEvents = false
-
-function trackWebSocketEvents (debugLog = websocketDebuglog) {
-  if (isTrackingWebSocketEvents) {
-    return
-  }
-
-  // Check if any of the channels already have subscribers to prevent duplicate subscriptions
-  // This can happen when both Node.js built-in undici and undici as a dependency are present
-  if (channels.open.hasSubscribers || channels.close.hasSubscribers ||
-      channels.socketError.hasSubscribers || channels.ping.hasSubscribers ||
-      channels.pong.hasSubscribers) {
-    isTrackingWebSocketEvents = true
-    return
   }
 
-  isTrackingWebSocketEvents = true
-
-  diagnosticsChannel.subscribe('undici:websocket:open',
-    evt => {
-      if (evt.address != null) {
-        const { address, port } = evt.address
-        debugLog('connection opened %s%s', address, port ? `:${port}` : '')
-      } else {
-        debugLog('connection opened')
-      }
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:close',
-    evt => {
-      const { websocket, code, reason } = evt
-      debugLog(
-        'closed connection to %s - %s %s',
-        websocket.url,
-        code,
-        reason
-      )
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:socket_error',
-    err => {
-      debugLog('connection errored - %s', err.message)
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:ping',
-    evt => {
-      debugLog('ping received')
-    })
-
-  diagnosticsChannel.subscribe('undici:websocket:pong',
-    evt => {
-      debugLog('pong received')
-    })
-}
-
-if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
-  trackClientEvents(fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog)
-  trackRequestEvents(fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog)
-}
-
-if (websocketDebuglog.enabled) {
-  trackClientEvents(undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog)
-  trackWebSocketEvents(websocketDebuglog)
+  // Track all WebSocket events
+  diagnosticsChannel.channel('undici:websocket:open').subscribe(evt => {
+    const {
+      address: { address, port }
+    } = evt
+    websocketDebuglog('connection opened %s%s', address, port ? `:${port}` : '')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:close').subscribe(evt => {
+    const { websocket, code, reason } = evt
+    websocketDebuglog(
+      'closed connection to %s - %s %s',
+      websocket.url,
+      code,
+      reason
+    )
+  })
+
+  diagnosticsChannel.channel('undici:websocket:socket_error').subscribe(err => {
+    websocketDebuglog('connection errored - %s', err.message)
+  })
+
+  diagnosticsChannel.channel('undici:websocket:ping').subscribe(evt => {
+    websocketDebuglog('ping received')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:pong').subscribe(evt => {
+    websocketDebuglog('pong received')
+  })
 }
 
 module.exports = {