@wiajs/request 3.0.29 → 3.0.30

package/dist/request.cjs

@@ -1,16 +1,16 @@
 /*!
-  * wia request v3.0.29
+  * wia request v3.0.30
   * (c) 2022-2024 Sibyl Yu and contributors
   * Released under the MIT License.
   */
 'use strict';
 
+const stream = require('node:stream');
 const log$2 = require('@wiajs/log');
 const http = require('node:http');
 const https = require('node:https');
 const assert = require('node:assert');
 const url = require('node:url');
-const stream = require('node:stream');
 const zlib = require('node:zlib');
 const mime = require('mime-types');
 
@@ -467,7 +467,7 @@ const log$1 = log$2.log({env: `wia:req:${log$2.name((typeof document === 'undefi
  * @prop {*} [beforeRedirect]
  * @prop {boolean} [followRedirects]
  * @prop {number} [maxRedirects=21]
- * @prop {number} [maxBodyLength = 0]
+ * @prop {number} [maxBodyLength = -1]
  * @prop {*} [trackRedirects]
  * @prop {*} [data]
  */
@@ -478,7 +478,7 @@ const log$1 = log$2.log({env: `wia:req:${log$2.name((typeof document === 'undefi
  * @prop {number} [responseStartTime]
  */
 
-/** @typedef { http.IncomingMessage & ResponseExt} Response*/
+/** @typedef { http.IncomingMessage & ResponseExt} Response */
 
 const httpModules = {'http:': http, 'https:': https};
 
@@ -528,12 +528,12 @@ const writeEvents = [
   'connect',
   'continue',
   'drain',
-  'error',
+  // 'error', // 单独处理，未注册 'error' 事件处理程序，错误将冒泡到全局导致程序崩溃
   'finish',
   'information',
   'pipe',
   // 'response', 由 processResponse 触发
-  'socket',
+  'socket', // 建立连接时触发
   'timeout',
   'unpipe',
   'upgrade',
@@ -545,7 +545,7 @@ for (const ev of writeEvents)
   writeEventEmit[ev] = /** @param  {...any} args */ function (...args) {
     const m = this; // 事件回调，this === clientRequest 实例
     // log('req event', {ev})
-    m.redirectReq.emit(ev, ...args); // req 事情映射到 redirectReq 上触发
+    m.redirectReq.emit(ev, ...args); // 内部请求req 事情转发到 Request
   };
 
 // stream.Readable，在响应流上转发读流取事件
@@ -578,6 +578,21 @@ const MaxBodyLengthExceededError = utils.createErrorType(
 
 const WriteAfterEndError = utils.createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
 
+// request err
+const HostNotfoundError = utils.createErrorType('ERR_HOSTNOTFOUND', 'DNS 解析失败，主机名可能无效');
+const ConnRefusedError = utils.createErrorType(
+  'ERR_CONNREFUSED',
+  '连接被拒绝，目标服务器可能不可用'
+);
+const ConnTimedoutError = utils.createErrorType(
+  'ERR_CONNTIMEDOUT',
+  '请求超时，请检查网络连接或服务器负载'
+);
+const ConnResetError = utils.createErrorType(
+  'ERR_CONNRESET',
+  '连接被重置，可能是网络问题或服务器关闭了连接'
+);
+
 /**
  * An HTTP(S) request that can be redirected
  * wrap http.ClientRequest
@@ -777,7 +792,39 @@ class Request extends stream.Duplex {
       // 启动 startTimer
       if (m.startTimer) m._currentRequest.once('socket', m.startTimer);
 
-      // 接收req事件，转发 到 redirectReq 发射
+      // set tcp keep alive to prevent drop connection by peer
+      req.on(
+        'socket',
+        /** @param {*} socket */ socket => {
+          // default interval of sending ack packet is 1 minute
+          socket.setKeepAlive(true, 1000 * 60);
+        }
+      );
+
+      // 请求error单独处理
+      // 'error' 事件处理，避免错误将冒泡到全局导致程序崩溃
+      req.on('error', err => {
+        destroyRequest(req); // 释放资源
+        log$1.error({errcode: err.code}, 'request');
+        switch (err.code) {
+          case 'ENOTFOUND':
+            m.emit('error', new HostNotfoundError());
+            break
+          case 'ECONNREFUSED':
+            m.emit('error', new ConnRefusedError());
+            break
+          case 'ETIMEDOUT':
+            m.emit('error', new ConnTimedoutError());
+            break
+          case 'ECONNRESET':
+            m.emit('error', new ConnResetError());
+            break
+          default:
+            m.emit('error', utils.createErrorType('ERR_CONNOTHER', `网络错误: ${err.message}`));
+        }
+      });
+
+      // 接收req事件，转发 到 request 上发射，网络关闭事件，触发 error
       for (const ev of writeEvents) req.on(ev, writeEventEmit[ev]);
 
       // RFC7230§5.3.1: When making a request directly to an origin server, […]
@@ -826,9 +873,11 @@ class Request extends stream.Duplex {
     return R
   }
 
+  /**
+   * 写入错误，释放请求，触发 abort 终止事件
+   */
   abort() {
     destroyRequest(this._currentRequest);
-    this._currentRequest.abort();
     this.emit('abort');
   }
 
@@ -892,7 +941,11 @@ class Request extends stream.Duplex {
     // log({data: chunk, encoding, cb}, 'write')
 
     // Writing is not allowed if end has been called
-    if (m._ending) throw new WriteAfterEndError()
+    if (m._ending) {
+      // throw new WriteAfterEndError()
+      m.emit('error', new WriteAfterEndError());
+      return
+    }
 
     // ! 数据写入时连接，pipe 时可设置 header
     if (!m._currentRequest) m.request();
@@ -1087,6 +1140,7 @@ class Request extends stream.Duplex {
     m.on('error', clearTimer);
     m.on('response', clearTimer);
     m.on('close', clearTimer);
+
     return m
   }
 
@@ -1277,14 +1331,15 @@ class Request extends stream.Duplex {
   /**
    * 处理响应stream
    * 自动解压，透传流，需设置 decompress = false，避免解压数据
-   * @param {*} res
+   * @param {Response} res
+   * @returns {Response | stream.Readable}
    */
   processStream(res) {
     const m = this;
     const {opt} = m;
 
     const streams = [res];
-
+    let responseStream = res;
     // 'transfer-encoding': 'chunked'时，无content-length，axios v1.2 不能自动解压
     const responseLength = +res.headers['content-length'];
 
@@ -1317,6 +1372,7 @@ class Request extends stream.Duplex {
         case 'compress':
         case 'x-compress':
           // add the unzipper to the body stream processing pipeline
+          // @ts-ignore
           streams.push(zlib.createUnzip(zlibOptions));
 
           // remove the content-encoding in order to not confuse downstream operations
@@ -1324,9 +1380,11 @@ class Request extends stream.Duplex {
           break
 
         case 'deflate':
+          // @ts-ignore
           streams.push(new ZlibTransform());
 
           // add the unzipper to the body stream processing pipeline
+          // @ts-ignore
           streams.push(zlib.createUnzip(zlibOptions));
 
           // remove the content-encoding in order to not confuse downstream operations
@@ -1335,6 +1393,7 @@ class Request extends stream.Duplex {
 
         case 'br':
           if (isBrotliSupported) {
+            // @ts-ignore
             streams.push(zlib.createBrotliDecompress(brotliOptions));
             res.headers['content-encoding'] = undefined;
           }
@@ -1343,10 +1402,13 @@ class Request extends stream.Duplex {
     }
 
     // 响应流，用于读
-    const responseStream = streams.length > 1 ? stream.pipeline(streams, utils.noop) : streams[0];
+    // @ts-ignore
+    responseStream = streams.length > 1 ? stream.pipeline(streams, utils.noop) : streams[0];
     // 将内部 responseStream 可读流 映射到 redirectReq
 
+    // @ts-ignore
     m.responseStream = responseStream;
+    // @ts-ignore
     responseStream.redirectReq = m; // 事情触发时引用
 
     // stream 模式，事件透传到 请求类
@@ -1518,7 +1580,9 @@ class Request extends stream.Duplex {
 }
 
 /**
- *
+ * 释放请求，触发error事件
+ *  'error' event, and emit a 'close' event.
+ * Calling this will cause remaining data in the response to be dropped and the socket to be destroyed.
  * @param {*} request
  * @param {*} error
  */
@@ -1527,7 +1591,7 @@ function destroyRequest(request, error) {
     request.removeListener(ev, writeEventEmit[ev]);
   }
   request.on('error', utils.noop);
-  request.destroy(error);
+  request.destroy(error); // 触发 error 事件
 }
 
 /**
@@ -1569,9 +1633,35 @@ function isSubdomain(subdomain, domain) {
  * 代理模式下，http or https 请求，取决于 proxy 代理服务器，而不是目的服务器。
  */
 
-
 const log = log$2.log({env: `wia:req:${log$2.name((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('request.cjs', document.baseURI).href)))}`}); // __filename
 
+/** @typedef { import('./request').Response} Response */
+
+/**
+ * @typedef {object} Opts
+ * @prop {Object.<string,string>} [headers]
+ * @prop {string} [url]
+ * @prop {'http:' | 'https:'} [protocol]
+ * @prop {string} [host]
+ * @prop {string} [family]
+ * @prop {string} [path]
+ * @prop {string} [method]
+ * @prop {*} [agent] - 发送请求的agent
+ * @prop {*} [agents] - http、https agent，根据协议自动选择
+ * @prop {*} [body] - body 数据，优先body，其次data
+ * @prop {*} [data] - body 数据
+ * @prop {boolean} [stream] -  以流的方式工作
+ * @prop {boolean} [decompress=true] - 自动解压
+ * @prop {*} [transformStream]
+ * @prop {*} [beforeRedirect]
+ * @prop {boolean} [followRedirects] - 自动完成重定向
+ * @prop {number} [maxRedirects=21] - 最大重定向次数
+ * @prop {number} [maxBodyLength = 0] - body限制，缺省不限
+ * @prop {*} [trackRedirects]
+ */
+
+/** @typedef {(res: Response, stream?: stream.Readable) => void} Cb*/
+
 utils.createErrorType(
   'ERR_STREAM_WRITE_BEEN_ABORTED',
   'Request stream has been aborted'
@@ -1596,10 +1686,10 @@ utils.createErrorType(
 
 /**
  * 初始化参数
- * @param {*} uri/opts
- * @param {*} opts/cb
- * @param {*} cb/null
- * @returns
+ * @param {string | Opts} uri/opts
+ * @param {Opts | Cb} [opts] /cb
+ * @param {Cb} [cb]
+ * @returns {{opts: Opts, cb: Cb}}
  */
 function init(uri, opts, cb) {
   let R;
@@ -1608,39 +1698,55 @@ function init(uri, opts, cb) {
     if (utils.isURL(uri)) uri = utils.spreadUrlObject(uri);
     else if (utils.isString(uri)) uri = utils.spreadUrlObject(utils.parseUrl(uri));
     else {
+      // @ts-ignore
       cb = opts;
+      // @ts-ignore
       opts = uri;
+      // @ts-ignore
       const {url} = opts;
+      // 有url，解析
       if (url) {
+        // @ts-ignore
+        // biome-ignore lint/performance/noDelete: <explanation>
         delete opts.url;
         if (utils.isURL(url)) uri = utils.spreadUrlObject(url);
         else if (utils.isString(url)) uri = utils.spreadUrlObject(utils.parseUrl(url));
       } else {
-        opts = utils.validateUrl(uri);
+        // @ts-ignore
+        opts = uri; // 不判断 utils.validateUrl(uri)
         uri = {};
       }
     }
 
     if (utils.isFunction(opts)) {
+      // @ts-ignore
       cb = opts;
-      opts = null;
+      opts = {};
     }
 
     // copy options
     opts = {
+      // @ts-ignore
       ...uri,
       ...opts,
     };
 
+    // @ts-ignore
     if (!utils.isString(opts.host) && !utils.isString(opts.hostname)) opts.hostname = '::1';
+    // @ts-ignore
     if (opts.method) opts.method = opts.method.toUpperCase();
 
-    R = {opts: opts, cb: cb};
+    // @ts-ignore
+    // follow-redirects does not skip comparison, so it should always succeed for axios -1 unlimited
+    opts.maxBodyLength = opts.maxBodyLength ?? Number.POSITIVE_INFINITY;
+
+    R = {opts, cb};
     // log({R}, 'init')
   } catch (e) {
     log.err(e, 'init');
   }
 
+  // @ts-ignore
   return R
 }
 
@@ -1651,19 +1757,26 @@ function init(uri, opts, cb) {
  * 注意变参 (options[, callback]) or (url[, options][, callback])
     maxRedirects: _.maxRedirects,
     maxBodyLength: _.maxBodyLength,
- * @param {*} uri/options
- * @param {*} options/callback
- * @param {*} callback/null
- * @returns
+ * @param {string | Opts} uri /options
+ * @param {Opts | Cb} [options] /callback
+ * @param {Cb} [callback] /null
+ * @returns {Request}
  */
 function request(uri, options, callback) {
   let R = null;
 
   try {
+    // @ts-ignore
     const {opts, cb} = init(uri, options, callback);
-    // log({uri, options, opts}, 'request')
-    const req = new Request(opts, cb);
+    // log.error({uri, options, opts}, 'request')
+
     const {data, stream} = opts;
+    // data 在本函数完成处理，不传递到 request
+    opts.data = undefined;
+
+    // @ts-ignore
+    const req = new Request(opts, cb);
+
     // 非流模式，自动发送请求，流模式通过流写入发送
     if (!stream) {
       // 发送数据
@@ -1690,8 +1803,12 @@ function request(uri, options, callback) {
           }
         });
 
+        // log.error({data}, 'request data.pipe')
         data.pipe(req); // 写入数据流
-      } else req.end(data);
+      } else {
+        // log.error({data}, 'request req.end')
+        req.end(data); // 写入数据
+      }
     }
 
     R = req;
@@ -1708,40 +1825,23 @@ function request(uri, options, callback) {
  * 复杂数据，请使用 @wiajs/req库（fork from axios），该库封装了当前库，提供了更多功能
  * organize params for patch, post, put, head, del
  * @param {string} verb
- * @returns {Request} Duplex 流
+ * @returns {(url: string | Opts, opts?: Opts | Cb, cb?: Cb) => void}}
  */
 function fn(verb) {
   const method = verb.toUpperCase();
-
-  // @ts-ignore
-  return (uri, options, callback) => {
-    const {opts, cb} = init(uri, options, callback);
+  /**
+   *
+   * @param {string | Opts} uri /options
+   * @param {Opts | Cb} [opts] /callback
+   * @param {Cb} [cb] /null
+   * @returns
+   */
+  function fn(uri, opts, cb) {
+    // @ts-ignore
     opts.method = method;
-    const req = new Request(opts, cb);
-    const {data, stream} = opts;
-    // 非流模式，自动发送请求，流模式通过流写入发送
-    if (!stream) {
-      // 发送数据
-      if (utils.isStream(data)) {
-
-        data.on('end', () => {
-        });
-
-        data.once(
-          'error',
-          /** @param {*} err */ err => {
-            // req.destroy(err)
-          }
-        );
-
-        data.on('close', () => {
-        });
-
-        data.pipe(req); // 写入数据流
-      } else req.end(data);
-    }
-    return req
+    return request(uri, opts, cb)
   }
+  return fn
 }
 
 // define like this to please codeintel/intellisense IDEs