node-red-contrib-influxdb3 1.0.4 → 1.0.6

package/README.md

@@ -118,6 +118,55 @@ msg.payload = {
 return msg;
 ```
 
+#### 4. Array of Multiple Measurements
+
+Send an array to write multiple measurements in a single message:
+
+```javascript
+// Array of objects
+msg.payload = [
+    {
+        measurement: "temperature",
+        fields: { value: 21.5 },
+        tags: { location: "room1" }
+    },
+    {
+        measurement: "temperature",
+        fields: { value: 19.8 },
+        tags: { location: "room2" }
+    },
+    {
+        measurement: "humidity",
+        fields: { value: 65 },
+        tags: { location: "room1" }
+    }
+];
+return msg;
+```
+
+```javascript
+// Array of line protocol strings
+msg.payload = [
+    "temperature,location=room1 value=21.5",
+    "temperature,location=room2 value=19.8",
+    "humidity,location=room1 value=65"
+];
+return msg;
+```
+
+```javascript
+// Mixed array (objects and strings)
+msg.payload = [
+    "temperature,location=room1 value=21.5",
+    {
+        measurement: "humidity",
+        fields: { value: 65 },
+        tags: { location: "room1" }
+    }
+];
+return msg;
+```
+
 ### Data Types
 
 **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.

package/__tests__/influxdb3.test.js

@@ -737,7 +737,20 @@ describe('buildLineProtocol – error cases', () => {
     expect(done.mock.calls[0][0].message).toContain('Line protocol string is empty');
   });
 
-  test('invalid payload type (array) produces error', async () => {
+  test('empty array produces error', async () => {
+    const { writeNode } = createWriteNode();
+    const msg = {
+      payload: []
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    expect(done).toHaveBeenCalledWith(expect.any(Error));
+    expect(done.mock.calls[0][0].message).toContain('Payload array is empty');
+  });
+
+  test('array with invalid item type produces error', async () => {
     const { writeNode } = createWriteNode();
     const msg = {
       payload: [1, 2, 3]
@@ -747,7 +760,180 @@ describe('buildLineProtocol – error cases', () => {
     await writeNode._handlers.input(msg, send, done);
 
     expect(done).toHaveBeenCalledWith(expect.any(Error));
-    expect(done.mock.calls[0][0].message).toContain('Invalid payload format');
+    expect(done.mock.calls[0][0].message).toContain('Array item 0 has invalid format');
+  });
+});
+
+describe('Array payload support', () => {
+  test('writes array of line protocol strings', async () => {
+    const { writeNode, influxModule } = createWriteNode();
+    const msg = {
+      payload: [
+        'temperature,location=room1 value=21.5',
+        'temperature,location=room2 value=19.8',
+        'humidity,location=room1 value=65'
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const client = influxModule.__getLastClientInstance();
+    expect(client.write).toHaveBeenCalledWith(
+      'temperature,location=room1 value=21.5\ntemperature,location=room2 value=19.8\nhumidity,location=room1 value=65',
+      'metrics'
+    );
+    expect(send).toHaveBeenCalledWith(msg);
+    expect(done).toHaveBeenCalled();
+  });
+
+  test('writes array of object payloads', async () => {
+    const { writeNode, influxModule } = createWriteNode();
+    const msg = {
+      payload: [
+        {
+          measurement: 'temperature',
+          fields: { value: 21.5 },
+          tags: { location: 'room1' }
+        },
+        {
+          measurement: 'temperature',
+          fields: { value: 19.8 },
+          tags: { location: 'room2' }
+        },
+        {
+          measurement: 'humidity',
+          fields: { value: 65 },
+          tags: { location: 'room1' }
+        }
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const client = influxModule.__getLastClientInstance();
+    expect(client.write).toHaveBeenCalled();
+    expect(send).toHaveBeenCalledWith(msg);
+    expect(done).toHaveBeenCalled();
+  });
+
+  test('writes mixed array of objects and line protocol strings', async () => {
+    const { writeNode, influxModule } = createWriteNode();
+    const msg = {
+      payload: [
+        'temperature,location=room1 value=21.5',
+        {
+          measurement: 'humidity',
+          fields: { value: 65 },
+          tags: { location: 'room1' }
+        },
+        'pressure,location=room1 value=1013.25'
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const client = influxModule.__getLastClientInstance();
+    expect(client.write).toHaveBeenCalled();
+    expect(send).toHaveBeenCalledWith(msg);
+    expect(done).toHaveBeenCalled();
+  });
+
+  test('array objects can use msg.measurement as fallback', async () => {
+    const { writeNode, influxModule } = createWriteNode();
+    const msg = {
+      measurement: 'temperature',
+      payload: [
+        {
+          fields: { value: 21.5 },
+          tags: { location: 'room1' }
+        },
+        {
+          fields: { value: 19.8 },
+          tags: { location: 'room2' }
+        }
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const client = influxModule.__getLastClientInstance();
+    expect(client.write).toHaveBeenCalled();
+    expect(send).toHaveBeenCalledWith(msg);
+    expect(done).toHaveBeenCalled();
+  });
+
+  test('array item error includes item index', async () => {
+    const { RED, influxModule } = setup();
+    const ConfigCtor = RED._types['influxdb3-config'];
+    const WriteCtor = RED._types['influxdb3-write'];
+
+    const configNode = new ConfigCtor({
+      host: 'https://example.com',
+      database: 'metrics',
+      name: 'Test',
+      credentials: { token: 'token' }
+    });
+
+    // Create node without default measurement
+    const writeNode = new WriteCtor({
+      influxdb: configNode,
+      measurement: '',  // No default measurement
+      database: ''
+    });
+
+    const msg = {
+      payload: [
+        'temperature,location=room1 value=21.5',
+        {
+          // Missing measurement and no fallback
+          fields: { value: 19.8 }
+        }
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    expect(done).toHaveBeenCalledWith(expect.any(Error));
+    expect(done.mock.calls[0][0].message).toContain('Array item 1');
+  });
+
+  test('array with empty string produces error', async () => {
+    const { writeNode } = createWriteNode();
+    const msg = {
+      payload: [
+        'temperature,location=room1 value=21.5',
+        '   ',
+        'humidity,location=room1 value=65'
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    expect(done).toHaveBeenCalledWith(expect.any(Error));
+    expect(done.mock.calls[0][0].message).toContain('Array item 1 is an empty string');
+  });
+
+  test('array with invalid line protocol produces error with index', async () => {
+    const { writeNode } = createWriteNode();
+    const msg = {
+      payload: [
+        'temperature,location=room1 value=21.5',
+        'invalid line protocol no equals',
+        'humidity,location=room1 value=65'
+      ]
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    expect(done).toHaveBeenCalledWith(expect.any(Error));
+    expect(done.mock.calls[0][0].message).toContain('Array item 1');
   });
 });
 

package/influxdb3.html

@@ -117,11 +117,12 @@
     
     <h3>Inputs</h3>
     <dl class="message-properties">
-        <dt>payload <span class="property-type">string | object</span></dt>
+        <dt>payload <span class="property-type">string | object | array</span></dt>
         <dd>The data to write. Can be either:
             <ul>
                 <li>A string in line protocol format</li>
                 <li>An object with <code>fields</code> (required) and optionally <code>tags</code> and <code>timestamp</code></li>
+                <li>An array of strings (line protocol) or objects (multiple measurements in one write)</li>
             </ul>
         </dd>
         <dt class="optional">measurement <span class="property-type">string</span></dt>
@@ -233,6 +234,34 @@ return msg;</pre>
     <pre>msg.payload = "weather,location=garden temperature=18.5,humidity=75";
 return msg;</pre>
 
+    <h4>Example 4: Array of multiple measurements</h4>
+    <pre>msg.payload = [
+  {
+    "measurement": "temperature",
+    "fields": { "value": 21.5 },
+    "tags": { "location": "room1" }
+  },
+  {
+    "measurement": "temperature", 
+    "fields": { "value": 19.8 },
+    "tags": { "location": "room2" }
+  },
+  {
+    "measurement": "humidity",
+    "fields": { "value": 65 },
+    "tags": { "location": "room1" }
+  }
+];
+return msg;</pre>
+
+    <h4>Example 5: Array of line protocol strings</h4>
+    <pre>msg.payload = [
+  "temperature,location=room1 value=21.5",
+  "temperature,location=room2 value=19.8",
+  "humidity,location=room1 value=65"
+];
+return msg;</pre>
+
     <h3>References</h3>
     <ul>
         <li><a href="https://github.com/InfluxCommunity/influxdb3-js">InfluxDB v3 JavaScript Client</a></li>

package/influxdb3.js

@@ -141,16 +141,54 @@ module.exports = function(RED) {
          * Safely serialize a value for diagnostic logging.
          * Handles circular references and large objects.
          * @param {*} value
+         * @param {number} [maxLength=200] - Maximum length before truncation
          * @returns {string}
          */
-        function safeStringify(value) {
+        function safeStringify(value, maxLength) {
+            maxLength = maxLength || 200;
             try {
-                return JSON.stringify(value);
+                const str = JSON.stringify(value);
+                if (str && str.length > maxLength) {
+                    return str.substring(0, maxLength) + '...(truncated)';
+                }
+                return str;
             } catch (e) {
                 return `[unserializable: ${e.message}]`;
             }
         }
 
+        /**
+         * Validate that a string looks like InfluxDB line protocol.
+         * 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)
+            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}`
+                );
+            }
+
+            // Line protocol 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}`
+                );
+            }
+
+            return null;
+        }
+
         /**
          * Process a field value and add it to a Point.
          * Returns true if the field was added, false if it was skipped.
@@ -363,14 +401,71 @@ module.exports = function(RED) {
                     if (!lineProtocol) {
                         throw new Error('Line protocol string is empty');
                     }
-                } else if (msg.payload && typeof msg.payload === 'object' && !Array.isArray(msg.payload)) {
+
+                    // Validate line protocol format
+                    const validationError = validateLineProtocol(lineProtocol);
+                    if (validationError) {
+                        throw new Error(validationError);
+                    }
+                } else if (Array.isArray(msg.payload)) {
+                    // Handle array of measurements
+                    if (msg.payload.length === 0) {
+                        throw new Error('Payload array is empty');
+                    }
+
+                    const lineProtocols = [];
+                    for (let i = 0; i < msg.payload.length; i++) {
+                        const item = msg.payload[i];
+                        
+                        if (typeof item === 'string') {
+                            // String line protocol
+                            const lp = item.trim();
+                            if (!lp) {
+                                throw new Error(`Array item ${i} is an empty string`);
+                            }
+                            const validationError = validateLineProtocol(lp);
+                            if (validationError) {
+                                throw new Error(`Array item ${i}: ${validationError}`);
+                            }
+                            lineProtocols.push(lp);
+                        } else if (item && typeof item === 'object' && !Array.isArray(item)) {
+                            // Object payload - build line protocol
+                            const tempMsg = {
+                                ...msg,
+                                payload: item,
+                                measurement: item.measurement || msg.measurement || node.measurement
+                            };
+                            const result = buildLineProtocol(tempMsg);
+                            if (result.error) {
+                                throw new Error(`Array item ${i}: ${result.error}`);
+                            }
+                            lineProtocols.push(result.lineProtocol);
+                        } else {
+                            throw new Error(
+                                `Array item ${i} has invalid format. Expected string (line protocol) or object with fields. ` +
+                                `Received: ${typeof item}`
+                            );
+                        }
+                    }
+                    
+                    lineProtocol = lineProtocols.join('\n');
+                } else if (msg.payload && typeof msg.payload === 'object') {
                     const result = buildLineProtocol(msg);
                     if (result.error) {
                         throw new Error(result.error);
                     }
                     lineProtocol = result.lineProtocol;
                 } else {
-                    throw new Error('Invalid payload format. Expected string (line protocol) or object with fields');
+                    const actualType = typeof msg.payload;
+                    const detail = msg.payload === null
+                        ? 'null'
+                        : msg.payload === undefined
+                            ? 'undefined'
+                            : `${actualType}${msg.payload && msg.payload.constructor ? ` [${msg.payload.constructor.name}]` : ''}: ${safeStringify(msg.payload)}`;
+                    throw new Error(
+                        `Invalid payload format. Expected string (line protocol), object with fields, or array of objects/strings. ` +
+                        `Received: ${detail}`
+                    );
                 }
 
                 // Write to InfluxDB
@@ -382,7 +477,10 @@ module.exports = function(RED) {
                 done();
 
             } catch (error) {
-                setStatus({ fill: 'red', shape: 'dot', text: 'error' });
+                const shortMsg = error.message
+                    ? (error.message.length > 80 ? error.message.substring(0, 80) + '...' : error.message)
+                    : 'unknown error';
+                setStatus({ fill: 'red', shape: 'dot', text: shortMsg });
                 done(error);
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-influxdb3",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Node-RED nodes for InfluxDB v3 integration",
   "main": "influxdb3.js",
   "scripts": {
@@ -16,7 +16,7 @@
   "author": "Stuart B",
   "license": "MIT",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "repository": {
     "type": "git",
@@ -33,9 +33,9 @@
     }
   },
   "dependencies": {
-    "@influxdata/influxdb3-client": "^2.0.0"
+    "@influxdata/influxdb3-client": "^2.1.0"
   },
   "devDependencies": {
-    "jest": "^30.2.0"
+    "jest": "^30.3.0"
   }
 }

package/test/line-protocol-validation.test.js

@@ -0,0 +1,83 @@
+/**
+ * Tests for line protocol string validation.
+ * Mirrors the validateLineProtocol logic in influxdb3.js.
+ */
+
+// Re-implement the validation logic here to test it in isolation
+// (the function is not exported from influxdb3.js)
+function validateLineProtocol(lp) {
+    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}`
+        );
+    }
+
+    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}`
+        );
+    }
+
+    return null;
+}
+
+describe('Line protocol string validation', () => {
+    test('valid line protocol returns null', () => {
+        expect(validateLineProtocol('weather,location=us-midwest temperature=82 1465839830100400200')).toBeNull();
+    });
+
+    test('valid line protocol without timestamp returns null', () => {
+        expect(validateLineProtocol('weather,location=us-midwest temperature=82')).toBeNull();
+    });
+
+    test('valid line protocol without tags returns null', () => {
+        expect(validateLineProtocol('weather temperature=82')).toBeNull();
+    });
+
+    test('valid line protocol with multiple fields returns null', () => {
+        expect(validateLineProtocol('weather temperature=82,humidity=71')).toBeNull();
+    });
+
+    test('detects JSON object string', () => {
+        const input = '{"fields":{"used":12.0},"tags":{"location":"office"}}';
+        const result = validateLineProtocol(input);
+        expect(result).toContain('JSON/object string');
+        expect(result).toContain('not line protocol');
+        expect(result).toContain('JSON parse node');
+    });
+
+    test('detects JS object notation string (unquoted keys)', () => {
+        const input = '{fields:{used:12.0,path:root},tags:{location:office,node:grafana2}}';
+        const result = validateLineProtocol(input);
+        expect(result).toContain('JSON/object string');
+    });
+
+    test('detects JSON array string', () => {
+        const input = '[{"measurement":"test","fields":{"value":1}}]';
+        const result = validateLineProtocol(input);
+        expect(result).toContain('JSON/object string');
+    });
+
+    test('detects string with no space (not line protocol)', () => {
+        const result = validateLineProtocol('justameasurement');
+        expect(result).toContain('does not appear to be valid line protocol');
+    });
+
+    test('detects string with no equals sign (not line protocol)', () => {
+        const result = validateLineProtocol('measurement nofields');
+        expect(result).toContain('does not appear to be valid line protocol');
+    });
+
+    test('truncates long strings in error message', () => {
+        const longJson = '{' + '"a":1,'.repeat(50) + '"b":2}';
+        const result = validateLineProtocol(longJson);
+        expect(result).toContain('...');
+    });
+});