@zwa73/utils 1.0.198 → 1.0.200

package/src/UtilCom.ts

@@ -1,14 +1,16 @@
 import { AnyString,JToken, MPromise, PartialOption, StatusVerifyFn } from "@/src/UtilInterfaces";
-import https from 'https';
 import http from 'http';
+import https from 'https';
 import { SLogger } from "@/src/UtilLogger";
-import { RepeatPromiseOpt, UtilFunc } from "@/src/UtilFunctions";
+import { PromiseRetries, UtilFunc } from "@/src/UtilFunctions";
 import qs from "querystring";
-import { matchProc } from "./QuickExport";
 import { Success } from "./UtilSymbol";
+import FormData from "form-data";
+import HttpProxyAgent from "http-proxy-agent";
+import HttpsProxyAgent from "https-proxy-agent";
 
 /**网络请求返回值 */
-export type ComResp<T> = {
+export type RequestResult<T> = {
     /**响应头 */
     headers: http.IncomingHttpHeaders;
     /**响应状态码 */
@@ -18,7 +20,7 @@ export type ComResp<T> = {
 }
 
 /**网络请求选项 */
-export type ComRequestOption = {
+export type RequestOption = {
     /**请求协议 */
     protocol: 'http:'|'https:';
     /**超时时间/毫秒  最小为10_000 默认无限 */
@@ -34,14 +36,14 @@ export type ComRequestOption = {
     /**请求头 */
     headers?: {
         /**内容类型 */
-        'Content-Type'?: 'application/json'|AnyString;
+        'Content-Type'?: 'application/json'|'multipart/form-data'|AnyString;
         /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
         'Content-Length'?: number;
     };
 }&http.RequestOptions;
 
-/**get请求所允许的数据 */
-export type GetReqData = NodeJS.Dict<
+/**getquery请求所允许的数据 */
+export type QueryRequestData = NodeJS.Dict<
 | string
 | number
 | boolean
@@ -52,36 +54,37 @@ export type GetReqData = NodeJS.Dict<
 >;
 
 /**请求处理函数 需调用req.end() */
-export type ProcReqFn = ((req:http.ClientRequest)=>MPromise<void>);
+export type RequestProcFn = ((req:http.ClientRequest)=>MPromise<void>);
 /**数据处理函数 */
-export type ReduceDataFn<T> = (acc:T,data:string)=>MPromise<T>;
+export type RequestReduceFn<T> = (acc:T,data:string)=>MPromise<T>;
 
 
-const AcceptTypeList = ["json"]as const;
+const AcceptTypeList = ["json","string"]as const;
 /**可用的接受类型 */
 type AcceptType = typeof AcceptTypeList[number];
-const SendTypeList = ["json","none"] as const;
+const SendTypeList = ["json","query","formData","none"] as const;
 /**可用的发送类型 */
 type SendType = typeof SendTypeList[number];
 
 /**accept处理数据 */
 type AcceptProc<D,T> = {
-    init:D;
-    reduce:ReduceDataFn<D>,
-    parse:(result:ComResp<D>|undefined)=>MPromise<T>
+    init  :D;
+    reduce:RequestReduceFn<D>,
+    parse :(result:RequestResult<D>|undefined)=>MPromise<T>
 }
 /**send处理数据 */
 type SendProc<T extends any[]> = {
-    proc:(opt:ComRequestOption,...args:T)=>MPromise<ProcReqFn>,
+    proc:(opt:RequestOption,...args:T)=>MPromise<RequestProcFn>,
 }
-const defSend = {
-    proc:()=>(req:http.ClientRequest)=>void req.end()
+const SendNoneProc:SendProc<[]> = {
+    proc:(opt)=>(req)=>void req.end()
 }
-const defAccept = {
-    init:'',
+const AcceptStringProc:AcceptProc<string,RequestResult<string>|undefined> = {
+    init  :'',
     reduce:(acc:string,dat:string)=>acc+dat,
-    parse:(result:ComResp<string>|undefined)=>void console.log(result)
+    parse :(result:RequestResult<string>|undefined)=>result
 }
+
 /**send处理的参数 */
 type SendParams<T extends SendProc<any>> = T extends SendProc<infer T>
     ? T : never;
@@ -89,57 +92,112 @@ type SendParams<T extends SendProc<any>> = T extends SendProc<infer T>
 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>,
+D extends Partial<RequestOption>&Required<Pick<RequestOption,'protocol'>>,
 S extends SendProc<any>,
 A extends AcceptProc<any,any>,
 >{
     private constructor(private _data:D,private _send:S, private _accept:A){}
 
-    //#region 快速流式创建
+    //#region 流式创建
     /**设为https请求 */
     static https(){
-        return new UtilCom({protocol:'https:'} as const,defSend,defAccept);
+        return new UtilCom({protocol:'https:'} as const,SendNoneProc,AcceptStringProc);
     }
     /**设为http请求 */
     static http(){
-        return new UtilCom({protocol:'http:'} as const,defSend,defAccept);
+        return new UtilCom({protocol:'http:'} as const,SendNoneProc,AcceptStringProc);
     }
     /**设为get方式的请求 */
     get(){
-        return new UtilCom({...this._data,method:'GET'} as const,this._send,this._accept);
+        this._data.method = 'GET';
+        return this as any as UtilCom<D & {method:'GET'},S,A>;
     }
     /**设为Post方式的请求 */
     post(){
-        return new UtilCom({...this._data,method:'POST'} as const,this._send,this._accept);
+        this._data.method = 'POST';
+        return this as any as UtilCom<D & {method:'POST'},S,A>;
+    }
+    /**补充参数  
+     * 将会替换对应字段, 修改headers请用header函数
+     */
+    option<OPT extends Partial<RequestOption>>(option:OPT){
+        this._data = {...this._data,...option};
+        return this as any as UtilCom<D & OPT,S,A>;
     }
-    /**补充参数 */
-    option<OPT extends Partial<ComRequestOption>>(opt:OPT){
-        return new UtilCom({...this._data,...opt} as const,this._send,this._accept);
+    /**补充header */
+    header<HAD extends http.OutgoingHttpHeaders>(headers:HAD){
+        this._data.headers = {
+            ...this._data.headers,
+            ...headers,
+        };
+        return this as any as UtilCom<D & {headers:HAD} ,S,A>;
+    }
+    /**设置agent */
+    proxyAgent(url:string){
+        this._data.agent = UtilFunc.matchProc(this._data['protocol'],{
+            'http:' :()=>HttpProxyAgent(url),
+            'https:':()=>HttpsProxyAgent(url),
+        })
+        return this;
+    }
+    /**添加一段query */
+    query(data:QueryRequestData){
+        this._data.path = UtilCom.buildQuery(this._data.path??'',data);
+        return this;
     }
     //#endregion
 
     //#region 快速预设
+    /**收发皆为json的预设 */
+    json(){
+        return this.sendJson().acceptJson();
+    }
     /**收发皆为json的post预设 */
     postJson(){
         return this.post().json();
     }
-    /**收发皆为json的预设 */
-    json(){
-        return this.sendJson().acceptJson();
+    /**无查询参数获取json的get预设 */
+    getJson(){
+        return this.get().sendNone().acceptJson();
+    }
+    /**有查询参数获取json的get预设 */
+    queryJson(){
+        return this.get().sendQuery().acceptJson();
+    }
+    /**收发皆为json的https-post预设 */
+    static httpsPostJson(){
+        return UtilCom.https().postJson();
+    }
+    /**收发皆为json的http-post预设 */
+    static httpPostJson(){
+        return UtilCom.http().postJson();
+    }
+    /**无查询参数获取json的https-get预设 */
+    static httpsGetJson(){
+        return UtilCom.https().getJson();
+    }
+    /**有查询参数获取json的https-get预设 */
+    static httpsQueryJson(){
+        return UtilCom.http().queryJson();
+    }
+    /**无查询参数获取json的http-get预设 */
+    static httpGetJson(){
+        return UtilCom.http().getJson();
+    }
+    /**有查询参数获取json的http-get预设 */
+    static httpQueryJson(){
+        return UtilCom.http().queryJson();
     }
     //#endregion
 
     //#region 接收数据类型
-    /**接收数据类型*/
+    /**预设的接收数据类型*/
     accept<T extends AcceptType>(t:T){
         const map = {
-            'json':this.acceptJson(),
-            'log':this.acceptLog(),
+            'json'  :this.acceptJson(),
+            'string':this.acceptString(),
         } as const;
         return map[t];
     }
@@ -152,66 +210,59 @@ A extends AcceptProc<any,any>,
                 const {data,...rest} = result;
 
                 if(data.trim()==""){
-                    SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`);
+                    SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`,UtilFunc.stringifyJToken(result,{compress:true,space:2}));
                     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}));
+                    SLogger.http(
+                        `json accept 接受信息 data:`,
+                        UtilFunc.stringifyJToken(obj,{compress:true,space:2}),
+                        `result:`,
+                        UtilFunc.stringifyJToken(rest,{compress:true,space:2})
+                    );
                     return{...rest,data:obj};
                 }
                 catch(e){
-                    SLogger.warn(`json accept 接收反馈错误:${e}\n原始字符串:${data}`);
+                    SLogger.warn(`json accept 接收反馈错误:${e}`,UtilFunc.stringifyJToken(result,{compress:true,space:2}));
                     return {...result,raw:data,data:null};
                 }
             }
         }
-        return new UtilCom(this._data,this._send,proc)
+        this._accept = proc as any;
+        return this as any as UtilCom<D,S,typeof 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)
+    acceptString(){
+        this._accept = AcceptStringProc as any;
+        return this as any as UtilCom<D,S,typeof AcceptStringProc>;
+    }
+    /**自定的接收数据类型*/
+    acceptRaw<AD,AT>(proc:AcceptProc<AD,AT>){
+        this._accept = proc as any;
+        return this as any as UtilCom<D,S,typeof proc>;
     }
     //#endregion
 
     //#region 发送数据类型
-    /**发送数据类型*/
+    /**预设的发送数据类型*/
     send<T extends SendType>(t:T){
         const map = {
-            'json':this.sendJson(),
-            "none":this.sendNone(),
+            'json'      :this.sendJson(),
+            'query'     :this.sendQuery(),
+            'formData'  :this.sendFormData(),
+            'none'      :this.sendNone(),
         } as const;
         return map[t];
     }
+    /**利用 req.write 发送一段json */
     sendJson(){
-        const proc:SendProc<[JsonType<D>]>={
-            proc:(opt:ComRequestOption,reqData:JsonType<D>)=>{
+        const proc:SendProc<[JToken]>={
+            proc:(opt:RequestOption,reqData:JToken)=>{
                 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,
-                    }
-                }
+                this._data.headers??={};
+                this._data.headers['Content-Length'] = Buffer.byteLength(JSON.stringify(reqData));
 
                 const procReq = (req:http.ClientRequest)=>{
                     if(isPost) req.write(JSON.stringify(reqData));
@@ -220,70 +271,107 @@ A extends AcceptProc<any,any>,
                 return procReq;
             }
         }
-        return new UtilCom(this._data,proc,this._accept);
+        this._send = proc as any;
+        this._data.headers??={};
+        this._data.headers['Content-Type'] = 'application/json';
+        return this as any as UtilCom<D&{
+            headers:{ 'Content-Type': 'application/json' }
+        },typeof proc,A>;
     }
-    sendNone(){
-        const proc:SendProc<[]>={
-            proc:(opt:ComRequestOption)=>{
-                const procReq = (req:http.ClientRequest)=>{
-                    req.end();
-                }
+    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    sendQuery(){
+        const proc:SendProc<[QueryRequestData]>={
+            proc:(opt:RequestOption,reqData:QueryRequestData)=>{
+                opt.path = UtilCom.buildQuery(opt.path??'',reqData)
+                const procReq = (req:http.ClientRequest)=>void req.end();
                 return procReq;
             }
         }
-        return new UtilCom(this._data,proc,this._accept)
+        this._send = proc as any;
+        return this as any as UtilCom<D,typeof proc,A>;
+    }
+    sendFormData() {
+        const proc: SendProc<[FormData]> = {
+            proc: (opt: RequestOption, formData: FormData) => {
+                opt.headers = formData.getHeaders();
+                const procReq = (req: http.ClientRequest) => {
+                    formData.pipe(req);
+                    req.end();
+                };
+                return procReq;
+            },
+        };
+        this._send = proc as any;
+        this._data.headers??={};
+        this._data.headers['Content-Type'] = 'multipart/form-data';
+        return this as any as UtilCom<D&{
+            headers:{ 'Content-Type': 'multipart/form-data' }
+        }, typeof proc, A>;
+    }
+    sendNone(){
+        this._send = SendNoneProc as any;
+        return this as any as UtilCom<D,typeof SendNoneProc,A>;
+    }
+    /**自定的发送数据类型*/
+    sendRaw<T extends any[]>(proc:SendProc<T>){
+        this._send = proc as any;
+        return this as any as UtilCom<D, typeof proc, A>;
     }
     //#endregion
 
-    /**发送请求 
-     * @param option       - 网络请求选项
-     * @param datas     - 数据对象
+    /**发送请求
+     * @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[]);
+    async once(option:PartialOption<RequestOption,D>,...datas:SendParams<S>){
+        const fullopt = Object.assign({},this._data,option) as RequestOption;
+        const proc = 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);
+        const res = await UtilCom.request(fullopt,proc,reduce,init);
+        return parse(res) as ParseResult<A>;
     }
     /**重复发送网络请求  
-     * @param option       - 网络请求选项
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @param datas     - 数据对象
+     * @param option  - 网络请求选项
+     * @param verify  - 有效性验证函数
+     * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+     * @param datas   - 数据对象
      */
-    async repeat(
-        option:PartialOption<ComRequestOption,D>,
-        verifyFn?:StatusVerifyFn<ParseResult<A>>,
-        repeatOpt:RepeatPromiseOpt={},
+    async retry(
+        opt:{
+            option  :PartialOption<RequestOption,D>,
+            verify? :StatusVerifyFn<ParseResult<A>>,
+            retries?:PromiseRetries,
+        },
         ...datas:SendParams<S>
     ){
-        repeatOpt.tryDelay    = repeatOpt.tryDelay??1000;
+        let {option,retries,verify} = opt;
+        retries??={};
+        retries.tryDelay    = retries.tryDelay??1000;
         const procFn = ()=>this.once(option,...datas);
-        return UtilFunc.repeatPromise(procFn,verifyFn,repeatOpt);
+        return UtilFunc.retryPromise(procFn,verify,retries);
     }
 
-    /**网络请求
-     * @param comReqOpt  - 网络请求选项
-     * @param procReq    - 请求处理函数 需调用req.end()
-     * @param reduceData - 数据处理函数
-     * @param initData   - 初始数据
+    /**发送网络请求
+     * @param option  - 网络请求选项
+     * @param proc    - 请求处理函数 需调用req.end()
+     * @param reduce  - 数据处理函数
+     * @param init    - 初始数据
      */
-    static async comReq<T>(
-        comReqOpt:ComRequestOption,
-        procReq:ProcReqFn,
-        reduceData:ReduceDataFn<T>,
-        initData:T,
+    static async request<T>(
+        option:RequestOption,
+        proc:RequestProcFn,
+        reduce:RequestReduceFn<T>,
+        init:T,
     ){
-        const {protocol,timeout,...baseReqOpt} = comReqOpt;
+        const {protocol,timeout,...baseReqOpt} = option;
 
         const hasTimeLimit = (timeout ? timeout>=10_000 : false );
 
-        const flagName = `UtilCom.comReq ${protocol}${baseReqOpt.method} ${UtilFunc.genUUID()}`;
+        const flagName = `UtilCom.request ${protocol}${baseReqOpt.method} ${UtilFunc.genUUID()}`;
 
         let dataPromise:Promise<any>|null = null;
 
-        return new Promise<ComResp<T>|undefined>(async (resolve, rejecte)=>{
+        return new Promise<RequestResult<T>|undefined>(async (resolve, rejecte)=>{
             const resFunc = (res:http.IncomingMessage)=>{
                 try{
                     //请求超时
@@ -294,10 +382,10 @@ A extends AcceptProc<any,any>,
                         });
                     }
 
-                    let mergedata:T = initData;
+                    let mergedata:T = init;
                     res.setEncoding('utf8');
                     res.on('data', chunk => {
-                        dataPromise = UtilFunc.queueProc(flagName,async()=>mergedata=await reduceData(mergedata,chunk))
+                        dataPromise = UtilFunc.queueProc(flagName,async()=>mergedata=await reduce(mergedata,chunk))
                     });
 
                     res.on('error',(e)=>{
@@ -321,8 +409,8 @@ A extends AcceptProc<any,any>,
             };
             //路由 http/https
             const req:http.ClientRequest= protocol=="https:"
-                ? https.request(baseReqOpt as http.RequestOptions, resFunc)
-                : http.request(baseReqOpt  as http.RequestOptions, resFunc);
+                ? https.request(baseReqOpt, resFunc)
+                : http .request(baseReqOpt, resFunc);
 
             //请求超时
             if(hasTimeLimit){
@@ -337,18 +425,33 @@ A extends AcceptProc<any,any>,
                 resolve(undefined);
             });
 
-            await procReq(req);
+            await proc(req);
         });
     }
+
+    /**构建query */
+    static buildQuery(base:string,data:QueryRequestData){
+        const queryString = qs.stringify(data);
+        if (queryString) {
+            // 检查当前路径是否已经包含问号
+            const separator = base.includes('?') ? '&' : '?';
+            base += separator + queryString;
+        }
+        return base;
+    }
 }
 
 
 if(false)((async ()=>{
-    const t = await UtilCom.https().post().accept('json').send('json')
-        .repeat({
-            hostname:'httpbin.org',
-            path:'/post',
-            timeout:10000
-        },()=>Success,{},{test:1});
+    const t = await UtilCom.https().postJson()
+        .retry({
+            option:{
+                hostname:'httpbin.org',
+                path:'/post',
+                timeout:10000
+            },
+            verify:()=>Success,
+            retries:{}
+        },{test:1});
     console.log(t);
 })())

package/src/UtilFileTools.ts

@@ -231,7 +231,6 @@ export async function loadJSONFile<T extends JToken>(filePath: string,opt?:LoadJ
 }
 
 /**写入JSON文件
- * void (string,Object)
  * @async
  * @param filePath - 文件路径
  * @param token    - 所要写入的JToken