@tdengine/websocket 3.2.3 → 3.3.0

package/lib/src/tmq/wsTmq.js

@@ -17,27 +17,28 @@ const utils_1 = require("../common/utils");
 const constant_2 = require("../common/constant");
 class WsConsumer {
     constructor(wsConfig) {
-        this._wsConfig = new config_1.TmqConfig(wsConfig);
+        this._config = new config_1.TmqConfig(wsConfig);
         if (log_1.default.isDebugEnabled()) {
-            log_1.default.debug("WsConsumer config: " + (0, utils_1.maskTmqConfigForLog)(this._wsConfig));
+            log_1.default.debug("WsConsumer config: " + (0, utils_1.maskTmqConfigForLog)(this._config));
         }
-        if (wsConfig.size == 0 || !this._wsConfig.url) {
+        if (wsConfig.size == 0 || !this._config.dsn) {
             throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, "invalid url, password or username needed.");
         }
-        this._wsClient = new wsClient_1.WsClient(this._wsConfig.url, this._wsConfig.timeout);
+        this._wsClient = new wsClient_1.WsClient(this._config.dsn, this._config.timeout);
+        this.bindSessionRecoveryHook();
         this._lastMessageID = BigInt(0);
     }
     async init() {
         let wsSql = null;
         try {
-            if (this._wsConfig.sql_url) {
-                wsSql = new wsClient_1.WsClient(this._wsConfig.sql_url, this._wsConfig.timeout);
+            if (this._config.sqlDsn) {
+                wsSql = new wsClient_1.WsClient(this._config.sqlDsn, this._config.timeout);
                 await wsSql.connect();
                 await wsSql.checkVersion();
                 await this._wsClient.ready();
             }
             else {
-                throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, url: ${(0, utils_1.maskUrlForLog)(this._wsConfig.url)}`);
+                throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `connection creation failed, dsn: ${this._config.dsn}`);
             }
         }
         catch (e) {
@@ -53,33 +54,54 @@ class WsConsumer {
     }
     static async newConsumer(wsConfig) {
         if (wsConfig.size == 0 || !wsConfig.get(constant_1.TMQConstants.WS_URL)) {
-            throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, "invalid url, password or username needed.");
+            throw new wsError_1.WebSocketInterfaceError(wsError_1.ErrorCode.ERR_INVALID_URL, "Invalid DSN");
         }
-        let wsConsumer = new WsConsumer(wsConfig);
+        const wsConsumer = new WsConsumer(wsConfig);
         return await wsConsumer.init();
     }
-    async subscribe(topics, reqId) {
-        if (!topics || topics.length == 0) {
-            throw new wsError_1.TaosResultError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "WsTmq Subscribe params is error!");
-        }
-        let queryMsg = {
+    bindSessionRecoveryHook() {
+        this._wsClient.setSessionRecoveryHook(async () => {
+            await this.recoverSessionContext();
+        });
+    }
+    buildSubscribeMessage(topics, reqId) {
+        const user = this._config.user === null
+            ? null
+            : (0, utils_1.safeDecodeURIComponent)(this._config.user);
+        const password = this._config.password === null
+            ? null
+            : (0, utils_1.safeDecodeURIComponent)(this._config.password);
+        return {
             action: constant_1.TMQMessageType.Subscribe,
             args: {
                 req_id: reqid_1.ReqId.getReqID(reqId),
-                user: this._wsConfig.user,
-                password: this._wsConfig.password,
-                group_id: this._wsConfig.group_id,
-                client_id: this._wsConfig.client_id,
+                user,
+                password,
+                group_id: this._config.group_id,
+                client_id: this._config.client_id,
                 topics: topics,
-                offset_rest: this._wsConfig.offset_rest,
-                auto_commit: String(this._wsConfig.auto_commit),
-                auto_commit_interval_ms: String(this._wsConfig.auto_commit_interval_ms),
-                config: Object.fromEntries(this._wsConfig.otherConfigs),
+                offset_rest: this._config.offset_rest,
+                auto_commit: String(this._config.auto_commit),
+                auto_commit_interval_ms: String(this._config.auto_commit_interval_ms),
+                config: Object.fromEntries(this._config.otherConfigs),
                 connector: constant_2.ConnectorInfo,
             },
         };
-        this._topics = topics;
-        return await this._wsClient.exec(JSON.stringify(queryMsg));
+    }
+    async recoverSessionContext() {
+        if (!this._topics || this._topics.length === 0) {
+            return;
+        }
+        log_1.default.info(`Recovering TMQ session context, re-subscribing ${this._topics.length} topic(s).`);
+        await this._wsClient.sendMsgDirect(JSON.stringify(this.buildSubscribeMessage(this._topics)), false);
+    }
+    async subscribe(topics, reqId) {
+        if (!topics || topics.length == 0) {
+            throw new wsError_1.TaosResultError(wsError_1.ErrorCode.ERR_INVALID_PARAMS, "WsTmq Subscribe params is error!");
+        }
+        let queryMsg = this.buildSubscribeMessage(topics, reqId);
+        await this._wsClient.exec(JSON.stringify(queryMsg));
+        this._topics = [...topics];
     }
     async unsubscribe(reqId) {
         let queryMsg = {
@@ -88,14 +110,15 @@ class WsConsumer {
                 req_id: reqid_1.ReqId.getReqID(reqId),
             },
         };
-        return await this._wsClient.exec(JSON.stringify(queryMsg));
+        await this._wsClient.exec(JSON.stringify(queryMsg));
+        this._topics = undefined;
     }
     async poll(timeoutMs, reqId) {
-        if (this._wsConfig.auto_commit) {
+        if (this._config.auto_commit) {
             if (this._commitTime) {
                 let currTime = new Date().getTime();
                 let diff = Math.abs(currTime - this._commitTime);
-                if (diff >= this._wsConfig.auto_commit_interval_ms) {
+                if (diff >= this._config.auto_commit_interval_ms) {
                     await this.doCommit();
                     this._commitTime = new Date().getTime();
                 }

package/lib/test/bulkPulling/a.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=a.test.d.ts.map

package/lib/test/bulkPulling/a.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/a.test.ts"],"names":[],"mappings":""}

package/lib/test/bulkPulling/a.test.js

@@ -0,0 +1,166 @@
+"use strict";
+// import { w3cwebsocket } from "websocket";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// test("test ws", async () => {
+//     const conn = new w3cwebsocket(
+//         "ws://localhost:6041/ws",
+//         undefined,
+//         undefined,
+//         undefined,
+//         undefined,
+//         {
+//             maxReceivedFrameSize: 0x60000000,
+//             maxReceivedMessageSize: 0x60000000,
+//         }
+//     );
+//     conn.onopen = function () {
+//         console.log("websocket connection opened");
+//     };
+//     conn.onmessage = function (message) {
+//         console.log("Received message:", message.data);
+//     };
+//     conn.onerror = function (err: Error) {
+//         console.error(`webSocket connection failed, url: ${this.url}, error: ${err.message}`);
+//     };
+//     conn.onclose = function () {
+//         console.log("websocket connection closed");
+//     };
+//     // cannot call send() while not connected
+//     conn.send("hello world");
+//     conn.close();
+// });
+const websocket_1 = require("websocket");
+const utils_1 = require("../helpers/utils");
+const log_1 = __importStar(require("../../src/common/log"));
+(0, log_1.setLevel)("debug");
+function waitForOpen(conn, timeoutMs = 5000) {
+    if (conn.readyState === websocket_1.w3cwebsocket.OPEN) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error(`waitForOpen timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            conn.onopen = prevOpen;
+            conn.onerror = prevError;
+            conn.onclose = prevClose;
+        };
+        const prevOpen = conn.onopen;
+        const prevError = conn.onerror;
+        const prevClose = conn.onclose;
+        conn.onopen = function () {
+            prevOpen?.call(this);
+            cleanup();
+            resolve();
+        };
+        conn.onerror = function (err) {
+            prevError?.call(this, err);
+            cleanup();
+            reject(err);
+        };
+        conn.onclose = function (e) {
+            prevClose?.call(this, e);
+            cleanup();
+            reject(new Error(`socket closed before open: ${e.code} ${e.reason || ""}`.trim()));
+        };
+    });
+}
+function waitForClose(conn, timeoutMs = 5000) {
+    if (conn.readyState === websocket_1.w3cwebsocket.CLOSED) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error(`waitForClose timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const cleanup = () => {
+            clearTimeout(timer);
+            conn.onclose = prevClose;
+            conn.onerror = prevError;
+        };
+        const prevClose = conn.onclose;
+        const prevError = conn.onerror;
+        conn.onclose = function (e) {
+            prevClose?.call(this, e);
+            cleanup();
+            resolve();
+        };
+        conn.onerror = function (err) {
+            prevError?.call(this, err);
+            cleanup();
+            reject(err);
+        };
+    });
+}
+test("test ws", async () => {
+    const conn = new websocket_1.w3cwebsocket("ws://localhost:6041/ws", undefined, undefined, undefined, undefined, {
+        maxReceivedFrameSize: 0x60000000,
+        maxReceivedMessageSize: 0x60000000,
+    });
+    conn.onopen = function () {
+        console.log("websocket connection opened");
+    };
+    conn.onmessage = function (message) {
+        console.log("Received message:", message.data);
+    };
+    conn.onerror = function (err) {
+        console.error(`webSocket connection failed, url: ${this.url}, error: ${err.message}`);
+    };
+    conn.onclose = function (e) {
+        console.log("websocket connection closed, event", e);
+    };
+    await waitForOpen(conn);
+    // cannot call send() while not connected
+    conn.send("hello world");
+    // conn.close();
+    // await waitForClose(conn);
+    // restart taosadapter
+    console.log("Please restart taosadapter now...");
+    log_1.default.info("Please restart taosadapter now...");
+    await (0, utils_1.Sleep)(5000);
+    // cannot call send() while not connected
+    conn.send("hello world after close"); // should not throw, but will be ignored
+    await (0, utils_1.Sleep)(5000);
+}, 15000);
+test("test url", async () => {
+    const url = new URL("ws://user:pass@localhost:6041/dbname?param1=value1&param2=value2");
+    console.log("url", url);
+    console.log(url.port);
+});

package/lib/test/bulkPulling/dsn.test.js

@@ -11,6 +11,7 @@ describe("dsn", () => {
             expect(result.addresses).toEqual([{ host: "localhost", port: 6041 }]);
             expect(result.database).toBe("");
             expect(result.params.size).toBe(0);
+            expect(result.endpoint).toBe(dsn_1.WS_SQL_ENDPOINT);
         });
         test("single host with database", () => {
             const result = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/power");
@@ -375,4 +376,22 @@ describe("dsn", () => {
             expect(() => (0, dsn_1.parse)("ws://root:taosdata@host1:6041,[::1:6042,host2:6043")).toThrow("Unclosed bracket");
         });
     });
+    describe("toString", () => {
+        test("masks password and sensitive params", () => {
+            const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041/mydb?token=t1&bearer_token=b1&td.connect.token=c1&timezone=UTC");
+            const masked = JSON.parse(dsn.toString());
+            expect(masked.password).toBe("[REDACTED]");
+            expect(masked.params.token).toBe("[REDACTED]");
+            expect(masked.params.bearer_token).toBe("[REDACTED]");
+            expect(masked.params["td.connect.token"]).toBe("[REDACTED]");
+            expect(masked.params.timezone).toBe("UTC");
+        });
+        test("treats sensitive param keys as case-insensitive", () => {
+            const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?Token=t1&Bearer_Token=b1&TD.CONNECT.TOKEN=c1");
+            const masked = JSON.parse(dsn.toString());
+            expect(masked.params.Token).toBe("[REDACTED]");
+            expect(masked.params.Bearer_Token).toBe("[REDACTED]");
+            expect(masked.params["TD.CONNECT.TOKEN"]).toBe("[REDACTED]");
+        });
+    });
 });

package/lib/test/bulkPulling/retryConfig.test.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const dsn_1 = require("../../src/common/dsn");
-const retryConfig_1 = require("../../src/client/retryConfig");
+const wsConnector_1 = require("../../src/client/wsConnector");
 describe("RetryConfig", () => {
     test("uses defaults when retry params are not provided", () => {
         const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
-        const config = retryConfig_1.RetryConfig.fromDsn(dsn);
-        expect(config.retries).toBe(3);
-        expect(config.retryBackoffMs).toBe(100);
-        expect(config.retryBackoffMaxMs).toBe(10000);
+        const config = wsConnector_1.RetryConfig.fromDsn(dsn);
+        expect(config.retries).toBe(5);
+        expect(config.retryBackoffMs).toBe(200);
+        expect(config.retryBackoffMaxMs).toBe(2000);
     });
     test("reads retry params from dsn", () => {
         const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?retries=5&retry_backoff_ms=200&retry_backoff_max_ms=3200");
-        const config = retryConfig_1.RetryConfig.fromDsn(dsn);
+        const config = wsConnector_1.RetryConfig.fromDsn(dsn);
         expect(config.retries).toBe(5);
         expect(config.retryBackoffMs).toBe(200);
         expect(config.retryBackoffMaxMs).toBe(3200);
     });
     test("normalizes invalid params to safe defaults", () => {
         const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041?retries=-1&retry_backoff_ms=abc&retry_backoff_max_ms=0");
-        const config = retryConfig_1.RetryConfig.fromDsn(dsn);
-        expect(config.retries).toBe(3);
-        expect(config.retryBackoffMs).toBe(100);
-        expect(config.retryBackoffMaxMs).toBe(10000);
+        const config = wsConnector_1.RetryConfig.fromDsn(dsn);
+        expect(config.retries).toBe(5);
+        expect(config.retryBackoffMs).toBe(200);
+        expect(config.retryBackoffMaxMs).toBe(2000);
     });
     test("computes exponential backoff and caps at max", () => {
-        const config = new retryConfig_1.RetryConfig(3, 100, 350);
+        const config = new wsConnector_1.RetryConfig(3, 100, 350);
         expect(config.getBackoffDelay(0)).toBe(100);
         expect(config.getBackoffDelay(1)).toBe(200);
         expect(config.getBackoffDelay(2)).toBe(350);

package/lib/test/bulkPulling/sql.failover.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sql.failover.test.d.ts.map

package/lib/test/bulkPulling/sql.failover.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.failover.test.d.ts","sourceRoot":"","sources":["../../../test/bulkPulling/sql.failover.test.ts"],"names":[],"mappings":""}