@zwa73/utils 1.0.195 → 1.0.197

package/src/UtilCom_bak.txt

@@ -0,0 +1,345 @@
+import { AnyString,JToken, MPromise, StatusVerifyFn } from "@/src/UtilInterfaces";
+import https from 'https';
+import http from 'http';
+import { SLogger } from "@/src/UtilLogger";
+import { RepeatPromiseOpt, UtilFunc } from "@/src/UtilFunctions";
+import qs from "querystring";
+
+/**网络请求返回值 */
+export type ComResp<T> = {
+    /**响应头 */
+    headers: http.IncomingHttpHeaders;
+    /**响应状态码 */
+    statusCode?: number;
+    /**响应数据 */
+    data: T;
+}
+
+/**网络请求选项 */
+export type ComRequestOption = {
+    /**请求协议 */
+    protocol: 'http:'|'https:';
+    /**超时时间/毫秒  最小为10_000 默认无限 */
+    timeout?:number;
+    /**请求域名 */
+    hostname: string;
+    /**请求路径 */
+    path?: string;
+    /**请求方式 post 为 */
+    method: 'POST'|'GET';
+    /**端口 */
+    port?:number;
+    /**请求头 */
+    headers?: {
+        /**内容类型 */
+        'Content-Type'?: 'application/json'|AnyString;
+        /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
+        'Content-Length'?: number;
+    };
+}&http.RequestOptions;
+
+/**get请求所允许的数据 */
+export type GetReqData = NodeJS.Dict<
+| string
+| number
+| boolean
+| readonly string[]
+| readonly number[]
+| readonly boolean[]
+| null
+>;
+
+/**请求处理函数 需调用req.end() */
+export type ProcReqFn = ((req:http.ClientRequest)=>MPromise<void>);
+/**数据处理函数 */
+export type ReduceDataFn<T> = (acc:T,data:string)=>MPromise<T>;
+
+/**网络工具 */
+export namespace UtilCom{
+
+
+/**网络请求
+ * @param comReqOpt  - 网络请求选项
+ * @param procReq    - 请求处理函数 需调用req.end()
+ * @param reduceData - 数据处理函数
+ * @param initData   - 初始数据
+ */
+export async function 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 = `${comReq.name}.${protocol}${baseReqOpt.method}`;
+
+    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', async chunk => mergedata=await 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(timeout!, ()=>{
+                SLogger.warn(`${flagName} 发送请求超时: ${timeout} 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 ComRequestOption>(
+    comReqOpt:T,
+    reqData?:T['method'] extends "POST" ? JToken :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;
+        }
+    }
+
+    const procReq = (req:http.ClientRequest)=>{
+        if(isPost) req.write(JSON.stringify(reqData));
+        req.end();
+    }
+
+    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 {...result,raw:"",data:null};
+    }
+
+    try{
+        const obj = JSON.parse(data.trim()) as JToken;
+        SLogger.http(`${jsonReq.name} 接受信息:`,UtilFunc.stringifyJToken(obj,{compress:true,space:2}));
+        return{...rest,data:obj};
+    }
+    catch(e){
+        SLogger.warn(`${jsonReq.name} 接收反馈错误:${e}\n原始字符串:${data}`);
+        return {...result,raw:data,data:null};
+    }
+}
+
+/**重复发送json的网络请求  
+ * @async
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+ * @returns 结果 undefined 为未能成功接收
+ */
+async function repeatJsonComReq<T extends ComRequestOption>(
+    comReqOpt:T,
+    reqData?:T['method'] extends "POST" ? JToken :GetReqData,
+    verifyFn?:StatusVerifyFn<ComResp<JToken>|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<ComRequestOption,'protocol'|'method'>,reqData?:JToken){
+    return jsonReq({
+        ...comReqOpt,
+        method:"POST",
+        protocol:"https:",
+    },reqData);
+}
+
+/**发送一个 http POST 请求并接受数据  
+ * @async
+ * @param comReqOpt   - 请求参数
+ * @param reqData 	  - 数据对象
+ * @returns 结果 undefined 为未能成功接收
+ */
+export function httpPost(comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,reqData?:JToken){
+    return jsonReq({
+        ...comReqOpt,
+        method:"POST",
+        protocol:"http:",
+    },reqData);
+}
+
+/**发送一个 https GET 请求并接受数据  
+ * @async
+ * @param comReqOpt   - 请求参数
+ * @param reqData     - 数据对象
+ * @returns 结果 undefined 为未能成功接收
+ */
+export function httpsGet(comReqOpt:Omit<ComRequestOption,'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<ComRequestOption,'protocol'|'method'>,reqData?:GetReqData){
+    return jsonReq({
+        ...comReqOpt,
+        method:"GET",
+        protocol:"http:",
+    },reqData);
+}
+
+
+/**重复一个 https POST请求并接受数据  
+ * @async
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+ * @returns 结果 undefined 为未能成功接收
+ */
+export function httpsRepeatPost(
+    comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,
+    reqData?:JToken,
+    verifyFn?:StatusVerifyFn<JToken|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
+        ...comReqOpt,
+        method:"POST",
+        protocol:"https:",
+    },reqData,verifyFn,repeatOpt);
+}
+
+/**重复一个 http POST请求并接受数据  
+ * @async
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+ * @returns 结果 undefined 为未能成功接收
+ */
+export function httpRepeatPost(
+    comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,
+    reqData?:JToken,
+    verifyFn?:StatusVerifyFn<JToken|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
+        ...comReqOpt,
+        method:"POST",
+        protocol:"http:",
+    },reqData,verifyFn,repeatOpt);
+}
+
+/**重复一个 https GET 请求并接受数据  
+ * @async
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+ * @returns 结果 undefined 为未能成功接收
+ */
+export function httpsRepeatGet(
+    comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,
+    reqData?:GetReqData,
+    verifyFn?:StatusVerifyFn<JToken|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
+        ...comReqOpt,
+        method:"GET",
+        protocol:"https:",
+    },reqData,verifyFn,repeatOpt);
+}
+
+/**重复一个 http GET 请求并接受数据  
+ * @async
+ * @param comReqOpt - 网络请求选项
+ * @param reqData   - 数据对象
+ * @param verifyFn  - 有效性验证函数
+ * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+ * @returns 结果 undefined 为未能成功接收
+ */
+export function httpRepeatGet(
+    comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,
+    reqData?:GetReqData,
+    verifyFn?:StatusVerifyFn<JToken|undefined>,
+    repeatOpt?:RepeatPromiseOpt
+){
+    return repeatJsonComReq({
+        ...comReqOpt,
+        method:"GET",
+        protocol:"http:",
+    },reqData,verifyFn,repeatOpt);
+}
+
+}

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment, MPromise } from "@/src/UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, PromiseStatus, StatusVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment, MPromise } from "@/src/UtilInterfaces";
 import * as cp from "child_process";
 import { LogLevel, SLogger } from "@/src/UtilLogger";
 import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
@@ -51,7 +51,7 @@ type PromiseResult<T> = {
     /**请求结果 */
     result:T;
     /**请求状态 */
-    stat:ReqStat;
+    stat:PromiseStatus;
     /**请求下标/序号 */
     index:number;
 };
@@ -228,7 +228,7 @@ static getNeverResolvedPromise<T>():Promise<T>{
  * @returns 重复结果
  */
 @LogTimeAsync("repeatPromise ",true)
-static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,opt:RepeatPromiseOpt = {}):
+static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:StatusVerifyFn<T>,opt:RepeatPromiseOpt = {}):
 Promise<RepeatPromiseResult<T>>{
     opt.count = opt.count??3;
     opt.tryInterval = opt.tryInterval??180_000;

package/src/UtilInterfaces.ts

@@ -140,14 +140,14 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
     TMP extends JArray = ExclusiveRecursive<B,T,K>> = TMP[number];
 
 
-/**请求完成状态 成功/失败/终止  
- * 成功 将直接返回  结果  
- * 终止 将直接返回  null  
+/**Promise完成状态 成功/失败/终止  
+ * 成功 将直接返回 结果  
+ * 终止 将直接返回 结果  
  * 失败 将重试  
  */
-export type ReqStat = Success|Failed|Terminated;
-/**请求状态验证函数 */
-export type ReqVerifyFn<T> = (obj:T)=>Promise<ReqStat>|ReqStat;
+export type PromiseStatus = Success|Failed|Terminated;
+/**状态验证函数 */
+export type StatusVerifyFn<T> = (obj:T)=>Promise<PromiseStatus>|PromiseStatus;
 
 /**获取Promise的结果类型 如同await那样
  * @deprecated 请使用官方的 Awaited<T> 类型