@tdengine/websocket 3.2.3 → 3.3.0

package/lib/test/helpers/wsProxy.js

@@ -0,0 +1,429 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __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 });
+exports.WsProxy = void 0;
+const http = __importStar(require("http"));
+const websocket_1 = require("websocket");
+const DEFAULT_UPSTREAM_BASE_URL = "ws://localhost:6041";
+class WsProxy {
+    constructor(options) {
+        this._lockedPort = null;
+        this._httpServer = null;
+        this._wsServer = null;
+        this._running = false;
+        this._nextConnectionId = 1;
+        this._lifecycleChain = Promise.resolve();
+        this._tunnels = new Map();
+        this._eventLog = [];
+        if (!options.host || options.host.trim().length === 0) {
+            throw new Error("listen host must not be empty");
+        }
+        if (!Number.isInteger(options.port) ||
+            options.port < 0 ||
+            options.port > 65535) {
+            throw new Error(`invalid listen port: ${options.port}, expected 0-65535`);
+        }
+        this._listenHost = options.host;
+        this._requestedPort = options.port;
+        this._onEvent = options.onEvent;
+        this._control = {
+            restart: async (opts) => {
+                await this.restart(opts);
+            },
+            stop: async (reason) => {
+                await this.stop(reason);
+            },
+            isRunning: () => this.isRunning(),
+        };
+    }
+    static async create(options) {
+        const proxy = new WsProxy(options);
+        await proxy.start("initial start");
+        return proxy;
+    }
+    async start(reason) {
+        await this.enqueueLifecycle(async () => {
+            await this.startInternal(reason);
+        });
+    }
+    async stop(reason) {
+        await this.enqueueLifecycle(async () => {
+            await this.stopInternal(reason);
+        });
+    }
+    async restart(opts) {
+        await this.enqueueLifecycle(async () => {
+            const reason = opts?.reason || "restart";
+            const downtimeMs = Math.max(0, opts?.downtimeMs || 0);
+            await this.stopInternal(reason);
+            if (downtimeMs > 0) {
+                await sleep(downtimeMs);
+            }
+            await this.startInternal(reason);
+        });
+    }
+    isRunning() {
+        return this._running;
+    }
+    getPort() {
+        if (this._lockedPort === null) {
+            throw new Error("proxy has not started yet");
+        }
+        return this._lockedPort;
+    }
+    getHost() {
+        return this._listenHost;
+    }
+    getUrl() {
+        return `ws://${this._listenHost}:${this.getPort()}`;
+    }
+    getEventLog() {
+        return [...this._eventLog];
+    }
+    async enqueueLifecycle(task) {
+        this._lifecycleChain = this._lifecycleChain.then(task, task);
+        await this._lifecycleChain;
+    }
+    async startInternal(reason) {
+        if (this._running) {
+            return;
+        }
+        const listenPort = this._lockedPort === null
+            ? this._requestedPort
+            : this._lockedPort;
+        const httpServer = http.createServer((_req, res) => {
+            res.statusCode = 404;
+            res.end();
+        });
+        await new Promise((resolve, reject) => {
+            const onError = (err) => {
+                httpServer.removeListener("listening", onListening);
+                reject(err);
+            };
+            const onListening = () => {
+                httpServer.removeListener("error", onError);
+                resolve();
+            };
+            httpServer.once("error", onError);
+            httpServer.once("listening", onListening);
+            httpServer.listen(listenPort, this._listenHost);
+        });
+        const address = httpServer.address();
+        if (!address || typeof address === "string") {
+            httpServer.close();
+            throw new Error("failed to get proxy listen address");
+        }
+        if (this._lockedPort === null) {
+            this._lockedPort = address.port;
+        }
+        const wsServer = new websocket_1.server({
+            httpServer,
+            autoAcceptConnections: false,
+        });
+        wsServer.on("request", (request) => {
+            this.handleClientRequest(request);
+        });
+        this._httpServer = httpServer;
+        this._wsServer = wsServer;
+        this._running = true;
+        this.emitEvent({
+            type: "proxy_started",
+            timestamp: Date.now(),
+            host: this._listenHost,
+            port: this.getPort(),
+            url: this.getUrl(),
+            reason,
+        });
+    }
+    async stopInternal(reason) {
+        if (!this._running && !this._httpServer && !this._wsServer) {
+            return;
+        }
+        this._running = false;
+        for (const tunnel of Array.from(this._tunnels.values())) {
+            this.closeTunnel(tunnel.id, `proxy stopping${reason ? `: ${reason}` : ""}`, "proxy");
+        }
+        if (this._wsServer) {
+            try {
+                this._wsServer.removeAllListeners("request");
+                this._wsServer.closeAllConnections();
+                this._wsServer.unmount();
+            }
+            catch (_err) {
+                // Ignore shutdown errors and continue releasing resources.
+            }
+        }
+        if (this._httpServer) {
+            await new Promise((resolve) => {
+                if (!this._httpServer || !this._httpServer.listening) {
+                    resolve();
+                    return;
+                }
+                this._httpServer.close(() => resolve());
+            });
+        }
+        this._wsServer = null;
+        this._httpServer = null;
+        this.emitEvent({
+            type: "proxy_stopped",
+            timestamp: Date.now(),
+            reason,
+        });
+    }
+    handleClientRequest(request) {
+        if (!this._running) {
+            request.reject(503, "proxy is not running");
+            return;
+        }
+        const path = request.resourceURL?.pathname || request.resource;
+        const clientConn = request.accept(undefined, request.origin);
+        const connectionId = this._nextConnectionId;
+        this._nextConnectionId += 1;
+        const tunnel = {
+            id: connectionId,
+            path,
+            closed: false,
+            messageSeq: 0,
+            clientConn,
+            pendingFrames: [],
+        };
+        this._tunnels.set(connectionId, tunnel);
+        this.emitEvent({
+            type: "client_connected",
+            timestamp: Date.now(),
+            connectionId,
+            path,
+            remoteAddress: request.remoteAddress,
+        });
+        clientConn.on("message", (message) => {
+            this.handleClientMessage(tunnel, message);
+        });
+        clientConn.on("close", (code, desc) => {
+            this.closeTunnel(connectionId, `client closed: ${code} ${desc}`, "client");
+        });
+        clientConn.on("error", (error) => {
+            this.emitError("client_error", error, connectionId);
+            this.closeTunnel(connectionId, `client error: ${error.message}`, "client");
+        });
+        this.connectUpstream(tunnel);
+    }
+    connectUpstream(tunnel) {
+        const upstreamClient = new websocket_1.client();
+        tunnel.upstreamClient = upstreamClient;
+        const upstreamUrl = this.buildUpstreamUrl(tunnel.path);
+        upstreamClient.on("connect", (upstreamConn) => {
+            if (tunnel.closed) {
+                upstreamConn.close();
+                return;
+            }
+            tunnel.upstreamConn = upstreamConn;
+            this.emitEvent({
+                type: "upstream_connected",
+                timestamp: Date.now(),
+                connectionId: tunnel.id,
+                upstreamUrl,
+            });
+            upstreamConn.on("message", (message) => {
+                this.handleUpstreamMessage(tunnel, message);
+            });
+            upstreamConn.on("close", (code, desc) => {
+                this.closeTunnel(tunnel.id, `upstream closed: ${code} ${desc}`, "upstream");
+            });
+            upstreamConn.on("error", (error) => {
+                this.emitError("upstream_error", error, tunnel.id);
+                this.closeTunnel(tunnel.id, `upstream error: ${error.message}`, "upstream");
+            });
+            this.flushPendingFrames(tunnel);
+        });
+        upstreamClient.on("connectFailed", (error) => {
+            this.emitError("upstream_connect_failed", error, tunnel.id);
+            this.closeTunnel(tunnel.id, `upstream connect failed: ${error.message}`, "upstream");
+        });
+        upstreamClient.connect(upstreamUrl);
+    }
+    buildUpstreamUrl(path) {
+        const upstream = new URL(DEFAULT_UPSTREAM_BASE_URL);
+        upstream.pathname = ensureLeadingSlash(path);
+        return upstream.toString();
+    }
+    handleClientMessage(tunnel, message) {
+        if (tunnel.closed) {
+            return;
+        }
+        if (message.type === "utf8") {
+            const rawData = message.utf8Data;
+            this.emitMessageEvent(tunnel, "client_to_upstream", false, rawData);
+            if (this.isConnected(tunnel.upstreamConn)) {
+                tunnel.upstreamConn.sendUTF(rawData);
+                return;
+            }
+            tunnel.pendingFrames.push({
+                isBinary: false,
+                data: rawData,
+            });
+            return;
+        }
+        const rawData = Buffer.from(message.binaryData);
+        this.emitMessageEvent(tunnel, "client_to_upstream", true, rawData);
+        if (this.isConnected(tunnel.upstreamConn)) {
+            tunnel.upstreamConn.sendBytes(rawData);
+            return;
+        }
+        tunnel.pendingFrames.push({
+            isBinary: true,
+            data: rawData,
+        });
+    }
+    handleUpstreamMessage(tunnel, message) {
+        if (tunnel.closed || !this.isConnected(tunnel.clientConn)) {
+            this.closeTunnel(tunnel.id, "client connection unavailable while forwarding upstream message", "client");
+            return;
+        }
+        if (message.type === "utf8") {
+            const rawData = message.utf8Data;
+            this.emitMessageEvent(tunnel, "upstream_to_client", false, rawData);
+            tunnel.clientConn.sendUTF(rawData);
+            return;
+        }
+        const rawData = Buffer.from(message.binaryData);
+        this.emitMessageEvent(tunnel, "upstream_to_client", true, rawData);
+        tunnel.clientConn.sendBytes(rawData);
+    }
+    flushPendingFrames(tunnel) {
+        if (!this.isConnected(tunnel.upstreamConn) || tunnel.closed) {
+            return;
+        }
+        while (tunnel.pendingFrames.length > 0) {
+            const frame = tunnel.pendingFrames.shift();
+            if (!frame) {
+                break;
+            }
+            if (frame.isBinary) {
+                tunnel.upstreamConn.sendBytes(frame.data);
+            }
+            else {
+                tunnel.upstreamConn.sendUTF(frame.data);
+            }
+        }
+    }
+    closeTunnel(connectionId, reason, source) {
+        const tunnel = this._tunnels.get(connectionId);
+        if (!tunnel || tunnel.closed) {
+            return;
+        }
+        tunnel.closed = true;
+        this._tunnels.delete(connectionId);
+        const isProxyInjectedFailure = source === "proxy";
+        this.safeCloseConnection(tunnel.clientConn, isProxyInjectedFailure);
+        this.safeCloseConnection(tunnel.upstreamConn, isProxyInjectedFailure);
+        this.emitEvent({
+            type: "tunnel_closed",
+            timestamp: Date.now(),
+            connectionId,
+            reason,
+            source,
+        });
+    }
+    isConnected(conn) {
+        return !!conn && conn.connected;
+    }
+    emitMessageEvent(tunnel, direction, isBinary, rawData) {
+        tunnel.messageSeq += 1;
+        this.emitEvent({
+            type: "message",
+            timestamp: Date.now(),
+            connectionId: tunnel.id,
+            direction,
+            isBinary,
+            byteLength: typeof rawData === "string"
+                ? Buffer.byteLength(rawData)
+                : rawData.byteLength,
+            rawData,
+            messageSeq: tunnel.messageSeq,
+        });
+    }
+    emitError(stage, error, connectionId, sourceEventType, details, notifyCallback = true) {
+        this.emitEvent({
+            type: "error",
+            timestamp: Date.now(),
+            connectionId,
+            error: normalizeError(error),
+            stage,
+            sourceEventType,
+            details,
+        }, notifyCallback);
+    }
+    emitEvent(event, notifyCallback = true) {
+        this._eventLog.push(event);
+        if (!notifyCallback || !this._onEvent) {
+            return;
+        }
+        void Promise.resolve(this._onEvent(event, this._control)).catch((err) => {
+            this.emitError("event_handler", err, event.connectionId, event.type, "event callback threw an error", false);
+        });
+    }
+    safeCloseConnection(conn, abnormal) {
+        try {
+            if (!this.isConnected(conn)) {
+                return;
+            }
+            if (abnormal) {
+                conn.close(1012, "proxy restart");
+                return;
+            }
+            conn.close();
+        }
+        catch (_err) {
+            // Ignore close failures.
+        }
+    }
+}
+exports.WsProxy = WsProxy;
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}
+function ensureLeadingSlash(path) {
+    if (!path || path.trim().length === 0) {
+        throw new Error("proxy supported path must not be empty");
+    }
+    const trimmed = path.trim();
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/test/sql/core/decimal.test.d.ts

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

package/lib/test/sql/core/decimal.test.d.ts.map

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

package/lib/test/sql/core/decimal.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const wsConnectorPool_1 = require("@src/client/wsConnectorPool");
+const config_1 = require("@src/common/config");
+const wsSql_1 = require("@src/sql/wsSql");
+const utils_1 = require("@test-helpers/utils");
+const log_1 = require("@src/common/log");
+const constant_1 = require("@src/tmq/constant");
+const wsTmq_1 = require("@src/tmq/wsTmq");
+let dns = "ws://localhost:6041";
+let createTopic = `create topic if not exists topic_decimal_test as select * from power.decimal_test`;
+let dropTopic = `DROP TOPIC IF EXISTS topic_decimal_test;`;
+(0, log_1.setLevel)("debug");
+beforeAll(async () => {
+    let conf = new config_1.WSConfig(dns);
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec(dropTopic);
+    await wsSql.exec("drop database if exists power");
+    await wsSql.exec("create database if not exists power KEEP 3650 DURATION 10 BUFFER 16 WAL_LEVEL 1;");
+    await (0, utils_1.Sleep)(100);
+    await wsSql.exec("use power");
+    await wsSql.exec("CREATE STABLE if not exists decimal_test (ts timestamp, dec64 decimal(10,6), dec128 decimal(24,10), int1 int) TAGS (location binary(64), groupId int);");
+    await wsSql.exec(createTopic);
+    await wsSql.close();
+});
+const expectedResultsMap = new Map([
+    [
+        "-1234.654321",
+        {
+            dec128: "-123456789012.0987654321",
+            int1: 3,
+            location: "California",
+            groupId: 3,
+        },
+    ],
+    [
+        "-0.000654",
+        {
+            dec128: "-0.0009876543",
+            int1: 2,
+            location: "California",
+            groupId: 3,
+        },
+    ],
+    [
+        "9876.123456",
+        {
+            dec128: "1234567890.0987654321",
+            int1: 1,
+            location: "California",
+            groupId: 3,
+        },
+    ],
+]);
+describe("TDWebSocket.WsSql()", () => {
+    jest.setTimeout(20 * 1000);
+    test("insert recoder", async () => {
+        let conf = new config_1.WSConfig(dns);
+        conf.setUser((0, utils_1.testUsername)());
+        conf.setPwd((0, utils_1.testPassword)());
+        let wsSql = await wsSql_1.WsSql.open(conf);
+        let taosResult = await wsSql.exec("use power");
+        console.log(taosResult);
+        expect(taosResult).toBeTruthy();
+        taosResult = await wsSql.exec("describe decimal_test");
+        console.log(taosResult);
+        taosResult = await wsSql.exec('INSERT INTO d1001 USING decimal_test (location, groupid) TAGS ("California", 3) VALUES (NOW, "9876.123456", "1234567890.0987654321", 1) (NOW + 1a, "-0.000654", "-0.0009876543", 2) (NOW + 2a, "-1234.654321", "-123456789012.0987654321", 3)');
+        console.log(taosResult);
+        expect(taosResult.getAffectRows()).toBeGreaterThanOrEqual(3);
+        let wsRows = await wsSql.query("select * from decimal_test");
+        expect(wsRows).toBeTruthy();
+        let meta = wsRows.getMeta();
+        expect(meta).toBeTruthy();
+        console.log("wsRow:meta:=>", meta);
+        let count = 0;
+        while (await wsRows.next()) {
+            let result = wsRows.getData();
+            if (result != null && result.length > 0) {
+                if (expectedResultsMap.has(result[1])) {
+                    console.log("result:=>", result);
+                    const expected = expectedResultsMap.get(result[1]);
+                    expect(result[2]).toBe(expected?.dec128);
+                    expect(result[3]).toBe(expected?.int1);
+                    expect(result[4]).toBe(expected?.location);
+                    expect(result[5]).toBe(expected?.groupId);
+                    count++;
+                }
+            }
+        }
+        await wsSql.close();
+        expect(count).toBe(3);
+    });
+});
+test("normal Subscribe", async () => {
+    let configMap = new Map([
+        [constant_1.TMQConstants.GROUP_ID, "gId"],
+        [constant_1.TMQConstants.CONNECT_USER, (0, utils_1.testUsername)()],
+        [constant_1.TMQConstants.CONNECT_PASS, (0, utils_1.testPassword)()],
+        [constant_1.TMQConstants.AUTO_OFFSET_RESET, "earliest"],
+        [constant_1.TMQConstants.CLIENT_ID, "test_tmq_client"],
+        [constant_1.TMQConstants.WS_URL, dns],
+        [constant_1.TMQConstants.ENABLE_AUTO_COMMIT, "true"],
+        [constant_1.TMQConstants.AUTO_COMMIT_INTERVAL_MS, "1000"],
+        ["session.timeout.ms", "10000"],
+        ["max.poll.interval.ms", "30000"],
+        ["msg.with.table.name", "true"],
+    ]);
+    let consumer = await wsTmq_1.WsConsumer.newConsumer(configMap);
+    await consumer.subscribe(["topic_decimal_test"]);
+    let assignment = await consumer.assignment();
+    console.log(assignment);
+    let useTime = [];
+    let count = 0;
+    for (let i = 0; i < 5; i++) {
+        let startTime = new Date().getTime();
+        let res = await consumer.poll(500);
+        let currTime = new Date().getTime();
+        useTime.push(Math.abs(currTime - startTime));
+        for (let [key, value] of res) {
+            console.log(key, value.getMeta());
+            let data = value.getData();
+            if (data == null || data.length == 0) {
+                break;
+            }
+            for (let record of data) {
+                console.log("record:=----------->", record);
+                if (expectedResultsMap.has(record[1])) {
+                    const expected = expectedResultsMap.get(record[1]);
+                    expect(record[2]).toBe(expected?.dec128);
+                    expect(record[3]).toBe(expected?.int1);
+                    expect(record[4]).toBe(expected?.location);
+                    expect(record[5]).toBe(expected?.groupId);
+                    count++;
+                }
+            }
+        }
+    }
+    await consumer.unsubscribe();
+    await consumer.close();
+    expect(count).toBe(3);
+});
+afterAll(async () => {
+    let conf = new config_1.WSConfig(dns);
+    conf.setUser((0, utils_1.testUsername)());
+    conf.setPwd((0, utils_1.testPassword)());
+    let wsSql = await wsSql_1.WsSql.open(conf);
+    await wsSql.exec(dropTopic);
+    await wsSql.exec("drop database power");
+    await wsSql.close();
+    wsConnectorPool_1.WebSocketConnectionPool.instance().destroyed();
+});

package/lib/test/sql/core/queryTables.test.d.ts

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

package/lib/test/sql/core/queryTables.test.d.ts.map

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