@frangoteam/fuxa-min 1.2.10 → 1.3.0

package/runtime/devices/odbc/index.js

@@ -24,7 +24,7 @@ function ODBCclient(_data, _logger, _events) {
      * initialize the device type 
      */
     this.init = function (_type) {
-        console.error('Not supported!');
+        console.error('Not supported! (odbc.init)');
     }
 
     /**
@@ -165,14 +165,14 @@ function ODBCclient(_data, _logger, _events) {
      * Return Tags values array { id: <name>, value: <value> }
      */
     this.getValues = function () {
-        console.error('Not supported!');
+        console.error('Not supported! (odbc.getValues)');
     }
 
     /**
      * Return Tag value { id: <name>, value: <value>, ts: <lastTimestampValue> }
      */
     this.getValue = function (tagid) {
-        console.error('Not supported!');
+        console.error(`Not supported! (odbc.getValue) (TagID: ${tagid})`);
     }
 
     /**
@@ -186,14 +186,14 @@ function ODBCclient(_data, _logger, _events) {
      * Return Tag property to show in frontend
      */
     this.getTagProperty = function (tagid) {
-        console.error('Not supported!');
+        console.error(`Not supported! (odbc.getTagProperty) (TagID: ${tagid})`);
     }
 
     /**
      * Set the Tag value to device
      */
     this.setValue = function (tagid, value) {
-        console.error('Not supported!');
+        console.error(`Not supported! (odbc.setValue) (TagID: ${tagid}, Value: ${value})`);
     }
 
     /**

package/runtime/devices/template/index.js

@@ -14,7 +14,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * initialize the device type 
      */
     this.init = function (_type) {
-        console.error('Not supported!');
+        console.error('Not supported! (template.init)');
     }
 
     /**
@@ -22,7 +22,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * Emit connection status to clients, clear all Tags values
      */
     this.connect = function () {
-        console.error('Not supported!');
+        console.error('Not supported! (template.connect)');
         // events.emit('device-status:changed', { id: data.id, status: 'connect-ok' });
         // events.emit('device-status:changed', { id: data.id, status: 'connect-error' });
     }
@@ -33,7 +33,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * Emit connection status to clients, clear all Tags values
      */
     this.disconnect = function () {
-        console.error('Not supported!');
+        console.error('Not supported! (template.disconnect)');
         // events.emit('device-status:changed', { id: data.id, status: 'connect-off' });
     }
 
@@ -42,7 +42,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * Update the tags values list, save in DAQ if value changed or in interval and emit values to clients
      */
     this.polling = async function () {
-        console.error('Not supported!');
+        console.error('Not supported! (template.polling)');
         // events.emit('device-value:changed', { id: data.name, values: values });
     }
 
@@ -50,49 +50,49 @@ function DeviceTemplate(_data, _logger, _events) {
      * Load Tags attribute to read with polling
      */
     this.load = function (_data) {
-        console.error('Not supported!');
+        console.error(`Not supported! (template.load) (Data: ${_data})`);
     }
 
     /**
      * Return Tags values array { id: <name>, value: <value> }
      */
     this.getValues = function () {
-        console.error('Not supported!');
+        console.error('Not supported! (template.getValues)');
     }
 
     /**
      * Return Tag value { id: <name>, value: <value>, ts: <lastTimestampValue> }
      */
     this.getValue = function (tagid) {
-        console.error('Not supported!');
+        console.error(`Not supported! (template.getValue) (TagID: ${tagid})`);
     }
 
     /**
      * Return connection status 'connect-off', 'connect-ok', 'connect-error', 'connect-busy'
      */
     this.getStatus = function () {
-        console.error('Not supported!');
+        console.error('Not supported! (template.getStatus)');
     }
 
     /**
      * Return Tag property to show in frontend
      */
     this.getTagProperty = function (tagid) {
-        console.error('Not supported!');
+        console.error(`Not supported! (template.getTagProperty) (TagID: ${tagid})`);
     }
 
     /**
      * Set the Tag value to device
      */
     this.setValue = function (tagid, value) {
-        console.error('Not supported!');
+        console.error(`Not supported! (template.setValue) (TagID: ${tagid}, Value: ${value})`);
     }
 
     /**
      * Return if device is connected
      */
     this.isConnected = function () {
-        console.error('Not supported!');
+        console.error('Not supported! (template.isConnected)');
     }
 
     /**
@@ -107,7 +107,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * @returns 
      */
     this.lastReadTimestamp = () => {
-        console.error('Not supported!');
+        console.error('Not supported! (template.lastReadTimestamp)');
     }
 
     /**
@@ -115,7 +115,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * @returns 
      */
     this.getTagDaqSettings = (tagId) => {
-        console.error('Not supported!');
+        console.error(`Not supported! (template.getTagDaqSettings) (TagID: ${tagId})`);
     }
 
     /**
@@ -123,7 +123,7 @@ function DeviceTemplate(_data, _logger, _events) {
      * @returns 
      */
     this.setTagDaqSettings = (tagId, settings) => {
-        console.error('Not supported!');
+        console.error(`Not supported! (template.setTagDaqSettings) (TagID: ${tagId}, Settings: ${settings})`);
     }
 }
 

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

@@ -123,7 +123,7 @@ function Influx(_settings, _log, _currentStorate) {
             } else {
                 const point = new Point(tag.id)
                     .tag('id', tag.id)
-                    .tag('name', tag.name || tag.tagref.name)
+                    .tag('name', tag.name || tag.tagref?.name)
                     .tag('type', tag.type)
                     .timestamp(new Date(tag.timestamp || new Date().getTime()));
                 if (deviceName) {

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.stringColumn('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/utils.js

@@ -1,5 +1,6 @@
 const os = require('os');
 const ip = require('ip');
+const crypto = require('crypto');
 
 'use strict';
 var utils = module.exports = {
@@ -361,5 +362,9 @@ var utils = module.exports = {
             }
         }
         return target;
+    },
+
+    generateSecretCode: function(byteLength = 32) {
+        return crypto.randomBytes(byteLength).toString('hex');
     }
 }

package/settings.default.js

@@ -24,6 +24,7 @@ module.exports = {
     // - 'common': Less detailed than 'combined', omitting the referrer and user-agent.
     // - 'short': Shorter format that includes the remote address and request details.
     // - 'tiny': Minimalist format, showing just the method, URL, status, response length, and response time.
+	// - 'none': Completely disables HTTP request logging to clean the console for custom debugging scripts and reduce I/O overhead.
     //
     // Default Value:
     // - 'combined': By default, logApiLevel is set to 'combined', providing detailed logs suitable for thorough tracking and analysis.
@@ -91,8 +92,10 @@ module.exports = {
 
     // Used to enable security, authentication and authorization and crypt Token
     //secureEnabled: true,
-    //secretCode: 'frangoteam751',
-    //tokenExpiresIn: '1h'  // '1h'=1hour, 60=60seconds, '1d'=1day
+    //secretCode: '<set-a-strong-random-secret>',
+    //tokenExpiresIn: '1h',  // '1h'=1hour, 60=60seconds, '1d'=1day
+    //enableRefreshCookieAuth: false, // if true, use refresh token HttpOnly cookie flow
+    //refreshTokenExpiresIn: '7d' // '7d'=7days, 12h=12hours, 3600=3600seconds
 
     // Heartbeat interval in seconds (1-20)
     heartbeatIntervalSec: 10,
@@ -110,4 +113,11 @@ module.exports = {
     swaggerEnabled: false,
 
     nodeRedEnabled: false,
-}
+
+    // Node-RED access mode: "secure" (auth required) or "legacy-open" (no auth)
+    nodeRedAuthMode: "secure",
+
+    // Node-RED: allow unsafe stdlib modules in functionGlobalContext
+    // WARNING: Enabling this exposes modules like child_process/net to flows.
+    nodeRedUnsafeModules: false,
+}