@tdengine/websocket 3.2.2 → 3.3.0

package/lib/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "@tdengine/websocket",
+    "version": "3.3.0",
+    "description": "The websocket Node.js connector for TDengine. TDengine versions 3.3.2.0 and above are recommended to use this connector.",
+    "source": "index.ts",
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "directories": {
+        "example": "example",
+        "test": "test"
+    },
+    "scripts": {
+        "test": "jest --coverage --coverageDirectory=../coverage",
+        "example": "tsc && node lib/example/basicSql.js",
+        "build": "tsc",
+        "prepublish": "node ./prepare.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/taosdata/taos-connector-node.git"
+    },
+    "keywords": [
+        "taosdata",
+        "taos",
+        "IOT",
+        "TypeScript",
+        "TDengine",
+        "database"
+    ],
+    "author": "TaosData Inc.",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/taosdata/taos-connector-node/issues"
+    },
+    "files": [
+        "lib"
+    ],
+    "homepage": "https://github.com/taosdata/taos-connector-node#readme",
+    "dependencies": {
+        "async-mutex": "^0.5.0",
+        "json-bigint": "^1.0.0",
+        "moment-timezone": "^0.5.45",
+        "typescript": "^5.3.3",
+        "uuid": "^9.0.1",
+        "websocket": "^1.0.34",
+        "winston": "^3.17.0",
+        "winston-daily-rotate-file": "^5.0.0"
+    },
+    "devDependencies": {
+        "@parcel/packager-ts": "^2.7.0",
+        "@parcel/transformer-typescript-types": "^2.7.0",
+        "@types/jest": "^29.2.1",
+        "@types/json-bigint": "^1.0.1",
+        "@types/node": "^18.0.0",
+        "@types/uuid": "^9.0.8",
+        "@types/websocket": "^1.0",
+        "jest": "^29.7.0",
+        "parcel": "^2.7.0",
+        "qingwa": "^1.0.7",
+        "ts-jest": "^29.0.3",
+        "typescript": "^5.3.3"
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Dsn } from "../common/dsn";
+export declare class RetryConfig {
+    readonly retries: number;
+    readonly retryBackoffMs: number;
+    readonly retryBackoffMaxMs: number;
+    constructor(retries: number, retryBackoffMs: number, retryBackoffMaxMs: number);
+    getBackoffDelay(attempt: number): number;
+    static fromDsn(dsn: Dsn): RetryConfig;
+}
+//# sourceMappingURL=retryConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retryConfig.d.ts","sourceRoot":"","sources":["../../../src/client/retryConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAkCpC,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"}

package/lib/src/client/retryConfig.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryConfig = void 0;
+const DEFAULT_RETRIES = 3;
+const DEFAULT_BACKOFF_MS = 100;
+const DEFAULT_BACKOFF_MAX_MS = 10000;
+function parseNonNegativeInt(value, fallback) {
+    if (value === undefined || value === null || value.length === 0) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || Number.isNaN(parsed) || parsed < 0) {
+        return fallback;
+    }
+    return parsed;
+}
+function parsePositiveInt(value, fallback) {
+    if (value === undefined || value === null || value.length === 0) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || Number.isNaN(parsed) || parsed <= 0) {
+        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;

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

@@ -1,25 +1,42 @@
+import type { SessionRecoveryHook } from "./wsConnector";
+import { Dsn } from "../common/dsn";
 import { WSQueryResponse } from "./wsResponse";
 import { TSDB_OPTION_CONNECTION } from "../common/constant";
 export declare class WsClient {
     private _wsConnector?;
     private _timeout?;
     private _timezone?;
-    private readonly _url;
+    private readonly _dsn;
     private static readonly _minVersion;
     private _version?;
-    constructor(url: URL, timeout?: number | undefined | null);
+    private _bearerToken?;
+    private _connectedDatabase;
+    private _connectionOptions;
+    private _customRecoveryHook;
+    constructor(dsn: Dsn, timeout?: number | undefined | null);
+    private buildConnMessage;
+    private getWsConnector;
+    private bindReconnectRecoveryHook;
+    private isSqlPath;
+    private normalizeConnectedDatabase;
+    private recoverSqlSessionContext;
+    setSessionRecoveryHook(hook: SessionRecoveryHook | null | undefined): void;
     connect(database?: string | undefined | null): Promise<void>;
     setOptionConnection(option: TSDB_OPTION_CONNECTION, value: string | null): Promise<void>;
-    execNoResp(queryMsg: string): Promise<void>;
-    exec(queryMsg: string, bSqlQuery?: boolean): Promise<any>;
+    execNoResp(message: string): Promise<void>;
+    exec(message: string, bSqlQuery?: boolean): Promise<any>;
+    sendMsgDirect(message: string, bSqlQuery?: boolean): Promise<any>;
     sendBinaryMsg(reqId: bigint, action: string, message: ArrayBuffer, bSqlQuery?: boolean, bResultBinary?: boolean): Promise<any>;
     getState(): number;
     ready(): Promise<void>;
-    sendMsg(msg: string): Promise<any>;
-    freeResult(res: WSQueryResponse): Promise<unknown>;
+    waitForReady(): Promise<void>;
+    isNetworkError(err: unknown): boolean;
+    getReconnectRetries(): number;
+    sendMsg(message: string): Promise<any>;
+    freeResult(res: WSQueryResponse): Promise<void>;
     version(): Promise<string>;
     close(): Promise<void>;
-    checkURL(url: URL): void;
+    private checkAuth;
     checkVersion(): Promise<void>;
 }
 //# sourceMappingURL=wsClient.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wsClient.d.ts","sourceRoot":"","sources":["../../../src/client/wsClient.ts"],"names":[],"mappings":"AASA,OAAO,EAAqB,eAAe,EAAE,MAAM,cAAc,CAAC;AAKlE,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,qBAAa,QAAQ;IACjB,OAAO,CAAC,YAAY,CAAC,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,CAA4B;IAC7C,OAAO,CAAC,SAAS,CAAC,CAA4B;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAM;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAa;IAChD,OAAO,CAAC,QAAQ,CAAC,CAA4B;gBAEjC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAWnD,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA4C5D,mBAAmB,CACrB,MAAM,EAAE,sBAAsB,EAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,IAAI,CAAC;IAyBV,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3C,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,OAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAwC/D,aAAa,CACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,EACpB,SAAS,GAAE,OAAc,EACzB,aAAa,GAAE,OAAe,GAC/B,OAAO,CAAC,GAAG,CAAC;IA0Cf,QAAQ;IAOF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BtB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAwBlC,UAAU,CAAC,GAAG,EAAE,eAAe;IAkC/B,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAwC1B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,QAAQ,CAAC,GAAG,EAAE,GAAG;IAYX,YAAY;CAarB"}
+{"version":3,"file":"wsClient.d.ts","sourceRoot":"","sources":["../../../src/client/wsClient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAAE,GAAG,EAAmB,MAAM,eAAe,CAAC;AAOrD,OAAO,EAAqB,eAAe,EAAE,MAAM,cAAc,CAAC;AASlE,OAAO,EAEH,sBAAsB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,qBAAa,QAAQ;IACjB,OAAO,CAAC,YAAY,CAAC,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,CAA4B;IAC7C,OAAO,CAAC,SAAS,CAAC,CAA4B;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAM;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAa;IAChD,OAAO,CAAC,QAAQ,CAAC,CAA4B;IAC7C,OAAO,CAAC,YAAY,CAAC,CAA4B;IACjD,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,kBAAkB,CAAyD;IACnF,OAAO,CAAC,mBAAmB,CAAoC;gBAEnD,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAYzD,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,yBAAyB;IAejC,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,0BAA0B;YAOpB,wBAAwB;IA6B/B,sBAAsB,CACzB,IAAI,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,GAC7C,IAAI;IAKD,OAAO,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAmC5D,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBxF,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK1C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,OAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAmB9D,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,OAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAmBvE,aAAa,CACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,EACpB,SAAS,GAAE,OAAc,EACzB,aAAa,GAAE,OAAe,GAC/B,OAAO,CAAC,GAAG,CAAC;IAmBf,QAAQ;IAOF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BtB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAIrC,mBAAmB,IAAI,MAAM;IAIvB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAKtC,UAAU,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAa/C,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAiC1B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B,OAAO,CAAC,SAAS;IAYX,YAAY;CAarB"}

package/lib/src/client/wsClient.js

@@ -6,44 +6,113 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WsClient = void 0;
 const json_bigint_1 = __importDefault(require("json-bigint"));
 const wsConnectorPool_1 = require("./wsConnectorPool");
+const dsn_1 = require("../common/dsn");
 const wsError_1 = require("../common/wsError");
 const wsResponse_1 = require("./wsResponse");
 const reqid_1 = require("../common/reqid");
 const log_1 = __importDefault(require("../common/log"));
 const utils_1 = require("../common/utils");
 const websocket_1 = require("websocket");
+const constant_1 = require("../common/constant");
 class WsClient {
-    constructor(url, timeout) {
-        this.checkURL(url);
-        this._url = url;
+    constructor(dsn, timeout) {
+        this._connectedDatabase = null;
+        this._connectionOptions = new Map();
+        this._customRecoveryHook = null;
+        this.checkAuth(dsn);
+        this._dsn = dsn;
         this._timeout = timeout;
-        if (this._url.searchParams.has("timezone")) {
-            this._timezone =
-                this._url.searchParams.get("timezone") || undefined;
-            this._url.searchParams.delete("timezone");
+        if (this._dsn.params.has("timezone")) {
+            this._timezone = this._dsn.params.get("timezone") || undefined;
+        }
+        if (this._dsn.params.has("bearer_token")) {
+            this._bearerToken = this._dsn.params.get("bearer_token") || undefined;
         }
     }
-    async connect(database) {
-        let connMsg = {
+    buildConnMessage(database) {
+        return {
             action: "conn",
             args: {
                 req_id: reqid_1.ReqId.getReqID(),
-                user: (0, utils_1.safeDecodeURIComponent)(this._url.username),
-                password: (0, utils_1.safeDecodeURIComponent)(this._url.password),
+                user: (0, utils_1.safeDecodeURIComponent)(this._dsn.username),
+                password: (0, utils_1.safeDecodeURIComponent)(this._dsn.password),
                 db: database,
+                connector: constant_1.ConnectorInfo,
                 ...(this._timezone && { tz: this._timezone }),
+                ...(this._bearerToken && { bearer_token: this._bearerToken }),
+            },
+        };
+    }
+    getWsConnector() {
+        if (!this._wsConnector) {
+            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "Invalid websocket connection");
+        }
+        return this._wsConnector;
+    }
+    bindReconnectRecoveryHook() {
+        if (!this._wsConnector) {
+            return;
+        }
+        this._wsConnector.setSessionRecoveryHook(async () => {
+            if (this.isSqlPath()) {
+                await this.recoverSqlSessionContext();
+            }
+            if (this._customRecoveryHook) {
+                await this._customRecoveryHook();
+            }
+        });
+    }
+    isSqlPath() {
+        return this._dsn.endpoint === dsn_1.WS_SQL_ENDPOINT;
+    }
+    normalizeConnectedDatabase(database) {
+        if (database && database.length > 0) {
+            return database;
+        }
+        return this.isSqlPath() ? "information_schema" : null;
+    }
+    async recoverSqlSessionContext() {
+        if (!this._wsConnector) {
+            return;
+        }
+        const connMsg = this.buildConnMessage(this.normalizeConnectedDatabase(this._connectedDatabase));
+        await this.sendMsgDirect(JSON.stringify(connMsg), false);
+        if (this._connectionOptions.size <= 0) {
+            return;
+        }
+        const options = Array.from(this._connectionOptions.entries()).map(([option, value]) => ({
+            option,
+            value,
+        }));
+        const optionsMsg = {
+            action: "options_connection",
+            args: {
+                req_id: reqid_1.ReqId.getReqID(),
+                options,
             },
         };
-        log_1.default.debug("[wsClient.connect.connMsg]===>" + json_bigint_1.default.stringify(connMsg));
-        this._wsConnector =
-            await wsConnectorPool_1.WebSocketConnectionPool.instance().getConnection(this._url, this._timeout);
+        await this.sendMsgDirect(json_bigint_1.default.stringify(optionsMsg), false);
+    }
+    setSessionRecoveryHook(hook) {
+        this._customRecoveryHook = hook || null;
+        this.bindReconnectRecoveryHook();
+    }
+    async connect(database) {
+        const connMsg = this.buildConnMessage(database);
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsClient.connect.connMsg]===>" + json_bigint_1.default.stringify(connMsg, (key, value) => (key === "password" || key === "bearer_token") ? "[REDACTED]" : value));
+        }
+        this._wsConnector = await wsConnectorPool_1.WebSocketConnectionPool.instance().getConnection(this._dsn, this._timeout);
+        this.bindReconnectRecoveryHook();
         if (this._wsConnector.readyState() === websocket_1.w3cwebsocket.OPEN) {
+            this._connectedDatabase = this.normalizeConnectedDatabase(database ?? null);
             return;
         }
         try {
             await this._wsConnector.ready();
             let result = await this._wsConnector.sendMsg(JSON.stringify(connMsg));
             if (result.msg.code == 0) {
+                this._connectedDatabase = this.normalizeConnectedDatabase(database ?? null);
                 return;
             }
             await this.close();
@@ -51,8 +120,8 @@ class WsClient {
         }
         catch (e) {
             await this.close();
-            log_1.default.error(`connection creation failed, url: ${this._url}, code:${e.code}, msg:${e.message}`);
-            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._url}, code:${e.code}, msg:${e.message}`);
+            log_1.default.error(`connection creation failed, dsn:${this._dsn}, code:${e.code}, msg:${e.message}`);
+            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, dsn:${this._dsn}, code:${e.code}, msg:${e.message}`);
         }
     }
     async setOptionConnection(option, value) {
@@ -71,82 +140,55 @@ class WsClient {
         };
         try {
             await this.exec(json_bigint_1.default.stringify(connMsg), false);
+            this._connectionOptions.set(option, value);
         }
         catch (e) {
             log_1.default.error("[wsClient.setOptionConnection] failed: " + e.message);
             throw e;
         }
     }
-    async execNoResp(queryMsg) {
-        log_1.default.debug("[wsQueryInterface.query.queryMsg]===>" + queryMsg);
-        if (this._wsConnector &&
-            this._wsConnector.readyState() === websocket_1.w3cwebsocket.OPEN) {
-            await this._wsConnector.sendMsgNoResp(queryMsg);
-            return;
-        }
-        throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect");
+    async execNoResp(message) {
+        log_1.default.debug("[wsClient.execNoResp]===>" + message);
+        await this.getWsConnector().sendMsgNoResp(message);
     }
-    // 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() === websocket_1.w3cwebsocket.OPEN) {
-                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);
-                });
+    async exec(message, bSqlQuery = true) {
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsClient.exec]===>" + (0, utils_1.maskSensitiveForLog)(message));
+        }
+        const resp = await this.getWsConnector().sendMsg(message);
+        if (resp.msg.code == 0) {
+            if (bSqlQuery) {
+                return new wsResponse_1.WSQueryResponse(resp);
             }
-            else {
-                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
+            return resp;
+        }
+        throw new wsError_1.WebSocketInterfaceError(resp.msg.code, resp.msg.message);
+    }
+    async sendMsgDirect(message, bSqlQuery = true) {
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsClient.sendMsgDirect]===>" + (0, utils_1.maskSensitiveForLog)(message));
+        }
+        const resp = await this.getWsConnector().sendMsgDirect(message);
+        if (resp.msg.code == 0) {
+            if (bSqlQuery) {
+                return new wsResponse_1.WSQueryResponse(resp);
             }
-        });
+            return resp;
+        }
+        throw new wsError_1.WebSocketQueryError(resp.msg.code, resp.msg.message);
     }
-    // need to construct Response.
     async sendBinaryMsg(reqId, action, message, bSqlQuery = true, bResultBinary = false) {
-        return new Promise((resolve, reject) => {
-            if (this._wsConnector &&
-                this._wsConnector.readyState() === websocket_1.w3cwebsocket.OPEN) {
-                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"));
+        const resp = await this.getWsConnector().sendBinaryMsg(reqId, action, message);
+        if (bResultBinary) {
+            return resp;
+        }
+        if (resp.msg.code == 0) {
+            if (bSqlQuery) {
+                return new wsResponse_1.WSQueryResponse(resp);
             }
-        });
+            return resp;
+        }
+        throw new wsError_1.WebSocketInterfaceError(resp.msg.code, resp.msg.message);
     }
     getState() {
         if (this._wsConnector) {
@@ -156,60 +198,45 @@ class WsClient {
     }
     async ready() {
         try {
-            this._wsConnector =
-                await wsConnectorPool_1.WebSocketConnectionPool.instance().getConnection(this._url, this._timeout);
+            this._wsConnector = await wsConnectorPool_1.WebSocketConnectionPool.instance().getConnection(this._dsn, this._timeout);
+            this.bindReconnectRecoveryHook();
             if (this._wsConnector.readyState() !== websocket_1.w3cwebsocket.OPEN) {
                 await this._wsConnector.ready();
             }
-            log_1.default.debug("ready status ", this._url, this._wsConnector.readyState());
+            if (log_1.default.isDebugEnabled()) {
+                log_1.default.debug(`ready status, dsn: ${this._dsn}, state: ${this._wsConnector.readyState()}`);
+            }
             return;
         }
         catch (e) {
-            log_1.default.error(`connection creation failed, url: ${this._url}, code: ${e.code}, message: ${e.message}`);
-            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._url}, code: ${e.code}, message: ${e.message}`);
+            log_1.default.error(`connection creation failed, dsn: ${this._dsn}, code: ${e.code}, message: ${e.message}`);
+            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, dsn: ${this._dsn}, code: ${e.code}, message: ${e.message}`);
         }
     }
-    async sendMsg(msg) {
-        return new Promise((resolve, reject) => {
-            log_1.default.debug("[wsQueryInterface.sendMsg]===>" + msg);
-            if (this._wsConnector &&
-                this._wsConnector.readyState() === websocket_1.w3cwebsocket.OPEN) {
-                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 waitForReady() {
+        await this.getWsConnector().ready();
+    }
+    isNetworkError(err) {
+        return this.getWsConnector().isNetworkError(err);
+    }
+    getReconnectRetries() {
+        return this.getWsConnector().getReconnectRetries();
+    }
+    async sendMsg(message) {
+        log_1.default.debug("[wsClient.sendMsg]===>" + message);
+        return this.getWsConnector().sendMsg(message);
     }
     async freeResult(res) {
-        let freeResultMsg = {
+        const 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() === websocket_1.w3cwebsocket.OPEN) {
-                this._wsConnector
-                    .sendMsgNoResp(jsonStr)
-                    .then((e) => {
-                    resolve(e);
-                })
-                    .catch((e) => reject(e));
-            }
-            else {
-                reject(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect"));
-            }
-        });
+        const jsonStr = json_bigint_1.default.stringify(freeResultMsg);
+        log_1.default.debug("[wsClient.freeResult]===>" + jsonStr);
+        await this.getWsConnector().sendMsgNoResp(jsonStr);
     }
     async version() {
         if (this._version) {
@@ -221,35 +248,35 @@ class WsClient {
                 req_id: reqid_1.ReqId.getReqID(),
             },
         };
-        if (this._wsConnector) {
-            try {
-                if (this._wsConnector.readyState() !== websocket_1.w3cwebsocket.OPEN) {
-                    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);
+        try {
+            const connector = this.getWsConnector();
+            if (connector.readyState() !== websocket_1.w3cwebsocket.OPEN) {
+                await connector.ready();
             }
-            catch (e) {
-                log_1.default.error(`connection creation failed, url: ${this._url}, code: ${e.code}, message: ${e.message}`);
-                throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${this._url}, code: ${e.code}, message: ${e.message}`);
+            let result = await connector.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(`connection creation failed, dsn: ${this._dsn}, code: ${e.code}, message: ${e.message}`);
+            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, dsn: ${this._dsn}, code: ${e.code}, message: ${e.message}`);
         }
-        throw (wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "invalid websocket connect");
     }
     async close() {
         if (this._wsConnector) {
+            this._wsConnector.setSessionRecoveryHook(null);
             await wsConnectorPool_1.WebSocketConnectionPool.instance().releaseConnection(this._wsConnector);
             this._wsConnector = undefined;
         }
+        this._customRecoveryHook = null;
     }
-    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.");
+    checkAuth(dsn) {
+        const hasToken = dsn.params.get("token") || dsn.params.get("bearer_token");
+        if (!hasToken) {
+            if (!(dsn.username || dsn.password)) {
+                throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_AUTHENTICATION, `invalid url, provide non-empty "token" or "bearer_token", or provide username/password`);
             }
         }
     }

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

@@ -1,16 +1,62 @@
+import { Dsn } from "../common/dsn";
+export type SessionRecoveryHook = () => Promise<void>;
+export declare class RetryConfig {
+    readonly retries: number;
+    readonly retryBackoffMs: number;
+    readonly retryBackoffMaxMs: number;
+    constructor(retries: number, retryBackoffMs: number, retryBackoffMaxMs: number);
+    getBackoffDelay(attempt: number): number;
+    static fromDsn(dsn: Dsn): RetryConfig;
+}
 export declare class WebSocketConnector {
-    private _wsConn;
-    private _wsURL;
-    _timeout: number;
-    constructor(url: URL, timeout: number | undefined | null);
-    ready(): Promise<unknown>;
-    private _onclose;
+    private _conn;
+    private readonly _poolKey;
+    private readonly _dsn;
+    private _currentAddress;
+    private _retryConfig;
+    private _inflightStore;
+    private readonly _suppressedSockets;
+    private _reconnectLock;
+    private _isReconnecting;
+    private _allowReconnect;
+    private _connectionReady;
+    private _sessionRecoveryHook;
+    private _timeout;
+    constructor(dsn: Dsn, poolKey: string, timeout: number | undefined | null);
+    refreshRetryConfig(dsn: Dsn): void;
+    private buildUrl;
+    private createConnection;
     private _onmessage;
+    private shouldSkipReconnect;
+    private failNonRetriableCallbacksOnDisconnect;
+    private handleDisconnect;
+    private extractReqId;
+    private isRetriableAction;
+    private extractBinaryAction;
+    private isRetriableBinaryAction;
+    isNetworkError(err: unknown): boolean;
+    private send;
+    ready(): Promise<void>;
+    private getCurrentAddress;
+    private selectLeastConnectedAddress;
+    private sleep;
+    private isReconnectAllowed;
+    private triggerReconnect;
+    private _doReconnect;
+    private reconnect;
+    private attemptReconnect;
+    private replayRequests;
+    private failAllInflightRequests;
     close(): void;
     readyState(): number;
+    setSessionRecoveryHook(hook: SessionRecoveryHook | undefined | null): void;
+    private recoverSessionContext;
+    sendMsgDirect(message: string): Promise<any>;
     sendMsgNoResp(message: string): Promise<void>;
-    sendMsg(message: string, register?: Boolean): Promise<unknown>;
-    sendBinaryMsg(reqId: bigint, action: string, message: ArrayBuffer, register?: Boolean): Promise<unknown>;
-    getWsURL(): URL;
+    sendMsg(message: string): Promise<unknown>;
+    sendBinaryMsg(reqId: bigint, action: string, message: ArrayBuffer): Promise<unknown>;
+    private sendAndTrackResponse;
+    getPoolKey(): string;
+    getReconnectRetries(): number;
 }
 //# sourceMappingURL=wsConnector.d.ts.map