node-red-contrib-ntrip 0.2.3 → 0.2.8

package/ntrip/nodes/rtcm-encoder-node.js

@@ -0,0 +1,90 @@
+module.exports = function (RED) {
+    'use strict';
+
+    const { RtcmTransport, RtcmMessage } = require('@gnss/rtcm');
+
+    // Maximum RTCM 3 frame size — 3-byte header + 1023-byte payload + 3-byte CRC.
+    const MaxFrameBytes = 1029;
+
+    function RtcmEncoderNode(config) {
+        RED.nodes.createNode(this, config);
+        let node = this;
+        node.rtcmMessagesReceived = 0;
+        node.invalidMessagesReceived = 0;
+
+        function updateStatus(ok) {
+            node.status({
+                fill: ok ? 'green' : 'red',
+                shape: 'ring',
+                text: 'RTCM: ' + node.rtcmMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
+            });
+        }
+
+        this.on('input', function (msg) {
+            let payload = msg.payload;
+
+            // Accept either an RtcmMessage instance directly as msg.payload, or the
+            // shape emitted by the RtcmDecoder (msg.payload.message). Anything else
+            // routes to the error output.
+            let message;
+            if (payload instanceof RtcmMessage) {
+                message = payload;
+            } else if (payload != null && payload.message instanceof RtcmMessage) {
+                message = payload.message;
+            } else {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: 'Invalid input. Expected an RtcmMessage instance as msg.payload, or msg.payload.message.',
+                            input: payload,
+                        },
+                    },
+                ]);
+                node.invalidMessagesReceived++;
+                updateStatus(false);
+                return;
+            }
+
+            try {
+                let buffer = Buffer.alloc(MaxFrameBytes);
+                let length = RtcmTransport.encode(message, buffer);
+                let encoded = buffer.slice(0, length);
+                let messageType = message.constructor.name.replace('RtcmMessage', '');
+
+                node.send([
+                    {
+                        payload: {
+                            rtcmMessage: encoded,
+                            rtcm: message.messageType,
+                            messageType: messageType,
+                            input: payload,
+                        },
+                    },
+                    null,
+                ]);
+                node.rtcmMessagesReceived++;
+                updateStatus(true);
+            } catch (ex) {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: ex,
+                            input: payload,
+                        },
+                    },
+                ]);
+                node.invalidMessagesReceived++;
+                updateStatus(false);
+            }
+        });
+
+        this.on('close', function (done) {
+            node.status({});
+            done();
+        });
+    }
+
+    return RtcmEncoderNode;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ntrip",
-    "version": "0.2.3",
+    "version": "0.2.8",
     "description": "Node for ntrip and rtcm handling.",
     "node-red": {
         "version": ">=0.1.0",
@@ -9,7 +9,7 @@
         }
     },
     "engines": {
-        "node": ">=7.6.0"
+        "node": ">=18.0.0"
     },
     "keywords": [
         "node-red",
@@ -24,9 +24,27 @@
     },
     "author": "Karl-Heinz Wind",
     "license": "MIT",
+    "scripts": {
+        "test": "mocha test/**/*.spec.js --timeout 5000",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "format": "prettier --write .",
+        "format:check": "prettier --check ."
+    },
     "dependencies": {
         "@gnss/nmea": "^0.1.2",
         "@gnss/rtcm": "^0.1.5",
         "ntrip-client": "^1.1.1"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "chai": "^4.5.0",
+        "eslint": "^10.3.0",
+        "eslint-config-prettier": "^10.1.8",
+        "globals": "^17.6.0",
+        "mocha": "^11.7.5",
+        "node-red": "^4.1.10",
+        "node-red-node-test-helper": "^0.3.6",
+        "prettier": "^3.8.3"
     }
 }

package/test/nmea-decoder.spec.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const helper = require('node-red-node-test-helper');
+const { expect } = require('chai');
+const ntripModule = require('../ntrip/99-ntrip.js');
+
+helper.init(require.resolve('node-red'));
+
+const GGA = '$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47';
+const GLL = '$GPGLL,4916.45,N,12311.12,W,225444,A,*1D';
+
+function flow() {
+    return [
+        { id: 'n1', type: 'NmeaDecoder', wires: [['ok'], ['err']] },
+        { id: 'ok', type: 'helper' },
+        { id: 'err', type: 'helper' },
+    ];
+}
+
+describe('NmeaDecoder', function () {
+    before(() => helper.startServer());
+    after(() => helper.stopServer());
+    afterEach(() => helper.unload());
+
+    it('decodes a valid GGA sentence on the success output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.messageType).to.equal('GGA');
+                        expect(msg.payload.nmeaMessage).to.have.property('latitude');
+                        expect(msg.payload.input).to.equal(GGA);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: GGA });
+            });
+        });
+    });
+
+    it('splits a multi-sentence chunk into separate output messages', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const types = [];
+                ok.on('input', (msg) => {
+                    types.push(msg.payload.messageType);
+                    if (types.length === 2) {
+                        try {
+                            expect(types).to.deep.equal(['GGA', 'GLL']);
+                            resolve();
+                        } catch (e) {
+                            reject(e);
+                        }
+                    }
+                });
+                n1.receive({ payload: GGA + '\r\n' + GLL + '\r\n' });
+            });
+        });
+    });
+
+    it('accepts a Buffer payload and decodes it as UTF-8', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.messageType).to.equal('GGA');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: Buffer.from(GGA, 'utf8') });
+            });
+        });
+    });
+
+    it('reads payload.nmeaMessage when payload is an object', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.messageType).to.equal('GGA');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: { nmeaMessage: GGA } });
+            });
+        });
+    });
+
+    it('error output preserves Buffer input as `input`, utf8 as `inputString`', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                const garbage = Buffer.from([0xd3, 0x00, 0x13, 0x3e, 0xd0, 0x00]);
+                err.on('input', (msg) => {
+                    try {
+                        expect(Buffer.isBuffer(msg.payload.input)).to.equal(true);
+                        expect(msg.payload.input).to.deep.equal(garbage);
+                        expect(msg.payload.inputString).to.be.a('string');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: garbage });
+            });
+        });
+    });
+
+    it('does not call node.error on decode failure (regression: log flood)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                let errorCalled = false;
+                const originalError = n1.error.bind(n1);
+                n1.error = function (...args) {
+                    errorCalled = true;
+                    return originalError(...args);
+                };
+                n1.receive({ payload: Buffer.from([0xd3, 0x00, 0x13, 0x3e]) });
+                setTimeout(() => {
+                    try {
+                        expect(errorCalled).to.equal(false);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                }, 50);
+            });
+        });
+    });
+});

package/test/nmea-encoder.spec.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const helper = require('node-red-node-test-helper');
+const { expect } = require('chai');
+const { NmeaTransport } = require('@gnss/nmea');
+const ntripModule = require('../ntrip/99-ntrip.js');
+
+helper.init(require.resolve('node-red'));
+
+const GGA = '$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47';
+
+function flow() {
+    return [
+        { id: 'n1', type: 'NmeaEncoder', wires: [['ok'], ['err']] },
+        { id: 'ok', type: 'helper' },
+        { id: 'err', type: 'helper' },
+    ];
+}
+
+describe('NmeaEncoder', function () {
+    before(() => helper.startServer());
+    after(() => helper.stopServer());
+    afterEach(() => helper.unload());
+
+    it('encodes a pre-constructed NmeaMessage instance (instanceof passthrough)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const instance = NmeaTransport.decode(GGA);
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.nmeaMessage).to.be.a('string');
+                        expect(msg.payload.nmeaMessage).to.match(/^\$.+\*[0-9A-Fa-f]{2}\r?\n?$/);
+                        expect(msg.payload.nmeaMessage).to.include('GGA');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                // Even with a bogus messageType, an instance must take precedence and
+                // flow straight through to NmeaTransport.encode without re-construction.
+                n1.receive({ payload: { messageType: 'NONSENSE', nmeaMessage: instance } });
+            });
+        });
+    });
+
+    it('routes unknown messageType to the error output (no silent success)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const err = helper.getNode('err');
+                ok.on('input', () => reject(new Error('unexpected success output')));
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.exist;
+                        expect(String(msg.payload.error).toLowerCase()).to.include('unsupported');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: { messageType: 'XYZ', nmeaMessage: { foo: 1 } } });
+            });
+        });
+    });
+
+    it('routes missing nmeaMessage to the error output without crashing', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.exist;
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: { messageType: 'GGA' } });
+            });
+        });
+    });
+
+    it('routes empty payload to the error output without crashing', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.exist;
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: {} });
+            });
+        });
+    });
+});

package/test/rtcm-decoder.spec.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const helper = require('node-red-node-test-helper');
+const { expect } = require('chai');
+const ntripModule = require('../ntrip/99-ntrip.js');
+
+helper.init(require.resolve('node-red'));
+
+// A real RTCM 3 message type 1005 (Stationary RTK Reference Station ARP).
+// 25 bytes total: 3-byte header + 19-byte payload + 3-byte CRC.
+const RTCM_1005 = Buffer.from('D300133ED7D30202980EDEEF34B4BD62AC0941986F33360B98', 'hex');
+
+function flow() {
+    return [
+        { id: 'n1', type: 'RtcmDecoder', wires: [['ok'], ['err']] },
+        { id: 'ok', type: 'helper' },
+        { id: 'err', type: 'helper' },
+    ];
+}
+
+describe('RtcmDecoder', function () {
+    before(() => helper.startServer());
+    after(() => helper.stopServer());
+    afterEach(() => helper.unload());
+
+    it('decodes a valid RTCM 1005 frame on the success output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.rtcm).to.equal(1005);
+                        expect(msg.payload.messageType).to.be.a('string');
+                        expect(msg.payload.message).to.be.an('object');
+                        expect(Buffer.isBuffer(msg.payload.input)).to.equal(true);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: RTCM_1005 });
+            });
+        });
+    });
+
+    it('decodes two concatenated frames as two separate output messages', function () {
+        return new Promise((resolve) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                let count = 0;
+                ok.on('input', () => {
+                    count++;
+                    if (count === 2) resolve();
+                });
+                n1.receive({ payload: Buffer.concat([RTCM_1005, RTCM_1005]) });
+            });
+        });
+    });
+
+    it('reassembles a frame split across two input events (carry-over buffer)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                let received = false;
+                ok.on('input', (msg) => {
+                    if (received) return;
+                    received = true;
+                    try {
+                        expect(msg.payload.rtcm).to.equal(1005);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                const half = Math.floor(RTCM_1005.length / 2);
+                n1.receive({ payload: RTCM_1005.slice(0, half) });
+                setImmediate(() => n1.receive({ payload: RTCM_1005.slice(half) }));
+            });
+        });
+    });
+
+    it('does not call node.error on decode failure (regression: log flood)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                let errorCalled = false;
+                const originalError = n1.error.bind(n1);
+                n1.error = function (...args) {
+                    errorCalled = true;
+                    return originalError(...args);
+                };
+                // A buffer of garbage larger than the pending-buffer cap triggers the
+                // error-output path. node.error must NOT be called for that.
+                const big = Buffer.alloc(70000, 0xff);
+                let errEmitted = false;
+                err.on('input', () => {
+                    errEmitted = true;
+                });
+                n1.receive({ payload: big });
+                setTimeout(() => {
+                    try {
+                        expect(errEmitted).to.equal(true);
+                        expect(errorCalled).to.equal(false);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                }, 200);
+            });
+        });
+    });
+});

package/test/rtcm-encoder.spec.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const helper = require('node-red-node-test-helper');
+const { expect } = require('chai');
+const { RtcmTransport, RtcmMessage } = require('@gnss/rtcm');
+const ntripModule = require('../ntrip/99-ntrip.js');
+
+helper.init(require.resolve('node-red'));
+
+// A real RTCM 3 message type 1005 (Stationary RTK Reference Station ARP).
+const RTCM_1005 = Buffer.from('D300133ED7D30202980EDEEF34B4BD62AC0941986F33360B98', 'hex');
+
+function flow() {
+    return [
+        { id: 'n1', type: 'RtcmEncoder', wires: [['ok'], ['err']] },
+        { id: 'ok', type: 'helper' },
+        { id: 'err', type: 'helper' },
+    ];
+}
+
+describe('RtcmEncoder', function () {
+    before(() => helper.startServer());
+    after(() => helper.stopServer());
+    afterEach(() => helper.unload());
+
+    it('encodes an RtcmMessage instance round-tripped from the decoder', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const [instance] = RtcmTransport.decode(RTCM_1005);
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.rtcm).to.equal(1005);
+                        expect(msg.payload.messageType).to.be.a('string');
+                        expect(Buffer.isBuffer(msg.payload.rtcmMessage)).to.equal(true);
+                        expect(msg.payload.rtcmMessage).to.deep.equal(RTCM_1005);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: instance });
+            });
+        });
+    });
+
+    it('accepts the decoder output shape (msg.payload.message)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const [instance, length] = RtcmTransport.decode(RTCM_1005);
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.rtcm).to.equal(1005);
+                        expect(Buffer.isBuffer(msg.payload.rtcmMessage)).to.equal(true);
+                        expect(msg.payload.rtcmMessage.length).to.equal(length);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                // Mimic the RtcmDecoder's success payload shape.
+                n1.receive({
+                    payload: {
+                        rtcm: instance.messageType,
+                        messageType: 'StationArp',
+                        message: instance,
+                        input: RTCM_1005,
+                    },
+                });
+            });
+        });
+    });
+
+    it('routes a non-RtcmMessage payload to the error output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const err = helper.getNode('err');
+                ok.on('input', () => reject(new Error('unexpected success output')));
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.be.a('string');
+                        expect(msg.payload.error.toLowerCase()).to.include('invalid');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: { foo: 'bar' } });
+            });
+        });
+    });
+
+    it('routes empty payload to the error output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                err.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.error).to.exist;
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: null });
+            });
+        });
+    });
+
+    it('does not call node.error on decode-shape failure (regression: log flood)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                let errorCalled = false;
+                const originalError = n1.error.bind(n1);
+                n1.error = function (...args) {
+                    errorCalled = true;
+                    return originalError(...args);
+                };
+                n1.receive({ payload: 'not-an-rtcm-message' });
+                setTimeout(() => {
+                    try {
+                        expect(errorCalled).to.equal(false);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                }, 50);
+            });
+        });
+    });
+
+    // Sanity check: RtcmMessage is exported and the test fixture decodes to an instance.
+    it('test fixture sanity: decoded 1005 frame is an RtcmMessage instance', function () {
+        const [instance] = RtcmTransport.decode(RTCM_1005);
+        expect(instance).to.be.instanceOf(RtcmMessage);
+    });
+});

package/.github/workflows/npm-publish.yml

@@ -1,33 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-#      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}