@tdengine/websocket 3.2.3 → 3.3.0

package/lib/test/bulkPulling/urlParser.test.js

@@ -0,0 +1,452 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const urlParser_1 = require("../../src/common/urlParser");
+describe("urlParser", () => {
+    describe("parseMultiHostUrl", () => {
+        test("single host with port", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("single host with database", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041/power");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("power");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple hosts", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:6041,host2:6042,host3:6043/mydb");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.hosts[2]).toEqual({ host: "host3", port: 6043 });
+            expect(result.database).toBe("mydb");
+            expect(result.params.size).toBe(0);
+        });
+        test("IPv6 address in brackets", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[::1]:6041,host2:6042/db");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(2);
+            expect(result.hosts[0]).toEqual({ host: "[::1]", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.database).toBe("db");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple IPv6 addresses", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[::1]:6041,[fe80::1]:6042");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(2);
+            expect(result.hosts[0]).toEqual({ host: "[::1]", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "[fe80::1]", port: 6042 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("wss scheme", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("wss://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("wss");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("query parameters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:6041/db?retries=5&retry_backoff_ms=300&timezone=UTC");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("db");
+            expect(result.params.get("retries")).toBe("5");
+            expect(result.params.get("retry_backoff_ms")).toBe("300");
+            expect(result.params.get("timezone")).toBe("UTC");
+        });
+        test("deduplicates hosts", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:6041,host2:6042,host1:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(2);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no user info", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://host1:6041?token=mytoken");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("");
+            expect(result.hosts).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.get("token")).toBe("mytoken");
+        });
+        test("username only (no password)", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root@host1:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("");
+            expect(result.hosts).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("host without port uses default 6041", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@myhost");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "myhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("complex URL with all features", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://user:p%40ss@host1:6041,host2:6042,[::1]:6043/testdb?retries=5&retry_backoff_ms=100&retry_backoff_max_ms=5000&resend_write=true&token=abc");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("user");
+            expect(result.password).toBe("p%40ss");
+            expect(result.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6042 });
+            expect(result.hosts[2]).toEqual({ host: "[::1]", port: 6043 });
+            expect(result.database).toBe("testdb");
+            expect(result.params.get("retries")).toBe("5");
+            expect(result.params.get("retry_backoff_ms")).toBe("100");
+            expect(result.params.get("retry_backoff_max_ms")).toBe("5000");
+            expect(result.params.get("resend_write")).toBe("true");
+            expect(result.params.get("token")).toBe("abc");
+        });
+        // Additional normal test cases
+        test("empty password with colon", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("database with special characters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041/test_db-123");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("test_db-123");
+            expect(result.params.size).toBe(0);
+        });
+        test("empty database path with slash", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041/");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple hosts without ports use default", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1,host2,host3");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6041 });
+            expect(result.hosts[2]).toEqual({ host: "host3", port: 6041 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("IPv6 without port uses default", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[::1]");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "[::1]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("scheme is case insensitive", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("WS://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("WSS scheme is case insensitive", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("WSS://root:taosdata@localhost:6041");
+            expect(result.scheme).toBe("wss");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("single query parameter", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041?token=abc123");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(1);
+            expect(result.params.get("token")).toBe("abc123");
+        });
+        test("database with query parameters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041/mydb?timezone=UTC");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("mydb");
+            expect(result.params.get("timezone")).toBe("UTC");
+        });
+        test("full IPv6 address (not abbreviated)", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("full IPv6 address without port uses default", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no username only password", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://:pass@localhost:6041");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("pass");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("no username only password with database", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://:taosdata@localhost:6041/mydb");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("mydb");
+            expect(result.params.size).toBe(0);
+        });
+        test("empty port uses default 6041", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "host1", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("IPv4 with empty port uses default 6041", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@127.0.1.0:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "127.0.1.0", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("multiple hosts with empty ports use default", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:,host2:,127.0.0.1:");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(3);
+            expect(result.hosts[0]).toEqual({ host: "host1", port: 6041 });
+            expect(result.hosts[1]).toEqual({ host: "host2", port: 6041 });
+            expect(result.hosts[2]).toEqual({ host: "127.0.0.1", port: 6041 });
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        // Boundary test cases
+        test("port boundary - minimum valid port 1", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:1");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 1 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("port boundary - maximum valid port 65535", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:65535");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 65535 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("very long username", () => {
+            const longUsername = "a".repeat(100);
+            const result = (0, urlParser_1.parseMultiHostUrl)(`ws://${longUsername}:pass@localhost:6041`);
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe(longUsername);
+            expect(result.password).toBe("pass");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("very long password", () => {
+            const longPassword = "p".repeat(100);
+            const result = (0, urlParser_1.parseMultiHostUrl)(`ws://user:${longPassword}@localhost:6041`);
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("user");
+            expect(result.password).toBe(longPassword);
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("many hosts", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@h1:6041,h2:6042,h3:6043,h4:6044,h5:6045,h6:6046,h7:6047,h8:6048");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toHaveLength(8);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(0);
+        });
+        test("many query parameters", () => {
+            const result = (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@localhost:6041?p1=v1&p2=v2&p3=v3&p4=v4&p5=v5");
+            expect(result.scheme).toBe("ws");
+            expect(result.username).toBe("root");
+            expect(result.password).toBe("taosdata");
+            expect(result.hosts).toEqual([{ host: "localhost", port: 6041 }]);
+            expect(result.database).toBe("");
+            expect(result.params.size).toBe(5);
+            expect(result.params.get("p1")).toBe("v1");
+            expect(result.params.get("p5")).toBe("v5");
+        });
+        // Exception test cases
+        test("empty URL throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("")).toThrow("URL must not be empty");
+        });
+        test("whitespace only URL throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("   ")).toThrow("URL must not be empty");
+        });
+        test("invalid scheme throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("http://host:6041")).toThrow("Invalid URL scheme");
+        });
+        test("missing scheme throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("root:taosdata@host:6041")).toThrow("Invalid URL scheme");
+        });
+        test("unclosed IPv6 bracket throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@[::1:6041")).toThrow("Unclosed bracket");
+        });
+        test("invalid port throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:abc")).toThrow("Invalid port");
+        });
+        test("port out of range throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:70000")).toThrow("Invalid port");
+        });
+        test("port zero throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:0")).toThrow("Invalid port");
+        });
+        test("negative port throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:-1")).toThrow("Invalid port");
+        });
+        test("port with spaces throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:60 41")).toThrow("Invalid port");
+        });
+        test("IPv6 with unclosed bracket in middle of host list throws", () => {
+            expect(() => (0, urlParser_1.parseMultiHostUrl)("ws://root:taosdata@host1:6041,[::1:6042,host2:6043")).toThrow("Unclosed bracket");
+        });
+    });
+    describe("buildHostUrl", () => {
+        test("builds single host URL with /ws path", () => {
+            const parsed = {
+                hosts: [{ host: "host1", port: 6041 }],
+                scheme: "ws",
+                username: "root",
+                password: "taosdata",
+                database: "mydb",
+                params: new Map([["timezone", "UTC"]]),
+            };
+            const url = (0, urlParser_1.buildHostUrl)(parsed, parsed.hosts[0]);
+            expect(url.origin).toBe("ws://host1:6041");
+            expect(url.pathname).toBe("/ws");
+            expect(url.username).toBe("root");
+            expect(url.password).toBe("taosdata");
+            expect(url.searchParams.get("timezone")).toBe("UTC");
+        });
+        test("excludes retry params from URL", () => {
+            const parsed = {
+                hosts: [{ host: "host1", port: 6041 }],
+                scheme: "ws",
+                username: "root",
+                password: "taosdata",
+                database: "",
+                params: new Map([
+                    ["retries", "5"],
+                    ["retry_backoff_ms", "200"],
+                    ["timezone", "UTC"],
+                ]),
+            };
+            const url = (0, urlParser_1.buildHostUrl)(parsed, parsed.hosts[0]);
+            expect(url.searchParams.has("retries")).toBe(false);
+            expect(url.searchParams.has("retry_backoff_ms")).toBe(false);
+            expect(url.searchParams.get("timezone")).toBe("UTC");
+        });
+        test("adds extra params", () => {
+            const parsed = {
+                hosts: [{ host: "host1", port: 6041 }],
+                scheme: "wss",
+                username: "",
+                password: "",
+                database: "",
+                params: new Map(),
+            };
+            const extras = new Map([["token", "abc123"]]);
+            const url = (0, urlParser_1.buildHostUrl)(parsed, parsed.hosts[0], extras);
+            expect(url.searchParams.get("token")).toBe("abc123");
+            expect(url.protocol).toBe("wss:");
+        });
+    });
+    describe("extractRetryOptions", () => {
+        test("extracts all retry params", () => {
+            const params = new Map([
+                ["retries", "5"],
+                ["retry_backoff_ms", "300"],
+                ["retry_backoff_max_ms", "5000"],
+                ["resend_write", "true"],
+            ]);
+            const opts = (0, urlParser_1.extractRetryOptions)(params);
+            expect(opts.retries).toBe(5);
+            expect(opts.retryBackoffMs).toBe(300);
+            expect(opts.retryBackoffMaxMs).toBe(5000);
+            expect(opts.resendWrite).toBe(true);
+        });
+        test("returns empty object for no params", () => {
+            const opts = (0, urlParser_1.extractRetryOptions)(new Map());
+            expect(opts.retries).toBeUndefined();
+            expect(opts.retryBackoffMs).toBeUndefined();
+        });
+        test("resend_write false values", () => {
+            expect((0, urlParser_1.extractRetryOptions)(new Map([["resend_write", "false"]])).resendWrite).toBe(false);
+            expect((0, urlParser_1.extractRetryOptions)(new Map([["resend_write", "0"]])).resendWrite).toBe(false);
+        });
+    });
+});

package/lib/test/bulkPulling/wsClient.reconnect.integration.test.js

@@ -118,7 +118,7 @@ describe("WsClient reconnect integration", () => {
             { disconnectOnActions: ["insert"] },
             {},
         ]);
-        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?timezone=UTC&retries=0&retry_backoff_ms=1");
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?timezone=UTC&retries=1&retry_backoff_ms=1");
         const client = new wsClient_1.WsClient(dsn, 1000);
         await client.connect("mydb");
         await client.setOptionConnection(constant_1.TSDB_OPTION_CONNECTION.TSDB_OPTION_CONNECTION_TIMEZONE, "UTC");
@@ -148,7 +148,7 @@ describe("WsClient reconnect integration", () => {
             },
             {},
         ]);
-        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=0&retry_backoff_ms=1");
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=1&retry_backoff_ms=1");
         const client = new wsClient_1.WsClient(dsn, 1000);
         await client.connect("mydb");
         const pending = client.exec(JSON.stringify({

package/lib/test/bulkPulling/wsClient.recovery.test.d.ts

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

package/lib/test/bulkPulling/wsClient.recovery.test.d.ts.map

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

package/lib/test/bulkPulling/wsClient.recovery.test.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = require("websocket");
+const wsClient_1 = require("../../src/client/wsClient");
+const wsConnectorPool_1 = require("../../src/client/wsConnectorPool");
+const dsn_1 = require("../../src/common/dsn");
+const wsError_1 = require("../../src/common/wsError");
+function createMockConnector() {
+    return {
+        readyState: jest.fn(() => websocket_1.w3cwebsocket.OPEN),
+        ready: jest.fn(async () => { }),
+        setSessionRecoveryHook: jest.fn(),
+        sendMsgDirect: jest.fn(async (_message) => ({
+            msg: { code: 0, message: "" }
+        })),
+        sendMsg: jest.fn(async () => ({ msg: { code: 0, message: "" } })),
+        sendMsgNoResp: jest.fn(async () => { }),
+    };
+}
+describe("WsClient recovery hook", () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    test("uses dsn endpoint when creating connection", async () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
+        dsn.endpoint = dsn_1.WS_TMQ_ENDPOINT;
+        const connector = createMockConnector();
+        const getConnectionSpy = jest
+            .spyOn(wsConnectorPool_1.WebSocketConnectionPool.instance(), "getConnection")
+            .mockResolvedValue(connector);
+        const client = new wsClient_1.WsClient(dsn, 4321);
+        await client.ready();
+        expect(getConnectionSpy).toHaveBeenCalledWith(dsn, 4321);
+    });
+    test("runs custom recovery hook without sql conn recovery on tmq path", async () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
+        dsn.endpoint = dsn_1.WS_TMQ_ENDPOINT;
+        const connector = createMockConnector();
+        jest
+            .spyOn(wsConnectorPool_1.WebSocketConnectionPool.instance(), "getConnection")
+            .mockResolvedValue(connector);
+        const customRecoveryHook = jest.fn(async () => { });
+        const client = new wsClient_1.WsClient(dsn, 5000);
+        client.setSessionRecoveryHook(customRecoveryHook);
+        await client.ready();
+        const hookCalls = connector.setSessionRecoveryHook.mock.calls;
+        const hook = hookCalls[hookCalls.length - 1]?.[0];
+        expect(hook).toBeTruthy();
+        await hook();
+        expect(connector.sendMsgDirect).not.toHaveBeenCalled();
+        expect(customRecoveryHook).toHaveBeenCalledTimes(1);
+    });
+    test("keeps sql conn recovery and then runs custom recovery on sql endpoint", async () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
+        const connector = createMockConnector();
+        const callOrder = [];
+        connector.sendMsgDirect.mockImplementation(async (message) => {
+            const action = JSON.parse(message).action;
+            callOrder.push(action);
+            return { msg: { code: 0, message: "" } };
+        });
+        jest
+            .spyOn(wsConnectorPool_1.WebSocketConnectionPool.instance(), "getConnection")
+            .mockResolvedValue(connector);
+        const client = new wsClient_1.WsClient(dsn, 5000);
+        client._connectedDatabase = "db_recovery";
+        client.setSessionRecoveryHook(async () => {
+            callOrder.push("custom");
+        });
+        await client.ready();
+        const hookCalls = connector.setSessionRecoveryHook.mock.calls;
+        const hook = hookCalls[hookCalls.length - 1]?.[0];
+        expect(hook).toBeTruthy();
+        await hook();
+        expect(connector.sendMsgDirect).toHaveBeenCalledTimes(1);
+        const firstCall = connector.sendMsgDirect.mock.calls[0];
+        const connMsg = JSON.parse(firstCall[0]);
+        expect(connMsg.action).toBe("conn");
+        expect(connMsg.args.db).toBe("db_recovery");
+        expect(callOrder).toEqual(["conn", "custom"]);
+    });
+    test("throws WebSocketQueryError when sql recovery direct call fails", async () => {
+        const dsn = (0, dsn_1.parse)("ws://root:taosdata@localhost:6041");
+        const connector = createMockConnector();
+        connector.sendMsgDirect.mockResolvedValue({
+            msg: {
+                code: 9001,
+                message: "conn failed",
+            },
+        });
+        jest
+            .spyOn(wsConnectorPool_1.WebSocketConnectionPool.instance(), "getConnection")
+            .mockResolvedValue(connector);
+        const customRecoveryHook = jest.fn(async () => { });
+        const client = new wsClient_1.WsClient(dsn, 5000);
+        client.setSessionRecoveryHook(customRecoveryHook);
+        await client.ready();
+        const hookCalls = connector.setSessionRecoveryHook.mock.calls;
+        const hook = hookCalls[hookCalls.length - 1]?.[0];
+        expect(hook).toBeTruthy();
+        await expect(hook()).rejects.toBeInstanceOf(wsError_1.WebSocketQueryError);
+        expect(customRecoveryHook).not.toHaveBeenCalled();
+    });
+});

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = require("../../src/common/config");
 const utils_1 = require("../../src/common/utils");
+const dsn_1 = require("../../src/common/dsn");
 describe("WSConfig to Dsn conversion", () => {
     test("parses multi-address dsn and keeps connector-level params", () => {
         const conf = new config_1.WSConfig("ws://root:taosdata@host1:6041,host2:6042/mydb?retries=5&retry_backoff_ms=120&timezone=UTC");
@@ -12,6 +13,7 @@ describe("WSConfig to Dsn conversion", () => {
             { host: "host2", port: 6042 },
         ]);
         expect(dsn.database).toBe("mydb");
+        expect(dsn.endpoint).toBe(dsn_1.WS_SQL_ENDPOINT);
         expect(dsn.params.get("retries")).toBe("5");
         expect(dsn.params.get("retry_backoff_ms")).toBe("120");
         expect(dsn.params.get("timezone")).toBe("UTC");