@frangoteam/fuxa-min 1.2.11 → 1.3.1

package/runtime/storage/calculator.js

@@ -1,5 +1,5 @@
 /**
- *  Calculator for DAQ value array (integrale, max, min, average...) 
+ *  Calculator for DAQ value array (integrale, max, min, average...)
  */
 
 'use strict';
@@ -19,11 +19,11 @@ function getFunctionValues(values, fromts, tots, fnc, interval, format) {
 }
 
 /**
- * 
- * @param {*} values 
- * @param {*} fnc 
- * @param {*} intervalType hour / day 
- * @returns 
+ *
+ * @param {*} values
+ * @param {*} fnc
+ * @param {*} intervalType hour / day
+ * @returns
  */
 function getMin(timeserie, fromts, tots, intervalType) {
     let result = getInterval(fromts, tots, intervalType, Number.MAX_VALUE);
@@ -39,7 +39,7 @@ function getMin(timeserie, fromts, tots, intervalType) {
             intervals[intervalIndex] = value;
         }
     }
-    
+
     for (let i = 0; i < sorted.length; i++) {
         let intervalIndex = getIntervalTime(sorted[i].dt, intervalType, false).getTime();
         addToInterval(result, intervalIndex, utils.parseFloat(sorted[i].value, 5));
@@ -61,7 +61,7 @@ function getMax(timeserie, fromts, tots, intervalType) {
             intervals[intervalIndex] = value;
         }
     }
-    
+
     for (let i = 0; i < sorted.length; i++) {
         let intervalIndex = getIntervalTime(sorted[i].dt, intervalType, false).getTime();
         addToInterval(result, intervalIndex, utils.parseFloat(sorted[i].value, 5));
@@ -85,7 +85,7 @@ function getAverage(timeserie, fromts, tots, intervalType, format) {
         }
         counters[intervalIndex]++;
     }
-    
+
     for (let i = 0; i < sorted.length; i++) {
         let intervalIndex = getIntervalTime(sorted[i].dt, intervalType, false).getTime();
         addToInterval(result, counts, intervalIndex, parseFloat(sorted[i].value));
@@ -96,7 +96,7 @@ function getAverage(timeserie, fromts, tots, intervalType, format) {
             result[k] = utils.parseFloat(result[k] / counts[k], format || 5);
         }
     });
-    return result; 
+    return result;
 }
 
 function getSum(timeserie, fromts, tots, intervalType) {
@@ -114,12 +114,12 @@ function getSum(timeserie, fromts, tots, intervalType) {
             intervals[intervalIndex] = utils.parseFloat(intervals[intervalIndex], 5)
         }
     }
-    
+
     for (let i = 0; i < sorted.length; i++) {
         let intervalIndex = getIntervalTime(sorted[i].dt, intervalType, false).getTime();
         addToInterval(result, intervalIndex, parseFloat(sorted[i].value));
     }
-    return result;    
+    return result;
 }
 
 
@@ -137,7 +137,7 @@ function getIntegral(timeserie, fromts, tots, intervalType) {
             intervals[intervalIndex] += value;
         }
     }
-    
+
     let lastRecord = null;// : TimeValue { dt: number, value: number };
     let lastIntervalIndex = null;
     for (let i = 0; i < sorted.length; i++) {
@@ -191,6 +191,10 @@ function getStepDate(ts, type, toadd) {
         dtRange = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate(), dt.getHours(), 0, 0);
         var minutesRange = parseInt(dt.getMinutes() / 30);
         dtRange.setMinutes((minutesRange + toadd) * 30);
+    } else if (type === ReportIntervalType.min15) {
+        dtRange = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate(), dt.getHours(), 0, 0);
+        var minutesRange = parseInt(dt.getMinutes() / 15);
+        dtRange.setMinutes((minutesRange + toadd) * 15);
     } else if (type === ReportIntervalType.min10) {
         dtRange = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate(), dt.getHours(), 0, 0);
         var minutesRange = parseInt(dt.getMinutes() / 10);

package/runtime/storage/daqstorage.js

@@ -21,6 +21,7 @@ var logger;
 var daqDB = {};                 // list of daqDB node: SQlite one pro device, influxDB only one
 var currentStorateDB;
 var runtime;
+var questDbModule = null;
 
 function init(_settings, _log, _runtime) {
     settings = _settings;
@@ -42,7 +43,7 @@ function reset() {
 function addDaqNode(_id, fncgetprop) {
     var id = _id;
     const dbType = _getDbType();
-    if (dbType === DaqStoreTypeEnum.influxDB || dbType === DaqStoreTypeEnum.influxDB18 || dbType === DaqStoreTypeEnum.TDengine) {
+    if (dbType === DaqStoreTypeEnum.influxDB || dbType === DaqStoreTypeEnum.influxDB18 || dbType === DaqStoreTypeEnum.TDengine || dbType === DaqStoreTypeEnum.questDB) {
         id = dbType;
     }
     if (!daqDB[id]) {
@@ -50,6 +51,14 @@ function addDaqNode(_id, fncgetprop) {
             daqDB[id] = InfluxDB.create(settings, logger, currentStorateDB);
         } else if(id === DaqStoreTypeEnum.TDengine){
             daqDB[id] = TDengine.create(settings, logger, currentStorateDB);
+        } else if(id === DaqStoreTypeEnum.questDB){
+            const QuestDB = _getQuestDbModule();
+            if (QuestDB) {
+                daqDB[id] = QuestDB.create(settings, logger, currentStorateDB);
+            } else {
+                logger.warn('daqstorage: QuestDB storage selected but package dependencies are not installed. Falling back to SQLite.');
+                daqDB[id] = SqliteDB.create(settings, logger, id, currentStorateDB);
+            }
         } else {
             daqDB[id] = SqliteDB.create(settings, logger, id, currentStorateDB);
         }
@@ -160,16 +169,33 @@ function _getDaqNode(tagid) {
 
 function _getDbType() {
     if (settings.daqstore && settings.daqstore.type) {
+        if (settings.daqstore.type === 'QuestDB') {
+            return DaqStoreTypeEnum.questDB;
+        }
         return settings.daqstore.type;
     }
     return DaqStoreTypeEnum.SQlite;
 }
 
+function _getQuestDbModule() {
+    if (questDbModule) {
+        return questDbModule;
+    }
+    try {
+        questDbModule = require("./questdb");
+    } catch (err) {
+        questDbModule = null;
+        logger.warn(`daqstorage: QuestDB module unavailable (${err.message})`);
+    }
+    return questDbModule;
+}
+
 var DaqStoreTypeEnum = {
     SQlite: 'SQlite',
     influxDB: 'influxDB',
     influxDB18: 'influxDB18',
     TDengine: 'TDengine',
+    questDB: 'questDB',
 }
 
 function _getValue(value) {
@@ -187,4 +213,4 @@ module.exports = {
     getNodesValues: getNodesValues,
     checkRetention: checkRetention,
     getCurrentStorageFnc: getCurrentStorageFnc,
-};
+};

package/runtime/storage/influxdb/index.js

@@ -12,6 +12,10 @@ var { InfluxDB, Point, flux } = require('@influxdata/influxdb-client');
 const VERSION_18_FLUX = '1.8-flux';
 const VERSION_20 = '2.0';
 
+function escapeInfluxIdentifier(value) {
+    return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
 function Influx(_settings, _log, _currentStorate) {
 
     var settings = _settings;               // Application settings
@@ -157,7 +161,8 @@ function Influx(_settings, _log, _currentStorate) {
                 if (influxdbVersion === VERSION_18_FLUX) {
                     fromts *= 1000000;
                     tots *= 1000000;
-                    const query = `SELECT * FROM "${tagid}" WHERE time >= ${fromts} AND time <= ${tots}`;
+                    const measurement = escapeInfluxIdentifier(tagid);
+                    const query = `SELECT * FROM "${measurement}" WHERE time >= ${Number(fromts)} AND time <= ${Number(tots)}`;
                     client.query(query).then((result) => {
                         resolve(result.map(row => {
                             return {
@@ -171,7 +176,7 @@ function Influx(_settings, _log, _currentStorate) {
                         reject(error);
                     });
                 } else {
-                    const query = flux`from(bucket: "${settings.daqstore.bucket}") |> range(start: ${new Date(fromts)}, stop: ${new Date(tots)}) |> filter(fn: (r) => r.id == "${tagid}")`;
+                    const query = flux`from(bucket: ${settings.daqstore.bucket}) |> range(start: ${new Date(fromts)}, stop: ${new Date(tots)}) |> filter(fn: (r) => r.id == ${String(tagid)})`;
                     var result = [];
                     queryApi.queryRows(query, {
                         next(row, tableMeta) {
@@ -234,4 +239,4 @@ module.exports = {
 var InfluxDBStatusEnum = {
     OPEN: 'open',
     CLOSE: 'close',
-}
+}

package/runtime/storage/questdb/index.js

@@ -0,0 +1,224 @@
+'use strict'
+
+const { Pool } = require('pg');
+const { Sender } = require('@questdb/nodejs-client');
+let utils = require('../../utils');
+
+function QuestDB(_settings, _log, _currentStorage) {
+    let settings = _settings;               // Application settings
+    const logger = _log;                    // Application logger
+    const currentStorage = _currentStorage; // Database to set the last value (current)
+    let pool = null;
+    let sender = null;
+    const tableName = getTableName();
+    let writeQueue = Promise.resolve();
+    let initPromise = Promise.resolve();
+
+    this.setCall = function (_fncGetProp) {
+        fncGetTagProp = _fncGetProp;
+        return this.addDaqValues;
+    }
+    var fncGetTagProp = null;
+
+    this.init = async function () {
+        try {
+            pool = new Pool(getQueryClientConfig());
+            sender = await Sender.fromConfig(getIngestConfigString());
+            await ensureSchema();
+            logger.info('QuestDB connected');
+        } catch (error) {
+            logger.error(`questdb-init failed! ${error}`);
+        }
+    }
+
+    this.addDaqValues = function (tagsValues, deviceName, deviceId) {
+        var dataToRestore = [];
+        var rowsToWrite = [];
+
+        for (const tagid in tagsValues) {
+            let tag = tagsValues[tagid];
+            if (!tag.daq || utils.isNullOrUndefined(tag.value) || Number.isNaN(tag.value)) {
+                if (tag.daq && tag.daq.restored) {
+                    dataToRestore.push({ id: tag.id, deviceId: deviceId, value: tag.value });
+                }
+                if (tag.daq && !tag.daq.enabled) {
+                    continue;
+                }
+            }
+
+            rowsToWrite.push({
+                tagid,
+                deviceId,
+                deviceName: deviceName || '',
+                unsPath: normalizeUnsPath(tag.unsPath),
+                value: tag.value,
+                timestamp: tag.timestamp || Date.now(),
+            });
+        }
+
+        if (rowsToWrite.length) {
+            writeQueue = writeQueue.then(async () => {
+                await initPromise;
+                if (!sender) {
+                    return;
+                }
+
+                for (const row of rowsToWrite) {
+                    const parsedValue = normalizeValue(row.value);
+                    let line = sender
+                        .table(tableName)
+                        .symbol('tag_id', row.tagid)
+                        .symbol('device_id', row.deviceId)
+                        .stringColumn('device_name', row.deviceName);
+                    if (!utils.isNullOrUndefined(row.unsPath)) {
+                        line = line.symbol('uns_path', row.unsPath);
+                    }
+
+                    if (!utils.isNullOrUndefined(parsedValue.numberValue)) {
+                        line = line.floatColumn('number_value', parsedValue.numberValue);
+                    }
+                    if (!utils.isNullOrUndefined(parsedValue.stringValue)) {
+                        line = line.stringColumn('string_value', parsedValue.stringValue);
+                    }
+                    await line.at(Number(row.timestamp), 'ms');
+                }
+                await sender.flush();
+            }).catch((error) => {
+                logger.error(`questdb-addDaqValues failed! ${error}`);
+            });
+        }
+
+        if (dataToRestore.length && currentStorage) {
+            currentStorage.setValues(dataToRestore);
+        }
+    }
+
+    this.getDaqValue = function (tagid, fromts, tots) {
+        return new Promise(function (resolve, reject) {
+            initPromise.then(() => {
+                if (!pool) {
+                    resolve([]);
+                    return;
+                }
+
+                const query = `SELECT timestamp, number_value, string_value
+                               FROM ${tableName}
+                               WHERE tag_id = $1
+                                 AND timestamp >= $2
+                                 AND timestamp < $3
+                               ORDER BY timestamp`;
+                const params = [tagid, new Date(fromts), new Date(tots)];
+
+                pool.query(query, params)
+                    .then((result) => {
+                        let data = [];
+                        result.rows.forEach((row) => {
+                            const value = !utils.isNullOrUndefined(row.number_value) ? Number(row.number_value) : row.string_value;
+                            data.push({ dt: new Date(row.timestamp).getTime(), value });
+                        });
+                        resolve(data)
+                    })
+                    .catch((error) => {
+                        logger.error(`questdb-getDaqValue failed! ${error}`)
+                        reject(error)
+                    })
+            }).catch((error) => {
+                logger.error(`questdb-getDaqValue failed! ${error}`)
+                reject(error)
+            });
+        })
+    }
+
+    this.close = function () {
+        if (sender) {
+            sender.close().catch((error) => {
+                logger.error(`questdb-close sender failed! ${error}`);
+            });
+            sender = null;
+        }
+        if (pool) {
+            pool.end().catch((error) => {
+                logger.error(`questdb-close pool failed! ${error}`);
+            });
+            pool = null;
+        }
+    }
+
+    this.getDaqMap = function (tagid) {
+        var dummy = {};
+        dummy[tagid] = true;
+        return dummy;
+    }
+
+    async function ensureSchema() {
+        if (!pool) {
+            return;
+        }
+        await pool.query(`CREATE TABLE IF NOT EXISTS ${tableName} (
+            timestamp TIMESTAMP,
+            tag_id SYMBOL,
+            number_value FLOAT,
+            string_value STRING,
+            device_id SYMBOL,
+            device_name STRING,
+            uns_path SYMBOL
+        ) TIMESTAMP(timestamp) PARTITION BY DAY`);
+    }
+
+    function getIngestConfigString() {
+        return settings.daqstore.configurationString || 'http::addr=localhost:9000;';
+    }
+
+    function getQueryClientConfig() {
+        return {
+            host: settings.daqstore.host || '127.0.0.1',
+            port: 8812, // Standard port
+            database: 'qdb', // Standard database
+            user: settings.daqstore.credentials?.username || 'admin',
+            password: settings.daqstore.credentials?.password || 'quest',
+            max: 10, // Pool with 10 connections
+            idleTimeoutMillis: 30000, // 30s
+        };
+    }
+
+    function getTableName() {
+        const name = (settings.daqstore.tableName || 'meters').trim();
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+            return name.toLowerCase();
+        }
+        logger.warn(`questdb invalid tableName "${name}", fallback to meters`);
+        return 'meters';
+    }
+
+    function normalizeValue(value) {
+        if (utils.isNullOrUndefined(value)) {
+            return { numberValue: null, stringValue: null };
+        }
+        if (utils.isBoolean(value)) {
+            return {
+                numberValue: value ? 1 : 0,
+                stringValue: null
+            };
+        }
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return { numberValue: value, stringValue: null };
+        }
+        return { numberValue: null, stringValue: String(value) };
+    }
+
+    function normalizeUnsPath(value) {
+        if (utils.isNullOrUndefined(value)) {
+            return null;
+        }
+        const normalized = String(value).trim();
+        return normalized.length ? normalized : null;
+    }
+
+    initPromise = this.init();
+}
+
+module.exports = {
+    create: function (data, logger, currentStorage) {
+        return new QuestDB(data, logger, currentStorage);
+    }
+};

package/runtime/storage/sqlite/index.js

@@ -227,14 +227,14 @@ function DaqNode(_settings, _log, _id, _currentStorate) {
                         _checkDataWorking(false);
                     });
                 } 
-                // check function to add daq data            
+                // check function to add daq data
                 if (addDaqfnc.length > 0) {
                     if (_checkDataWorking(true)) {
                         Promise.all(addDaqfnc).then(result => {
                             // check db tokenizer after inserted
                             var lastts = 0 || result[0];
                             if (daqNextToken && daqNextToken < lastts) {
-                                // close data DB, open and bind the new db, rename and move the closed db 
+                                // close data DB, open and bind the new db, rename and move the closed db
                                 db_daqdata.close(function () {
                                     var suffix = _getDateTimeSuffix(new Date());
                                     var oldfile = db_daqdata_file;
@@ -262,6 +262,9 @@ function DaqNode(_settings, _log, _id, _currentStorate) {
                             }
                             _checkDataWorking(false);
                         });
+                    } else {
+                        // overload: attach no-op catch handlers to prevent UnhandledPromiseRejection
+                        addDaqfnc.forEach(function (p) { p.catch(function () {}); });
                     }
                 }
                 if (dataToRestore.length && currentStorage) {
@@ -554,8 +557,8 @@ function DaqNode(_settings, _log, _id, _currentStorate) {
 
     function _insertTagToMap(tagid, name, type) {
         return new Promise(function (resolve, reject) {
-            var sqlRequest = "INSERT INTO data (id, name, type) ";
-            db_daqmap.run(sqlRequest + "VALUES('" + tagid + "','" + name + "','" + type + "'); SELECT last_insert_rowid() FROM data", function (err) {
+            var sqlRequest = "INSERT INTO data (id, name, type) VALUES (?, ?, ?)";
+            db_daqmap.run(sqlRequest, [tagid, name, type], function (err) {
                 if (err !== null) {
                     reject(err);
                 } else {
@@ -615,10 +618,10 @@ function DaqNode(_settings, _log, _id, _currentStorate) {
     function _insertTagValue(mapid, value) {
         return new Promise(function (resolve, reject) {
             var ts = new Date().getTime();
-            var sqlRequest = "INSERT INTO data (dt, id, value) ";
-            db_daqdata.run(sqlRequest + "VALUES('" + ts + "','" + mapid + "','" + value + "')", function (err) {
+            var sqlRequest = "INSERT INTO data (dt, id, value) VALUES (?, ?, ?)";
+            db_daqdata.run(sqlRequest, [ts, mapid, value], function (err) {
                 if (err !== null) {
-                    reject();
+                    reject(err);
                 }
                 else {
                     resolve(ts);
@@ -692,4 +695,4 @@ module.exports = {
         return new DaqNode(data, logger, id, currentStorate);
     },
     checkRetention: checkRetention
-};
+};

package/runtime/storage/tdengine/index.js

@@ -3,11 +3,20 @@
 let { options, connect } = require("@tdengine/rest");
 let utils = require('../../utils');
 
+function quoteTdIdentifier(value) {
+    return '`' + String(value).replace(/`/g, '``') + '`';
+}
+
+function escapeTdString(value) {
+    return String(value).replace(/'/g, "''");
+}
+
 function TDengine(_settings, _log, _currentStorage) {
     let settings = _settings;               // Application settings
     const logger = _log;                      // Application logger
     const currentStorage = _currentStorage;  // Database to set the last value (current)
     const database = settings.daqstore.database || 'fuxa';
+    const databaseRef = quoteTdIdentifier(database);
     let conn;
 
     this.setCall = function (_fncGetProp) {
@@ -25,8 +34,8 @@ function TDengine(_settings, _log, _currentStorage) {
         const cursor = conn.cursor();
         try {
             //TODO add retention
-            let res = await cursor.query(`CREATE DATABASE IF NOT EXISTS ${database} `);
-            res = await cursor.query(`CREATE STABLE IF NOT EXISTS ${database}.meters (dt TIMESTAMP,tag_id VARCHAR(200), tag_value BINARY(20)) TAGS (device_id VARCHAR(200),device_name BINARY(256) )`);
+            let res = await cursor.query(`CREATE DATABASE IF NOT EXISTS ${databaseRef} `);
+            res = await cursor.query(`CREATE STABLE IF NOT EXISTS ${databaseRef}.meters (dt TIMESTAMP,tag_id VARCHAR(200), tag_value BINARY(20)) TAGS (device_id VARCHAR(200),device_name BINARY(256) )`);
 
         } catch (error) {
             console.error(error);
@@ -47,8 +56,13 @@ function TDengine(_settings, _log, _currentStorage) {
                     continue;
                 }
             }
-            let insertSql = `INSERT INTO ${database}.\`${deviceId}\` USING ${database}.meters TAGS('${deviceId}','${deviceName}')
-                             VALUES (NOW, '${tagid}', '${tag.value}')`;
+            const safeDeviceId = quoteTdIdentifier(deviceId);
+            const safeDeviceTag = escapeTdString(deviceId);
+            const safeDeviceName = escapeTdString(deviceName);
+            const safeTagId = escapeTdString(tagid);
+            const safeTagValue = escapeTdString(tag.value);
+            let insertSql = `INSERT INTO ${databaseRef}.${safeDeviceId} USING ${databaseRef}.meters TAGS('${safeDeviceTag}','${safeDeviceName}')
+                             VALUES (NOW, '${safeTagId}', '${safeTagValue}')`;
             //async
 
             cursor.query(insertSql).then((rst) => {
@@ -71,11 +85,12 @@ function TDengine(_settings, _log, _currentStorage) {
             const cursor = conn.cursor()
             let data = []
             //add by J, the tagid is missed in the sql, should be one of the filter condition
+            const safeTagId = escapeTdString(tagid);
             cursor.query(`SELECT CAST(dt as BIGINT) as dt, tag_value
-                          FROM ${database}.meters
-                            WHERE tag_id = '${tagid}' 
-                            and dt >= ${fromts}
-                            and dt < ${tots} `).then((result) => {
+                          FROM ${databaseRef}.meters
+                            WHERE tag_id = '${safeTagId}'
+                            and dt >= ${Number(fromts)}
+                            and dt < ${Number(tots)} `).then((result) => {
                 // logger.debug(result)
                 result.getData().forEach((row) => {
                     data.push({ dt: row[0], value: row[1] })
@@ -105,4 +120,4 @@ module.exports = {
     create: function (data, logger, currentStorage) {
         return new TDengine(data, logger, currentStorage);
     }
-};
+};