@maiyunnet/kebab 9.18.1 → 9.18.2

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "9.18.1";
+export declare const VER = "9.18.2";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 /** --- 框架的 LIB，以 / 结尾 --- */

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '9.18.1';
+export const VER = '9.18.2';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/undici/request.d.ts

@@ -47,6 +47,16 @@ export declare class Request {
      * @param timeout 秒
      */
     timeout(timeout: number): this;
+    /**
+     * --- 设置空闲连接允许复用的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒
+     */
+    keepAliveTimeout(timeout: number): this;
+    /**
+     * --- 设置连接建立后允许承接新请求的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制
+     */
+    reuseTimeout(timeout: number): this;
     /**
      * --- 设置网络异常后的重试次数 ---
      * @param retry 重试次数，默认为 1；非幂等请求需由调用方保证安全

package/lib/undici/request.js

@@ -59,6 +59,22 @@ export class Request {
         this._opt['timeout'] = timeout;
         return this;
     }
+    /**
+     * --- 设置空闲连接允许复用的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒
+     */
+    keepAliveTimeout(timeout) {
+        this._opt['keepAliveTimeout'] = timeout;
+        return this;
+    }
+    /**
+     * --- 设置连接建立后允许承接新请求的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制
+     */
+    reuseTimeout(timeout) {
+        this._opt['reuseTimeout'] = timeout;
+        return this;
+    }
     /**
      * --- 设置网络异常后的重试次数 ---
      * @param retry 重试次数，默认为 1；非幂等请求需由调用方保证安全

package/lib/undici.d.ts

@@ -74,6 +74,10 @@ export declare function fetch(input: string | URL | Request, init?: RequestInit
     'hosts'?: Record<string, string> | string;
     /** --- 网络异常后的重试次数，默认 0；流式请求体不可重试，非幂等请求需由调用方保证安全 --- */
     'retry'?: number;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制 --- */
+    'reuseTimeout'?: number;
 }): Promise<Response>;
 /**
  * --- 发起一个请求 ---
@@ -152,6 +156,10 @@ export interface IRequestOptions {
     };
     /** --- 连接是否保持长连接（即是否允许复用），默认为 true --- */
     'keep'?: boolean;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒；自定义 Agent 由其自身配置 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制；自定义 Agent 由其自身配置 --- */
+    'reuseTimeout'?: number;
     /** --- 复用池名/Agent，默认为 default --- */
     'reuse'?: string | undici.ProxyAgent | undici.Agent;
     /** --- cookie 托管对象 --- */
@@ -170,6 +178,10 @@ export interface IMproxyOptions {
     'hosts'?: Record<string, string> | string;
     'local'?: string;
     'headers'?: THttpHeaders;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制 --- */
+    'reuseTimeout'?: number;
     /** --- 过滤 header，返回 true 则留下 --- */
     filter?: (h: string) => boolean;
     /** --- 默认为 default --- */
@@ -184,6 +196,10 @@ export interface IRproxyOptions {
     'hosts'?: Record<string, string> | string;
     'local'?: string;
     'headers'?: THttpHeaders;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制 --- */
+    'reuseTimeout'?: number;
     /** --- 过滤 header，返回 true 则留下 --- */
     filter?: (h: string) => boolean;
     /** --- 正向 mproxy 代理，url 如 https://xxx/abc --- */

package/lib/undici.js

@@ -45,14 +45,31 @@ function normalizeRetry(retry) {
     return (typeof retry === 'number') && Number.isFinite(retry) ?
         Math.max(0, Math.floor(retry)) : 0;
 }
+/**
+ * --- 将 Agent 的秒数配置转换为毫秒 ---
+ * @param timeout 秒数
+ * @returns 未设置或数值无效时返回 undefined，否则返回毫秒数
+ */
+function normalizeAgentTimeout(timeout) {
+    if (timeout === undefined) {
+        return undefined;
+    }
+    const milliseconds = timeout * 1_000;
+    if (!Number.isFinite(milliseconds) || (milliseconds <= 0)) {
+        return undefined;
+    }
+    return milliseconds;
+}
 /** --- 获取或创建 undici.agent 对象 --- */
 function getAgent(opt = {}) {
     let k = opt.reuse ?? 'default';
     if (typeof k !== 'string') {
         return k;
     }
+    const keepAliveTimeout = normalizeAgentTimeout(opt.keepAliveTimeout);
+    const reuseTimeout = normalizeAgentTimeout(opt.reuseTimeout);
     if (k === 'default') {
-        // --- hosts/local/keep 均会影响 agent 行为，需生成独立的 key ---
+        // --- hosts/local/keep/连接时长均会影响 agent 行为，需生成独立的 key ---
         const features = [];
         if (opt.hosts) {
             features.push(`h:${lCrypto.hashHmac('md5', lText.stringifyJson(opt.hosts))}`);
@@ -63,6 +80,12 @@ function getAgent(opt = {}) {
         if (opt.keep === false) {
             features.push('k:0');
         }
+        if (keepAliveTimeout !== undefined) {
+            features.push(`ka:${keepAliveTimeout}`);
+        }
+        if (reuseTimeout !== undefined) {
+            features.push(`rt:${reuseTimeout}`);
+        }
         if (features.length > 0) {
             k = features.join('|');
         }
@@ -74,6 +97,13 @@ function getAgent(opt = {}) {
                 lookup: buildDnsLookup(opt.hosts),
             },
             'pipelining': opt.keep === false ? 0 : 1,
+            ...(keepAliveTimeout === undefined ? {} : {
+                'keepAliveTimeout': keepAliveTimeout,
+                'keepAliveMaxTimeout': keepAliveTimeout,
+            }),
+            ...(reuseTimeout === undefined ? {} : {
+                'clientTtl': reuseTimeout,
+            }),
         }));
     }
     return agents.get(k);
@@ -293,6 +323,8 @@ export async function fetch(input, init = {}) {
         'hosts': init.hosts,
         'mproxy': init.mproxy,
         'retry': init.retry,
+        'keepAliveTimeout': init.keepAliveTimeout,
+        'reuseTimeout': init.reuseTimeout,
         'signal': init.signal ?? undefined,
         'follow': init.redirect === 'follow' ? 10 : 0,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.18.1",
+  "version": "9.18.2",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [

package/sys/child.js

@@ -203,7 +203,7 @@ async function requestHandler(req, res, https) {
         'timer': {},
         'timeout': 30_000,
         'callback': () => {
-            if (!req.socket?.writable) {
+            if (!sCtr.isHttpRequestAvailable(req, res)) {
                 // --- 用户连接已中断 ---
                 return;
             }

package/sys/ctr.d.ts

@@ -58,6 +58,13 @@ export type TValibotResult<TSchema extends v.GenericSchema, TIssue extends v.Bas
     readonly issues: [TIssue, ...TIssue[]];
     readonly response: kebab.Json[];
 };
+/**
+ * --- 判断当前 HTTP 请求是否仍可响应 ---
+ * @param req 请求对象
+ * @param res 响应对象
+ * @returns 客户端对应的请求流仍可响应时返回 true
+ */
+export declare function isHttpRequestAvailable(req: http2.Http2ServerRequest | http.IncomingMessage, res: http2.Http2ServerResponse | http.ServerResponse): boolean;
 export declare class Ctr {
     /** --- 路由参数序列数组 --- */
     protected _param: string[];

package/sys/ctr.js

@@ -19,6 +19,27 @@ export function clearLocaleData() {
     localeFiles = [];
     localeData = {};
 }
+/**
+ * --- 判断当前 HTTP 请求是否仍可响应 ---
+ * @param req 请求对象
+ * @param res 响应对象
+ * @returns 客户端对应的请求流仍可响应时返回 true
+ */
+export function isHttpRequestAvailable(req, res) {
+    if (req.destroyed && !req.complete) {
+        return false;
+    }
+    if (('stream' in req) && (req.stream.closed || req.stream.destroyed)) {
+        return false;
+    }
+    if (req.socket.destroyed || !req.socket.writable) {
+        return false;
+    }
+    if (res.destroyed || res.closed || res.writableEnded || !res.writable) {
+        return false;
+    }
+    return true;
+}
 export class Ctr {
     /** --- 路由参数序列数组 --- */
     _param = [];
@@ -69,7 +90,13 @@ export class Ctr {
     }
     /** --- 当前用户连接是否还在连接中 --- */
     get _isAvail() {
-        return this._req.socket.writable;
+        if (this._socket) {
+            return this._socket.writable;
+        }
+        if (!this._res) {
+            return !this._req.socket.destroyed && this._req.socket.writable;
+        }
+        return isHttpRequestAvailable(this._req, this._res);
     }
     /** --- timeout 的 timer --- */
     _timer;

package/sys/route.d.ts

@@ -51,12 +51,13 @@ export declare function waitCtr(cctr: sCtr.Ctr): Promise<void>;
 /**
  * --- 获取 post 对象（通常已自动获取），如果是文件上传（formdata）的情况则不获取 ---
  * @param req 请求对象
+ * @returns 解析后的 POST 数据，请求传输中断时返回 false
  */
 export declare function getPost(req: http2.Http2ServerRequest | http.IncomingMessage): Promise<{
     'input': string;
     'raw': Record<string, any>;
     'post': Record<string, any>;
-}>;
+} | false>;
 /**
  * --- 获取 formdata 的 post ---
  * @param req 请求头

package/sys/route.js

@@ -453,6 +453,9 @@ export async function run(data) {
     }
     if (reqStartRtn === 1) {
         const rawPost = await getPost(data.req);
+        if (!rawPost) {
+            return true;
+        }
         // --- 原始 POST ---
         middle.setPrototype('_rawPost', rawPost.raw);
         // --- 原始 input ---
@@ -844,6 +847,7 @@ export async function waitCtr(cctr) {
 /**
  * --- 获取 post 对象（通常已自动获取），如果是文件上传（formdata）的情况则不获取 ---
  * @param req 请求对象
+ * @returns 解析后的 POST 数据，请求传输中断时返回 false
  */
 export function getPost(req) {
     return new Promise(function (resolve) {
@@ -861,7 +865,28 @@ export function getPost(req) {
         const maxPostSize = 50 * 1024 * 1024;
         let buffer = Buffer.from('');
         let overflow = false;
-        req.on('data', function (chunk) {
+        let finished = false;
+        let onData;
+        let onEnd;
+        let onError;
+        let onAborted;
+        let onClose;
+        const cleanup = () => {
+            req.off('data', onData);
+            req.off('end', onEnd);
+            req.off('error', onError);
+            req.off('aborted', onAborted);
+            req.off('close', onClose);
+        };
+        const finish = (result) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            cleanup();
+            resolve(result);
+        };
+        onData = (chunk) => {
             if (overflow) {
                 return;
             }
@@ -871,10 +896,10 @@ export function getPost(req) {
                 return;
             }
             buffer = Buffer.concat([buffer, chunk], buffer.length + chunk.length);
-        });
-        req.on('end', function () {
+        };
+        onEnd = () => {
             if (overflow) {
-                resolve({
+                finish({
                     'input': '',
                     'raw': {},
                     'post': {},
@@ -883,7 +908,7 @@ export function getPost(req) {
             }
             const s = buffer.toString();
             if (!s) {
-                resolve({
+                finish({
                     'input': '',
                     'raw': {},
                     'post': {},
@@ -894,14 +919,14 @@ export function getPost(req) {
             if (ct.includes('json')) {
                 try {
                     const raw = lText.parseJson(s);
-                    resolve({
+                    finish({
                         'input': s,
                         'raw': raw,
                         'post': lText.trimJson(raw),
                     });
                 }
                 catch {
-                    resolve({
+                    finish({
                         'input': '',
                         'raw': {},
                         'post': {},
@@ -910,12 +935,26 @@ export function getPost(req) {
                 return;
             }
             const raw = lText.queryParse(s);
-            resolve({
+            finish({
                 'input': s,
                 'raw': raw,
                 'post': lText.trimJson(raw),
             });
-        });
+        };
+        onError = () => {
+            finish(false);
+        };
+        onAborted = () => {
+            finish(false);
+        };
+        onClose = () => {
+            finish(false);
+        };
+        req.on('data', onData);
+        req.on('end', onEnd);
+        req.on('error', onError);
+        req.on('aborted', onAborted);
+        req.on('close', onClose);
     });
 }
 /**