@zwa73/utils 1.0.201 → 1.0.203

package/src/UtilCom.ts

@@ -1,457 +0,0 @@
-import { AnyString,JToken, MPromise, PartialOption, StatusVerifyFn } from "@/src/UtilInterfaces";
-import http from 'http';
-import https from 'https';
-import { SLogger } from "@/src/UtilLogger";
-import { PromiseRetries, UtilFunc } from "@/src/UtilFunctions";
-import qs from "querystring";
-import { Success } from "./UtilSymbol";
-import FormData from "form-data";
-import HttpProxyAgent from "http-proxy-agent";
-import HttpsProxyAgent from "https-proxy-agent";
-
-/**网络请求返回值 */
-export type RequestResult<T> = {
-    /**响应头 */
-    headers: http.IncomingHttpHeaders;
-    /**响应状态码 */
-    statusCode?: number;
-    /**响应数据 */
-    data: T;
-}
-
-/**网络请求选项 */
-export type RequestOption = {
-    /**请求协议 */
-    protocol: 'http:'|'https:';
-    /**超时时间/毫秒  最小为10_000 默认无限 */
-    timeout?:number;
-    /**请求域名 */
-    hostname: string;
-    /**请求路径 */
-    path?: string;
-    /**请求方式 post 为 */
-    method: 'POST'|'GET';
-    /**端口 */
-    port?:number;
-    /**请求头 */
-    headers?: {
-        /**内容类型 */
-        'Content-Type'?: 'application/json'|'multipart/form-data'|AnyString;
-        /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
-        'Content-Length'?: number;
-    };
-}&http.RequestOptions;
-
-/**getquery请求所允许的数据 */
-export type QueryRequestData = NodeJS.Dict<
-| string
-| number
-| boolean
-| readonly string[]
-| readonly number[]
-| readonly boolean[]
-| null
->;
-
-/**请求处理函数 需调用req.end() */
-export type RequestProcFn = ((req:http.ClientRequest)=>MPromise<void>);
-/**数据处理函数 */
-export type RequestReduceFn<T> = (acc:T,data:string)=>MPromise<T>;
-
-
-const AcceptTypeList = ["json","string"]as const;
-/**可用的接受类型 */
-type AcceptType = typeof AcceptTypeList[number];
-const SendTypeList = ["json","query","formData","none"] as const;
-/**可用的发送类型 */
-type SendType = typeof SendTypeList[number];
-
-/**accept处理数据 */
-type AcceptProc<D,T> = {
-    init  :D;
-    reduce:RequestReduceFn<D>,
-    parse :(result:RequestResult<D>|undefined)=>MPromise<T>
-}
-/**send处理数据 */
-type SendProc<T extends any[]> = {
-    proc:(opt:RequestOption,...args:T)=>MPromise<RequestProcFn>,
-}
-const SendNoneProc:SendProc<[]> = {
-    proc:(opt)=>(req)=>void req.end()
-}
-const AcceptStringProc:AcceptProc<string,RequestResult<string>|undefined> = {
-    init  :'',
-    reduce:(acc:string,dat:string)=>acc+dat,
-    parse :(result:RequestResult<string>|undefined)=>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;
-
-/**网络请求工具 */
-export class UtilCom<
-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 流式创建
-    /**设为https请求 */
-    static https(){
-        return new UtilCom({protocol:'https:'} as const,SendNoneProc,AcceptStringProc);
-    }
-    /**设为http请求 */
-    static http(){
-        return new UtilCom({protocol:'http:'} as const,SendNoneProc,AcceptStringProc);
-    }
-    /**设为get方式的请求 */
-    get(){
-        this._data.method = 'GET';
-        return this as any as UtilCom<D & {method:'GET'},S,A>;
-    }
-    /**设为Post方式的请求 */
-    post(){
-        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>;
-    }
-    /**补充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的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(),
-            'string':this.acceptString(),
-        } as const;
-        return map[t];
-    }
-    acceptJson(){
-        const proc:AcceptProc<string,RequestResult<JToken>|undefined>={
-            init:'',
-            reduce:(acc,curr)=>acc+curr,
-            parse:(result)=>{
-                if(result==undefined) return undefined;
-                const {data,...rest} = result;
-
-                if(data.trim()==""){
-                    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 接受信息 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}`,UtilFunc.stringifyJToken(result,{compress:true,space:2}));
-                    return {...result,raw:data,data:null};
-                }
-            }
-        }
-        this._accept = proc as any;
-        return this as any as UtilCom<D,S,typeof 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(),
-            'query'     :this.sendQuery(),
-            'formData'  :this.sendFormData(),
-            'none'      :this.sendNone(),
-        } as const;
-        return map[t];
-    }
-    /**利用 req.write 发送一段json */
-    sendJson(){
-        const proc:SendProc<[JToken]>={
-            proc:(opt:RequestOption,reqData:JToken)=>{
-                const {method} = opt;
-                const isPost = (method=="POST");
-
-                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));
-                    req.end();
-                }
-                return procReq;
-            }
-        }
-        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>;
-    }
-    /**利用 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;
-            }
-        }
-        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  - 数据对象
-     */
-    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.request(fullopt,proc,reduce,init);
-        return parse(res) as ParseResult<A>;
-    }
-    /**重复发送网络请求  
-     * @param option  - 网络请求选项
-     * @param verify  - 有效性验证函数
-     * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @param datas   - 数据对象
-     */
-    async retry(
-        opt:{
-            option  :PartialOption<RequestOption,D>,
-            verify? :StatusVerifyFn<ParseResult<A>>,
-            retries?:PromiseRetries,
-        },
-        ...datas:SendParams<S>
-    ){
-        let {option,retries,verify} = opt;
-        retries??={};
-        retries.tryDelay    = retries.tryDelay??1000;
-        const procFn = ()=>this.once(option,...datas);
-        return UtilFunc.retryPromise(procFn,verify,retries);
-    }
-
-    /**发送网络请求
-     * @param option  - 网络请求选项
-     * @param proc    - 请求处理函数 需调用req.end()
-     * @param reduce  - 数据处理函数
-     * @param init    - 初始数据
-     */
-    static async request<T>(
-        option:RequestOption,
-        proc:RequestProcFn,
-        reduce:RequestReduceFn<T>,
-        init:T,
-    ){
-        const {protocol,timeout,...baseReqOpt} = option;
-
-        const hasTimeLimit = (timeout ? timeout>=10_000 : false );
-
-        const flagName = `UtilCom.request ${protocol}${baseReqOpt.method} ${UtilFunc.genUUID()}`;
-
-        let dataPromise:Promise<any>|null = null;
-
-        return new Promise<RequestResult<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 = init;
-                    res.setEncoding('utf8');
-                    res.on('data', chunk => {
-                        dataPromise = UtilFunc.queueProc(flagName,async()=>mergedata=await reduce(mergedata,chunk))
-                    });
-
-                    res.on('error',(e)=>{
-                        SLogger.warn(`${flagName} 接收反馈错误:${e}`);
-                        resolve(undefined);
-                    });
-
-                    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, resFunc)
-                : http .request(baseReqOpt, resFunc);
-
-            //请求超时
-            if(hasTimeLimit){
-                req.setTimeout(timeout!, ()=>{
-                    SLogger.warn(`${flagName} 发送请求超时: ${timeout} ms`);
-                    req.destroy();
-                });
-            }
-
-            req.on('error', (e)=>{
-                SLogger.warn(`${flagName} 发送请求错误:${e}`);
-                resolve(undefined);
-            });
-
-            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().postJson()
-        .retry({
-            option:{
-                hostname:'httpbin.org',
-                path:'/post',
-                timeout:10000
-            },
-            verify:()=>Success,
-            retries:{}
-        },{test:1});
-    console.log(t);
-})())