node-red-contrib-questdb 0.6.9 → 0.6.23

package/nodes/questdb-value.html

@@ -0,0 +1,145 @@
+<style>
+    .questdb-white-text { fill: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="questdb-value"] .red-ui-palette-label { color: #ffffff !important; }
+    .red-ui-palette-node[data-palette-type="questdb-value"] .red-ui-palette-icon-container { background-color: #f0f0f0 !important; }
+</style>
+
+<script type="text/javascript">
+    RED.nodes.registerType('questdb-value', {
+        category: 'questdb',
+        color: '#a23154',
+        defaults: {
+            name: { value: "" },
+            questdb: { value: "", type: "questdb-config", required: true },
+            table: { value: "" },
+            tagName: { value: "tag" },
+            tagSource: { value: "topic" },
+            valueName: { value: "value" },
+            extraFields: { value: [] }
+        },
+        inputs: 1,
+        outputs: 2,
+        outputLabels: ["success", "error"],
+        icon: "questdb-logo.png",
+        paletteLabel: "Value",
+        label: function () { return this.name || "Value"; },
+        labelStyle: function () { return (this.name ? "node_label_italic" : "") + " questdb-white-text"; },
+        oneditprepare: function () {
+            var node = this;
+            var fieldList = $("#node-input-extraFields-container").css("min-height", "100px").editableList({
+                sortable: true,
+                removable: true,
+                addButton: true,
+                addItem: function (container, i, field) {
+                    var row = $('<div/>').appendTo(container);
+                    $('<label style="width:35px">msg.</label>').appendTo(row);
+                    $('<input/>', { class: "node-input-extra-msgProp", type: "text", style: "width:100px", placeholder: "property" })
+                        .val(field.msgProperty || "")
+                        .appendTo(row);
+                    $('<label style="width:20px; text-align:center">&rarr;</label>').appendTo(row);
+                    $('<input/>', { class: "node-input-extra-colName", type: "text", style: "width:100px", placeholder: "column name" })
+                        .val(field.columnName || "")
+                        .appendTo(row);
+                    $('<select/>', { class: "node-input-extra-fieldType", style: "width:80px; margin-left:5px" })
+                        .append($('<option value="column">column</option>'))
+                        .append($('<option value="symbol">symbol</option>'))
+                        .val(field.fieldType || "column")
+                        .appendTo(row);
+                }
+            });
+            if (node.extraFields) {
+                node.extraFields.forEach(function (f) { fieldList.editableList('addItem', f); });
+            }
+        },
+        oneditsave: function () {
+            var fields = [];
+            $("#node-input-extraFields-container").editableList('items').each(function () {
+                var msgProp = $(this).find(".node-input-extra-msgProp").val().trim();
+                var colName = $(this).find(".node-input-extra-colName").val().trim();
+                var fieldType = $(this).find(".node-input-extra-fieldType").val();
+                if (msgProp && colName) {
+                    fields.push({ msgProperty: msgProp, columnName: colName, fieldType: fieldType });
+                }
+            });
+            this.extraFields = fields;
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="questdb-value">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-questdb"><i class="fa fa-database"></i> Server</label>
+        <input type="text" id="node-input-questdb">
+    </div>
+    <div class="form-row">
+        <label for="node-input-table"><i class="fa fa-table"></i> Table</label>
+        <input type="text" id="node-input-table" placeholder="from msg.topic">
+    </div>
+    <div class="form-row">
+        <label for="node-input-tagName"><i class="fa fa-bookmark"></i> Tag Column</label>
+        <input type="text" id="node-input-tagName" placeholder="tag">
+    </div>
+    <div class="form-row">
+        <label for="node-input-tagSource"><i class="fa fa-sign-in"></i> Tag Source</label>
+        <input type="text" id="node-input-tagSource" placeholder="topic">
+        <div class="form-tips">msg property to use as tag value (e.g. <code>topic</code>)</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-valueName"><i class="fa fa-line-chart"></i> Value Column</label>
+        <input type="text" id="node-input-valueName" placeholder="value">
+    </div>
+    <div class="form-row">
+        <label><i class="fa fa-plus-square"></i> Extra Fields</label>
+        <ol id="node-input-extraFields-container"></ol>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="questdb-value">
+    <p>Writes a single typed value to QuestDB with auto type detection.</p>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">any</span></dt>
+        <dd>The value to write. Type is auto-detected (long, double, bool, string).</dd>
+        <dt class="optional">topic <span class="property-type">string</span></dt>
+        <dd>Table name (if not set in config). Also default source for the tag value.</dd>
+        <dt class="optional">timestamp <span class="property-type">number | Date | string</span></dt>
+        <dd>Row timestamp. Uses server time if not provided.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <ol class="node-ports">
+        <li>Success
+            <dl class="message-properties">
+                <dt>payload.success <span class="property-type">boolean</span></dt>
+                <dd><code>true</code></dd>
+                <dt>payload.type <span class="property-type">string</span></dt>
+                <dd>Detected type (long, double, bool, string)</dd>
+            </dl>
+        </li>
+        <li>Error
+            <dl class="message-properties">
+                <dt>payload.error <span class="property-type">string</span></dt>
+                <dd>Error description</dd>
+            </dl>
+        </li>
+    </ol>
+
+    <h3>Details</h3>
+    <p>Combines type detection and writing into a single node. Detects the type of
+    <code>msg.payload</code> and writes it to QuestDB with a tag (symbol) and timestamp.</p>
+    <p>Configure extra fields to include additional msg properties as symbols or columns.</p>
+
+    <h3>Example</h3>
+    <pre>// Input
+msg.topic = "temperature"
+msg.payload = 23.5
+msg.timestamp = Date.now()
+
+// Writes to QuestDB:
+// table: "temperature", tag: "temperature", value: 23.5 (double)</pre>
+</script>

package/nodes/questdb-value.js

@@ -0,0 +1,280 @@
+module.exports = function (RED) {
+  const { normalizeTimestamp } = require('./lib/timestamp');
+  const { formatError, isDisconnectionError } = require('./lib/errors');
+
+  // Detect the canonical QuestDB type from a value.
+  function detectType(value) {
+    if (typeof value === 'boolean') return 'bool';
+    if (typeof value === 'number') {
+      if (!isFinite(value)) return null;
+      return Number.isInteger(value) ? 'long' : 'double';
+    }
+    if (typeof value === 'string') {
+      var trimmed = value.trim();
+      var lower = trimmed.toLowerCase();
+      if (lower === 'true' || lower === 'false') return 'bool';
+      if (trimmed !== '' && !isNaN(trimmed)) {
+        return trimmed.includes('.') ? 'double' : 'long';
+      }
+      return 'string';
+    }
+    return null;
+  }
+
+  // Cast value to the target type.
+  function castValue(value, type) {
+    if (type === 'long') {
+      var n = Number(value);
+      return isFinite(n) ? Math.trunc(n) : null;
+    }
+    if (type === 'double') {
+      var d = Number(value);
+      return isFinite(d) ? d : null;
+    }
+    if (type === 'bool') {
+      if (typeof value === 'boolean') return value;
+      if (typeof value === 'string') {
+        var t = value.trim().toLowerCase();
+        if (t === 'true') return true;
+        if (t === 'false') return false;
+      }
+      return null;
+    }
+    if (type === 'string') return String(value);
+    return null;
+  }
+
+  function QuestDBValueNode(config) {
+    RED.nodes.createNode(this, config);
+    var node = this;
+
+    node.questdbConfig = RED.nodes.getNode(config.questdb);
+    if (!node.questdbConfig) {
+      node.error('QuestDB configuration not set');
+      node.status({ fill: 'red', shape: 'ring', text: 'no config' });
+      return;
+    }
+
+    node.table = config.table || '';
+    node.tagName = config.tagName || 'tag';
+    node.tagSource = config.tagSource || 'topic';
+    node.valueName = config.valueName || 'value';
+    node.extraFields = config.extraFields || [];
+
+    var connection = node.questdbConfig.getConnection();
+    if (!connection) {
+      node.error('Failed to get connection from config');
+      node.status({ fill: 'red', shape: 'ring', text: 'no connection' });
+      return;
+    }
+
+    connection.users++;
+
+    if (!connection.connected && !connection.connecting) {
+      connection.connect();
+    }
+
+    var statusMap = {
+      connected: { fill: 'green', shape: 'dot', text: 'connected' },
+      connecting: { fill: 'yellow', shape: 'ring', text: 'connecting...' },
+      disconnected: { fill: 'red', shape: 'ring', text: 'disconnected' },
+    };
+
+    var stateChangeHandler = function (state) {
+      var statusConfig = statusMap[state.status] || {
+        fill: 'grey',
+        shape: 'ring',
+        text: 'unknown',
+      };
+      if (state.error) {
+        statusConfig.text = state.status + ': ' + state.error.substring(0, 30);
+      }
+      node.status(statusConfig);
+    };
+
+    connection.emitter.on('stateChange', stateChangeHandler);
+
+    var initialStatus = connection.connected
+      ? 'connected'
+      : connection.connecting
+        ? 'connecting'
+        : 'disconnected';
+    stateChangeHandler({ status: initialStatus, error: connection.lastError });
+
+    function sendError(msg, errorText) {
+      node.error(errorText, msg);
+      node.status({ fill: 'red', shape: 'ring', text: errorText.substring(0, 30) });
+      var errMsg = RED.util.cloneMessage(msg);
+      errMsg.payload = { success: false, error: errorText };
+      node.send([null, errMsg]);
+    }
+
+    node.on('input', async function (msg) {
+      // Connection checks (rate-limit error logging to once per 5s)
+      if (!connection.connected && !connection.connecting) {
+        connection.connect();
+        var now = Date.now();
+        if (now - connection.lastNotConnectedLog > 5000) {
+          connection.lastNotConnectedLog = now;
+          sendError(msg, 'Not connected to QuestDB, reconnecting...');
+        } else {
+          var errMsg = RED.util.cloneMessage(msg);
+          errMsg.payload = { success: false, error: 'Not connected to QuestDB, reconnecting...' };
+          node.send([null, errMsg]);
+        }
+        return;
+      }
+      if (!connection.connected || !connection.sender) {
+        var now2 = Date.now();
+        if (now2 - connection.lastNotConnectedLog > 5000) {
+          connection.lastNotConnectedLog = now2;
+          sendError(msg, 'Not connected to QuestDB');
+        } else {
+          var errMsg2 = RED.util.cloneMessage(msg);
+          errMsg2.payload = { success: false, error: 'Not connected to QuestDB' };
+          node.send([null, errMsg2]);
+        }
+        return;
+      }
+      if (
+        connection.sender.transport &&
+        typeof connection.sender.transport.connected === 'boolean' &&
+        !connection.sender.transport.connected
+      ) {
+        connection.updateState(false);
+        connection.connect();
+        sendError(msg, 'TCP transport disconnected, reconnecting...');
+        return;
+      }
+
+      // Validate table name
+      var tableName = node.table || msg.topic;
+      if (!tableName) {
+        sendError(msg, 'Table name not specified (set in config or msg.topic)');
+        return;
+      }
+
+      // Validate tag
+      var tagValue = msg[node.tagSource];
+      if (tagValue === null || tagValue === undefined || tagValue === '') {
+        sendError(msg, 'Tag value is empty (msg.' + node.tagSource + ')');
+        return;
+      }
+
+      // Validate payload
+      var value = msg.payload;
+      if (value === null || value === undefined) {
+        sendError(msg, 'Payload is null or undefined');
+        return;
+      }
+
+      // Detect and cast type
+      var type = detectType(value);
+      if (type === null) {
+        sendError(msg, 'Cannot detect type of payload: ' + typeof value);
+        return;
+      }
+      var castedValue = castValue(value, type);
+      if (castedValue === null) {
+        sendError(msg, 'Cannot cast payload to ' + type);
+        return;
+      }
+
+      try {
+        connection.sender.table(tableName);
+        connection.sender.symbol(node.tagName, String(tagValue));
+
+        // Write the value with the detected type
+        if (type === 'long') {
+          connection.sender.intColumn(node.valueName, castedValue);
+        } else if (type === 'double') {
+          connection.sender.floatColumn(node.valueName, castedValue);
+        } else if (type === 'bool') {
+          connection.sender.booleanColumn(node.valueName, castedValue);
+        } else if (type === 'string') {
+          connection.sender.stringColumn(node.valueName, castedValue);
+        }
+
+        // Process extra fields from msg
+        for (var i = 0; i < node.extraFields.length; i++) {
+          var field = node.extraFields[i];
+          var extraVal = msg[field.msgProperty];
+          if (extraVal === null || extraVal === undefined) {
+            sendError(msg, 'Extra field msg.' + field.msgProperty + ' is null or undefined (column: ' + field.columnName + ')');
+            return;
+          }
+
+          if (field.fieldType === 'symbol') {
+            connection.sender.symbol(field.columnName, String(extraVal));
+          } else {
+            // Auto-detect column type
+            var extraType = detectType(extraVal);
+            if (extraType === 'long') {
+              connection.sender.intColumn(field.columnName, Math.trunc(Number(extraVal)));
+            } else if (extraType === 'double') {
+              connection.sender.floatColumn(field.columnName, Number(extraVal));
+            } else if (extraType === 'bool') {
+              connection.sender.booleanColumn(field.columnName, castValue(extraVal, 'bool'));
+            } else {
+              connection.sender.stringColumn(field.columnName, String(extraVal));
+            }
+          }
+        }
+
+        // Timestamp
+        var timestampMicros = normalizeTimestamp(msg.timestamp, node);
+        if (timestampMicros === null) {
+          connection.sender.atNow();
+        } else {
+          connection.sender.at(timestampMicros);
+        }
+
+        // Track rows and flush at threshold
+        connection.rowCount++;
+        if (connection.flushRows && connection.rowCount >= connection.flushRows) {
+          try {
+            await connection.sender.flush();
+            connection.rowCount = 0;
+          } catch (flushErr) {
+            var flushErrMsg = formatError(flushErr, { operation: 'flush', table: tableName });
+            RED.log.error('[QuestDB] Flush failed: ' + flushErrMsg);
+            if (isDisconnectionError(flushErr)) {
+              connection.updateState(false, flushErr.message);
+              connection.sender = null;
+              connection.connect();
+            }
+            sendError(msg, flushErrMsg);
+            return;
+          }
+        }
+
+        var label = type + ': ' + String(castedValue);
+        if (label.length > 25) label = label.substring(0, 25) + '...';
+        node.status({ fill: 'green', shape: 'dot', text: tableName + ' ' + label });
+        msg.payload = { success: true, table: tableName, type: type, value: castedValue };
+        node.send([msg, null]);
+      } catch (err) {
+        var errMsg = formatError(err, { operation: 'write', table: tableName });
+
+        if (isDisconnectionError(err)) {
+          node.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
+          connection.updateState(false, err.message);
+          connection.sender = null;
+          connection.connect();
+        } else {
+          node.status({ fill: 'yellow', shape: 'ring', text: 'write failed' });
+        }
+
+        sendError(msg, errMsg);
+      }
+    });
+
+    node.on('close', function (done) {
+      connection.emitter.removeListener('stateChange', stateChangeHandler);
+      connection.users--;
+      done();
+    });
+  }
+
+  RED.nodes.registerType('questdb-value', QuestDBValueNode);
+};