node-red-contrib-influxdb3 1.0.5 → 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

@@ -407,7 +407,49 @@ module.exports = function(RED) {
                     if (validationError) {
                         throw new Error(validationError);
                     }
-                } else if (msg.payload && typeof msg.payload === 'object' && !Array.isArray(msg.payload)) {
+                } 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);
@@ -419,11 +461,9 @@ module.exports = function(RED) {
                         ? 'null'
                         : msg.payload === undefined
                             ? 'undefined'
-                            : Array.isArray(msg.payload)
-                                ? `Array (length ${msg.payload.length}): ${safeStringify(msg.payload)}`
-                                : `${actualType}${msg.payload && msg.payload.constructor ? ` [${msg.payload.constructor.name}]` : ''}: ${safeStringify(msg.payload)}`;
+                            : `${actualType}${msg.payload && msg.payload.constructor ? ` [${msg.payload.constructor.name}]` : ''}: ${safeStringify(msg.payload)}`;
                     throw new Error(
-                        `Invalid payload format. Expected string (line protocol) or object with fields. ` +
+                        `Invalid payload format. Expected string (line protocol), object with fields, or array of objects/strings. ` +
                         `Received: ${detail}`
                     );
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-influxdb3",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Node-RED nodes for InfluxDB v3 integration",
   "main": "influxdb3.js",
   "scripts": {
@@ -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"
   }
 }