deps: update undici to 6.16.1

PR-URL: #52948
Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>

Author: nodejs-github-bot

deps/undici/src/docs/docs/api/EnvHttpProxyAgent.md

@@ -0,0 +1,162 @@
+# Class: EnvHttpProxyAgent
+
+Stability: Experimental.
+
+Extends: `undici.Dispatcher`
+
+EnvHttpProxyAgent automatically reads the proxy configuration from the environment variables `http_proxy`, `https_proxy`, and `no_proxy` and sets up the proxy agents accordingly. When `http_proxy` and `https_proxy` are set, `http_proxy` is used for HTTP requests and `https_proxy` is used for HTTPS requests. If only `http_proxy` is set, `http_proxy` is used for both HTTP and HTTPS requests. If only `https_proxy` is set, it is only used for HTTPS requests.
+
+`no_proxy` is a comma or space-separated list of hostnames that should not be proxied. The list may contain leading wildcard characters (`*`). If `no_proxy` is set, the EnvHttpProxyAgent will bypass the proxy for requests to hosts that match the list. If `no_proxy` is set to `"*"`, the EnvHttpProxyAgent will bypass the proxy for all requests.
+
+Uppercase environment variables are also supported: `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY`. However, if both the lowercase and uppercase environment variables are set, the uppercase environment variables will be ignored.
+
+## `new EnvHttpProxyAgent([options])`
+
+Arguments:
+
+***options**`EnvHttpProxyAgentOptions` (optional) - extends the `Agent` options.
+
+Returns: `EnvHttpProxyAgent`
+
+### Parameter: `EnvHttpProxyAgentOptions`
+
+Extends: [`AgentOptions`](Agent.md#parameter-agentoptions)
+
+***httpProxy**`string` (optional) - When set, it will override the `HTTP_PROXY` environment variable.
+***httpsProxy**`string` (optional) - When set, it will override the `HTTPS_PROXY` environment variable.
+***noProxy**`string` (optional) - When set, it will override the `NO_PROXY` environment variable.
+
+Examples:
+
+```js
+import { EnvHttpProxyAgent } from'undici'
+
+constenvHttpProxyAgent=newEnvHttpProxyAgent()
+// or
+constenvHttpProxyAgent=newEnvHttpProxyAgent({ httpProxy:'my.proxy.server:8080', httpsProxy:'my.proxy.server:8443', noProxy:'localhost' })
+```
+
+#### Example - EnvHttpProxyAgent instantiation
+
+This will instantiate the EnvHttpProxyAgent. It will not do anything until registered as the agent to use with requests.
+
+```js
+import { EnvHttpProxyAgent } from'undici'
+
+constenvHttpProxyAgent=newEnvHttpProxyAgent()
+```
+
+#### Example - Basic Proxy Fetch with global agent dispatcher
+
+```js
+import { setGlobalDispatcher, fetch, EnvHttpProxyAgent } from'undici'
+
+constenvHttpProxyAgent=newEnvHttpProxyAgent()
+setGlobalDispatcher(envHttpProxyAgent)
+
+const { status, json } =awaitfetch('http://localhost:3000/foo')
+
+console.log('response received', status) // response received 200
+
+constdata=awaitjson() // data { foo: "bar" }
+```
+
+#### Example - Basic Proxy Request with global agent dispatcher
+
+```js
+import { setGlobalDispatcher, request, EnvHttpProxyAgent } from'undici'
+
+constenvHttpProxyAgent=newEnvHttpProxyAgent()
+setGlobalDispatcher(envHttpProxyAgent)
+
+const { statusCode, body } =awaitrequest('http://localhost:3000/foo')
+
+console.log('response received', statusCode) // response received 200
+
+forawait (constdataofbody) {
+console.log('data', data.toString('utf8')) // data foo
+}
+```
+
+#### Example - Basic Proxy Request with local agent dispatcher
+
+```js
+import { EnvHttpProxyAgent, request } from'undici'
+
+constenvHttpProxyAgent=newEnvHttpProxyAgent()
+
+const {
+statusCode,
+body
+} =awaitrequest('http://localhost:3000/foo', { dispatcher: envHttpProxyAgent })
+
+console.log('response received', statusCode) // response received 200
+
+forawait (constdataofbody) {
+console.log('data', data.toString('utf8')) // data foo
+}
+```
+
+#### Example - Basic Proxy Fetch with local agent dispatcher
+
+```js
+import { EnvHttpProxyAgent, fetch } from'undici'
+
+constenvHttpProxyAgent=newEnvHttpProxyAgent()
+
+const {
+status,
+json
+} =awaitfetch('http://localhost:3000/foo', { dispatcher: envHttpProxyAgent })
+
+console.log('response received', status) // response received 200
+
+constdata=awaitjson() // data { foo: "bar" }
+```
+
+## Instance Methods
+
+### `EnvHttpProxyAgent.close([callback])`
+
+Implements [`Dispatcher.close([callback])`](Dispatcher.md#dispatcherclosecallback-promise).
+
+### `EnvHttpProxyAgent.destroy([error, callback])`
+
+Implements [`Dispatcher.destroy([error, callback])`](Dispatcher.md#dispatcherdestroyerror-callback-promise).
+
+### `EnvHttpProxyAgent.dispatch(options, handler: AgentDispatchOptions)`
+
+Implements [`Dispatcher.dispatch(options, handler)`](Dispatcher.md#dispatcherdispatchoptions-handler).
+
+#### Parameter: `AgentDispatchOptions`
+
+Extends: [`DispatchOptions`](Dispatcher.md#parameter-dispatchoptions)
+
+***origin**`string | URL`
+***maxRedirections**`Integer`.
+
+Implements [`Dispatcher.destroy([error, callback])`](Dispatcher.md#dispatcherdestroyerror-callback-promise).
+
+### `EnvHttpProxyAgent.connect(options[, callback])`
+
+See [`Dispatcher.connect(options[, callback])`](Dispatcher.md#dispatcherconnectoptions-callback).
+
+### `EnvHttpProxyAgent.dispatch(options, handler)`
+
+Implements [`Dispatcher.dispatch(options, handler)`](Dispatcher.md#dispatcherdispatchoptions-handler).
+
+### `EnvHttpProxyAgent.pipeline(options, handler)`
+
+See [`Dispatcher.pipeline(options, handler)`](Dispatcher.md#dispatcherpipelineoptions-handler).
+
+### `EnvHttpProxyAgent.request(options[, callback])`
+
+See [`Dispatcher.request(options [, callback])`](Dispatcher.md#dispatcherrequestoptions-callback).
+
+### `EnvHttpProxyAgent.stream(options, factory[, callback])`
+
+See [`Dispatcher.stream(options, factory[, callback])`](Dispatcher.md#dispatcherstreamoptions-factory-callback).
+
+### `EnvHttpProxyAgent.upgrade(options[, callback])`
+
+See [`Dispatcher.upgrade(options[, callback])`](Dispatcher.md#dispatcherupgradeoptions-callback).

deps/undici/src/docs/docs/api/Util.md

@@ -8,11 +8,11 @@ Receives a header object and returns the parsed value.
 
 Arguments:
 
--**headers**`Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]` (required) - Header object.
+-**headers**`(Buffer | string | (Buffer | string)[])[]` (required) - Header object.
 
 -**obj**`Record<string, string | string[]>` (optional) - Object to specify a proxy object. The parsed value is assigned to this object. But, if **headers** is an object, it is not used.
 
-Returns: `Record<string, string | string[]>` If **headers** is an object, it is **headers**. Otherwise, if **obj** is specified, it is equivalent to **obj**.
+Returns: `Record<string, string | string[]>` If **obj** is specified, it is equivalent to **obj**.
 
 ## `headerNameToString(value)`
 

deps/undici/src/docs/docs/best-practices/proxy.md

@@ -2,7 +2,7 @@
 
 Connecting through a proxy is possible by:
 
-- Using [AgentProxy](../api/ProxyAgent.md).
+- Using [ProxyAgent](../api/ProxyAgent.md).
 - Configuring `Client` or `Pool` constructor.
 
 The proxy url should be passed to the `Client` or `Pool` constructor, while the upstream server url

deps/undici/src/lib/api/api-request.js

@@ -2,11 +2,10 @@
 
 constassert=require('node:assert')
 const{ Readable }=require('./readable')
-const{ InvalidArgumentError }=require('../core/errors')
+const{ InvalidArgumentError, RequestAbortedError}=require('../core/errors')
 constutil=require('../core/util')
 const{ getResolveErrorBodyCallback }=require('./util')
 const{ AsyncResource }=require('node:async_hooks')
-const{ addSignal, removeSignal }=require('./abort-signal')
 
 classRequestHandlerextendsAsyncResource{
 constructor(opts,callback){
@@ -45,6 +44,7 @@ class RequestHandler extends AsyncResource {
 throwerr
 }
 
+this.method=method
 this.responseHeaders=responseHeaders||null
 this.opaque=opaque||null
 this.callback=callback
@@ -56,14 +56,36 @@ class RequestHandler extends AsyncResource {
 this.onInfo=onInfo||null
 this.throwOnError=throwOnError
 this.highWaterMark=highWaterMark
+this.signal=signal
+this.reason=null
+this.removeAbortListener=null
 
 if(util.isStream(body)){
 body.on('error',(err)=>{
 this.onError(err)
 })
 }
 
-addSignal(this,signal)
+if(this.signal){
+if(this.signal.aborted){
+this.reason=this.signal.reason??newRequestAbortedError()
+}else{
+this.removeAbortListener=util.addAbortListener(this.signal,()=>{
+this.reason=this.signal.reason??newRequestAbortedError()
+if(this.res){
+util.destroy(this.res,this.reason)
+}elseif(this.abort){
+this.abort(this.reason)
+}
+
+if(this.removeAbortListener){
+this.res?.off('close',this.removeAbortListener)
+this.removeAbortListener()
+this.removeAbortListener=null
+}
+})
+}
+}
 }
 
 onConnect(abort,context){
@@ -93,48 +115,52 @@ class RequestHandler extends AsyncResource {
 constparsedHeaders=responseHeaders==='raw' ? util.parseHeaders(rawHeaders) : headers
 constcontentType=parsedHeaders['content-type']
 constcontentLength=parsedHeaders['content-length']
-constbody=newReadable({ resume, abort, contentType, contentLength, highWaterMark })
+constres=newReadable({
+ resume,
+ abort,
+ contentType,
+contentLength: this.method!=='HEAD'&&contentLength
+ ? Number(contentLength)
+ : null,
+ highWaterMark
+})
+
+if(this.removeAbortListener){
+res.on('close',this.removeAbortListener)
+}
 
 this.callback=null
-this.res=body
+this.res=res
 if(callback!==null){
 if(this.throwOnError&&statusCode>=400){
 this.runInAsyncScope(getResolveErrorBodyCallback,null,
-{ callback, body, contentType, statusCode, statusMessage, headers }
+{ callback,body: res, contentType, statusCode, statusMessage, headers }
 )
 }else{
 this.runInAsyncScope(callback,null,null,{
  statusCode,
  headers,
 trailers: this.trailers,
  opaque,
- body,
+body: res,
  context
 })
 }
 }
 }
 
 onData(chunk){
-const{ res }=this
-returnres.push(chunk)
+returnthis.res.push(chunk)
 }
 
 onComplete(trailers){
-const{ res }=this
-
-removeSignal(this)
-
 util.parseHeaders(trailers,this.trailers)
-
-res.push(null)
+this.res.push(null)
 }
 
 onError(err){
 const{ res, callback, body, opaque }=this
 
-removeSignal(this)
-
 if(callback){
 // TODO: Does this need queueMicrotask?
 this.callback=null
@@ -155,6 +181,12 @@ class RequestHandler extends AsyncResource {
 this.body=null
 util.destroy(body,err)
 }
+
+if(this.removeAbortListener){
+res?.off('close',this.removeAbortListener)
+this.removeAbortListener()
+this.removeAbortListener=null
+}
 }
 }
 

deps/undici/src/lib/api/readable.js

@@ -63,9 +63,13 @@ class BodyReadable extends Readable {
 // tick as it is created, then a user who is waiting for a
 // promise (i.e micro tick) for installing a 'error' listener will
 // never get a chance and will always encounter an unhandled exception.
-setImmediate(()=>{
+if(!this[kReading]){
+setImmediate(()=>{
+callback(err)
+})
+}else{
 callback(err)
-})
+}
 }
 
 on(ev, ...args){

deps/undici/src/lib/core/connect.js

@@ -165,7 +165,7 @@ function setupTimeout (onConnectTimeout, timeout) {
 lets1=null
 lets2=null
 consttimeoutId=setTimeout(()=>{
-// setImmediate is added to make sure that we priotorise socket error events over timeouts
+// setImmediate is added to make sure that we prioritize socket error events over timeouts
 s1=setImmediate(()=>{
 if(process.platform==='win32'){
 // Windows needs an extra setImmediate probably due to implementation differences in the socket logic

deps/undici/src/lib/dispatcher/client-h2.js

@@ -524,6 +524,7 @@ function writeH2 (client, request) {
 }
 }elseif(util.isStream(body)){
 writeStream({
+ abort,
  body,
  client,
  request,
@@ -535,6 +536,7 @@ function writeH2 (client, request) {
 })
 }elseif(util.isIterable(body)){
 writeIterable({
+ abort,
  body,
  client,
  request,