node-red-contrib-influxdb3 1.0.8 → 1.0.9

package/README.md

@@ -80,6 +80,8 @@ msg.payload = "temperature,location=room1 value=21.5";
 return msg;
 ```
 
+> **Note:** raw line protocol strings are passed through unmodified (each line is only sanity-checked). When data comes from an untrusted source, prefer the object formats below — the node escapes measurement, tag and field values automatically.
+
 #### 2. Object with Fields and Tags
 
 Send an object with explicit `fields` and `tags` properties:
@@ -102,7 +104,7 @@ return msg;
 
 #### 3. Simplified Object Format
 
-Send an object where all properties (except 'tags' and 'timestamp') are treated as fields:
+Send an object where all properties are treated as fields, except the reserved keys `measurement`, `fields`, `tags`, `timestamp` and `integers`:
 
 ```javascript
 msg.measurement = "environment";
@@ -416,7 +418,7 @@ The node will display error status and log details to the Node-RED debug panel:
 
 ## Requirements
 
-- Node.js v18.0.0 or higher
+- Node.js v24.0.0 or higher
 - Node-RED v3.0.0 or higher
 - InfluxDB v3 instance (Cloud or Edge)
 

package/influxdb3.html

@@ -6,7 +6,14 @@
         category: 'config',
         defaults: {
             name: { value: '' },
-            host: { value: '', required: true },
+            host: {
+                value: '',
+                required: true,
+                validate: function(v) {
+                    // Accept http(s) URLs or Node-RED ${ENV_VAR} substitution
+                    return /^https?:\/\/\S+$/.test(v) || /\$\{[^}]+\}/.test(v);
+                }
+            },
             database: { value: '', required: true },
             tlsRejectUnauthorized: { value: true },
             caCertPath: { value: '' }
@@ -130,7 +137,7 @@
         <dt class="optional">database <span class="property-type">string</span></dt>
         <dd>Override the database configured in the node or connection</dd>
         <dt class="optional">timestamp <span class="property-type">Date | number</span></dt>
-        <dd>Timestamp for the data point (if not in payload)</dd>
+        <dd>Timestamp for the data point (if not in payload). Numbers are interpreted as <b>milliseconds</b> since the epoch</dd>
     </dl>
 
     <h3>Outputs</h3>
@@ -145,6 +152,9 @@
     <h4>Line Protocol Format</h4>
     <p>Send a string in line protocol format:</p>
     <pre>msg.payload = "temperature,location=room1 value=21.5";</pre>
+    <p><b>Note:</b> raw line protocol strings are passed through unmodified. When data comes from
+    an untrusted source, prefer the object format below — the node escapes measurement, tag and
+    field values automatically.</p>
     
     <h4>Object Format</h4>
     <p>Send an object with fields and optionally tags:</p>
@@ -161,7 +171,8 @@
 }</pre>
 
     <h4>Simplified Object Format</h4>
-    <p>Send an object where all properties (except 'tags' and 'timestamp') are treated as fields:</p>
+    <p>Send an object where all properties are treated as fields, except the reserved keys
+    <code>measurement</code>, <code>fields</code>, <code>tags</code>, <code>timestamp</code> and <code>integers</code>:</p>
     <pre>{
   "temperature": 21.5,
   "humidity": 65,

package/influxdb3.js

@@ -16,6 +16,11 @@ module.exports = function(RED) {
     const fs = require('fs');
     const { validateLineProtocol } = require('./lib/line-protocol');
 
+    // Heuristic bounds for plausible millisecond timestamps. Values outside this
+    // range usually mean the source supplied seconds or nanoseconds instead.
+    const MS_TIMESTAMP_PLAUSIBLE_MIN = Date.UTC(2000, 0, 1);
+    const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
     /**
      * Normalize host URL to ensure it has trailing slash
      * @param {string} host
@@ -220,7 +225,14 @@ module.exports = function(RED) {
             if (typeof value === 'string') {
                 // Check for integer suffix e.g. "42i"
                 if (/^-?\d+i$/.test(value)) {
-                    point.setIntegerField(key, parseInt(value.slice(0, -1), 10));
+                    const parsed = parseInt(value.slice(0, -1), 10);
+                    if (!Number.isSafeInteger(parsed)) {
+                        node.warn(
+                            `Field '${key}': integer value '${value}' exceeds JavaScript's safe integer ` +
+                            `range and loses precision (stored as ${parsed})${context}.`
+                        );
+                    }
+                    point.setIntegerField(key, parsed);
                     return true;
                 }
                 point.setStringField(key, value);
@@ -337,8 +349,19 @@ module.exports = function(RED) {
                     }
                 }
             } else {
-                // Simplified format: treat all non-reserved properties as fields
-                const reservedKeys = new Set(['tags', 'timestamp', 'integers', 'fields']);
+                if (msg.payload.fields !== null && msg.payload.fields !== undefined) {
+                    const typeName = Array.isArray(msg.payload.fields)
+                        ? 'Array'
+                        : typeof msg.payload.fields;
+                    node.warn(
+                        `'fields' is present but is not a plain object (${typeName}) (measurement: '${measurement}'). ` +
+                        `It will be ignored and the other payload properties will be treated as fields.`
+                    );
+                }
+                // Simplified format: treat all non-reserved properties as fields.
+                // 'measurement' is reserved too so that array items like
+                // { measurement: 'temp', value: 1 } don't write it as a string field.
+                const reservedKeys = new Set(['measurement', 'tags', 'timestamp', 'integers', 'fields']);
                 for (const [key, value] of Object.entries(msg.payload)) {
                     if (!reservedKeys.has(key)) {
                         if (addFieldToPoint(point, key, value, integerFields, measurement)) {
@@ -363,7 +386,27 @@ module.exports = function(RED) {
                 if (ts instanceof Date && !isNaN(ts.getTime())) {
                     point.setTimestamp(ts);
                 } else if (typeof ts === 'number' && isFinite(ts) && ts >= 0) {
-                    point.setTimestamp(new Date(ts));
+                    const date = new Date(ts);
+                    if (isNaN(date.getTime())) {
+                        // Beyond the representable Date range (±8.64e15 ms) — almost
+                        // always a nanosecond timestamp passed where ms are expected.
+                        node.warn(
+                            `Invalid timestamp: ${ts} is outside the representable date range. ` +
+                            `Numeric timestamps are interpreted as milliseconds - if the source ` +
+                            `supplies nanoseconds, convert to milliseconds first. The timestamp ` +
+                            `was ignored; InfluxDB will assign the write time.`
+                        );
+                    } else {
+                        // 0 is deliberately allowed without a warning (explicit epoch).
+                        if (ts !== 0 && (ts < MS_TIMESTAMP_PLAUSIBLE_MIN || ts > Date.now() + ONE_DAY_MS)) {
+                            node.warn(
+                                `Numeric timestamp ${ts} resolves to ${date.toISOString()}. ` +
+                                `Numeric timestamps are interpreted as milliseconds - if the source ` +
+                                `supplies seconds or nanoseconds, convert to milliseconds first.`
+                            );
+                        }
+                        point.setTimestamp(date);
+                    }
                 } else if (typeof ts === 'string' && ts.trim() !== '') {
                     const parsed = new Date(ts);
                     if (!isNaN(parsed.getTime())) {
@@ -385,14 +428,7 @@ module.exports = function(RED) {
             return { lineProtocol: lp };
         }
 
-        // Process incoming messages
         node.on('input', async function(msg, send, done) {
-            // For Node-RED 0.x compatibility
-            send = send || function(m) { node.send(m); };
-            done = done || function(err) {
-                if (err) { node.error(err, msg); }
-            };
-
             try {
                 const client = node.influxdb.getClient();
 

package/lib/line-protocol.js

@@ -6,33 +6,52 @@
 
 'use strict';
 
+/**
+ * Truncate a string for use in error messages.
+ * @param {string} str
+ * @returns {string}
+ */
+function preview(str) {
+    return str.length > 100 ? str.substring(0, 100) + '...' : str;
+}
+
 /**
  * Validate that a string looks like InfluxDB line protocol.
+ * Multi-line strings (multiple points separated by newlines) are validated
+ * line by line; blank lines are allowed and skipped.
  * Returns null if valid, or an error message string if invalid.
  * @param {string} lp - Trimmed line protocol string
  * @returns {string|null}
  */
 function validateLineProtocol(lp) {
-    // Detect JSON-like strings (both valid JSON and JS object notation)
+    // Detect JSON-like strings (both valid JSON and JS object notation).
+    // Checked against the whole string first, because pretty-printed JSON
+    // spans multiple lines.
     if (/^\{[\s\S]*}$/.test(lp) || /^\[[\s\S]*]$/.test(lp)) {
-        const preview = lp.length > 100 ? lp.substring(0, 100) + '...' : lp;
         return (
             'The payload appears to be a JSON/object string, not line protocol. ' +
             'If you are sending JSON, ensure msg.payload is a parsed object (not a string). ' +
             'Use a JSON parse node before this node to convert the string to an object. ' +
-            `Received string: ${preview}`
+            `Received string: ${preview(lp)}`
         );
     }
 
-    // Line protocol must have at least: measurement field=value
+    // Each line must have at least: measurement field=value
     // i.e. at least one space and one '=' in the field set
-    if (!lp.includes(' ') || !lp.includes('=')) {
-        const preview = lp.length > 100 ? lp.substring(0, 100) + '...' : lp;
-        return (
-            'The payload string does not appear to be valid line protocol. ' +
-            'Expected format: measurement[,tag=val] field=val[,field=val] [timestamp]. ' +
-            `Received: ${preview}`
-        );
+    const lines = lp.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line) {
+            continue;
+        }
+        if (!line.includes(' ') || !line.includes('=')) {
+            const where = lines.length > 1 ? `Line ${i + 1} of the payload` : 'The payload string';
+            return (
+                `${where} does not appear to be valid line protocol. ` +
+                'Expected format: measurement[,tag=val] field=val[,field=val] [timestamp]. ' +
+                `Received: ${preview(line)}`
+            );
+        }
     }
 
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-influxdb3",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Node-RED nodes for InfluxDB v3 integration",
   "main": "influxdb3.js",
   "files": [
@@ -25,7 +25,7 @@
   "author": "Stuart B",
   "license": "MIT",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.0.0"
   },
   "repository": {
     "type": "git",