node-red-contrib-influxdb3 1.0.6 → 1.0.7

package/README.md

@@ -52,8 +52,8 @@ A configuration node that stores connection details for your InfluxDB v3 instanc
 - **Host**: Your InfluxDB v3 host URL (e.g., `https://us-east-1-1.aws.cloud2.influxdata.com`)
 - **Token**: Your InfluxDB v3 authentication token
 - **Database**: The default database (bucket) name
-- **Verify TLS**: Toggle TLS certificate verification (unchecked sets `NODE_TLS_REJECT_UNAUTHORIZED=0`)
-- **CA Cert Path**: Optional filesystem path for a custom root CA (`NODE_EXTRA_CA_CERTS`)
+- **Verify TLS**: Toggle TLS certificate verification for this connection (unchecked disables verification for this connection only)
+- **CA Cert Path**: Optional filesystem path to a PEM CA certificate used to verify this connection's TLS certificate
 
 ### InfluxDB v3 Write Node
 
@@ -399,8 +399,8 @@ Simply reference them in the Node-RED UI using `${INFLUX_HOST}` syntax (if using
 
 If you are connecting to a local InfluxDB v3 instance with a custom certificate:
 
-- Set **CA Cert Path** in the config node to the PEM file containing your root CA. This sets `NODE_EXTRA_CA_CERTS` for the Node-RED process.
-- As a last resort, disable **Verify TLS** to set `NODE_TLS_REJECT_UNAUTHORIZED=0` (this disables TLS verification globally for the process).
+- Set **CA Cert Path** in the config node to the PEM file containing your root CA. The certificate is read when the connection is first used and applied to this connection only.
+- As a last resort, disable **Verify TLS**. This skips certificate verification for this connection only (it does not affect other connections or the rest of the Node-RED process).
 
 ### Data Not Appearing
 
@@ -416,7 +416,8 @@ The node will display error status and log details to the Node-RED debug panel:
 
 ## Requirements
 
-- Node-RED v2.0.0 or higher
+- Node.js v18.0.0 or higher
+- Node-RED v3.0.0 or higher
 - InfluxDB v3 instance (Cloud or Edge)
 
 ## License

package/__tests__/influxdb3.test.js

@@ -1,4 +1,6 @@
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 
 let mockLastClientOptions;
 let mockLastClientInstance;
@@ -135,8 +137,37 @@ describe('InfluxDB v3 config node', () => {
     expect(options.token).toBe('token');
   });
 
-  test('sets extra CA certificate path when configured', () => {
-    const original = process.env.NODE_EXTRA_CA_CERTS;
+  test('passes CA certificate via transportOptions and does not touch global env', () => {
+    const originalEnv = process.env.NODE_EXTRA_CA_CERTS;
+    const caPath = path.join(os.tmpdir(), `influx-ca-${Date.now()}.pem`);
+    const caContents = '-----BEGIN CERTIFICATE-----\ntest-ca\n-----END CERTIFICATE-----\n';
+    fs.writeFileSync(caPath, caContents);
+
+    try {
+      const { RED, influxModule } = setup();
+      const ConfigCtor = RED._types['influxdb3-config'];
+
+      const configNode = new ConfigCtor({
+        host: 'https://example.com',
+        database: 'metrics',
+        name: 'Test',
+        caCertPath: caPath,
+        credentials: { token: 'token' }
+      });
+
+      configNode.getClient();
+
+      const options = influxModule.__getLastClientOptions();
+      expect(options.transportOptions).toBeDefined();
+      expect(options.transportOptions.ca.toString()).toBe(caContents);
+      // Global env must be left untouched
+      expect(process.env.NODE_EXTRA_CA_CERTS).toBe(originalEnv);
+    } finally {
+      fs.unlinkSync(caPath);
+    }
+  });
+
+  test('throws a clear error when the CA certificate cannot be read', () => {
     const { RED } = setup();
     const ConfigCtor = RED._types['influxdb3-config'];
 
@@ -144,14 +175,50 @@ describe('InfluxDB v3 config node', () => {
       host: 'https://example.com',
       database: 'metrics',
       name: 'Test',
-      caCertPath: path.join('C:', 'certs', 'root.pem'),
+      caCertPath: path.join(os.tmpdir(), 'does-not-exist-influx-ca.pem'),
+      credentials: { token: 'token' }
+    });
+
+    expect(() => configNode.getClient()).toThrow(/Failed to read CA certificate/);
+  });
+
+  test('disables TLS verification via transportOptions without setting global env', () => {
+    const originalEnv = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+    const { RED, influxModule } = setup();
+    const ConfigCtor = RED._types['influxdb3-config'];
+
+    const configNode = new ConfigCtor({
+      host: 'https://example.com',
+      database: 'metrics',
+      name: 'Test',
+      tlsRejectUnauthorized: false,
+      credentials: { token: 'token' }
+    });
+
+    configNode.getClient();
+
+    const options = influxModule.__getLastClientOptions();
+    expect(options.transportOptions).toBeDefined();
+    expect(options.transportOptions.rejectUnauthorized).toBe(false);
+    // Global env must be left untouched
+    expect(process.env.NODE_TLS_REJECT_UNAUTHORIZED).toBe(originalEnv);
+  });
+
+  test('omits transportOptions entirely when TLS defaults are used', () => {
+    const { RED, influxModule } = setup();
+    const ConfigCtor = RED._types['influxdb3-config'];
+
+    const configNode = new ConfigCtor({
+      host: 'https://example.com',
+      database: 'metrics',
+      name: 'Test',
       credentials: { token: 'token' }
     });
 
     configNode.getClient();
 
-    expect(process.env.NODE_EXTRA_CA_CERTS).toBe(path.join('C:', 'certs', 'root.pem'));
-    process.env.NODE_EXTRA_CA_CERTS = original;
+    const options = influxModule.__getLastClientOptions();
+    expect(options.transportOptions).toBeUndefined();
   });
 });
 
@@ -379,6 +446,27 @@ describe('addFieldToPoint – field type handling', () => {
       expect.stringContaining("marked as integer but value is 3.7")
     );
   });
+
+  test('negative non-integer float truncates toward zero (not floor)', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: 'sensor',
+      payload: {
+        fields: { value: -3.7 },
+        integers: ['value']
+      }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    // Math.trunc(-3.7) === -3 (toward zero), not Math.floor's -4
+    expect(point.integerFields.value).toBe(-3);
+    expect(writeNode.warn).toHaveBeenCalledWith(
+      expect.stringContaining("truncated to -3")
+    );
+  });
 });
 
 describe('addFieldToPoint – enhanced error messages (issue #16)', () => {
@@ -604,6 +692,91 @@ describe('buildLineProtocol – simplified payload format', () => {
   });
 });
 
+describe('buildLineProtocol – tag value handling', () => {
+  test('string, number and boolean tag values are coerced to strings', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: 'sensor',
+      payload: {
+        fields: { value: 1 },
+        tags: { location: 'lab', floor: 2, active: true }
+      }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.tags.location).toBe('lab');
+    expect(point.tags.floor).toBe('2');
+    expect(point.tags.active).toBe('true');
+  });
+
+  test('object tag value is skipped with a warning instead of "[object Object]"', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: 'sensor',
+      payload: {
+        fields: { value: 1 },
+        tags: { good: 'ok', broken: { nested: true } }
+      }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.tags.good).toBe('ok');
+    expect(point.tags.broken).toBeUndefined();
+    expect(writeNode.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Skipping tag 'broken': unsupported type 'object' (Object)")
+    );
+    // The valid field still writes, so the message succeeds
+    expect(send).toHaveBeenCalled();
+    expect(done).toHaveBeenCalled();
+  });
+
+  test('array tag value shows Array type name in warning and is skipped', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: 'sensor',
+      payload: {
+        fields: { value: 1 },
+        tags: { list: [1, 2, 3] }
+      }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.tags.list).toBeUndefined();
+    expect(writeNode.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Skipping tag 'list': unsupported type 'object' (Array)")
+    );
+  });
+
+  test('null and undefined tag values are skipped silently', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: 'sensor',
+      payload: {
+        fields: { value: 1 },
+        tags: { keep: 'yes', gone: null, missing: undefined }
+      }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.tags.keep).toBe('yes');
+    expect(point.tags.gone).toBeUndefined();
+    expect(point.tags.missing).toBeUndefined();
+    expect(writeNode.warn).not.toHaveBeenCalled();
+  });
+});
+
 describe('buildLineProtocol – timestamp handling', () => {
   test('numeric timestamp from msg.payload.timestamp', async () => {
     const { influxModule, writeNode } = createWriteNode();
@@ -867,7 +1040,7 @@ describe('Array payload support', () => {
   });
 
   test('array item error includes item index', async () => {
-    const { RED, influxModule } = setup();
+    const { RED } = setup();
     const ConfigCtor = RED._types['influxdb3-config'];
     const WriteCtor = RED._types['influxdb3-write'];
 
@@ -937,6 +1110,155 @@ describe('Array payload support', () => {
   });
 });
 
+describe('write node – client.write failure', () => {
+  test('rejected write sets red status and calls done with the error', async () => {
+    const { configNode, writeNode } = createWriteNode();
+
+    // Pre-create the cached client and make its write reject
+    const client = configNode.getClient();
+    client.write = jest.fn().mockRejectedValue(new Error('connection refused'));
+
+    const msg = {
+      measurement: 'sensor',
+      payload: { fields: { value: 1 } }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    expect(client.write).toHaveBeenCalled();
+    expect(done).toHaveBeenCalledWith(expect.any(Error));
+    expect(done.mock.calls[0][0].message).toBe('connection refused');
+    // Error status is red and the message is NOT forwarded
+    expect(writeNode.status).toHaveBeenCalledWith(
+      expect.objectContaining({ fill: 'red', text: 'connection refused' })
+    );
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  test('long error messages are truncated in the node status', async () => {
+    const { configNode, writeNode } = createWriteNode();
+    const longMessage = 'x'.repeat(200);
+
+    const client = configNode.getClient();
+    client.write = jest.fn().mockRejectedValue(new Error(longMessage));
+
+    const msg = { measurement: 'sensor', payload: { fields: { value: 1 } } };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const statusArg = writeNode.status.mock.calls.find(c => c[0] && c[0].fill === 'red')[0];
+    expect(statusArg.text.length).toBeLessThanOrEqual(83); // 80 chars + '...'
+    expect(statusArg.text.endsWith('...')).toBe(true);
+    // done still receives the full, untruncated error
+    expect(done.mock.calls[0][0].message).toBe(longMessage);
+  });
+});
+
+describe('config node – close()', () => {
+  test('close() closes the cached client and clears the reference', () => {
+    const { configNode } = createWriteNode();
+
+    const client = configNode.getClient();
+    expect(configNode.client).toBe(client);
+
+    configNode._handlers.close();
+
+    expect(client.close).toHaveBeenCalled();
+    expect(configNode.client).toBeNull();
+  });
+
+  test('close() is a no-op when no client was ever created', () => {
+    const { configNode } = createWriteNode();
+    expect(configNode.client).toBeNull();
+    expect(() => configNode._handlers.close()).not.toThrow();
+  });
+});
+
+describe('write node – measurement resolution', () => {
+  test('empty msg.measurement falls back to the node default', async () => {
+    const { influxModule, writeNode } = createWriteNode(); // node default: 'test_measurement'
+    const msg = {
+      measurement: '',
+      payload: { fields: { value: 1 } }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.measurement).toBe('test_measurement');
+    expect(done).toHaveBeenCalled();
+    expect(done.mock.calls[0][0]).toBeUndefined();
+  });
+
+  test('msg.measurement overrides the node default', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: 'override',
+      payload: { fields: { value: 1 } }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.measurement).toBe('override');
+  });
+
+  test('whitespace-only msg.measurement falls back to the node default', async () => {
+    const { influxModule, writeNode } = createWriteNode(); // node default: 'test_measurement'
+    const msg = {
+      measurement: '   ',
+      payload: { fields: { value: 1 } }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.measurement).toBe('test_measurement');
+    expect(done.mock.calls[0][0]).toBeUndefined();
+  });
+
+  test('a provided measurement is trimmed before use', async () => {
+    const { influxModule, writeNode } = createWriteNode();
+    const msg = {
+      measurement: '  spaced  ',
+      payload: { fields: { value: 1 } }
+    };
+    const send = jest.fn();
+    const done = jest.fn();
+    await writeNode._handlers.input(msg, send, done);
+
+    const point = influxModule.__getLastPoint();
+    expect(point.measurement).toBe('spaced');
+  });
+
+  test('whitespace-only measurement with no node default errors', async () => {
+    const { RED } = 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' }
+    });
+    const writeNode = new WriteCtor({ influxdb: configNode, measurement: '', database: '' });
+
+    const msg = { measurement: '   ', payload: { fields: { value: 1 } } };
+    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('Measurement not specified');
+  });
+});
+
 describe('InfluxDB v3 config node – credentials warning', () => {
   test('logs warning when credentials object is undefined', () => {
     const RED = buildRED();

package/influxdb3.html

@@ -62,9 +62,9 @@
         <dt>Database <span class="property-type">string</span></dt>
         <dd>The default database (bucket) name to write to</dd>
         <dt>Verify TLS <span class="property-type">boolean</span></dt>
-        <dd>When unchecked, sets <code>NODE_TLS_REJECT_UNAUTHORIZED=0</code> for the Node-RED process</dd>
+        <dd>When unchecked, disables TLS certificate verification for this connection only (insecure; use only for trusted local instances)</dd>
         <dt>CA Cert Path <span class="property-type">string</span></dt>
-        <dd>Optional filesystem path used to set <code>NODE_EXTRA_CA_CERTS</code> for custom root CAs</dd>
+        <dd>Optional filesystem path to a PEM CA certificate, used to verify this connection's TLS certificate</dd>
     </dl>
 </script>
 

package/influxdb3.js

@@ -13,6 +13,8 @@ module.exports = function(RED) {
     //   Point.setTimestamp(date)
     //   Point.toLineProtocol()
     const { InfluxDBClient, Point } = require('@influxdata/influxdb3-client');
+    const fs = require('fs');
+    const { validateLineProtocol } = require('./lib/line-protocol');
 
     /**
      * Normalize host URL to ensure it has trailing slash
@@ -75,23 +77,44 @@ module.exports = function(RED) {
 
                 const normalizedHost = normalizeHost(configNode.host);
 
+                // Build per-client transport (TLS) options. These are passed only to this
+                // client's HTTPS requests, so they do NOT affect other connections or the
+                // rest of the Node-RED process (unlike NODE_TLS_REJECT_UNAUTHORIZED /
+                // NODE_EXTRA_CA_CERTS, which are global and read only at process startup).
+                const transportOptions = {};
+
                 if (!configNode.tlsRejectUnauthorized) {
-                    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-                    RED.log.warn('InfluxDB v3: TLS certificate verification is disabled for this process.');
+                    transportOptions.rejectUnauthorized = false;
+                    RED.log.warn(
+                        'InfluxDB v3: TLS certificate verification is disabled for this connection. ' +
+                        'This is insecure and should only be used for trusted local instances.'
+                    );
                 }
 
                 if (configNode.caCertPath) {
-                    process.env.NODE_EXTRA_CA_CERTS = configNode.caCertPath;
-                    RED.log.info(`InfluxDB v3: Using extra CA certificates from ${configNode.caCertPath}`);
+                    try {
+                        transportOptions.ca = fs.readFileSync(configNode.caCertPath);
+                        RED.log.info(`InfluxDB v3: Using custom CA certificate from ${configNode.caCertPath}`);
+                    } catch (error) {
+                        throw new Error(
+                            `Failed to read CA certificate from '${configNode.caCertPath}': ${error.message}`,
+                            { cause: error }
+                        );
+                    }
                 }
 
                 RED.log.info(`InfluxDB v3: Connecting to ${normalizedHost} with database ${configNode.database}`);
 
-                configNode.client = new InfluxDBClient({
+                const clientOptions = {
                     host: normalizedHost,
                     token: configNode.token,
                     database: configNode.database
-                });
+                };
+                if (Object.keys(transportOptions).length > 0) {
+                    clientOptions.transportOptions = transportOptions;
+                }
+
+                configNode.client = new InfluxDBClient(clientOptions);
 
                 RED.log.info('InfluxDB v3: Client created successfully');
             }
@@ -157,38 +180,6 @@ module.exports = function(RED) {
             }
         }
 
-        /**
-         * 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.
@@ -253,10 +244,10 @@ module.exports = function(RED) {
                     if (!Number.isInteger(value)) {
                         node.warn(
                             `Field '${key}' is marked as integer but value is ${value}${context}. ` +
-                            `Value will be truncated to ${Math.floor(value)} using Math.floor.`
+                            `Value will be truncated to ${Math.trunc(value)}.`
                         );
                     }
-                    point.setIntegerField(key, Math.floor(value));
+                    point.setIntegerField(key, Math.trunc(value));
                 } else {
                     point.setFloatField(key, value);
                 }
@@ -297,7 +288,11 @@ module.exports = function(RED) {
          * @returns {{lineProtocol: string}|{error: string}} result or error
          */
         function buildLineProtocol(msg) {
-            const measurement = msg.measurement || node.measurement;
+            // Trim each source before the fallback so a blank/whitespace-only
+            // msg.measurement falls back to the node default (instead of being used
+            // verbatim) and never produces a measurement made of spaces.
+            const trim = (m) => (typeof m === 'string' ? m.trim() : m);
+            const measurement = trim(msg.measurement) || trim(node.measurement);
 
             if (!measurement) {
                 return { error: 'Measurement not specified' };
@@ -307,10 +302,25 @@ module.exports = function(RED) {
 
             // Add tags
             if (msg.payload.tags && typeof msg.payload.tags === 'object' && !Array.isArray(msg.payload.tags)) {
+                const tagContext = measurement ? ` (measurement: '${measurement}')` : '';
                 for (const [key, value] of Object.entries(msg.payload.tags)) {
-                    if (value !== null && value !== undefined) {
-                        point.setTag(key, String(value));
+                    if (value === null || value === undefined) {
+                        continue;
+                    }
+                    // Guard against objects/arrays, which would otherwise be coerced to
+                    // useless strings like "[object Object]". Mirrors addFieldToPoint.
+                    if (typeof value === 'object') {
+                        const typeName = Array.isArray(value)
+                            ? 'Array'
+                            : (value.constructor ? value.constructor.name : 'object');
+                        node.warn(
+                            `Skipping tag '${key}': unsupported type 'object' (${typeName})${tagContext}. ` +
+                            `Actual value: ${safeStringify(value)}. ` +
+                            `Tag values must be a string, number, or boolean.`
+                        );
+                        continue;
                     }
+                    point.setTag(key, String(value));
                 }
             }
 

package/lib/line-protocol.js

@@ -0,0 +1,41 @@
+/**
+ * Pure line-protocol helpers, extracted so they can be unit-tested directly
+ * (and shared) rather than re-implemented in test files.
+ * @module lib/line-protocol
+ */
+
+'use strict';
+
+/**
+ * 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;
+}
+
+module.exports = { validateLineProtocol };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "node-red-contrib-influxdb3",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Node-RED nodes for InfluxDB v3 integration",
   "main": "influxdb3.js",
   "scripts": {
+    "lint": "eslint .",
     "test": "jest"
   },
   "keywords": [
@@ -33,9 +34,12 @@
     }
   },
   "dependencies": {
-    "@influxdata/influxdb3-client": "^2.1.0"
+    "@influxdata/influxdb3-client": "^2.2.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.4.1",
+    "globals": "^17.6.0",
     "jest": "^30.3.0"
   }
 }

package/renovate.json

@@ -1,6 +1,14 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": [
-    "config:recommended"
+    "config:base"
+  ],
+  "platformAutomerge": true,
+  "packageRules": [
+    {
+      "description": "Automerge non-major updates",
+      "matchUpdateTypes": ["minor", "patch"],
+      "automerge": true
+    }
   ]
 }

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

@@ -1,32 +1,10 @@
 /**
  * Tests for line protocol string validation.
- * Mirrors the validateLineProtocol logic in influxdb3.js.
+ * Imports the real validateLineProtocol from the shipping code so the test
+ * cannot drift from the implementation.
  */
 
-// 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;
-}
+const { validateLineProtocol } = require('../lib/line-protocol');
 
 describe('Line protocol string validation', () => {
     test('valid line protocol returns null', () => {

package/test/point-api.test.js

@@ -1,56 +1,69 @@
 const { Point } = require('@influxdata/influxdb3-client');
 
-describe('@influxdata/influxdb3-client v2.x Point API', () => {
-    test('Point.setField exists and is a function', () => {
-        const point = new Point('test');
-        expect(typeof point.setField).toBe('function');
+/**
+ * Pins the real @influxdata/influxdb3-client Point API that influxdb3.js depends on.
+ * The node uses the type-specific setters (setFloatField / setIntegerField /
+ * setStringField / setBooleanField / setTag / setTimestamp) and toLineProtocol(),
+ * so those are what we verify here — if the library changes them, this suite fails.
+ */
+describe('@influxdata/influxdb3-client v2.x Point API used by influxdb3.js', () => {
+    test('setFloatField writes a float field', () => {
+        const lp = new Point('test').setFloatField('temp', 23.5).toLineProtocol();
+        expect(lp).toContain('temp=23.5');
     });
 
-    test('Point.setField accepts (name, value) for float', () => {
-        const point = new Point('test');
-        point.setField('temp', 23.5);
-        const lp = point.toLineProtocol();
-        expect(lp).toContain('temp=23.5');
+    test('setFloatField keeps whole numbers as floats (no i suffix)', () => {
+        const lp = new Point('test').setFloatField('count', 60).toLineProtocol();
+        expect(lp).toContain('count=60');
+        expect(lp).not.toContain('count=60i');
     });
 
-    test('Point.setField accepts (name, value, "integer") for integer', () => {
-        const point = new Point('test');
-        point.setField('count', 42, 'integer');
-        const lp = point.toLineProtocol();
+    test('setIntegerField writes an integer field with the i suffix', () => {
+        const lp = new Point('test').setIntegerField('count', 42).toLineProtocol();
         expect(lp).toContain('count=42i');
     });
 
-    test('Point.setField accepts (name, value) for string', () => {
-        const point = new Point('test');
-        point.setField('status', 'ok');
-        const lp = point.toLineProtocol();
+    test('setIntegerField supports negative integers', () => {
+        const lp = new Point('test').setIntegerField('offset', -7).toLineProtocol();
+        expect(lp).toContain('offset=-7i');
+    });
+
+    test('setStringField writes a quoted string field', () => {
+        const lp = new Point('test').setStringField('status', 'ok').toLineProtocol();
         expect(lp).toContain('status="ok"');
     });
 
-    test('Point.setField accepts (name, value) for boolean', () => {
-        const point = new Point('test');
-        point.setField('active', true);
-        const lp = point.toLineProtocol();
+    test('setBooleanField writes a boolean field', () => {
+        const lp = new Point('test').setBooleanField('active', true).toLineProtocol();
         // Library serializes booleans as T/F in line protocol
         expect(lp).toContain('active=T');
     });
 
-    test('Point.setTag exists and is a function', () => {
-        const point = new Point('test');
-        expect(typeof point.setTag).toBe('function');
+    test('setTag writes a tag in the measurement,tag=value section', () => {
+        const lp = new Point('test')
+            .setTag('location', 'room1')
+            .setFloatField('value', 1)
+            .toLineProtocol();
+        expect(lp).toContain('test,location=room1 ');
     });
 
-    test('Point.setTimestamp exists and is a function', () => {
-        const point = new Point('test');
-        expect(typeof point.setTimestamp).toBe('function');
+    test('setTimestamp accepts a Date and appends a nanosecond timestamp', () => {
+        const lp = new Point('test')
+            .setFloatField('value', 1)
+            .setTimestamp(new Date(1700000000000))
+            .toLineProtocol();
+        // 1700000000000 ms -> 1700000000000000000 ns
+        expect(lp).toContain('1700000000000000000');
     });
 
-    test('type-specific methods exist alongside generic setField', () => {
+    test('the setters used by the node are all functions', () => {
         const point = new Point('test');
-        expect(typeof point.setIntegerField).toBe('function');
         expect(typeof point.setFloatField).toBe('function');
+        expect(typeof point.setIntegerField).toBe('function');
         expect(typeof point.setStringField).toBe('function');
         expect(typeof point.setBooleanField).toBe('function');
+        expect(typeof point.setTag).toBe('function');
+        expect(typeof point.setTimestamp).toBe('function');
+        expect(typeof point.toLineProtocol).toBe('function');
     });
 });
-