node-red-contrib-questdb 0.6.6 → 0.6.8

package/nodes/questdb-mapper.html

@@ -100,7 +100,7 @@
                     const typeSelect = $('<select/>', {class: "column-type"})
                         .css({width: "20%"})
                         .appendTo(row);
-                    ['auto', 'float', 'double', 'integer', 'long', 'decimal', 'string', 'boolean', 'timestamp', 'array'].forEach(function(t) {
+                    ['auto', 'float', 'double', 'integer', 'long', 'decimal', 'varchar', 'string', 'boolean', 'timestamp', 'array'].forEach(function(t) {
                         $('<option/>').val(t).text(t).appendTo(typeSelect);
                     });
                     typeSelect.val(data.type || "auto");
@@ -211,7 +211,8 @@
         <li><b>integer</b> - 32-bit signed integer</li>
         <li><b>long</b> - 64-bit signed integer</li>
         <li><b>decimal</b> - Arbitrary precision decimal</li>
-        <li><b>string</b> - Text value</li>
+        <li><b>varchar</b> - Variable-length text (QuestDB native type, preferred over string)</li>
+        <li><b>string</b> - Text value (alias for varchar)</li>
         <li><b>boolean</b> - true/false</li>
         <li><b>timestamp</b> - Date/time value</li>
         <li><b>array</b> - Array of doubles (double[])</li>

package/nodes/questdb-mapper.js

@@ -72,6 +72,7 @@ module.exports = function(RED) {
                                 case 'boolean':
                                     value = Boolean(value);
                                     break;
+                                case 'varchar':
                                 case 'string':
                                     value = String(value);
                                     break;

package/nodes/questdb-type-router.html

@@ -8,11 +8,12 @@
         category: 'questdb',
         color: '#a54a7b',
         defaults: {
-            name: {value:""}
+            name: {value:""},
+            contextName: {value: "questdbTypeMap"}
         },
         inputs:1,
-        outputs:4,
-        outputLabels: ["int", "float", "bool", "string"],
+        outputs:5,
+        outputLabels: ["long", "double", "bool", "string", "unresolvable"],
         icon: "font-awesome/fa-random",
         paletteLabel: "Type Router",
         label: function() { return this.name || "Type Router"; },
@@ -25,24 +26,38 @@
         <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-contextName"><i class="fa fa-database"></i> Type Map</label>
+        <input type="text" id="node-input-contextName" placeholder="questdbTypeMap">
+    </div>
 </script>
 
 <script type="text/html" data-help-name="questdb-type-router">
-    <p>Routes messages to different outputs based on payload data type.</p>
+    <p>Routes messages to different outputs based on payload data type, with per-topic type latching.</p>
+
     <h3>Outputs</h3>
     <ol class="node-ports">
-        <li><b>Int:</b> Integer values</li>
-        <li><b>Float:</b> Floating point values</li>
+        <li><b>Long:</b> Integer values (int and long both map here)</li>
+        <li><b>Double:</b> Floating-point values (float and double both map here)</li>
         <li><b>Bool:</b> Boolean values (including "true"/"false" strings)</li>
-        <li><b>String:</b> String values</li>
+        <li><b>String:</b> String values that are not numbers or booleans</li>
+        <li><b>Unresolvable:</b> Values whose type cannot be determined, or that cannot be cast to the latched type for their topic</li>
     </ol>
+
     <h3>Type Detection</h3>
     <ul>
-        <li>Boolean: <code>true</code>, <code>false</code>, or strings "true"/"false"</li>
-        <li>Integer: Whole numbers without decimal point</li>
-        <li>Float: Numbers with decimal point</li>
-        <li>String: Everything else (converted if needed)</li>
+        <li><b>Bool:</b> <code>true</code>, <code>false</code>, or strings <code>"true"</code>/<code>"false"</code> (case-insensitive)</li>
+        <li><b>Long:</b> Whole numbers or numeric strings without a decimal point (e.g. <code>42</code>, <code>"42"</code>)</li>
+        <li><b>Double:</b> Numbers with a decimal point or numeric strings with <code>.</code> (e.g. <code>3.14</code>, <code>"3.14"</code>)</li>
+        <li><b>String:</b> Non-numeric, non-boolean strings</li>
+        <li><b>Unresolvable:</b> Objects, arrays, <code>null</code>, <code>NaN</code>, <code>Infinity</code></li>
     </ul>
+
+    <h3>Type Latching</h3>
+    <p>When a message includes <code>msg.topic</code>, the detected type is stored in the global context under the configured <b>Type Map</b> name (default: <code>questdbTypeMap</code>). The context holds a dictionary of <code>topic → type</code>.</p>
+    <p>Subsequent messages with the same topic are cast to the latched type. If the value cannot be cast (e.g. a string arrives for a topic latched as <code>long</code>), the message is routed to the <b>Unresolvable</b> output.</p>
+    <p>Messages without a topic are still routed by type but do not update the type map.</p>
+
     <h3>Conversion</h3>
-    <p>String representations of numbers and booleans are automatically converted to their native types.</p>
+    <p>String representations of numbers and booleans are automatically converted to their native types during both auto-detection and latched casting.</p>
 </script>

package/nodes/questdb-type-router.js

@@ -1,71 +1,125 @@
-module.exports = function(RED) {
-    function TypeRouterNode(config) {
-        RED.nodes.createNode(this, config);
-        var node = this;
+module.exports = function (RED) {
+  function TypeRouterNode(config) {
+    RED.nodes.createNode(this, config);
+    var node = this;
+    node.contextName = config.contextName || 'questdbTypeMap';
 
-        node.on('input', function(msg) {
-            var value = msg.payload;
+    // Detect the canonical type from a value.
+    // Returns 'long' | 'double' | 'bool' | 'string' | null (unresolvable)
+    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;
+    }
 
-            if (typeof value === 'boolean') {
-                msg.dataType = 'bool';
-                node.status({ fill: "purple", shape: "dot", text: "bool: " + value });
-                return node.send([null, null, msg, null]);
-            }
-            else if (typeof value === 'number') {
-                if (Number.isInteger(value)) {
-                    msg.dataType = 'int';
-                    node.status({ fill: "blue", shape: "dot", text: "int: " + value });
-                    return node.send([msg, null, null, null]);
-                } else {
-                    msg.dataType = 'float';
-                    node.status({ fill: "green", shape: "dot", text: "float: " + value.toFixed(2) });
-                    return node.send([null, msg, null, null]);
-                }
-            }
-            else if (typeof value === 'string') {
-                var trimmed = value.trim();
+    // Cast value to the required type.
+    // Returns the casted value, or null if the cast is not possible.
+    function castToType(value, type) {
+      var num, t;
+      if (type === 'long') {
+        if (typeof value === 'boolean') return null;
+        num = Number(value);
+        if (!isFinite(num) || !Number.isInteger(num)) return null;
+        return num;
+      }
+      if (type === 'double') {
+        if (typeof value === 'boolean') return null;
+        num = Number(value);
+        if (!isFinite(num)) return null;
+        return num;
+      }
+      if (type === 'bool') {
+        if (typeof value === 'boolean') return value;
+        if (typeof value === 'string') {
+          t = value.trim().toLowerCase();
+          if (t === 'true') return true;
+          if (t === 'false') return false;
+        }
+        return null;
+      }
+      if (type === 'string') {
+        if (typeof value === 'string') return value;
+        return null;
+      }
+      return null;
+    }
 
-                if (trimmed.toLowerCase() === 'true') {
-                    msg.payload = true;
-                    msg.dataType = 'bool';
-                    node.status({ fill: "purple", shape: "dot", text: "bool: true" });
-                    return node.send([null, null, msg, null]);
-                }
-                else if (trimmed.toLowerCase() === 'false') {
-                    msg.payload = false;
-                    msg.dataType = 'bool';
-                    node.status({ fill: "purple", shape: "dot", text: "bool: false" });
-                    return node.send([null, null, msg, null]);
-                }
-                else if (trimmed !== '' && !isNaN(trimmed)) {
-                    var num = Number(trimmed);
-                    msg.payload = num;
-                    if (Number.isInteger(num) && !trimmed.includes('.')) {
-                        msg.dataType = 'int';
-                        node.status({ fill: "blue", shape: "dot", text: "int: " + num });
-                        return node.send([msg, null, null, null]);
-                    } else {
-                        msg.dataType = 'float';
-                        node.status({ fill: "green", shape: "dot", text: "float: " + num.toFixed(2) });
-                        return node.send([null, msg, null, null]);
-                    }
-                }
-                else {
-                    msg.payload = String(value);
-                    msg.dataType = 'string';
-                    node.status({ fill: "yellow", shape: "dot", text: "str: " + (value.length > 10 ? value.substring(0,10) + "..." : value) });
-                    return node.send([null, null, null, msg]);
-                }
-            }
-            else {
-                msg.payload = String(value);
-                msg.dataType = 'string';
-                node.status({ fill: "yellow", shape: "dot", text: "str: (converted)" });
-                return node.send([null, null, null, msg]);
-            }
-        });
+    var TYPE_OUTPUT = { long: 0, double: 1, bool: 2, string: 3 };
+    var TYPE_COLOR = { long: 'blue', double: 'green', bool: 'purple', string: 'yellow' };
 
-        node.on('close', function() { node.status({}); });
-    }
-    RED.nodes.registerType("questdb-type-router", TypeRouterNode);
+    node.on('input', function (msg) {
+      var topic = msg.topic;
+      var value = msg.payload;
+      var globalCtx = node.context().global;
+      var typeMap = globalCtx.get(node.contextName) || {};
+
+      var type, castedValue;
+
+      if (topic && Object.prototype.hasOwnProperty.call(typeMap, topic)) {
+        // Latched: use the previously determined type
+        type = typeMap[topic];
+        if (type === 'unresolvable') {
+          node.status({ fill: 'red', shape: 'ring', text: 'unresolvable [' + topic + ']' });
+          return node.send([null, null, null, null, msg]);
+        }
+        castedValue = castToType(value, type);
+        if (castedValue === null) {
+          node.status({ fill: 'red', shape: 'ring', text: "can't cast [" + topic + ']' });
+          return node.send([null, null, null, null, msg]);
+        }
+      } else {
+        // First time: auto-detect and latch
+        type = detectType(value);
+        if (type === null) {
+          if (topic) {
+            typeMap[topic] = 'unresolvable';
+            globalCtx.set(node.contextName, typeMap);
+          }
+          node.status({ fill: 'red', shape: 'ring', text: 'unresolvable' });
+          return node.send([null, null, null, null, msg]);
+        }
+        if (topic) {
+          typeMap[topic] = type;
+          globalCtx.set(node.contextName, typeMap);
+        }
+        castedValue = castToType(value, type);
+        if (castedValue === null) {
+          // Guard: detectType and castToType should always be consistent
+          node.status({ fill: 'red', shape: 'ring', text: 'cast error' });
+          return node.send([null, null, null, null, msg]);
+        }
+      }
+
+      msg.payload = castedValue;
+      msg.dataType = type;
+
+      var outputIndex = TYPE_OUTPUT[type];
+      var outputs = [null, null, null, null, null];
+      outputs[outputIndex] = msg;
+
+      var label = String(castedValue);
+      if (label.length > 12) label = label.substring(0, 12) + '...';
+      node.status({ fill: TYPE_COLOR[type], shape: 'dot', text: type + ': ' + label });
+
+      return node.send(outputs);
+    });
+
+    node.on('close', function () {
+      node.status({});
+    });
+  }
+
+  RED.nodes.registerType('questdb-type-router', TypeRouterNode);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-questdb",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "Node-RED nodes for writing high-performance time-series data to QuestDB using Influx Line Protocol (ILP). Supports IoT, industrial monitoring, smart buildings, fleet telematics, healthcare, agriculture, and more.",
   "author": {
     "name": "Holger Amort"