@tdengine/websocket 3.0.0 → 3.1.1

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./src/client/wsClient";
+export * from "./src/client/wsConnector";
+export * from "./src/client/wsConnectorPool";
+export * from "./src/client/wsEventCallback";
+export * from "./src/client/wsResponse";
+export * from "./src/common/config";
+export * from "./src/common/constant";
+export * from "./src/common/log";
+export * from "./src/common/reqid";
+export * from "./src/common/taosResult";
+export * from "./src/common/ut8Helper";
+export * from "./src/common/utils";
+export * from "./src/common/wsError";
+export * from "./src/common/wsOptions";
+export * from "./src/index";
+export * from "./src/sql/wsProto";
+export * from "./src/sql/wsRows";
+export * from "./src/sql/wsSql";
+export * from "./src/stmt/wsParams";
+export * from "./src/stmt/wsProto";
+export * from "./src/stmt/wsStmt";
+export * from "./src/tmq/config";
+export * from "./src/tmq/constant";
+export * from "./src/tmq/tmqResponse";
+export * from "./src/tmq/wsTmq";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA"}

package/lib/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/client/wsClient"), exports);
+__exportStar(require("./src/client/wsConnector"), exports);
+__exportStar(require("./src/client/wsConnectorPool"), exports);
+__exportStar(require("./src/client/wsEventCallback"), exports);
+__exportStar(require("./src/client/wsResponse"), exports);
+__exportStar(require("./src/common/config"), exports);
+__exportStar(require("./src/common/constant"), exports);
+__exportStar(require("./src/common/log"), exports);
+__exportStar(require("./src/common/reqid"), exports);
+__exportStar(require("./src/common/taosResult"), exports);
+__exportStar(require("./src/common/ut8Helper"), exports);
+__exportStar(require("./src/common/utils"), exports);
+__exportStar(require("./src/common/wsError"), exports);
+__exportStar(require("./src/common/wsOptions"), exports);
+__exportStar(require("./src/index"), exports);
+__exportStar(require("./src/sql/wsProto"), exports);
+__exportStar(require("./src/sql/wsRows"), exports);
+__exportStar(require("./src/sql/wsSql"), exports);
+__exportStar(require("./src/stmt/wsParams"), exports);
+__exportStar(require("./src/stmt/wsProto"), exports);
+__exportStar(require("./src/stmt/wsStmt"), exports);
+__exportStar(require("./src/tmq/config"), exports);
+__exportStar(require("./src/tmq/constant"), exports);
+__exportStar(require("./src/tmq/tmqResponse"), exports);
+__exportStar(require("./src/tmq/wsTmq"), exports);

package/lib/src/client/wsClient.d.ts

@@ -0,0 +1,22 @@
+import { TaosResult } from '../common/taosResult';
+import { WSQueryResponse, WSFetchResponse } from './wsResponse';
+export declare class WsClient {
+    private _wsConnector?;
+    private _timeout?;
+    private readonly _url;
+    constructor(url: URL, timeout?: number | undefined | null);
+    connect(database?: string | undefined | null): Promise<void>;
+    execNoResp(queryMsg: string): Promise<void>;
+    exec(queryMsg: string, bSqlQuery?: boolean): Promise<any>;
+    sendBinaryMsg(reqId: bigint, action: string, message: ArrayBuffer, bSqlQuery?: boolean, bResultBinary?: boolean): Promise<any>;
+    getState(): number;
+    ready(): Promise<void>;
+    fetch(res: WSQueryResponse): Promise<WSFetchResponse>;
+    fetchBlock(fetchResponse: WSFetchResponse, taosResult: TaosResult): Promise<TaosResult>;
+    sendMsg(msg: string): Promise<any>;
+    freeResult(res: WSQueryResponse): Promise<unknown>;
+    version(): Promise<string>;
+    close(): Promise<void>;
+    checkURL(url: URL): void;
+}
+//# sourceMappingURL=wsClient.d.ts.map

package/lib/src/client/wsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsClient.d.ts","sourceRoot":"","sources":["../../../src/client/wsClient.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,EAGH,eAAe,EACf,eAAe,EAClB,MAAM,cAAc,CAAC;AAKtB,qBAAa,QAAQ;IACjB,OAAO,CAAC,YAAY,CAAC,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,CAA2B;IAC5C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAK;gBAEd,GAAG,EAAE,GAAG,EAAE,OAAQ,CAAC,EAAC,MAAM,GAAG,SAAS,GAAG,IAAI;IAOnD,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC5D,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU3C,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAC,OAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAuB9D,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,GAAC,OAAc,EAAE,aAAa,GAAE,OAAe,GAAG,OAAO,CAAC,GAAG,CAAC;IA0B/I,QAAQ;IAQF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,KAAK,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IA0BrD,UAAU,CAAC,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IA2BvF,OAAO,CAAC,GAAG,EAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAajC,UAAU,CAAC,GAAG,EAAE,eAAe;IAqB/B,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IA4B1B,KAAK,IAAG,OAAO,CAAC,IAAI,CAAC;IAS3B,QAAQ,CAAC,GAAG,EAAE,GAAG;CASpB"}

package/lib/src/client/wsClient.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = void 0;
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const wsConnectorPool_1 = require("./wsConnectorPool");
+const taosResult_1 = require("../common/taosResult");
+const wsError_1 = require("../common/wsError");
+const wsResponse_1 = require("./wsResponse");
+const reqid_1 = require("../common/reqid");
+const log_1 = __importDefault(require("../common/log"));
+class WsClient {
+    constructor(url, timeout) {
+        this.checkURL(url);
+        this._url = url;
+        this._timeout = timeout;
+    }
+    async connect(database) {
+        let _db = this._url.pathname.split('/')[3];
+        if (database) {
+            _db = database;
+        }
+        let connMsg = {
+            action: 'conn',
+            args: {
+                req_id: reqid_1.ReqId.getReqID(),
+                user: this._url.username,
+                password: this._url.password,
+                db: _db,
+            },
+        };
+        this._wsConnector = await wsConnectorPool_1.WebSocketConnectionPool.instance().getConnection(this._url, this._timeout);
+        if (this._wsConnector.readyState() > 0) {
+            return;
+        }
+        try {
+            await this._wsConnector.ready();
+            let result = await this._wsConnector.sendMsg(JSON.stringify(connMsg));
+            if (result.msg.code == 0) {
+                return;
+            }
+            throw (new wsError_1.WebSocketQueryError(result.msg.code, result.msg.message));
+        }
+        catch (e) {
+            log_1.default.error(e.code, e.message);
+            throw (new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._url}`));
+        }
+    }
+    async execNoResp(queryMsg) {
+        log_1.default.debug('[wsQueryInterface.query.queryMsg]===>' + queryMsg);
+        if (this._wsConnector && this._wsConnector.readyState() > 0) {
+            await this._wsConnector.sendMsgNoResp(queryMsg);
+            return;
+        }
+        throw (new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+    }
+    // need to construct Response.
+    async exec(queryMsg, bSqlQuery = true) {
+        return new Promise((resolve, reject) => {
+            log_1.default.debug('[wsQueryInterface.query.queryMsg]===>' + queryMsg);
+            if (this._wsConnector && this._wsConnector.readyState() > 0) {
+                this._wsConnector.sendMsg(queryMsg).then((e) => {
+                    if (e.msg.code == 0) {
+                        if (bSqlQuery) {
+                            resolve(new wsResponse_1.WSQueryResponse(e));
+                        }
+                        else {
+                            resolve(e);
+                        }
+                    }
+                    else {
+                        reject(new wsError_1.WebSocketInterfaceError(e.msg.code, e.msg.message));
+                    }
+                }).catch((e) => { reject(e); });
+            }
+            else {
+                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            }
+        });
+    }
+    // need to construct Response.
+    async sendBinaryMsg(reqId, action, message, bSqlQuery = true, bResultBinary = false) {
+        return new Promise((resolve, reject) => {
+            if (this._wsConnector && this._wsConnector.readyState() > 0) {
+                this._wsConnector.sendBinaryMsg(reqId, action, message).then((e) => {
+                    if (bResultBinary) {
+                        resolve(e);
+                    }
+                    if (e.msg.code == 0) {
+                        if (bSqlQuery) {
+                            resolve(new wsResponse_1.WSQueryResponse(e));
+                        }
+                        else {
+                            resolve(e);
+                        }
+                    }
+                    else {
+                        reject(new wsError_1.WebSocketInterfaceError(e.msg.code, e.msg.message));
+                    }
+                }).catch((e) => { reject(e); });
+            }
+            else {
+                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            }
+        });
+    }
+    getState() {
+        if (this._wsConnector) {
+            return this._wsConnector.readyState();
+        }
+        return -1;
+    }
+    async ready() {
+        try {
+            this._wsConnector = await wsConnectorPool_1.WebSocketConnectionPool.instance().getConnection(this._url, this._timeout);
+            if (this._wsConnector.readyState() <= 0) {
+                await this._wsConnector.ready();
+            }
+            log_1.default.debug("ready status ", this._url, this._wsConnector.readyState());
+            return;
+        }
+        catch (e) {
+            log_1.default.error(e.code, e.message);
+            throw (new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._url}`));
+        }
+    }
+    async fetch(res) {
+        let fetchMsg = {
+            action: 'fetch',
+            args: {
+                req_id: reqid_1.ReqId.getReqID(),
+                id: res.id,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            let jsonStr = json_bigint_1.default.stringify(fetchMsg);
+            log_1.default.debug('[wsQueryInterface.fetch.fetchMsg]===>' + jsonStr);
+            if (this._wsConnector && this._wsConnector.readyState() > 0) {
+                this._wsConnector.sendMsg(jsonStr).then((e) => {
+                    if (e.msg.code == 0) {
+                        resolve(new wsResponse_1.WSFetchResponse(e));
+                    }
+                    else {
+                        reject(new wsError_1.WebSocketInterfaceError(e.msg.code, e.msg.message));
+                    }
+                }).catch((e) => { reject(e); });
+            }
+            else {
+                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            }
+        });
+    }
+    async fetchBlock(fetchResponse, taosResult) {
+        let fetchBlockMsg = {
+            action: 'fetch_block',
+            args: {
+                req_id: reqid_1.ReqId.getReqID(),
+                id: fetchResponse.id,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            let jsonStr = json_bigint_1.default.stringify(fetchBlockMsg);
+            log_1.default.debug("[wsQueryInterface.fetchBlock.fetchBlockMsg]===>" + jsonStr);
+            if (this._wsConnector && this._wsConnector.readyState() > 0) {
+                this._wsConnector.sendMsg(jsonStr).then((e) => {
+                    let resp = e;
+                    taosResult.addTotalTime(resp.totalTime);
+                    // if retrieve JSON then reject with message
+                    // else is binary , so parse raw block to TaosResult
+                    (0, taosResult_1.parseBlock)(new wsResponse_1.WSFetchBlockResponse(resp.msg), taosResult);
+                    resolve(taosResult);
+                }).catch((e) => reject(e));
+            }
+            else {
+                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            }
+        });
+    }
+    async sendMsg(msg) {
+        return new Promise((resolve, reject) => {
+            log_1.default.debug("[wsQueryInterface.sendMsg]===>" + msg);
+            if (this._wsConnector && this._wsConnector.readyState() > 0) {
+                this._wsConnector.sendMsg(msg).then((e) => {
+                    resolve(e);
+                }).catch((e) => reject(e));
+            }
+            else {
+                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            }
+        });
+    }
+    async freeResult(res) {
+        let freeResultMsg = {
+            action: 'free_result',
+            args: {
+                req_id: reqid_1.ReqId.getReqID(),
+                id: res.id,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            let jsonStr = json_bigint_1.default.stringify(freeResultMsg);
+            log_1.default.debug("[wsQueryInterface.freeResult.freeResultMsg]===>" + jsonStr);
+            if (this._wsConnector && this._wsConnector.readyState() > 0) {
+                this._wsConnector.sendMsg(jsonStr, false)
+                    .then((e) => { resolve(e); })
+                    .catch((e) => reject(e));
+            }
+            else {
+                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            }
+        });
+    }
+    async version() {
+        let versionMsg = {
+            action: 'version',
+            args: {
+                req_id: reqid_1.ReqId.getReqID()
+            },
+        };
+        if (this._wsConnector) {
+            try {
+                if (this._wsConnector.readyState() <= 0) {
+                    await this._wsConnector.ready();
+                }
+                let result = await this._wsConnector.sendMsg(json_bigint_1.default.stringify(versionMsg));
+                if (result.msg.code == 0) {
+                    return new wsResponse_1.WSVersionResponse(result).version;
+                }
+                throw (new wsError_1.WebSocketInterfaceError(result.msg.code, result.msg.message));
+            }
+            catch (e) {
+                log_1.default.error(e.code, e.message);
+                throw (new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._url}`));
+            }
+        }
+        throw (wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect");
+    }
+    async close() {
+        if (this._wsConnector) {
+            await wsConnectorPool_1.WebSocketConnectionPool.instance().releaseConnection(this._wsConnector);
+            this._wsConnector = undefined;
+            // this._wsConnector.close();
+        }
+    }
+    checkURL(url) {
+        // Assert is cloud url
+        if (!url.searchParams.has('token')) {
+            if (!(url.username || url.password)) {
+                throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_AUTHENTICATION, 'invalid url, password or username needed.');
+            }
+        }
+    }
+}
+exports.WsClient = WsClient;

package/lib/src/client/wsConnector.d.ts

@@ -0,0 +1,17 @@
+export declare class WebSocketConnector {
+    private _wsConn;
+    private _wsURL;
+    _timeout: number;
+    constructor(url: URL, timeout: number | undefined | null);
+    ready(): Promise<unknown>;
+    private _onclose;
+    private _onmessage;
+    close(): void;
+    readyState(): number;
+    sendMsgNoResp(message: string): Promise<void>;
+    sendMsg(message: string, register?: Boolean): Promise<unknown>;
+    sendBinaryMsg(reqId: bigint, action: string, message: ArrayBuffer, register?: Boolean): Promise<unknown>;
+    configTimeout(ms: number): void;
+    getWsURL(): URL;
+}
+//# sourceMappingURL=wsConnector.d.ts.map

package/lib/src/client/wsConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsConnector.d.ts","sourceRoot":"","sources":["../../../src/client/wsConnector.ts"],"names":[],"mappings":"AAMA,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAAM;IACpB,QAAQ,SAAQ;gBAGJ,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAsBlD,KAAK;YAeG,QAAQ;IAKtB,OAAO,CAAC,UAAU;IA0BlB,KAAK;IASL,UAAU,IAAI,MAAM;IAId,aAAa,CAAC,OAAO,EAAE,MAAM,GAAE,OAAO,CAAC,IAAI,CAAC;IAmB5C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAc;IAuBjD,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,GAAE,OAAc;IAgBzF,aAAa,CAAC,EAAE,EAAE,MAAM;IAIxB,QAAQ,IAAI,GAAG;CAGzB"}

package/lib/src/client/wsConnector.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnector = void 0;
+const websocket_1 = require("websocket");
+const wsError_1 = require("../common/wsError");
+const wsEventCallback_1 = require("./wsEventCallback");
+const log_1 = __importDefault(require("../common/log"));
+const reqid_1 = require("../common/reqid");
+class WebSocketConnector {
+    // create ws
+    constructor(url, timeout) {
+        this._timeout = 5000;
+        // return w3bsocket3
+        if (url) {
+            this._wsURL = url;
+            let origin = url.origin;
+            let pathname = url.pathname;
+            let search = url.search;
+            if (timeout) {
+                this._timeout = timeout;
+            }
+            this._wsConn = new websocket_1.w3cwebsocket(origin.concat(pathname).concat(search));
+            this._wsConn.onerror = function (err) { log_1.default.error(err.message); throw err; };
+            this._wsConn.onclose = this._onclose;
+            this._wsConn.onmessage = this._onmessage;
+            this._wsConn._binaryType = "arraybuffer";
+        }
+        else {
+            throw new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_INVALID_URL, "websocket URL must be defined");
+        }
+    }
+    async ready() {
+        return new Promise((resolve, reject) => {
+            let reqId = reqid_1.ReqId.getReqID();
+            wsEventCallback_1.WsEventCallback.instance().registerCallback({ action: "websocket_connection", req_id: BigInt(reqId),
+                timeout: this._timeout, id: BigInt(reqId) }, resolve, reject);
+            this._wsConn.onopen = () => {
+                log_1.default.debug("websocket connection opened");
+                wsEventCallback_1.WsEventCallback.instance().handleEventCallback({ id: BigInt(reqId), action: "websocket_connection", req_id: BigInt(reqId) }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_CONNECTION, this);
+            };
+        });
+    }
+    async _onclose(e) {
+        log_1.default.info("websocket connection closed");
+    }
+    _onmessage(event) {
+        let data = event.data;
+        log_1.default.debug("wsClient._onMessage()====" + (Object.prototype.toString.call(data)));
+        if (Object.prototype.toString.call(data) === '[object ArrayBuffer]') {
+            let id = new DataView(data, 26, 8).getBigUint64(0, true);
+            wsEventCallback_1.WsEventCallback.instance().handleEventCallback({ id: id, action: '', req_id: BigInt(0) }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_ARRAYBUFFER, data);
+        }
+        else if (Object.prototype.toString.call(data) === '[object Blob]') {
+            data.arrayBuffer().then((d) => {
+                let id = new DataView(d, 8, 8).getBigUint64(0, true);
+                wsEventCallback_1.WsEventCallback.instance().handleEventCallback({ id: id, action: '', req_id: BigInt(0) }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_BLOB, d);
+            });
+        }
+        else if (Object.prototype.toString.call(data) === '[object String]') {
+            let msg = JSON.parse(data);
+            log_1.default.debug("[_onmessage.stringType]==>:" + data);
+            wsEventCallback_1.WsEventCallback.instance().handleEventCallback({ id: BigInt(0), action: msg.action, req_id: msg.req_id }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_STRING, msg);
+        }
+        else {
+            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_INVALID_MESSAGE_TYPE, `invalid message type ${Object.prototype.toString.call(data)}`);
+        }
+    }
+    close() {
+        if (this._wsConn) {
+            this._wsConn.close();
+        }
+        else {
+            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, "WebSocket connection is undefined.");
+        }
+    }
+    readyState() {
+        return this._wsConn.readyState;
+    }
+    async sendMsgNoResp(message) {
+        log_1.default.debug("[wsClient.sendMsgNoResp()]===>" + message);
+        let msg = JSON.parse(message);
+        if (msg.args.id !== undefined) {
+            msg.args.id = BigInt(msg.args.id);
+        }
+        return new Promise((resolve, reject) => {
+            if (this._wsConn && this._wsConn.readyState > 0) {
+                this._wsConn.send(message);
+                resolve();
+            }
+            else {
+                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready,status :${this._wsConn?.readyState}`));
+            }
+        });
+    }
+    async sendMsg(message, register = true) {
+        log_1.default.debug("[wsClient.sendMessage()]===>" + message);
+        let msg = JSON.parse(message);
+        if (msg.args.id !== undefined) {
+            msg.args.id = BigInt(msg.args.id);
+        }
+        return new Promise((resolve, reject) => {
+            if (this._wsConn && this._wsConn.readyState > 0) {
+                if (register) {
+                    wsEventCallback_1.WsEventCallback.instance().registerCallback({ action: msg.action, req_id: msg.args.req_id,
+                        timeout: this._timeout, id: msg.args.id === undefined ? msg.args.id : BigInt(msg.args.id) }, resolve, reject);
+                }
+                log_1.default.debug("[wsClient.sendMessage.msg]===>\n", message);
+                this._wsConn.send(message);
+            }
+            else {
+                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready,status :${this._wsConn?.readyState}`));
+            }
+        });
+    }
+    async sendBinaryMsg(reqId, action, message, register = true) {
+        return new Promise((resolve, reject) => {
+            if (this._wsConn && this._wsConn.readyState > 0) {
+                if (register) {
+                    wsEventCallback_1.WsEventCallback.instance().registerCallback({ action: action, req_id: reqId,
+                        timeout: this._timeout, id: reqId }, resolve, reject);
+                }
+                log_1.default.debug("[wsClient.sendBinaryMsg()]===>" + reqId + action + message.byteLength);
+                this._wsConn.send(message);
+            }
+            else {
+                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready,status :${this._wsConn?.readyState}`));
+            }
+        });
+    }
+    configTimeout(ms) {
+        this._timeout = ms;
+    }
+    getWsURL() {
+        return this._wsURL;
+    }
+}
+exports.WebSocketConnector = WebSocketConnector;

package/lib/src/client/wsConnectorPool.d.ts

@@ -0,0 +1,13 @@
+import { WebSocketConnector } from "./wsConnector";
+export declare class WebSocketConnectionPool {
+    private static _instance?;
+    private pool;
+    private _connectionCount;
+    private readonly _maxConnections;
+    private constructor();
+    static instance(maxConnections?: number): WebSocketConnectionPool;
+    getConnection(url: URL, timeout: number | undefined | null): Promise<WebSocketConnector>;
+    releaseConnection(connector: WebSocketConnector): Promise<void>;
+    destroyed(): void;
+}
+//# sourceMappingURL=wsConnectorPool.d.ts.map

package/lib/src/client/wsConnectorPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsConnectorPool.d.ts","sourceRoot":"","sources":["../../../src/client/wsConnectorPool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAKnD,qBAAa,uBAAuB;IAChC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAyB;IAClD,OAAO,CAAC,IAAI,CAAgD;IAC5D,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO;WAKO,QAAQ,CAAC,cAAc,GAAE,MAAW,GAAE,uBAAuB;IAOrE,aAAa,CAAC,GAAG,EAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA6BvF,iBAAiB,CAAC,SAAS,EAAE,kBAAkB,GAAE,OAAO,CAAC,IAAI,CAAC;IA0BpE,SAAS;CAYZ"}

package/lib/src/client/wsConnectorPool.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnectionPool = void 0;
+const async_mutex_1 = require("async-mutex");
+const wsConnector_1 = require("./wsConnector");
+const wsError_1 = require("../common/wsError");
+const log_1 = __importDefault(require("../common/log"));
+const mutex = new async_mutex_1.Mutex();
+class WebSocketConnectionPool {
+    constructor(maxConnections = -1) {
+        this.pool = new Map();
+        this._maxConnections = maxConnections;
+        this._connectionCount = 0;
+    }
+    static instance(maxConnections = -1) {
+        if (!WebSocketConnectionPool._instance) {
+            WebSocketConnectionPool._instance = new WebSocketConnectionPool(maxConnections);
+        }
+        return WebSocketConnectionPool._instance;
+    }
+    async getConnection(url, timeout) {
+        let connectAddr = url.origin.concat(url.pathname).concat(url.search);
+        let connector;
+        const unlock = await mutex.acquire();
+        try {
+            if (this.pool.has(connectAddr)) {
+                let connectors = this.pool.get(connectAddr);
+                if (connectors) {
+                    if (connectors.length > 0) {
+                        connector = connectors.pop();
+                    }
+                }
+            }
+            if (connector) {
+                log_1.default.debug("get connection success:", this._connectionCount);
+                return connector;
+            }
+            if (this._maxConnections != -1 && this._connectionCount > this._maxConnections) {
+                throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_ARRIVED_LIMIT, "websocket connect arrived limited:" + this._connectionCount);
+            }
+            this._connectionCount++;
+            return new wsConnector_1.WebSocketConnector(url, timeout);
+        }
+        finally {
+            unlock();
+        }
+    }
+    async releaseConnection(connector) {
+        if (connector) {
+            const unlock = await mutex.acquire();
+            try {
+                if (connector.readyState() > 0) {
+                    let url = connector.getWsURL();
+                    let connectAddr = url.origin.concat(url.pathname).concat(url.search);
+                    let connectors = this.pool.get(connectAddr);
+                    if (!connectors) {
+                        connectors = new Array();
+                        connectors.push(connector);
+                        this.pool.set(connectAddr, connectors);
+                    }
+                    else {
+                        connectors.push(connector);
+                    }
+                }
+                else {
+                    this._connectionCount--;
+                    connector.close();
+                }
+            }
+            finally {
+                unlock();
+            }
+        }
+    }
+    destroyed() {
+        if (this.pool) {
+            for (let values of this.pool.values()) {
+                for (let i in values) {
+                    values.pop()?.close();
+                }
+            }
+        }
+        log_1.default.info("destroyed connect:" + this._connectionCount);
+        this._connectionCount = 0;
+        this.pool = new Map();
+    }
+}
+exports.WebSocketConnectionPool = WebSocketConnectionPool;
+process.on('exit', (code) => {
+    log_1.default.info("begin destroy connect");
+    WebSocketConnectionPool.instance().destroyed();
+    process.exit();
+});
+process.on('SIGINT', () => {
+    log_1.default.info('Received SIGINT. Press Control-D to exit, begin destroy connect...');
+    WebSocketConnectionPool.instance().destroyed();
+    process.exit();
+});
+process.on('SIGTERM', () => {
+    log_1.default.info('Received SIGINT. Press Control-D to exit, begin destroy connect');
+    WebSocketConnectionPool.instance().destroyed();
+    process.exit();
+});
+// process.kill(process.pid, 'SIGINT');

package/lib/src/client/wsEventCallback.d.ts

@@ -0,0 +1,22 @@
+interface MessageId {
+    action: string;
+    req_id: bigint;
+    id?: bigint;
+    timeout?: number;
+}
+export declare enum OnMessageType {
+    MESSAGE_TYPE_ARRAYBUFFER = 1,
+    MESSAGE_TYPE_BLOB = 2,
+    MESSAGE_TYPE_STRING = 3,
+    MESSAGE_TYPE_CONNECTION = 4
+}
+export declare class WsEventCallback {
+    private static _instance?;
+    private static _msgActionRegister;
+    private constructor();
+    static instance(): WsEventCallback;
+    registerCallback(id: MessageId, res: (args: unknown) => void, rej: (reason: any) => void): Promise<void>;
+    handleEventCallback(msg: MessageId, messageType: OnMessageType, data: any): Promise<void>;
+}
+export {};
+//# sourceMappingURL=wsEventCallback.d.ts.map