node-red-contrib-influxdb3 1.0.0 → 1.0.1

package/README.md

@@ -118,14 +118,55 @@ return msg;
 
 ### Data Types
 
-When using object format, the node automatically handles data types:
-- **Numbers**: 
-  - Integers are written as integer fields
-  - Floats are written as float fields
+**Important:** By default, **all numbers are written as floats** to avoid schema conflicts in InfluxDB. This is because JavaScript doesn't distinguish between `1.0` and `1` (both equal `1`), which can cause issues when InfluxDB expects a float but receives an integer.
+
+When using object format, the node handles data types as follows:
+- **Numbers**: Written as **float fields** by default
+- **Integers**: Must be explicitly marked (see below)
 - **Booleans**: Written as boolean fields
 - **Strings**: Written as string fields
 - **Tags**: Always converted to strings
 
+#### Writing Integer Fields
+
+To write integers explicitly, use one of these methods:
+
+**Method 1: Using the `integers` array**
+```javascript
+msg.payload = {
+    fields: {
+        temperature: 21.5,   // float
+        count: 42,           // will be float by default
+        total: 100           // will be float by default
+    },
+    integers: ['count', 'total']  // mark these as integers
+};
+```
+
+**Method 2: Using the `i` suffix**
+```javascript
+msg.payload = {
+    fields: {
+        temperature: 21.5,   // float
+        count: "42i",        // integer (note the string with 'i' suffix)
+        total: "100i"        // integer
+    }
+};
+```
+
+**Example with both floats and integers:**
+```javascript
+msg.measurement = "sensor_data";
+msg.payload = {
+    temperature: 21.5,      // float
+    humidity: 65.0,         // float (even though it looks like an integer)
+    event_count: "50i",     // integer
+    tags: {
+        location: "room1"
+    }
+};
+```
+
 ### Message Properties
 
 The following message properties can be used to override node configuration:
@@ -133,6 +174,7 @@ The following message properties can be used to override node configuration:
 - `msg.measurement` - Override the measurement name
 - `msg.database` - Override the database name
 - `msg.timestamp` - Set the timestamp for the data point (Date object or milliseconds)
+- `msg.payload.integers` - Array of field names to write as integers (e.g., `['count', 'total']`)
 
 ## Examples
 
@@ -323,10 +365,6 @@ The node will display error status and log details to the Node-RED debug panel:
 
 MIT
 
-## Author
-
-Your Name
-
 ## Links
 
 - [InfluxDB v3 JavaScript Client](https://github.com/InfluxCommunity/influxdb3-js)

package/influxdb3.html

@@ -154,6 +154,30 @@
   }
 }</pre>
 
+    <h3>Data Types</h3>
+    <p><strong>Important:</strong> By default, <strong>all numbers are written as floats</strong> to avoid schema conflicts. 
+    JavaScript doesn't distinguish between <code>1.0</code> and <code>1</code>, which can cause issues when InfluxDB expects a float.</p>
+    
+    <h4>Writing Integer Fields</h4>
+    <p>To explicitly write integers, use one of these methods:</p>
+    
+    <p><strong>Method 1: Using the <code>integers</code> array</strong></p>
+    <pre>msg.payload = {
+  fields: {
+    temperature: 21.5,   // float
+    count: 42            // will be float by default
+  },
+  integers: ['count']    // mark count as integer
+};</pre>
+    
+    <p><strong>Method 2: Using the <code>i</code> suffix</strong></p>
+    <pre>msg.payload = {
+  fields: {
+    temperature: 21.5,   // float
+    count: "42i"         // integer (string with 'i' suffix)
+  }
+};</pre>
+
     <h3>Configuration</h3>
     <dl class="message-properties">
         <dt>Connection</dt>

package/influxdb3.js

@@ -5,6 +5,66 @@
 module.exports = function(RED) {
     const { InfluxDBClient, Point } = require('@influxdata/influxdb3-client');
 
+    /**
+     * Normalize host URL to ensure it has trailing slash
+     */
+    function normalizeHost(host) {
+        if (!host || typeof host !== 'string') {
+            return host;
+        }
+        return host.endsWith('/') ? host : host + '/';
+    }
+
+    /**
+     * Process a field value and add it to a Point
+     */
+    function addFieldToPoint(point, key, value, integerFields) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+
+        // Handle string with 'i' suffix for integers (e.g., "42i")
+        if (typeof value === 'string' && /^-?\d+i$/.test(value)) {
+            const intValue = parseInt(value.slice(0, -1), 10);
+            // Validate parsed value
+            if (!isNaN(intValue) && isFinite(intValue)) {
+                point.setIntegerField(key, intValue);
+                return true;
+            }
+        } else if (typeof value === 'number') {
+            // Validate number
+            if (!isFinite(value)) {
+                RED.log.warn(`Skipping field '${key}': value is not finite (${value})`);
+                return false;
+            }
+            
+            // Default to float for all numbers (safe default)
+            // Use integer only if explicitly marked in 'integers' array
+            if (integerFields.has(key)) {
+                const intValue = Math.floor(value);
+                if (intValue !== value) {
+                    RED.log.warn(`Field '${key}': truncating ${value} to ${intValue} for integer field`);
+                }
+                point.setIntegerField(key, intValue);
+            } else {
+                point.setFloatField(key, value);
+            }
+            return true;
+        } else if (typeof value === 'boolean') {
+            point.setBooleanField(key, value);
+            return true;
+        } else if (typeof value === 'string') {
+            point.setStringField(key, value);
+            return true;
+        } else {
+            // Complex types (arrays, objects) are not supported
+            RED.log.warn(`Skipping field '${key}': unsupported type ${typeof value}`);
+            return false;
+        }
+        
+        return false;
+    }
+
     /**
      * Configuration node to hold InfluxDB v3 connection details
      */
@@ -24,13 +84,31 @@ module.exports = function(RED) {
         // Get or create a client instance
         this.getClient = function() {
             if (!this.client) {
+                // Validate configuration
+                if (!this.host) {
+                    throw new Error('InfluxDB host is not configured');
+                }
+                if (!this.token) {
+                    throw new Error('InfluxDB token is not configured');
+                }
+                if (!this.database) {
+                    throw new Error('InfluxDB database is not configured');
+                }
+                
                 try {
+                    const normalizedHost = normalizeHost(this.host);
+                    
+                    RED.log.info(`InfluxDB v3: Connecting to ${normalizedHost} with database ${this.database}`);
+                    
                     this.client = new InfluxDBClient({
-                        host: this.host,
+                        host: normalizedHost,
                         token: this.token,
                         database: this.database
                     });
+                    
+                    RED.log.info(`InfluxDB v3: Client created successfully`);
                 } catch (error) {
+                    RED.log.error(`InfluxDB v3: Failed to create client - ${error.message}`);
                     throw new Error(`Failed to create InfluxDB client: ${error.message}`);
                 }
             }
@@ -41,10 +119,11 @@ module.exports = function(RED) {
         this.on('close', function() {
             if (this.client) {
                 try {
+                    RED.log.info('InfluxDB v3: Closing client connection');
                     this.client.close();
                     this.client = null;
                 } catch (error) {
-                    // Ignore errors on close
+                    RED.log.warn(`InfluxDB v3: Error closing client - ${error.message}`);
                 }
             }
         });
@@ -67,6 +146,7 @@ module.exports = function(RED) {
         this.database = config.database;
         
         const node = this;
+        let statusTimeout = null;
         
         if (!this.influxdb) {
             this.error('InfluxDB v3 config not set');
@@ -74,6 +154,23 @@ module.exports = function(RED) {
             return;
         }
         
+        // Helper to set status with auto-clear
+        function setStatus(status, clearAfterMs = 0) {
+            if (statusTimeout) {
+                clearTimeout(statusTimeout);
+                statusTimeout = null;
+            }
+            
+            node.status(status);
+            
+            if (clearAfterMs > 0) {
+                statusTimeout = setTimeout(() => {
+                    node.status({});
+                    statusTimeout = null;
+                }, clearAfterMs);
+            }
+        }
+        
         // Process incoming messages
         node.on('input', async function(msg, send, done) {
             // For Node-RED 0.x compatibility
@@ -98,8 +195,11 @@ module.exports = function(RED) {
                 
                 // Check if msg.payload is already in line protocol format
                 if (typeof msg.payload === 'string') {
-                    lineProtocol = msg.payload;
-                } else if (msg.payload && typeof msg.payload === 'object') {
+                    lineProtocol = msg.payload.trim();
+                    if (!lineProtocol) {
+                        throw new Error('Line protocol string is empty');
+                    }
+                } else if (msg.payload && typeof msg.payload === 'object' && !Array.isArray(msg.payload)) {
                     // Build line protocol from payload object
                     const measurement = msg.measurement || node.measurement;
                     
@@ -110,7 +210,7 @@ module.exports = function(RED) {
                     const point = new Point(measurement);
                     
                     // Add tags
-                    if (msg.payload.tags && typeof msg.payload.tags === 'object') {
+                    if (msg.payload.tags && typeof msg.payload.tags === 'object' && !Array.isArray(msg.payload.tags)) {
                         for (const [key, value] of Object.entries(msg.payload.tags)) {
                             if (value !== null && value !== undefined) {
                                 point.setTag(key, String(value));
@@ -118,61 +218,59 @@ module.exports = function(RED) {
                         }
                     }
                     
+                    // Get list of fields that should be treated as integers
+                    const integerFields = new Set(msg.payload.integers || []);
+                    let fieldCount = 0;
+                    
                     // Add fields
-                    if (msg.payload.fields && typeof msg.payload.fields === 'object') {
+                    if (msg.payload.fields && typeof msg.payload.fields === 'object' && !Array.isArray(msg.payload.fields)) {
+                        // Explicit fields object
                         for (const [key, value] of Object.entries(msg.payload.fields)) {
-                            if (value !== null && value !== undefined) {
-                                if (typeof value === 'number') {
-                                    if (Number.isInteger(value)) {
-                                        point.setIntegerField(key, value);
-                                    } else {
-                                        point.setFloatField(key, value);
-                                    }
-                                } else if (typeof value === 'boolean') {
-                                    point.setBooleanField(key, value);
-                                } else {
-                                    point.setStringField(key, String(value));
-                                }
+                            if (addFieldToPoint(point, key, value, integerFields)) {
+                                fieldCount++;
                             }
                         }
                     } else {
-                        // If no 'fields' property, treat all non-tag properties as fields
+                        // Simplified format: treat all non-reserved properties as fields
+                        const reservedKeys = new Set(['tags', 'timestamp', 'integers', 'fields']);
                         for (const [key, value] of Object.entries(msg.payload)) {
-                            if (key !== 'tags' && key !== 'timestamp' && value !== null && value !== undefined) {
-                                if (typeof value === 'number') {
-                                    if (Number.isInteger(value)) {
-                                        point.setIntegerField(key, value);
-                                    } else {
-                                        point.setFloatField(key, value);
-                                    }
-                                } else if (typeof value === 'boolean') {
-                                    point.setBooleanField(key, value);
-                                } else if (typeof value !== 'object') {
-                                    point.setStringField(key, String(value));
+                            if (!reservedKeys.has(key)) {
+                                if (addFieldToPoint(point, key, value, integerFields)) {
+                                    fieldCount++;
                                 }
                             }
                         }
                     }
                     
+                    if (fieldCount === 0) {
+                        throw new Error('No valid fields to write - at least one field is required');
+                    }
+                    
                     // Add timestamp if provided
                     if (msg.payload.timestamp) {
-                        if (msg.payload.timestamp instanceof Date) {
-                            point.setTimestamp(msg.payload.timestamp);
-                        } else if (typeof msg.payload.timestamp === 'number') {
-                            point.setTimestamp(new Date(msg.payload.timestamp));
+                        const ts = msg.payload.timestamp;
+                        if (ts instanceof Date && !isNaN(ts.getTime())) {
+                            point.setTimestamp(ts);
+                        } else if (typeof ts === 'number' && isFinite(ts) && ts > 0) {
+                            point.setTimestamp(new Date(ts));
+                        } else {
+                            node.warn(`Invalid timestamp in payload: ${ts}`);
                         }
                     } else if (msg.timestamp) {
-                        if (msg.timestamp instanceof Date) {
-                            point.setTimestamp(msg.timestamp);
-                        } else if (typeof msg.timestamp === 'number') {
-                            point.setTimestamp(new Date(msg.timestamp));
+                        const ts = msg.timestamp;
+                        if (ts instanceof Date && !isNaN(ts.getTime())) {
+                            point.setTimestamp(ts);
+                        } else if (typeof ts === 'number' && isFinite(ts) && ts > 0) {
+                            point.setTimestamp(new Date(ts));
+                        } else {
+                            node.warn(`Invalid timestamp in msg: ${ts}`);
                         }
                     }
                     
                     lineProtocol = point.toLineProtocol();
                     
-                    if (!lineProtocol) {
-                        throw new Error('No fields to write - at least one field is required');
+                    if (!lineProtocol || lineProtocol.trim() === '') {
+                        throw new Error('Generated line protocol is empty');
                     }
                 } else {
                     throw new Error('Invalid payload format. Expected string (line protocol) or object with fields');
@@ -181,27 +279,25 @@ module.exports = function(RED) {
                 // Write to InfluxDB
                 await client.write(lineProtocol, targetDatabase);
                 
-                node.status({ fill: 'green', shape: 'dot', text: 'written' });
-                
-                // Clear status after 3 seconds
-                setTimeout(() => {
-                    node.status({});
-                }, 3000);
+                setStatus({ fill: 'green', shape: 'dot', text: 'written' }, 3000);
                 
                 send(msg);
                 done();
                 
             } catch (error) {
-                node.status({ fill: 'red', shape: 'dot', text: 'error' });
+                setStatus({ fill: 'red', shape: 'dot', text: 'error' });
                 done(error);
             }
         });
         
         node.on('close', function() {
+            if (statusTimeout) {
+                clearTimeout(statusTimeout);
+                statusTimeout = null;
+            }
             node.status({});
         });
     }
     
     RED.nodes.registerType('influxdb3-write', InfluxDB3WriteNode);
 };
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-influxdb3",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Node-RED nodes for InfluxDB v3 integration",
   "main": "influxdb3.js",
   "scripts": {
@@ -15,6 +15,9 @@
   ],
   "author": "Stuart B",
   "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/stuartb55/nodered-influxdb3.git"
@@ -24,6 +27,7 @@
     "url": "https://github.com/stuartb55/nodered-influxdb3/issues"
   },
   "node-red": {
+    "version": ">=3.0.0",
     "nodes": {
       "influxdb3": "influxdb3.js"
     }
@@ -32,7 +36,7 @@
     "@influxdata/influxdb3-client": "^1.4.0"
   },
   "peerDependencies": {
-    "node-red": ">=2.0.0"
+    "node-red": ">=3.0.0"
   }
 }
 

package/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}