@tdengine/websocket 3.2.2 → 3.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"wsConnector.d.ts","sourceRoot":"","sources":["../../../src/client/wsConnector.ts"],"names":[],"mappings":"AAUA,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;IAuClD,KAAK;YA6BG,QAAQ;IAItB,OAAO,CAAC,UAAU;IA4BlB,KAAK;IAWL,UAAU,IAAI,MAAM;IAId,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB7C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,OAAc;IAqCjD,aAAa,CACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,EACpB,QAAQ,GAAE,OAAc;IAkCrB,QAAQ,IAAI,GAAG;CAGzB"}
+{"version":3,"file":"wsConnector.d.ts","sourceRoot":"","sources":["../../../src/client/wsConnector.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,GAAG,EAAE,MAAM,eAAe,CAAC;AA0D7C,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AA0DtD,qBAAa,WAAW;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;gBAEvB,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;IAM9E,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAOxC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,WAAW;CAexC;AAED,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAM;IAC3B,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAwC;IAC3E,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,gBAAgB,CAAoC;IAC5D,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,QAAQ,CAAS;gBAGrB,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAoB/B,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAIzC,OAAO,CAAC,QAAQ;IAahB,OAAO,CAAC,gBAAgB;IAmExB,OAAO,CAAC,UAAU;IA0BlB,OAAO,CAAC,mBAAmB;YAOb,qCAAqC;YAcrC,gBAAgB;IAkB9B,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,uBAAuB;IAIxB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IA4B5C,OAAO,CAAC,IAAI;IAcN,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB5B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,2BAA2B;YAWrB,KAAK;IAInB,OAAO,CAAC,kBAAkB;YAIZ,gBAAgB;YAkBhB,YAAY;YAkBZ,SAAS;YAUT,gBAAgB;YAsChB,cAAc;IAiB5B,OAAO,CAAC,uBAAuB;IAO/B,KAAK;IAiBL,UAAU,IAAI,MAAM;IAIb,sBAAsB,CACzB,IAAI,EAAE,mBAAmB,GAAG,SAAS,GAAG,IAAI,GAC7C,IAAI;YAIO,qBAAqB;IAOtB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAmCnD,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ7C,OAAO,CAAC,OAAO,EAAE,MAAM;IAgBvB,aAAa,CACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW;YAWV,oBAAoB;IAgF3B,UAAU,IAAI,MAAM;IAIpB,mBAAmB,IAAI,MAAM;CAGvC"}

package/lib/src/client/wsConnector.js

@@ -3,61 +3,193 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketConnector = void 0;
+exports.WebSocketConnector = exports.RetryConfig = void 0;
 const websocket_1 = require("websocket");
+const addressConnectionTracker_1 = require("../common/addressConnectionTracker");
 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), undefined, undefined, undefined, undefined, {
-                maxReceivedFrameSize: 0x60000000,
-                maxReceivedMessageSize: 0x60000000,
-            });
-            this._wsConn.onerror = function (err) {
-                log_1.default.error(`webSocket connection failed, url: ${this.url}, error: ${err.message}`);
-            };
-            this._wsConn.onclose = this._onclose;
-            this._wsConn.onmessage = this._onmessage;
-            this._wsConn._binaryType = "arraybuffer";
+const utils_1 = require("../common/utils");
+class InflightRequestStore {
+    constructor() {
+        this.nextMsgId = 1n;
+        this.reqIdToMsgId = new Map();
+        this.msgIdToRequest = new Map();
+    }
+    insert(req) {
+        const msgId = this.nextMsgId;
+        this.nextMsgId += 1n;
+        this.reqIdToMsgId.set(req.reqId, msgId);
+        this.msgIdToRequest.set(msgId, req);
+    }
+    remove(reqId) {
+        const msgId = this.reqIdToMsgId.get(reqId);
+        if (msgId === undefined) {
+            return;
         }
-        else {
+        this.reqIdToMsgId.delete(reqId);
+        this.msgIdToRequest.delete(msgId);
+    }
+    getRequests() {
+        return Array.from(this.msgIdToRequest.entries())
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([, req]) => req);
+    }
+    clear() {
+        this.nextMsgId = 1n;
+        this.reqIdToMsgId.clear();
+        this.msgIdToRequest.clear();
+    }
+}
+const RETRIABLE_ACTIONS = new Set(["insert", "options_connection", "poll", "subscribe"]);
+// TDengine websocket binary op codes that are safe to replay after reconnect.
+const BINARY_RETRIABLE_ACTIONS = new Set([4n, 5n, 6n, 10n]);
+const DEFAULT_RETRIES = 5;
+const DEFAULT_BACKOFF_MS = 200;
+const DEFAULT_BACKOFF_MAX_MS = 2000;
+const NETWORK_ERROR_CODES = new Set([
+    "econnreset",
+    "econnrefused",
+    "ehostunreach",
+    "enotfound",
+    "eai_again",
+    "epipe",
+    "etimedout",
+    "err_socket_closed",
+    "err_stream_write_after_end",
+]);
+const NETWORK_ERROR_MESSAGE_PATTERNS = [
+    "not connected",
+    "socket",
+    "network",
+    "econnreset",
+    "econnrefused",
+    "epipe",
+    "etimedout",
+    "write after end",
+    "broken pipe",
+    "connection reset",
+    "connection closed",
+];
+function parseNonNegativeInt(value, fallback) {
+    return parseIntWithValidation(value, fallback, (parsed) => parsed >= 0);
+}
+function parsePositiveInt(value, fallback) {
+    return parseIntWithValidation(value, fallback, (parsed) => parsed > 0);
+}
+function parseIntWithValidation(value, fallback, isValid) {
+    if (value === undefined || value === null || value.length === 0) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed) || !isValid(parsed)) {
+        return fallback;
+    }
+    return parsed;
+}
+class RetryConfig {
+    constructor(retries, retryBackoffMs, retryBackoffMaxMs) {
+        this.retries = retries;
+        this.retryBackoffMs = retryBackoffMs;
+        this.retryBackoffMaxMs = Math.max(retryBackoffMs, retryBackoffMaxMs);
+    }
+    getBackoffDelay(attempt) {
+        const safeAttempt = Math.max(0, attempt);
+        const rawDelay = this.retryBackoffMs * Math.pow(2, safeAttempt);
+        const finiteDelay = Number.isFinite(rawDelay) ? rawDelay : this.retryBackoffMaxMs;
+        return Math.min(finiteDelay, this.retryBackoffMaxMs);
+    }
+    static fromDsn(dsn) {
+        const retries = parseNonNegativeInt(dsn.params.get("retries"), DEFAULT_RETRIES);
+        const retryBackoffMs = parsePositiveInt(dsn.params.get("retry_backoff_ms"), DEFAULT_BACKOFF_MS);
+        const retryBackoffMaxMs = parsePositiveInt(dsn.params.get("retry_backoff_max_ms"), DEFAULT_BACKOFF_MAX_MS);
+        return new RetryConfig(retries, retryBackoffMs, retryBackoffMaxMs);
+    }
+}
+exports.RetryConfig = RetryConfig;
+class WebSocketConnector {
+    constructor(dsn, poolKey, timeout) {
+        this._suppressedSockets = new WeakSet();
+        this._reconnectLock = null;
+        this._isReconnecting = false;
+        this._allowReconnect = true;
+        this._connectionReady = Promise.resolve();
+        this._sessionRecoveryHook = null;
+        this._timeout = 60000;
+        if (!dsn || dsn.addresses.length === 0) {
             throw new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_INVALID_URL, "websocket URL must be defined");
         }
+        this._poolKey = poolKey;
+        this._dsn = dsn;
+        this._currentAddress = this.selectLeastConnectedAddress();
+        this._retryConfig = RetryConfig.fromDsn(dsn);
+        this._inflightStore = new InflightRequestStore();
+        if (timeout) {
+            this._timeout = timeout;
+        }
+        log_1.default.info(`Initial websocket address selected: ${this.getCurrentAddress()}`);
+        this.createConnection();
     }
-    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 = () => {
+    refreshRetryConfig(dsn) {
+        this._retryConfig = RetryConfig.fromDsn(dsn);
+    }
+    buildUrl(addr) {
+        const path = this._dsn.path();
+        const url = new URL(`${this._dsn.scheme}://${addr.host}:${addr.port}/${path}`);
+        const forwardedParams = ["token", "bearer_token"];
+        for (const key of forwardedParams) {
+            const value = this._dsn.params.get(key);
+            if (value !== undefined) {
+                url.searchParams.set(key, value);
+            }
+        }
+        return url.toString();
+    }
+    createConnection() {
+        const conn = new websocket_1.w3cwebsocket(this.buildUrl(this._currentAddress), undefined, undefined, undefined, undefined, {
+            maxReceivedFrameSize: 0x60000000,
+            maxReceivedMessageSize: 0x60000000,
+        });
+        conn._binaryType = "arraybuffer";
+        conn.onmessage = this._onmessage;
+        this._connectionReady = new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (handler) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeoutId);
+                handler();
+            };
+            const timeoutId = setTimeout(() => {
+                settle(() => {
+                    reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_QUERY_TIMEOUT, `websocket connection timeout with ${this._timeout} milliseconds`));
+                });
+            }, this._timeout);
+            conn.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);
+                addressConnectionTracker_1.AddressConnectionTracker.instance().increment(this.getCurrentAddress());
+                settle(resolve);
+            };
+            conn.onerror = (err) => {
+                log_1.default.error(`webSocket connection failed, url: ${(0, utils_1.maskUrlForLog)(new URL(conn.url))}, error: ${err.message}`);
+                if (conn.readyState !== websocket_1.w3cwebsocket.OPEN) {
+                    settle(() => reject(err));
+                }
+                void this.handleDisconnect(conn);
+            };
+            conn.onclose = (e) => {
+                log_1.default.info(`websocket connection closed, code: ${e.code}, reason: ${e.reason}`);
+                if (conn.readyState !== websocket_1.w3cwebsocket.OPEN) {
+                    settle(() => {
+                        reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `websocket connection closed: ${e.code} ${e.reason}`));
+                    });
+                }
+                void this.handleDisconnect(conn, e);
             };
         });
-    }
-    async _onclose(e) {
-        log_1.default.info("websocket connection closed");
+        this._conn = conn;
     }
     _onmessage(event) {
         let data = event.data;
@@ -75,83 +207,371 @@ class WebSocketConnector {
             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();
+    shouldSkipReconnect(conn) {
+        if (!this.isReconnectAllowed()) {
+            return true;
         }
-        else {
-            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, "WebSocket connection is undefined.");
+        return this._suppressedSockets.has(conn);
+    }
+    async failNonRetriableCallbacksOnDisconnect() {
+        const keepReqIds = new Set(this._inflightStore.getRequests().map((req) => req.reqId));
+        await wsEventCallback_1.WsEventCallback.instance().rejectCallbacksExceptReqIds(keepReqIds, new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "websocket connection closed before response was received"), this._poolKey);
+    }
+    async handleDisconnect(conn, event) {
+        if (this.shouldSkipReconnect(conn) || this._isReconnecting) {
+            return;
+        }
+        if (event && event.code === 1000) {
+            log_1.default.info("Websocket closed normally, skipping reconnect.");
+            return;
+        }
+        await this.failNonRetriableCallbacksOnDisconnect();
+        try {
+            await this.triggerReconnect();
+        }
+        catch (err) {
+            const type = event ? 'close' : 'error';
+            const message = err instanceof Error ? err.message : String(err);
+            log_1.default.error(`Reconnect failed after websocket ${type}: ${message}`);
         }
     }
-    readyState() {
-        return this._wsConn.readyState;
+    extractReqId(reqId) {
+        if (reqId === undefined || reqId === null) {
+            return null;
+        }
+        try {
+            return BigInt(reqId);
+        }
+        catch (err) {
+            return null;
+        }
     }
-    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);
+    isRetriableAction(action) {
+        return RETRIABLE_ACTIONS.has(action);
+    }
+    extractBinaryAction(message) {
+        if (message.byteLength < 24) {
+            return -1n;
         }
-        return new Promise((resolve, reject) => {
-            if (this._wsConn && this._wsConn.readyState === websocket_1.w3cwebsocket.OPEN) {
-                this._wsConn.send(message);
-                resolve();
+        return new DataView(message, 16, 8).getBigInt64(0, true);
+    }
+    isRetriableBinaryAction(action) {
+        return BINARY_RETRIABLE_ACTIONS.has(action);
+    }
+    isNetworkError(err) {
+        if (!this._conn || this._conn.readyState !== websocket_1.w3cwebsocket.OPEN) {
+            return true;
+        }
+        const errObj = err;
+        const code = errObj?.code;
+        if (typeof code === "number" && code === wsError_1.ErrorCode.ERR_CONNECTION_CLOSED) {
+            return true;
+        }
+        if (typeof code === "string") {
+            const loweredCode = code.toLowerCase();
+            if (loweredCode.length > 0 && NETWORK_ERROR_CODES.has(loweredCode)) {
+                return true;
+            }
+        }
+        const message = err instanceof Error
+            ? err.message
+            : typeof errObj?.message === "string"
+                ? errObj.message
+                : String(err);
+        const lowered = message.toLowerCase();
+        return NETWORK_ERROR_MESSAGE_PATTERNS.some((pattern) => lowered.includes(pattern));
+    }
+    send(message, triggerReconnect = true) {
+        try {
+            this._conn.send(message);
+        }
+        catch (err) {
+            if (triggerReconnect && this.isNetworkError(err)) {
+                void this.triggerReconnect().catch((err) => {
+                    const message = err instanceof Error ? err.message : String(err);
+                    log_1.default.error(`Reconnect trigger failed: ${message}`);
+                });
             }
-            else {
-                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready,status :${this._wsConn?.readyState}`));
+            throw err;
+        }
+    }
+    async ready() {
+        if (this._conn && this._conn.readyState === websocket_1.w3cwebsocket.OPEN) {
+            return;
+        }
+        if (this._reconnectLock) {
+            await this._reconnectLock;
+            return;
+        }
+        try {
+            await this._connectionReady;
+        }
+        catch (err) {
+            if (this._reconnectLock) {
+                await this._reconnectLock;
+                return;
             }
+            throw err;
+        }
+    }
+    getCurrentAddress() {
+        return `${this._currentAddress.host}:${this._currentAddress.port}`;
+    }
+    selectLeastConnectedAddress(excludedAddresses = new Set()) {
+        const candidates = this._dsn.addresses.filter((address) => {
+            const addressKey = `${address.host}:${address.port}`;
+            return !excludedAddresses.has(addressKey);
         });
+        const selectableAddresses = candidates.length > 0 ? candidates : this._dsn.addresses;
+        const selectedIndex = addressConnectionTracker_1.AddressConnectionTracker.instance()
+            .selectLeastConnected(selectableAddresses);
+        return selectableAddresses[selectedIndex];
+    }
+    async sleep(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
     }
-    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);
+    isReconnectAllowed() {
+        return this._allowReconnect;
+    }
+    async triggerReconnect() {
+        if (!this.isReconnectAllowed()) {
+            return;
         }
-        return new Promise((resolve, reject) => {
-            if (this._wsConn && this._wsConn.readyState === websocket_1.w3cwebsocket.OPEN) {
-                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);
+        if (!this._reconnectLock) {
+            this._reconnectLock = this._doReconnect();
+        }
+        const lock = this._reconnectLock;
+        try {
+            await lock;
+        }
+        finally {
+            if (this._reconnectLock === lock) {
+                this._reconnectLock = null;
+            }
+        }
+    }
+    async _doReconnect() {
+        if (!this.isReconnectAllowed()) {
+            return;
+        }
+        this._isReconnecting = true;
+        try {
+            await this.attemptReconnect();
+        }
+        catch (err) {
+            const reconnectError = err instanceof Error
+                ? err
+                : new Error("unknown reconnect error");
+            this.failAllInflightRequests(reconnectError);
+            throw reconnectError;
+        }
+        finally {
+            this._isReconnecting = false;
+        }
+    }
+    async reconnect() {
+        if (this._conn) {
+            addressConnectionTracker_1.AddressConnectionTracker.instance().decrement(this.getCurrentAddress());
+            this._suppressedSockets.add(this._conn);
+            this._conn.close();
+        }
+        this.createConnection();
+        await this._connectionReady;
+    }
+    async attemptReconnect() {
+        const totalAddresses = this._dsn.addresses.length;
+        const failedAddresses = new Set();
+        for (let i = 0; i < totalAddresses; i++) {
+            for (let retry = 0; retry < this._retryConfig.retries; retry++) {
+                if (!this.isReconnectAllowed()) {
+                    return;
+                }
+                try {
+                    log_1.default.info(`Reconnecting to ${this.getCurrentAddress()}, attempt ${retry + 1}`);
+                    await this.reconnect();
+                    await this.recoverSessionContext();
+                    await this.replayRequests();
+                    log_1.default.info(`Reconnection successful to ${this.getCurrentAddress()}`);
+                    return;
+                }
+                catch (err) {
+                    log_1.default.warn(`Reconnect failed: ${err.message}`);
+                    if (retry < this._retryConfig.retries - 1) {
+                        const delay = this._retryConfig.getBackoffDelay(retry);
+                        await this.sleep(delay);
+                    }
                 }
-                log_1.default.debug(`[wsClient.sendMessage.msg]===> ${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}`));
+            if (i < totalAddresses - 1) {
+                failedAddresses.add(this.getCurrentAddress());
+                this._currentAddress = this.selectLeastConnectedAddress(failedAddresses);
+                log_1.default.info(`Switching to least-connected address: ${this.getCurrentAddress()}`);
+            }
+        }
+        throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, "Failed to reconnect to any available address");
+    }
+    async replayRequests() {
+        log_1.default.info("Replaying requests after reconnection");
+        for (const req of this._inflightStore.getRequests()) {
+            try {
+                this.send(req.message, false);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (this.isNetworkError(err)) {
+                    log_1.default.warn(`Network error while replaying inflight request, stopping current replay round: ${message}`);
+                    throw err;
+                }
+                log_1.default.error(`Failed to replay inflight request: ${req}, error: ${message}`);
+                req.reject(err);
             }
+        }
+    }
+    failAllInflightRequests(error) {
+        for (const req of this._inflightStore.getRequests()) {
+            req.reject(error);
+        }
+        this._inflightStore.clear();
+    }
+    close() {
+        this._allowReconnect = false;
+        this.failAllInflightRequests(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "websocket connection closed"));
+        if (this._conn) {
+            addressConnectionTracker_1.AddressConnectionTracker.instance().decrement(this.getCurrentAddress());
+            this._suppressedSockets.add(this._conn);
+            this._conn.close();
+        }
+        else {
+            log_1.default.warn("close() called but websocket connection is undefined");
+        }
+    }
+    readyState() {
+        return this._conn.readyState;
+    }
+    setSessionRecoveryHook(hook) {
+        this._sessionRecoveryHook = hook || null;
+    }
+    async recoverSessionContext() {
+        if (!this._sessionRecoveryHook) {
+            return;
+        }
+        await this._sessionRecoveryHook();
+    }
+    async sendMsgDirect(message) {
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsClient.sendMsgDirect]===>" + (0, utils_1.maskSensitiveForLog)(message));
+        }
+        const msg = JSON.parse(message);
+        const reqId = this.extractReqId(msg?.args?.req_id) ?? BigInt(0);
+        let resolveResp = () => { };
+        let rejectResp = () => { };
+        const responsePromise = new Promise((resolve, reject) => {
+            resolveResp = resolve;
+            rejectResp = reject;
         });
+        await wsEventCallback_1.WsEventCallback.instance().registerCallback({
+            action: msg.action,
+            req_id: reqId,
+            timeout: this._timeout,
+            poolKey: this._poolKey,
+        }, resolveResp, rejectResp);
+        try {
+            this.send(message, false);
+            return await responsePromise;
+        }
+        catch (err) {
+            await wsEventCallback_1.WsEventCallback.instance().unregisterCallback(reqId);
+            throw err;
+        }
+    }
+    async sendMsgNoResp(message) {
+        log_1.default.debug("[wsClient.sendMsgNoResp]===>" + message);
+        if (this._reconnectLock) {
+            await this._reconnectLock;
+        }
+        this.send(message);
+    }
+    async sendMsg(message) {
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsConnector.sendMsg]===>" + (0, utils_1.maskSensitiveForLog)(message));
+        }
+        const msg = JSON.parse(message);
+        const id = msg?.args?.id !== undefined ? BigInt(msg.args.id) : undefined;
+        const reqId = this.extractReqId(msg?.args?.req_id) ?? BigInt(0);
+        return this.sendAndTrackResponse(reqId, msg.action, message, this.isRetriableAction(msg.action), id);
+    }
+    async sendBinaryMsg(reqId, action, message) {
+        return this.sendAndTrackResponse(reqId, action, message, this.isRetriableBinaryAction(this.extractBinaryAction(message)), reqId);
     }
-    async sendBinaryMsg(reqId, action, message, register = true) {
+    async sendAndTrackResponse(reqId, action, message, retriable, callbackId) {
+        if (this._reconnectLock) {
+            await this._reconnectLock;
+        }
         return new Promise((resolve, reject) => {
-            if (this._wsConn && this._wsConn.readyState === websocket_1.w3cwebsocket.OPEN) {
-                if (register) {
-                    wsEventCallback_1.WsEventCallback.instance().registerCallback({
-                        action: action,
-                        req_id: reqId,
-                        timeout: this._timeout,
-                        id: reqId,
-                    }, resolve, reject);
+            let settled = false;
+            const safeResolve = (result) => {
+                if (settled) {
+                    return;
                 }
-                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}`));
-            }
+                settled = true;
+                if (retriable) {
+                    this._inflightStore.remove(reqId);
+                }
+                resolve(result);
+            };
+            const safeReject = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (retriable) {
+                    this._inflightStore.remove(reqId);
+                }
+                void wsEventCallback_1.WsEventCallback.instance().unregisterCallback(reqId);
+                reject(error);
+            };
+            const registerAndSend = async () => {
+                if (retriable) {
+                    this._inflightStore.insert({
+                        reqId,
+                        action,
+                        id: callbackId,
+                        message,
+                        resolve: safeResolve,
+                        reject: safeReject,
+                    });
+                }
+                await wsEventCallback_1.WsEventCallback.instance().registerCallback({
+                    action,
+                    req_id: reqId,
+                    timeout: this._timeout,
+                    id: callbackId,
+                    poolKey: this._poolKey,
+                }, safeResolve, safeReject);
+                if (settled) {
+                    await wsEventCallback_1.WsEventCallback.instance().unregisterCallback(reqId);
+                    return;
+                }
+                try {
+                    this.send(message);
+                }
+                catch (err) {
+                    if (retriable && this.isNetworkError(err)) {
+                        return;
+                    }
+                    safeReject(err);
+                }
+            };
+            void registerAndSend().catch((error) => {
+                safeReject(error);
+            });
         });
     }
-    getWsURL() {
-        return this._wsURL;
+    getPoolKey() {
+        return this._poolKey;
+    }
+    getReconnectRetries() {
+        return this._retryConfig.retries;
     }
 }
 exports.WebSocketConnector = WebSocketConnector;