@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/undici/lib/dispatcher/client.js

@@ -1,10 +1,11 @@
+// @ts-check
+
 'use strict'
 
 const assert = require('node:assert')
 const net = require('node:net')
 const http = require('node:http')
 const util = require('../core/util.js')
-const { ClientStats } = require('../util/stats.js')
 const { channels } = require('../core/diagnostics.js')
 const Request = require('../core/request.js')
 const DispatcherBase = require('./dispatcher-base')
@@ -42,60 +43,32 @@ const {
   kBodyTimeout,
   kStrictContentLength,
   kConnector,
+  kMaxRedirections,
   kMaxRequests,
   kCounter,
   kClose,
   kDestroy,
   kDispatch,
+  kInterceptors,
   kLocalAddress,
   kMaxResponseSize,
   kOnError,
   kHTTPContext,
   kMaxConcurrentStreams,
-  kHostAuthority,
-  kResume,
-  kHTTP2Options
+  kResume
 } = require('../core/symbols.js')
 const connectH1 = require('./client-h1.js')
 const connectH2 = require('./client-h2.js')
+let deprecatedInterceptorWarned = false
 
 const kClosedResolve = Symbol('kClosedResolve')
 
-const getDefaultNodeMaxHeaderSize = http &&
-  http.maxHeaderSize &&
-  Number.isInteger(http.maxHeaderSize) &&
-  http.maxHeaderSize > 0
-  ? () => http.maxHeaderSize
-  : () => { throw new InvalidArgumentError('http module not available or http.maxHeaderSize invalid') }
-
-const noop = () => { }
+const noop = () => {}
 
 function getPipelining (client) {
   return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1
 }
 
-let h2NamespaceOptsWarning = false
-function emitH2OptionsNamespaceWarning (optName) {
-  if (h2NamespaceOptsWarning === true) return
-
-  process.emitWarning(`Use h2Options.${optName} instead. ${optName} for H2 will be deprecated in future major.`, {
-    code: 'UNDICI-H2-OPTIONS'
-  })
-  h2NamespaceOptsWarning = true
-}
-
-// Protocol-aware dispatch ceiling. h1 RFC7230 pipelining is unrelated to h2
-// stream multiplexing — over h2 the ceiling is the (server-confirmed)
-// maxConcurrentStreams. Before a context is attached we use the h1
-// pipelining factor; once h2 attaches the queued requests can drain in
-// one batch up to maxConcurrentStreams.
-function getMaxConcurrent (client) {
-  if (client[kHTTPContext]?.version === 'h2') {
-    return client[kMaxConcurrentStreams]
-  }
-  return getPipelining(client)
-}
-
 /**
  * @type {import('../../types/client.js').default}
  */
@@ -106,6 +79,7 @@ class Client extends DispatcherBase {
    * @param {import('../../types/client.js').Client.Options} options
    */
   constructor (url, {
+    interceptors,
     maxHeaderSize,
     headersTimeout,
     socketTimeout,
@@ -123,6 +97,7 @@ class Client extends DispatcherBase {
     tls,
     strictContentLength,
     maxCachedSessions,
+    maxRedirections,
     connect,
     maxRequestsPerClient,
     localAddress,
@@ -132,14 +107,10 @@ class Client extends DispatcherBase {
     // h2
     maxConcurrentStreams,
     allowH2,
-    useH2c,
-    initialWindowSize,
-    connectionWindowSize,
-    pingInterval,
-    webSocket,
-    h2Options,
-    eventSource
+    webSocket
   } = {}) {
+    super({ webSocket })
+
     if (keepAlive !== undefined) {
       throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead')
     }
@@ -160,14 +131,8 @@ class Client extends DispatcherBase {
       throw new InvalidArgumentError('unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead')
     }
 
-    if (maxHeaderSize != null) {
-      if (!Number.isInteger(maxHeaderSize) || maxHeaderSize < 1) {
-        throw new InvalidArgumentError('invalid maxHeaderSize')
-      }
-    } else {
-      // If maxHeaderSize is not provided, use the default value from the http module
-      // or if that is not available, throw an error.
-      maxHeaderSize = getDefaultNodeMaxHeaderSize()
+    if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
+      throw new InvalidArgumentError('invalid maxHeaderSize')
     }
 
     if (socketPath != null && typeof socketPath !== 'string') {
@@ -202,6 +167,10 @@ class Client extends DispatcherBase {
       throw new InvalidArgumentError('connect must be a function or an object')
     }
 
+    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
     if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
       throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')
     }
@@ -226,84 +195,38 @@ class Client extends DispatcherBase {
       throw new InvalidArgumentError('allowH2 must be a valid boolean value')
     }
 
-    // We validate only if allowH2 is enabled or null (enabled by default)
-    if (allowH2 !== false) {
-      // Prioritise new h2Options object, otherwise fallback to prior configuration options
-      if (h2Options != null) {
-        if (h2Options.useH2c != null && typeof h2Options.useH2c !== 'boolean') {
-          throw new InvalidArgumentError('h2Options.useH2c must be a valid boolean value')
-        }
-
-        if (h2Options.settings?.initialWindowSize != null && (!Number.isInteger(h2Options.settings.initialWindowSize) || h2Options.settings.initialWindowSize < 1)) {
-          throw new InvalidArgumentError('h2Options.settings.initialWindowSize must be a positive integer, greater than 0')
-        }
-
-        if (h2Options.maxConcurrentStreams != null && (!Number.isInteger(h2Options.maxConcurrentStreams) || h2Options.maxConcurrentStreams < 1)) {
-          throw new InvalidArgumentError('h2Options.maxConcurrentStreams must be a positive integer, greater than 0')
-        }
-
-        if (h2Options.connectionWindowSize != null && (!Number.isInteger(h2Options.connectionWindowSize) || h2Options.connectionWindowSize < 1)) {
-          throw new InvalidArgumentError('h2Options.connectionWindowSize must be a positive integer, greater than 0')
-        }
-
-        if (h2Options.pingInterval != null && (typeof h2Options.pingInterval !== 'number' || !Number.isInteger(h2Options.pingInterval) || h2Options.pingInterval < 0)) {
-          throw new InvalidArgumentError('h2Options.pingInterval must be a positive integer, greater or equal to 0')
-        }
-      } else {
-        if (useH2c != null && typeof useH2c !== 'boolean') {
-          emitH2OptionsNamespaceWarning('useH2c')
-          throw new InvalidArgumentError('useH2c must be a valid boolean value')
-        }
-
-        if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) {
-          emitH2OptionsNamespaceWarning('maxConcurrentStreams')
-          throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0')
-        }
-
-        if (initialWindowSize != null && (!Number.isInteger(initialWindowSize) || initialWindowSize < 1)) {
-          emitH2OptionsNamespaceWarning('initialWindowSize')
-          throw new InvalidArgumentError('initialWindowSize must be a positive integer, greater than 0')
-        }
-
-        if (connectionWindowSize != null && (!Number.isInteger(connectionWindowSize) || connectionWindowSize < 1)) {
-          emitH2OptionsNamespaceWarning('connectionWindowSize')
-          throw new InvalidArgumentError('connectionWindowSize must be a positive integer, greater than 0')
-        }
-
-        if (pingInterval != null && (typeof pingInterval !== 'number' || !Number.isInteger(pingInterval) || pingInterval < 0)) {
-          emitH2OptionsNamespaceWarning('pingInterval')
-          throw new InvalidArgumentError('pingInterval must be a positive integer, greater or equal to 0')
-        }
-      }
+    if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) {
+      throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0')
     }
 
-    super({ webSocket, eventSource })
-
     if (typeof connect !== 'function') {
       connect = buildConnector({
         ...tls,
         maxCachedSessions,
         allowH2,
         socketPath,
-        useH2c: h2Options?.useH2c ?? useH2c,
         timeout: connectTimeout,
-        ...(typeof autoSelectFamily === 'boolean' ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
         ...connect
       })
+    }
+
+    if (interceptors?.Client && Array.isArray(interceptors.Client)) {
+      this[kInterceptors] = interceptors.Client
+      if (!deprecatedInterceptorWarned) {
+        deprecatedInterceptorWarned = true
+        process.emitWarning('Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.', {
+          code: 'UNDICI-CLIENT-INTERCEPTOR-DEPRECATED'
+        })
+      }
     } else {
-      const customConnect = connect
-      connect = (opts, callback) => customConnect({
-        ...opts,
-        ...(socketPath != null ? { socketPath } : null),
-        ...(allowH2 != null ? { allowH2 } : null)
-      }, callback)
+      this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })]
     }
 
     this[kUrl] = util.parseOrigin(url)
-    this[kHostAuthority] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}`
     this[kConnector] = connect
     this[kPipelining] = pipelining != null ? pipelining : 1
-    this[kMaxHeadersSize] = maxHeaderSize
+    this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize
     this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout
     this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600e3 : keepAliveMaxTimeout
     this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold
@@ -312,29 +235,16 @@ class Client extends DispatcherBase {
     this[kLocalAddress] = localAddress != null ? localAddress : null
     this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming
     this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming
-    this[kHostHeader] = `host: ${this[kHostAuthority]}\r\n`
+    this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`
     this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3
     this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3
     this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength
+    this[kMaxRedirections] = maxRedirections
     this[kMaxRequests] = maxRequestsPerClient
     this[kClosedResolve] = null
     this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1
+    this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100 // Max peerConcurrentStreams for a Node h2 server
     this[kHTTPContext] = null
-    // h2
-    this[kHTTP2Options] = {
-      pingInterval: h2Options?.pingInterval ?? pingInterval ?? 60e3,
-      connectionWindowSize: h2Options?.connectionWindowSize ?? connectionWindowSize ?? 524288,
-      maxConcurrentStreams: h2Options?.maxConcurrentStreams ?? maxConcurrentStreams ?? 100, // Max peerConcurrentStreams for a Node h2 server
-      sessionOptions: {
-        // HTTP/2 window sizes are set to higher defaults than Node.js core for better performance:
-        // - initialWindowSize: 262144 (256KB) vs Node.js default 65535 (64KB - 1)
-        //   Allows more data to be sent before requiring acknowledgment, improving throughput
-        //   especially on high-latency networks. This matches common production HTTP/2 servers.
-        // - connectionWindowSize: 524288 (512KB) vs Node.js default (none set)
-        //   Provides better flow control for the entire connection across multiple streams.
-        initialWindowSize: h2Options?.initialWindowSize ?? initialWindowSize ?? 262144
-      }
-    }
 
     // kQueue is built up of 3 sections separated by
     // the kRunningIdx and kPendingIdx indices.
@@ -362,10 +272,6 @@ class Client extends DispatcherBase {
     this[kResume](true)
   }
 
-  get stats () {
-    return new ClientStats(this)
-  }
-
   get [kPending] () {
     return this[kQueue].length - this[kPendingIdx]
   }
@@ -383,27 +289,22 @@ class Client extends DispatcherBase {
   }
 
   get [kBusy] () {
-    // The `kPending > 0` check below is the gate Pool uses to decide whether
-    // to spin up an additional Client. For h1 that fan-out is correct —
-    // each socket only handles one pipelined request at a time. Once an h2
-    // context is attached we want concurrent dispatches to multiplex onto
-    // the shared session, so suppress that signal in the h2 case.
-    const allowsMux = this[kHTTPContext]?.version === 'h2'
-
     return Boolean(
       this[kHTTPContext]?.busy(null) ||
-      (this[kSize] >= (getMaxConcurrent(this) || 1)) ||
-      (this[kPending] > 0 && !allowsMux)
+      (this[kSize] >= (getPipelining(this) || 1)) ||
+      this[kPending] > 0
     )
   }
 
+  /* istanbul ignore: only used for test */
   [kConnect] (cb) {
     connect(this)
     this.once('connect', cb)
   }
 
   [kDispatch] (opts, handler) {
-    const request = new Request(this[kUrl].origin, opts, handler)
+    const origin = opts.origin || this[kUrl].origin
+    const request = new Request(origin, opts, handler)
 
     this[kQueue].push(request)
     if (this[kResuming]) {
@@ -423,7 +324,7 @@ class Client extends DispatcherBase {
     return this[kNeedDrain] < 2
   }
 
-  [kClose] () {
+  async [kClose] () {
     // TODO: for H2 we need to gracefully flush the remaining enqueued
     // request and close each stream.
     return new Promise((resolve) => {
@@ -435,14 +336,12 @@ class Client extends DispatcherBase {
     })
   }
 
-  [kDestroy] (err) {
+  async [kDestroy] (err) {
     return new Promise((resolve) => {
       const requests = this[kQueue].splice(this[kPendingIdx])
       for (let i = 0; i < requests.length; i++) {
         const request = requests[i]
-        if (request != null) {
-          util.errorRequest(this, request, err)
-        }
+        util.errorRequest(this, request, err)
       }
 
       const callback = () => {
@@ -466,6 +365,8 @@ class Client extends DispatcherBase {
   }
 }
 
+const createRedirectInterceptor = require('../interceptor/redirect-interceptor.js')
+
 function onError (client, err) {
   if (
     client[kRunning] === 0 &&
@@ -481,9 +382,7 @@ function onError (client, err) {
 
     for (let i = 0; i < requests.length; i++) {
       const request = requests[i]
-      if (request != null) {
-        util.errorRequest(client, request, err)
-      }
+      util.errorRequest(client, request, err)
     }
     assert(client[kSize] === 0)
   }
@@ -491,9 +390,9 @@ function onError (client, err) {
 
 /**
  * @param {Client} client
- * @returns {void}
+ * @returns
  */
-function connect (client) {
+async function connect (client) {
   assert(!client[kConnecting])
   assert(!client[kHTTPContext])
 
@@ -506,7 +405,7 @@ function connect (client) {
     assert(idx !== -1)
     const ip = hostname.substring(1, idx)
 
-    assert(net.isIPv6(ip))
+    assert(net.isIP(ip))
     hostname = ip
   }
 
@@ -528,111 +427,99 @@ function connect (client) {
   }
 
   try {
-    client[kConnector]({
-      host,
-      hostname,
-      protocol,
-      port,
-      servername: client[kServerName],
-      localAddress: client[kLocalAddress]
-    }, (err, socket) => {
-      if (err) {
-        handleConnectError(client, err, { host, hostname, protocol, port })
-        client[kResume]()
-        return
-      }
-
-      if (client.destroyed) {
-        util.destroy(socket.on('error', noop), new ClientDestroyedError())
-        client[kResume]()
-        return
-      }
-
-      assert(socket)
-
-      try {
-        client[kHTTPContext] = socket.alpnProtocol === 'h2'
-          ? connectH2(client, socket)
-          : connectH1(client, socket)
-      } catch (err) {
-        socket.destroy().on('error', noop)
-        handleConnectError(client, err, { host, hostname, protocol, port })
-        client[kResume]()
-        return
-      }
-
-      client[kConnecting] = false
-
-      socket[kCounter] = 0
-      socket[kMaxRequests] = client[kMaxRequests]
-      socket[kClient] = client
-      socket[kError] = null
-
-      if (channels.connected.hasSubscribers) {
-        channels.connected.publish({
-          connectParams: {
-            host,
-            hostname,
-            protocol,
-            port,
-            version: client[kHTTPContext]?.version,
-            servername: client[kServerName],
-            localAddress: client[kLocalAddress]
-          },
-          connector: client[kConnector],
-          socket
-        })
-      }
-
-      client.emit('connect', client[kUrl], [client])
-      client[kResume]()
-    })
-  } catch (err) {
-    handleConnectError(client, err, { host, hostname, protocol, port })
-    client[kResume]()
-  }
-}
-
-function handleConnectError (client, err, { host, hostname, protocol, port }) {
-  if (client.destroyed) {
-    return
-  }
-
-  client[kConnecting] = false
-
-  if (channels.connectError.hasSubscribers) {
-    channels.connectError.publish({
-      connectParams: {
+    const socket = await new Promise((resolve, reject) => {
+      client[kConnector]({
         host,
         hostname,
         protocol,
         port,
-        version: client[kHTTPContext]?.version,
         servername: client[kServerName],
         localAddress: client[kLocalAddress]
-      },
-      connector: client[kConnector],
-      error: err
+      }, (err, socket) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(socket)
+        }
+      })
     })
-  }
 
-  if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
-    const running = client[kQueue].splice(client[kRunningIdx], client[kRunning])
-    client[kPendingIdx] = client[kRunningIdx]
+    if (client.destroyed) {
+      util.destroy(socket.on('error', noop), new ClientDestroyedError())
+      return
+    }
 
-    for (let i = 0; i < running.length; i++) {
-      util.errorRequest(client, running[i], err)
+    assert(socket)
+
+    try {
+      client[kHTTPContext] = socket.alpnProtocol === 'h2'
+        ? await connectH2(client, socket)
+        : await connectH1(client, socket)
+    } catch (err) {
+      socket.destroy().on('error', noop)
+      throw err
+    }
+
+    client[kConnecting] = false
+
+    socket[kCounter] = 0
+    socket[kMaxRequests] = client[kMaxRequests]
+    socket[kClient] = client
+    socket[kError] = null
+
+    if (channels.connected.hasSubscribers) {
+      channels.connected.publish({
+        connectParams: {
+          host,
+          hostname,
+          protocol,
+          port,
+          version: client[kHTTPContext]?.version,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        },
+        connector: client[kConnector],
+        socket
+      })
+    }
+    client.emit('connect', client[kUrl], [client])
+  } catch (err) {
+    if (client.destroyed) {
+      return
     }
 
-    while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
-      const request = client[kQueue].splice(client[kPendingIdx], 1)[0]
-      util.errorRequest(client, request, err)
+    client[kConnecting] = false
+
+    if (channels.connectError.hasSubscribers) {
+      channels.connectError.publish({
+        connectParams: {
+          host,
+          hostname,
+          protocol,
+          port,
+          version: client[kHTTPContext]?.version,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        },
+        connector: client[kConnector],
+        error: err
+      })
     }
-  } else {
-    onError(client, err)
+
+    if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+      assert(client[kRunning] === 0)
+      while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
+        const request = client[kQueue][client[kPendingIdx]++]
+        util.errorRequest(client, request, err)
+      }
+    } else {
+      onError(client, err)
+    }
+
+    client.emit('connectionError', client[kUrl], [client], err)
   }
 
-  client.emit('connectionError', client[kUrl], [client], err)
+  client[kResume]()
 }
 
 function emitDrain (client) {
@@ -690,21 +577,12 @@ function _resume (client, sync) {
       return
     }
 
-    if (client[kRunning] >= (getMaxConcurrent(client) || 1)) {
+    if (client[kRunning] >= (getPipelining(client) || 1)) {
       return
     }
 
     const request = client[kQueue][client[kPendingIdx]]
 
-    if (request === null) {
-      return
-    }
-
-    if (request.aborted) {
-      client[kQueue].splice(client[kPendingIdx], 1)
-      continue
-    }
-
     if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) {
       if (client[kRunning] > 0) {
         return
@@ -722,7 +600,6 @@ function _resume (client, sync) {
     }
 
     if (!client[kHTTPContext]) {
-      client[kServerName] = request.servername
       connect(client)
       return
     }