@zwa73/utils 1.0.194 → 1.0.196

package/src/UtilCom.ts

@@ -1,9 +1,11 @@
-import { AnyString, JObject, PRecord, ReqVerifyFn } from "@/src/UtilInterfaces";
+import { AnyString,JToken, MPromise, PartialOption, StatusVerifyFn } from "@/src/UtilInterfaces";
 import https from 'https';
 import http from 'http';
 import { SLogger } from "@/src/UtilLogger";
-import { RepeatPromiseOpt, RepeatPromiseResult, UtilFunc } from "@/src/UtilFunctions";
+import { RepeatPromiseOpt, UtilFunc } from "@/src/UtilFunctions";
 import qs from "querystring";
+import { matchProc } from "./QuickExport";
+import { Success } from "./UtilSymbol";
 
 /**网络请求返回值 */
 export type ComResp<T> = {
@@ -16,12 +18,11 @@ export type ComResp<T> = {
 }
 
 /**网络请求选项 */
-export type ComReqOpt = {
+export type ComRequestOption = {
     /**请求协议 */
-    protocol: 'http'|'https';
+    protocol: 'http:'|'https:';
     /**超时时间/毫秒  最小为10_000 默认无限 */
-    timeLimit?:number;
-}&{
+    timeout?:number;
     /**请求域名 */
     hostname: string;
     /**请求路径 */
@@ -50,292 +51,294 @@ export type GetReqData = NodeJS.Dict<
 | null
 >;
 
-/**网络工具 */
-export namespace UtilCom{
+/**请求处理函数 需调用req.end() */
+export type ProcReqFn = ((req:http.ClientRequest)=>MPromise<void>);
+/**数据处理函数 */
+export type ReduceDataFn<T> = (acc:T,data:string)=>MPromise<T>;
 
 
-/**网络请求
- * @param comReqOpt  - 网络请求选项
- * @param procReq    - 请求处理函数 需调用req.end()
- * @param reduceData - 数据处理函数
- * @param initData   - 初始数据
- */
-export async function comReq<T>(
-    comReqOpt:ComReqOpt,
-    procReq:((req:http.ClientRequest)=>void|Promise<void>),
-    reduceData:(acc:T,data:string)=>T,
-    initData:T,
-){
-    const {protocol,timeLimit,...baseReqOpt} = comReqOpt;
+const AcceptTypeList = ["json"]as const;
+/**可用的接受类型 */
+type AcceptType = typeof AcceptTypeList[number];
+const SendTypeList = ["json","none"] as const;
+/**可用的发送类型 */
+type SendType = typeof SendTypeList[number];
 
-    const hasTimeLimit = (timeLimit ? timeLimit>=10_000 : false );
-
-    const flagName = `${comReq.name}.${protocol}${baseReqOpt.method}`;
-
-    return new Promise<ComResp<T>|undefined>(async (resolve, rejecte)=>{
-        const resFunc = (res:http.IncomingMessage)=>{
-            try{
-                //请求超时
-                if(hasTimeLimit){
-                    res.setTimeout(timeLimit!, ()=>{
-                        SLogger.warn(`${flagName} 接收反馈超时: ${timeLimit} ms`);
-                        resolve(undefined);
-                    });
+/**accept处理数据 */
+type AcceptProc<D,T> = {
+    init:D;
+    reduce:ReduceDataFn<D>,
+    parse:(result:ComResp<D>|undefined)=>MPromise<T>
+}
+/**send处理数据 */
+type SendProc<T extends any[]> = {
+    proc:(opt:ComRequestOption,...args:T)=>MPromise<ProcReqFn>,
+}
+const defSend = {
+    proc:()=>(req:http.ClientRequest)=>void req.end()
+}
+const defAccept = {
+    init:'',
+    reduce:(acc:string,dat:string)=>acc+dat,
+    parse:(result:ComResp<string>|undefined)=>void console.log(result)
+}
+/**send处理的参数 */
+type SendParams<T extends SendProc<any>> = T extends SendProc<infer T>
+    ? T : never;
+/**accept处理的结果 */
+type ParseResult<D extends AcceptProc<any,any>> = D extends AcceptProc<any,infer T>
+    ? Awaited<T> : never;
+
+/**根据方式自动推断json请求的可用数据类型 */
+type JsonType<OPT extends Record<string,any>> = OPT['method'] extends "POST" ? JToken :GetReqData;
+
+/**网络请求工具 */
+export class UtilCom<
+D extends Partial<ComRequestOption>,
+S extends SendProc<any>,
+A extends AcceptProc<any,any>,
+>{
+    private constructor(private _data:D,private _send:S, private _accept:A){}
+
+    //#region 快速流式创建
+    /**设为https请求 */
+    static https(){
+        return new UtilCom({protocol:'https:'} as const,defSend,defAccept);
+    }
+    /**设为http请求 */
+    static http(){
+        return new UtilCom({protocol:'http:'} as const,defSend,defAccept);
+    }
+    /**设为get方式的请求 */
+    get(){
+        return new UtilCom({...this._data,method:'GET'} as const,this._send,this._accept);
+    }
+    /**设为Post方式的请求 */
+    post(){
+        return new UtilCom({...this._data,method:'POST'} as const,this._send,this._accept);
+    }
+    /**补充参数 */
+    option<OPT extends Partial<ComRequestOption>>(opt:OPT){
+        return new UtilCom({...this._data,...opt} as const,this._send,this._accept);
+    }
+    //#endregion
+
+    //#region 接收数据类型
+    /**接收数据类型*/
+    accept<T extends AcceptType>(t:T){
+        const map = {
+            'json':this.acceptJson(),
+            'log':this.acceptLog(),
+        } as const;
+        return map[t];
+    }
+    acceptJson(){
+        const proc:AcceptProc<string,JToken>={
+            init:'',
+            reduce:(acc,curr)=>acc+curr,
+            parse:(result)=>{
+                if(result==undefined) return undefined;
+                const {data,...rest} = result;
+
+                if(data.trim()==""){
+                    SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`);
+                    return {...result,raw:"",data:null};
+                }
+                try{
+                    const obj = JSON.parse(data.trim()) as JToken;
+                    SLogger.http(`json accept 接受信息:`,UtilFunc.stringifyJToken(obj,{compress:true,space:2}));
+                    return{...rest,data:obj};
+                }
+                catch(e){
+                    SLogger.warn(`json accept 接收反馈错误:${e}\n原始字符串:${data}`);
+                    return {...result,raw:data,data:null};
                 }
-
-                let mergedata:T = initData;
-                res.setEncoding('utf8');
-                res.on('data',chunk => mergedata=reduceData(mergedata,chunk));
-
-                res.on('error',(e)=>{
-                    SLogger.warn(`${flagName} 接收反馈错误:${e}`);
-                    resolve(undefined);
-                });
-
-                res.on('end',()=>{
-                    resolve({
-                        headers: res.headers,
-                        statusCode: res.statusCode,
-                        data: mergedata,
-                    });
-                });
-            }catch(err){
-                SLogger.warn(`${flagName} 未知错误:${err}`);
-                resolve(undefined);
-                return;
             }
-        };
-        //路由 http/https
-        const req:http.ClientRequest= protocol=="https"
-            ? https.request(baseReqOpt as http.RequestOptions, resFunc)
-            : http.request(baseReqOpt  as http.RequestOptions, resFunc);
-
-        //请求超时
-        if(hasTimeLimit){
-            req.setTimeout(timeLimit!, ()=>{
-                SLogger.warn(`${flagName} 发送请求超时: ${timeLimit} ms`);
-                req.destroy();
-            });
-            //req.on('timeout', ()=>{
-            //    SLogger.warn(`${flagName} 发送请求超时(timeout): ${timeLimit} ms`);
-            //    req.destroy();
-            //});
         }
-
-        req.on('error', (e)=>{
-            SLogger.warn(`${flagName} 发送请求错误:${e}`);
-            resolve(undefined);
-        });
-
-        await procReq(req);
-    });
-}
-
-/**发送json的网络请求  
- * @param comReqOpt - 网络请求选项
- * @param reqData   - 数据对象
- * @returns 结果 undefined 为未能成功接收
- */
-async function jsonReq<T extends ComReqOpt>(
-    comReqOpt:T,
-    reqData?:T['method'] extends "POST" ? JObject :GetReqData
-){
-    const {method} = comReqOpt;
-    const isPost = (method=="POST");
-
-    if (!isPost && reqData != undefined) {
-        const queryString = qs.stringify(reqData as GetReqData);
-        if (queryString) {
-            // 检查当前路径是否已经包含问号
-            const separator = comReqOpt?.path?.includes('?') ? '&' : '?';
-            comReqOpt.path += separator + queryString;
+        return new UtilCom(this._data,this._send,proc)
+    }
+    acceptLog(){
+        const proc:AcceptProc<string,string>={
+            init:'',
+            reduce:(acc,curr)=>acc+curr,
+            parse:(result)=>{
+                SLogger.http(`log accept 接受信息:`,UtilFunc.stringifyJToken(result,{compress:true,space:2}));
+                if(result==undefined) return '';
+                const {data,...rest} = result;
+                return data;
+            }
         }
+        return new UtilCom(this._data,this._send,proc)
     }
-
-    const procReq = (req:http.ClientRequest)=>{
-        if(isPost) req.write(JSON.stringify(reqData));
-        req.end();
+    //#endregion
+
+    //#region 发送数据类型
+    /**发送数据类型*/
+    send<T extends SendType>(t:T){
+        const map = {
+            'json':this.sendJson(),
+            "none":this.sendNone(),
+        } as const;
+        return map[t];
     }
+    sendJson(){
+        const proc:SendProc<[JsonType<D>]>={
+            proc:(opt:ComRequestOption,reqData:JsonType<D>)=>{
+                const {method} = opt;
+                const isPost = (method=="POST");
+
+                if (!isPost && reqData != undefined) {
+                    const queryString = qs.stringify(reqData as GetReqData);
+                    if (queryString) {
+                        // 检查当前路径是否已经包含问号
+                        const separator = opt?.path?.includes('?') ? '&' : '?';
+                        opt.path += separator + queryString;
+                    }
+                }
+                if(isPost){
+                    this._data.headers??={
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.from(JSON.stringify(reqData)).length,
+                    }
+                }
 
-    const reduceData = (acc:string,data:string)=>acc+data;
-    const result = await comReq(comReqOpt,procReq,reduceData,"");
-    if(result==undefined) return undefined;
-    const {data,...rest} = result;
-
-    if(data.trim()==""){
-        SLogger.warn(`${jsonReq.name} 接收反馈错误: 原始字符串为空`);
-        return undefined;
+                const procReq = (req:http.ClientRequest)=>{
+                    if(isPost) req.write(JSON.stringify(reqData));
+                    req.end();
+                }
+                return procReq;
+            }
+        }
+        return new UtilCom(this._data,proc,this._accept);
     }
-
-    try{
-        const obj = JSON.parse(data.trim()) as JObject;
-        SLogger.http(`${jsonReq.name} 接受信息:`,UtilFunc.stringifyJToken(obj,{compress:true,space:2}));
-        return{...rest,data:obj};
+    sendNone(){
+        const proc:SendProc<[]>={
+            proc:(opt:ComRequestOption)=>{
+                const procReq = (req:http.ClientRequest)=>{
+                    req.end();
+                }
+                return procReq;
+            }
+        }
+        return new UtilCom(this._data,proc,this._accept)
     }
-    catch(e){
-        SLogger.warn(`${jsonReq.name} 接收反馈错误:${e}\n原始字符串:${data}`);
-        return undefined;
+    //#endregion
+
+    /**发送请求 
+     * @param option       - 网络请求选项
+     * @param datas     - 数据对象
+     */
+    async once(option:PartialOption<ComRequestOption,D>,...datas:SendParams<S>){
+        const fullopt = Object.assign({},this._data,option) as ComRequestOption;
+        const procReq = await this._send.proc(fullopt,...datas as any[]);
+        const {reduce,init,parse} = this._accept;
+        const res = await UtilCom.comReq(fullopt,procReq,reduce,init);
+        return parse(res);
+    }
+    /**重复发送网络请求  
+     * @param option       - 网络请求选项
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+     * @param datas     - 数据对象
+     */
+    async repeat(
+        option:PartialOption<ComRequestOption,D>,
+        verifyFn?:StatusVerifyFn<ParseResult<A>>,
+        repeatOpt:RepeatPromiseOpt={},
+        ...datas:SendParams<S>
+    ){
+        repeatOpt.tryDelay    = repeatOpt.tryDelay??1000;
+        const procFn = ()=>this.once(option,...datas);
+        return UtilFunc.repeatPromise(procFn,verifyFn,repeatOpt);
     }
-}
-
-/**重复发送json的网络请求  
- * @async
- * @param comReqOpt - 网络请求选项
- * @param reqData   - 数据对象
- * @param verifyFn  - 有效性验证函数
- * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
- * @returns 结果 undefined 为未能成功接收
- */
-async function repeatJsonComReq<T extends ComReqOpt>(
-    comReqOpt:T,
-    reqData?:T['method'] extends "POST" ? JObject :GetReqData,
-    verifyFn?:ReqVerifyFn<ComResp<JObject>|undefined>,
-    repeatOpt:RepeatPromiseOpt={},
-){
-    repeatOpt.tryDelay    = repeatOpt.tryDelay??1000;
-    const procFn = ()=>jsonReq(comReqOpt,reqData);
-    return UtilFunc.repeatPromise(procFn,verifyFn,repeatOpt);
-}
-
-/**发送一个 https POST 请求并接受数据  
- * @async
- * @param comReqOpt   - 请求参数
- * @param reqData     - 数据对象
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpsPost(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData?:JObject){
-    return jsonReq({
-        ...comReqOpt,
-        method:"POST",
-        protocol:"https",
-    },reqData);
-}
-
-/**发送一个 http POST 请求并接受数据  
- * @async
- * @param comReqOpt   - 请求参数
- * @param reqData 	  - 数据对象
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpPost(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData?:JObject){
-    return jsonReq({
-        ...comReqOpt,
-        method:"POST",
-        protocol:"http",
-    },reqData);
-}
-
-/**发送一个 https GET 请求并接受数据  
- * @async
- * @param comReqOpt   - 请求参数
- * @param reqData     - 数据对象
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpsGet(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData?:GetReqData){
-    return jsonReq({
-        ...comReqOpt,
-        method:"GET",
-        protocol:"https",
-    },reqData);
-}
 
-/**发送一个 http GET 请求并接受数据  
- * @async
- * @param comReqOpt   - 请求参数
- * @param reqData 	  - 数据对象
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpGet(comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,reqData?:GetReqData){
-    return jsonReq({
-        ...comReqOpt,
-        method:"GET",
-        protocol:"http",
-    },reqData);
-}
+    /**网络请求
+     * @param comReqOpt  - 网络请求选项
+     * @param procReq    - 请求处理函数 需调用req.end()
+     * @param reduceData - 数据处理函数
+     * @param initData   - 初始数据
+     */
+    static async comReq<T>(
+        comReqOpt:ComRequestOption,
+        procReq:ProcReqFn,
+        reduceData:ReduceDataFn<T>,
+        initData:T,
+    ){
+        const {protocol,timeout,...baseReqOpt} = comReqOpt;
+
+        const hasTimeLimit = (timeout ? timeout>=10_000 : false );
+
+        const flagName = `UtilCom.${protocol}${baseReqOpt.method}`;
+
+        const postflag = `comReq:${UtilFunc.genUUID()}`;
+        let dataPromise:Promise<any>|null = null;
+
+        return new Promise<ComResp<T>|undefined>(async (resolve, rejecte)=>{
+            const resFunc = (res:http.IncomingMessage)=>{
+                try{
+                    //请求超时
+                    if(hasTimeLimit){
+                        res.setTimeout(timeout!, ()=>{
+                            SLogger.warn(`${flagName} 接收反馈超时: ${timeout} ms`);
+                            resolve(undefined);
+                        });
+                    }
+
+                    let mergedata:T = initData;
+                    res.setEncoding('utf8');
+                    res.on('data', chunk => {
+                        dataPromise = UtilFunc.queueProc(postflag,async()=>mergedata=await reduceData(mergedata,chunk))
+                    });
 
+                    res.on('error',(e)=>{
+                        SLogger.warn(`${flagName} 接收反馈错误:${e}`);
+                        resolve(undefined);
+                    });
 
-/**重复一个 https POST请求并接受数据  
- * @async
- * @param comReqOpt - 网络请求选项
- * @param reqData   - 数据对象
- * @param verifyFn  - 有效性验证函数
- * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpsRepeatPost(
-    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
-    reqData?:JObject,
-    verifyFn?:ReqVerifyFn<JObject|undefined>,
-    repeatOpt?:RepeatPromiseOpt
-){
-    return repeatJsonComReq({
-        ...comReqOpt,
-        method:"POST",
-        protocol:"https",
-    },reqData,verifyFn,repeatOpt);
-}
+                    res.on('end',async ()=>{
+                        await dataPromise;
+                        resolve({
+                            headers: res.headers,
+                            statusCode: res.statusCode,
+                            data: mergedata,
+                        });
+                    });
+                }catch(err){
+                    SLogger.warn(`${flagName} 未知错误:${err}`);
+                    resolve(undefined);
+                    return;
+                }
+            };
+            //路由 http/https
+            const req:http.ClientRequest= protocol=="https:"
+                ? https.request(baseReqOpt as http.RequestOptions, resFunc)
+                : http.request(baseReqOpt  as http.RequestOptions, resFunc);
+
+            //请求超时
+            if(hasTimeLimit){
+                req.setTimeout(timeout!, ()=>{
+                    SLogger.warn(`${flagName} 发送请求超时: ${timeout} ms`);
+                    req.destroy();
+                });
+            }
 
-/**重复一个 http POST请求并接受数据  
- * @async
- * @param comReqOpt - 网络请求选项
- * @param reqData   - 数据对象
- * @param verifyFn  - 有效性验证函数
- * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpRepeatPost(
-    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
-    reqData?:JObject,
-    verifyFn?:ReqVerifyFn<JObject|undefined>,
-    repeatOpt?:RepeatPromiseOpt
-){
-    return repeatJsonComReq({
-        ...comReqOpt,
-        method:"POST",
-        protocol:"http",
-    },reqData,verifyFn,repeatOpt);
-}
+            req.on('error', (e)=>{
+                SLogger.warn(`${flagName} 发送请求错误:${e}`);
+                resolve(undefined);
+            });
 
-/**重复一个 https GET 请求并接受数据  
- * @async
- * @param comReqOpt - 网络请求选项
- * @param reqData   - 数据对象
- * @param verifyFn  - 有效性验证函数
- * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpsRepeatGet(
-    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
-    reqData?:GetReqData,
-    verifyFn?:ReqVerifyFn<JObject|undefined>,
-    repeatOpt?:RepeatPromiseOpt
-){
-    return repeatJsonComReq({
-        ...comReqOpt,
-        method:"GET",
-        protocol:"https",
-    },reqData,verifyFn,repeatOpt);
+            await procReq(req);
+        });
+    }
 }
 
-/**重复一个 http GET 请求并接受数据  
- * @async
- * @param comReqOpt - 网络请求选项
- * @param reqData   - 数据对象
- * @param verifyFn  - 有效性验证函数
- * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
- * @returns 结果 undefined 为未能成功接收
- */
-export function httpRepeatGet(
-    comReqOpt:Omit<ComReqOpt,'protocol'|'method'>,
-    reqData?:GetReqData,
-    verifyFn?:ReqVerifyFn<JObject|undefined>,
-    repeatOpt?:RepeatPromiseOpt
-){
-    return repeatJsonComReq({
-        ...comReqOpt,
-        method:"GET",
-        protocol:"http",
-    },reqData,verifyFn,repeatOpt);
-}
 
-}
+if(false)((async ()=>{
+    const t = await UtilCom.https().post().accept('json').send('json')
+        .repeat({
+            hostname:'httpbin.org',
+            path:'/post',
+            timeout:10000
+        },()=>Success,{},{test:1});
+    console.log(t);
+})())