@tdengine/websocket 3.0.0 → 3.1.1

package/src/wsQueryInterface.ts

@@ -1,212 +0,0 @@
-import { parseBlock, TaosResult } from './taosResult';
-import { TDWebSocketClient } from './wsClient'
-import { WebSocketInterfaceError, WebSocketQueryError } from './wsError'
-import { WSVersionResponse, WSFetchBlockResponse, WSQueryResponse, WSFetchResponse, WSConnResponse } from './wsQueryResponse'
-import JSONBig from 'json-bigint'
-
-export class WSInterface {
-    private _wsQueryClient: TDWebSocketClient;
-    private _req_id = 0;
-    private _url;
-
-    constructor(url: URL) {
-        this.checkURL(url);
-        this._url = url;
-        this._wsQueryClient = new TDWebSocketClient(this._url);
-    }
-
-    connect(database?: string): Promise<WSConnResponse> {
-
-        let _db = this._url.pathname.split('/')[3];
-
-        if (database) {
-            _db = database;
-        }
-        this._reqIDIncrement()
-        let connMsg = {
-            action: 'conn',
-            args: {
-                req_id: this._req_id,
-                user: this._url.username,
-                password: this._url.password,
-                db: _db,
-            }
-        }
-        // console.log(connMsg)
-        return new Promise((resolve, reject) => {
-            if (this._wsQueryClient.readyState() > 0) {
-                this._wsQueryClient.sendMsg(JSON.stringify(connMsg))
-                    .then((e: any) => {
-                        if (e.code == 0) {
-                            resolve(e);
-                        } else {
-                            reject(new WebSocketQueryError(`${e.message}, code ${e.code}`))
-                        }
-                    })
-            } else {
-                this._wsQueryClient.Ready()
-                    .then((ws: TDWebSocketClient) => {
-                        return ws.sendMsg(JSON.stringify(connMsg))
-                    })
-                    .then((e: any) => {
-                        if (e.code == 0) {
-                            resolve(e);
-                        } else {
-                            reject(new WebSocketQueryError(`${e.message}, code ${e.code}`))
-                        }
-                    })
-            }
-
-        })
-    }
-
-    // need to construct Response.
-    query(sql: string): Promise<WSQueryResponse> {
-        this._reqIDIncrement()
-        // construct msg
-        let queryMsg = {
-            action: 'query',
-            args: {
-                req_id: this._req_id,
-                sql: sql
-            },
-        }
-        return new Promise((resolve, reject) => {
-            let jsonStr = JSON.stringify(queryMsg)
-            // console.log("[wsQueryInterface.query.queryMsg]===>" + jsonStr)
-            this._wsQueryClient.sendMsg(jsonStr)
-                .then((e: any) => {
-                    if (e.code == 0) {
-                        resolve(new WSQueryResponse(e))
-                    } else {
-                        reject(new WebSocketInterfaceError(`${e.message},code ${e.code}`))
-                    }
-                })
-        })
-    }
-
-    getState() {
-        return this._wsQueryClient.readyState()
-    }
-
-    fetch(res: WSQueryResponse): Promise<WSFetchResponse> {
-        this._reqIDIncrement()
-        let fetchMsg = {
-            action: 'fetch',
-            args: {
-                req_id: this._req_id,
-                id: res.id
-            }
-        }
-        // console.log("[wsQueryInterface.fetch()]===>wsQueryResponse\n")
-        // console.log(res)
-        return new Promise((resolve, reject) => {
-            let jsonStr = JSONBig.stringify(fetchMsg)
-            // console.log("[wsQueryInterface.fetch.fetchMsg]===>" + jsonStr)
-            this._wsQueryClient.sendMsg(jsonStr)
-                .then((e: any) => {
-                    if (e.code == 0) {
-                        resolve(new WSFetchResponse(e))
-                    } else {
-                        reject(new WebSocketInterfaceError(`${e.message},code ${e.code}`))
-                    }
-                }).catch(e => {
-                    reject(e)
-                });
-        })
-    }
-
-    fetchBlock(fetchResponse: WSFetchResponse, taosResult: TaosResult): Promise<TaosResult> {
-        this._reqIDIncrement()
-        let fetchBlockMsg = {
-            action: 'fetch_block',
-            args: {
-                'req_id': this._req_id,
-                'id': fetchResponse.id,
-            }
-        }
-        return new Promise((resolve, reject) => {
-            let jsonStr = JSONBig.stringify(fetchBlockMsg)
-            // console.log("[wsQueryInterface.fetchBlock.fetchBlockMsg]===>" + jsonStr)
-            this._wsQueryClient.sendMsg(jsonStr).then((e: any) => {
-                resolve(parseBlock(fetchResponse, new WSFetchBlockResponse(e), taosResult))
-                // if retrieve JSON then reject with message
-                // else is binary , so parse raw block to TaosResult
-            }).catch(e => reject(e))
-        })
-    }
-
-    freeResult(res: WSQueryResponse) {
-        this._reqIDIncrement()
-        let freeResultMsg = {
-            action: 'free_result',
-            args: {
-                req_id: this._req_id,
-                id: res.id
-            }
-        }
-        return new Promise((resolve, reject) => {
-            let jsonStr = JSONBig.stringify(freeResultMsg)
-            // console.log("[wsQueryInterface.freeResult.freeResultMsg]===>" + jsonStr)
-            this._wsQueryClient.sendMsg(jsonStr, false).then((e: any) => {
-                resolve(e)
-            }).catch(e => reject(e))
-        })
-    }
-
-    version(): Promise<string> {
-        this._reqIDIncrement()
-        let versionMsg = {
-            action: 'version',
-            args: {
-                req_id: this._req_id
-            }
-        }
-        return new Promise((resolve, reject) => {
-            if (this._wsQueryClient.readyState() > 0) {
-                this._wsQueryClient.sendMsg(JSONBig.stringify(versionMsg))
-                    .then((e: any) => {
-                        // console.log(e)
-                        if (e.code == 0) {
-                            resolve(new WSVersionResponse(e).version)
-                        } else {
-                            reject(new WSVersionResponse(e).message)
-                        }
-                    }).catch(e => reject(e));
-            }
-            this._wsQueryClient.Ready()
-                .then((ws: TDWebSocketClient) => {
-                    return ws.sendMsg(JSONBig.stringify(versionMsg))
-                }).then((e: any) => {
-                    // console.log(e)
-                    if (e.code == 0) {
-                        resolve(new WSVersionResponse(e).version)
-                    } else {
-                        reject(new WSVersionResponse(e).message)
-                    }
-                }).catch(e => reject(e));
-        })
-    }
-
-    close() {
-        this._wsQueryClient.close();
-    }
-
-    checkURL(url: URL) {
-        // Assert is cloud url
-        if (!url.searchParams.has('token')) {
-            if (!(url.username || url.password)) {
-                throw new WebSocketInterfaceError("invalid url, password or username needed.")
-            }
-        }
-    }
-
-    private _reqIDIncrement() {
-        if (this._req_id == Number.MAX_SAFE_INTEGER) {
-            this._req_id = 0;
-        } else {
-            this._req_id += 1;
-        }
-    }
-
-}

package/src/wsQueryResponse.ts

@@ -1,112 +0,0 @@
-/**
- * define ws Response type|class, for query?
- */
-
-
-export class WSVersionResponse {
-
-    version: string;
-    code: number;
-    message: string;
-    action: string;
-
-    constructor(msg: any) {
-
-        this.version = msg.version;
-        this.code = msg.code;
-        this.message = msg.message;
-        this.action = msg.action;
-    }
-}
-
-export class WSQueryResponse {
-    code: number;
-    message: string;
-    action: string;
-    req_id: number;
-    timing: bigint;
-    id: bigint;
-    is_update: boolean;
-    affected_rows: number;
-    fields_count: number | null;
-    fields_names: Array<string> | null;
-    fields_types: Array<number> | null;
-    fields_lengths: Array<number> | null;
-    precision: number;
-
-    constructor(msg: any) {
-        this.code = msg.code;
-        this.message = msg.message;
-        this.action = msg.action;
-        this.req_id = msg.req_id;
-        this.timing = BigInt(msg.timing);
-        this.id = BigInt(msg.id);
-        this.is_update = msg.is_update;
-        this.affected_rows = msg.affected_rows;
-        this.fields_count = msg.fields_count;
-        this.fields_names = msg.fields_names;
-        this.fields_types = msg.fields_types;
-        this.fields_lengths = msg.fields_lengths;
-        this.precision = msg.precision;
-    }
-}
-
-export class WSFetchResponse {
-    code: number;
-    message: string;
-    action: string;
-    req_id: number;
-    timing: bigint;
-    id: bigint;
-    completed: boolean;
-    length: Array<number>;
-    rows: number;
-
-    constructor(msg: any) {
-        this.code = msg.code;
-        this.message = msg.message;
-        this.action = msg.action;
-        this.req_id = msg.req_id;
-        this.timing = BigInt(msg.timing);
-        this.id = BigInt(msg.id);
-        this.completed = msg.completed;
-        this.length = msg.length;
-        this.rows = msg.rows;
-    }
-}
-
-export class WSFetchBlockResponse {
-
-    id: bigint
-    data: ArrayBuffer
-    timing: bigint
-    constructor(msg: ArrayBuffer) {
-        this.timing = new DataView(msg, 0, 8).getBigUint64(0, true)
-        this.id = new DataView(msg, 8, 8).getBigUint64(0, true)
-        this.data = msg.slice(16)
-    }
-}
-
-interface IWSConnResponse {
-    code: number;
-    message: string;
-    action: string;
-    req_id: number;
-    timing: bigint;
-}
-
-export class WSConnResponse {
-    code: number;
-    message: string;
-    action: string;
-    req_id: number;
-    timing: bigint;
-
-    constructor(msg: IWSConnResponse) {
-        this.code = msg.code;
-        this.message = msg.message;
-        this.action = msg.action;
-        this.req_id = msg.req_id;
-        this.timing = BigInt(msg.timing);
-    }
-}

package/test/bulkPulling/connect.test.ts

@@ -1,27 +0,0 @@
-// import {describe, expect, test} from '@jest/globals';
-import { connect } from "../../index"
-const DSN = 'ws://root:taosdata@127.0.0.1:6041/rest/ws'
-// const DSN = 'ws://root:taosdata@182.92.127.131:6041/rest/ws'
-var ws = connect(DSN)
-
-describe('TDWebSocket.connect() success ', () => {
-    test('normal connect', async() => {
-        let connRes = await ws.connect()
-        expect(connRes.action).toBe('conn')
-    })
-
-    test.skip('connect fails with error', async() => {
-        expect.assertions(1)
-        try {
-            await  ws.connect("jest");
-        }catch(e){
-            expect(e).toMatch('Invalid database name')
-        }
-    })
-
-})
-
-afterEach(() => {
-    //close websocket and clear data
-    ws.close()
-})

package/test/bulkPulling/queryTables.test.ts

@@ -1,274 +0,0 @@
-import { connect } from "../../index"
-// const TDWebSocket = require("../../dist/main/index.js") 
-import { createSTable, createSTableJSON, createTable, expectStableData, insertNTable, insertStable, jsonMeta, tableMeta, tagMeta } from "../utils";
-const DSN = 'ws://root:taosdata@127.0.0.1:6041/rest/ws'
-// const DSN = 'ws://root:taosdata@182.92.127.131:6041/rest/ws'
-var ws = connect(DSN)
-const table = 'ws_q_n';
-const stable = 'ws_q_s';
-const tableCN = 'ws_q_n_cn';
-const stableCN = 'ws_q_s_cn';
-const db = 'ws_q_db'
-const jsonTable = 'ws_q_j';
-const jsonTableCN = 'ws_q_j_cn';
-
-const createDB = `create database if not exists ${db} keep 3650`
-const dropDB = `drop database if exists ${db}`
-const useDB = `use ${db}`
-
-const stableTags = [true, -1, -2, -3, BigInt(-4), 1, 2, 3, BigInt(4), parseFloat(3.1415.toFixed(5)), parseFloat(3.14159265.toFixed(15)), 'varchar_tag_1', 'nchar_tag_1']
-const stableCNTags = [false, -1 * 2, -2 * 2, -3 * 2, BigInt(-4 * 2), 1 * 2, 2 * 2, 3 * 2, BigInt(4 * 2), parseFloat((3.1415 * 2).toFixed(5)), parseFloat((3.14159265 * 2).toFixed(15)), 'varchar_标签_壹', 'nchar_标签_贰']
-
-const tableValues = [
-    [BigInt(1656677710000), 0, -1, -2, BigInt(-3), 0, 1, 2, BigInt(3), parseFloat(3.1415.toFixed(5)), parseFloat(3.14159265.toFixed(15)), 'varchar_col_1', 'nchar_col_1', true, 'NULL'],
-    [BigInt(1656677720000), -1, -2, -3, BigInt(-4), 1, 2, 3, BigInt(4), parseFloat((3.1415 * 2).toFixed(5)), parseFloat((3.14159265 * 2).toFixed(15)), 'varchar_col_2', 'nchar_col_2', false, 'NULL'],
-    [BigInt(1656677730000), -2, -3, -4, BigInt(-5), 2, 3, 4, BigInt(5), parseFloat((3.1415 * 3).toFixed(5)), parseFloat((3.14159265 * 3).toFixed(15)), 'varchar_col_3', 'nchar_col_3', true, 'NULL'],
-    [BigInt(1656677740000), -3, -4, -5, BigInt(-6), 3, 4, 5, BigInt(6), parseFloat((3.1415 * 4).toFixed(5)), parseFloat((3.14159265 * 4).toFixed(15)), 'varchar_col_4', 'nchar_col_4', false, 'NULL'],
-    [BigInt(1656677750000), -4, -5, -6, BigInt(-7), 4, 5, 6, BigInt(7), parseFloat((3.1415 * 5).toFixed(5)), parseFloat((3.14159265 * 5).toFixed(15)), 'varchar_col_5', 'nchar_col_5', true, 'NULL'],
-]
-
-const tableCNValues = [
-    [BigInt(1656677760000), 0, -1, -2, BigInt(-3), 0, 1, 2, BigInt(3), parseFloat(3.1415.toFixed(5)), parseFloat(3.14159265.toFixed(15)), 'varchar_列_壹', 'nchar_列_甲', true, 'NULL'],
-    [BigInt(1656677770000), -1, -2, -3, BigInt(-4), 1, 2, 3, BigInt(4), parseFloat((3.1415 * 2).toFixed(5)), parseFloat((3.14159265 * 2).toFixed(15)), 'varchar_列_贰', 'nchar_列_乙', false, 'NULL'],
-    [BigInt(1656677780000), -2, -3, -4, BigInt(-5), 2, 3, 4, BigInt(5), parseFloat((3.1415 * 3).toFixed(5)), parseFloat((3.14159265 * 3).toFixed(15)), 'varchar_列_叁', 'nchar_列_丙', true, 'NULL'],
-    [BigInt(1656677790000), -3, -4, -5, BigInt(-6), 3, 4, 5, BigInt(6), parseFloat((3.1415 * 4).toFixed(5)), parseFloat((3.14159265 * 4).toFixed(15)), 'varchar_列_肆', 'nchar_列_丁', false, 'NULL'],
-    [BigInt(1656677800000), -4, -5, -6, BigInt(-7), 4, 5, 6, BigInt(7), parseFloat((3.1415 * 5).toFixed(5)), parseFloat((3.14159265 * 5).toFixed(15)), 'varchar_列_伍', 'nchar_列_戊', true, 'NULL'],
-]
-const jsonTags = ["{\"key1\":\"taos\",\"key2\":null,\"key3\":\"TDengine\",\"key4\":0,\"key5\":false}"]
-const jsonTagsCN = ["{\"key1\":\"taosdata\",\"key2\":null,\"key3\":\"TDengine涛思数据\",\"key4\":1,\"key5\":true}"]
-
-const selectStable = `select * from ${stable}`
-const selectStableCN = `select * from ${stableCN}`
-const selectTable = `select * from ${table}`
-const selectTableCN = `select * from ${tableCN}`
-const selectJsonTable = `select * from ${jsonTable}`
-const selectJsonTableCN = `select * from ${jsonTableCN}`
-
-beforeAll(async () => {
-    return await ws.connect()
-        .then(() => ws.query(createDB))
-        .then(() => ws.query(useDB))
-        .then(() => ws.query(createSTable(stable)))
-        .then(() => ws.query(createSTable(stableCN)))
-        .then(() => ws.query(createTable(table)))
-        .then(() => ws.query(createTable(tableCN)))
-        .then(() => ws.query(createSTableJSON(jsonTable)))
-        .then(() => ws.query(createSTableJSON(jsonTableCN)))
-        .catch((e) => { throw new Error(e) })
-})
-
-describe('ws.query(stable)', () => {
-    test('Insert query stable without CN character', async () => {
-        let insert = insertStable(tableValues, stableTags, stable)
-        let insertRes = await ws.query(insert)
-        expect(insertRes.affectRows).toBe(5)
-
-        let queryRes = await ws.query(selectStable)
-
-        let expectMeta = tableMeta.concat(tagMeta)
-        let expectData = expectStableData(tableValues, stableTags)
-        let actualMeta = queryRes.getTDengineMeta()
-        let actualData = queryRes.data
-
-        if (actualData && actualMeta) {
-            actualMeta.forEach((meta, index) => {
-                ////   console.log(meta);
-                expect(meta.name).toBe(expectMeta[index].name)
-                expect(meta.type).toBe(expectMeta[index].type)
-                expect(meta.length).toBe(expectMeta[index].length)
-            })
-
-            for (let i = 0; i < actualData.length; i++) {
-                actualData[i].forEach((d, index) => {
-                    // //   console.log(i, index, d, expectData[i][index])
-                    expect(d).toBe(expectData[i][index])
-                })
-            }
-        } else {
-            throw new Error("retrieve empty result")
-        }
-    })
-
-    test('query stable with CN character', async () => {
-        let insertCN = insertStable(tableCNValues, stableCNTags, stableCN)
-        // console.log(insertCN)
-        let insertRes = await ws.query(insertCN)
-        // console.log(insertRes)
-        expect(insertRes.affectRows).toBe(5)
-
-        let queryRes = await ws.query(selectStableCN)
-
-        let expectMeta = tableMeta.concat(tagMeta)
-        let expectData = expectStableData(tableCNValues, stableCNTags)
-        let actualMeta = queryRes.getTDengineMeta()
-        let actualData = queryRes.data
-
-        if (actualData && actualMeta) {
-            actualMeta.forEach((meta, index) => {
-                expect(meta.name).toBe(expectMeta[index].name)
-                expect(meta.type).toBe(expectMeta[index].type)
-                expect(meta.length).toBe(expectMeta[index].length)
-                ////   console.log(meta);
-            })
-
-            for (let i = 0; i < actualData.length; i++) {
-                actualData[i].forEach((d, index) => {
-                    // //   console.log(i, index, d, expectData[i][index])
-                    expect(d).toBe(expectData[i][index])
-
-                })
-            }
-        } else {
-            throw new Error("retrieve empty result")
-        }
-
-
-    })
-
-
-})
-
-describe('ws.query(table)', () => {
-    test('Insert query normal table without CN character', async () => {
-        let insert = insertNTable(tableValues, table)
-        // console.log(insert)
-        let insertRes = await ws.query(insert)
-        expect(insertRes.affectRows).toBe(5)
-
-        let queryRes = await ws.query(selectTable)
-
-        let expectMeta = tableMeta
-        let expectData = tableValues
-        let actualMeta = queryRes.getTDengineMeta()
-        let actualData = queryRes.data
-
-        if (actualData && actualMeta) {
-            actualMeta.forEach((meta, index) => {
-                // console.log(meta,expectMeta[index]);
-                expect(meta.name).toBe(expectMeta[index].name)
-                expect(meta.type).toBe(expectMeta[index].type)
-                expect(meta.length).toBe(expectMeta[index].length)
-            })
-
-            for (let i = 0; i < actualData.length; i++) {
-                actualData[i].forEach((d, index) => {
-                    // //   console.log(i, index, d, expectData[i][index])
-                    expect(d).toBe(expectData[i][index])
-                })
-            }
-        } else {
-            throw new Error("retrieve empty result")
-        }
-    })
-
-    test('Insert query normal table with CN character', async () => {
-        let insertCN = insertNTable(tableCNValues, tableCN)
-        // console.log(insertCN)
-        let insertRes = await ws.query(insertCN)
-        // console.log(insertRes)
-        expect(insertRes.affectRows).toBe(5)
-
-        let queryRes = await ws.query(selectTableCN)
-
-        let expectMeta = tableMeta
-        let expectData = tableCNValues
-        let actualMeta = queryRes.getTDengineMeta()
-        let actualData = queryRes.data
-
-        if (actualData && actualMeta) {
-            actualMeta.forEach((meta, index) => {
-                // console.log(meta, expectMeta[index]);
-
-                expect(meta.name).toBe(expectMeta[index].name)
-                expect(meta.type).toBe(expectMeta[index].type)
-                expect(meta.length).toBe(expectMeta[index].length)
-            })
-
-            for (let i = 0; i < actualData.length; i++) {
-                actualData[i].forEach((d, index) => {
-                    // console.log(i, index, d, expectData[i][index])
-                    expect(d).toBe(expectData[i][index])
-
-                })
-            }
-        } else {
-            throw new Error("retrieve empty result")
-        }
-    })
-})
-
-describe('ws.query(jsonTable)', () => {
-    test('Insert and query json data from table without CN', async () => {
-        let insert = insertStable(tableValues, jsonTags, jsonTable)
-        // console.log(insert)
-
-        let insertRes = await ws.query(insert);
-        expect(insertRes.affectRows).toBe(5)
-
-        let queryRes = await ws.query(selectJsonTable)
-        let expectMeta = tableMeta.concat(jsonMeta)
-        let expectData = expectStableData(tableValues, jsonTags)
-        let actualMeta = queryRes.getTDengineMeta()
-        let actualData = queryRes.data
-
-        if (actualData && actualMeta) {
-            actualMeta.forEach((meta, index) => {
-                //   console.log(meta);
-                expect(meta.name).toBe(expectMeta[index].name)
-                expect(meta.type).toBe(expectMeta[index].type)
-                expect(meta.length).toBe(expectMeta[index].length)
-            })
-
-            for (let i = 0; i < actualData.length; i++) {
-                actualData[i].forEach((d, index) => {
-                    //   console.log(i, index, d, expectData[i][index])
-                    expect(d).toBe(expectData[i][index])
-                })
-            }
-        } else {
-            throw new Error("retrieve empty result")
-        }
-
-    })
-
-
-    test('Insert and query json data from table with CN', async () => {
-        let insert = insertStable(tableCNValues, jsonTagsCN, jsonTableCN)
-        // console.log(insert)
-
-        let insertRes = await ws.query(insert);
-        expect(insertRes.affectRows).toBe(5)
-
-        let queryRes = await ws.query(selectJsonTableCN)
-        let expectMeta = tableMeta.concat(jsonMeta)
-        let expectData = expectStableData(tableCNValues, jsonTagsCN)
-        let actualMeta = queryRes.getTDengineMeta()
-        let actualData = queryRes.data
-
-        if (actualData && actualMeta) {
-            actualMeta.forEach((meta, index) => {
-                //   console.log(meta);
-                expect(meta.name).toBe(expectMeta[index].name)
-                expect(meta.type).toBe(expectMeta[index].type)
-                expect(meta.length).toBe(expectMeta[index].length)
-            })
-
-            for (let i = 0; i < actualData.length; i++) {
-                actualData[i].forEach((d, index) => {
-                    //   console.log(i, index, d, expectData[i][index])
-                    expect(d).toBe(expectData[i][index])
-                })
-            }
-        } else {
-            throw new Error("retrieve empty result")
-        }
-    })
-
-})
-
-afterAll(async () => {
-    await ws.query(dropDB)
-    ws.close()
-})
-
-//--detectOpenHandles --maxConcurrency=1 --forceExit

package/test/bulkPulling/version.test.ts

@@ -1,19 +0,0 @@
-import { connect } from "../../index"
-const DSN = 'ws://root:taosdata@127.0.0.1:6041/rest/ws'
-// const DSN = 'ws://root:taosdata@182.92.127.131:6041/rest/ws'
-var ws = connect(DSN)
-
-describe('TDWebSocket.version()', () => {
-    test('check version', () => {
-        return ws.version()
-        .then((version) => {
-            // console.log(version)
-            expect(version.charAt(0)).toEqual('3')
-        })
-        .then(()=>{ws.close()})
-    })
-})
-afterAll(() => {
-    //close websocket and clear data
-    ws.close()
-})