node-red-contrib-scorp-io 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SCorp-io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# node-red-contrib-scorp-io
+
+Node-RED nodes for SCorp-io MQTTS integration.
+
+The package exposes a shared SCorp-io configuration node and a multi-device publishing node for:
+
+- `DBIRTH` messages: device metric declarations;
+- `DDATA` messages: device metric values with timestamps.
+
+## Requirements
+
+- Node.js `>=18.0.0`
+- Node-RED `>=3.0.0`
+- SCorp-io MQTT credentials for production mode
+
+## Installation
+
+### From the Node-RED editor
+
+Open **Menu → Manage palette → Install**, then search for:
+
+```text
+node-red-contrib-scorp-io
+```
+
+### From npm
+
+Run from the Node-RED user directory, usually `~/.node-red`:
+
+```bash
+cd ~/.node-red
+npm install node-red-contrib-scorp-io
+```
+
+Restart Node-RED after installation.
+
+## Nodes
+
+### `scorp-io-config`
+
+Shared configuration node for the SCorp-io MQTT connection.
+
+| Field | Description |
+| --- | --- |
+| Mode | `test` disables MQTT publishing; `production` publishes to the broker |
+| Client ID | MQTT client identifier |
+| Login | MQTT username |
+| Password | MQTT password, stored as a Node-RED credential |
+| Project ID | SCorp-io project identifier used in MQTT topics |
+| Node ID | Edge node identifier used in MQTT topics |
+
+Production broker endpoint:
+
+```text
+mqtts://broker-public-prod.scorp-io.com:8883
+```
+
+### `scorp-io-device`
+
+Multi-device node that builds and publishes SCorp-io `DBIRTH` and `DDATA` payloads.
+
+#### Input
+
+The node has one input.
+
+| Message | Behavior |
+| --- | --- |
+| `msg.topic === "birth"` | Emits a `DBIRTH` for all configured devices |
+| `msg.deviceId` set | Emits `DDATA` for the matching configured device |
+| regular payload | Emits `DDATA` for every device where at least one metric path resolves |
+
+#### Output
+
+The node has one debug output containing the generated message:
+
+| Property | Description |
+| --- | --- |
+| `msg.topic` | MQTT topic that was/would be published |
+| `msg.payload` | Generated SCorp-io payload |
+| `msg._scorp.type` | `DBIRTH` or `DDATA` |
+| `msg._scorp.device` | Target device id |
+| `msg._scorp.simulated` | `true` in test mode |
+
+## Metric configuration
+
+Each device has a list of metrics.
+
+| Metric field | Description | Example |
+| --- | --- | --- |
+| `name` | Metric name sent to SCorp-io | `pompe-1/etats` |
+| `dataType` | Metric type | `Integer`, `Boolean`, `Float` |
+| `valuePath` | Path resolved from incoming `msg` for `DDATA` | `msg.payload.pompe1.etats` |
+
+Supported value paths:
+
+```text
+msg.payload.pompe1.etats
+msg.pompe.etat
+pompe1.etats
+```
+
+Paths without the `msg.` prefix are resolved from `msg.payload`.
+
+## Topic format
+
+```text
+mqtts/{PROJECT_ID}/{MESSAGE_TYPE}/{EDGE_NODE_ID}/{DEVICE_ID}
+```
+
+Examples:
+
+```text
+mqtts/my-project/DBIRTH/edge-01/pompe-1
+mqtts/my-project/DDATA/edge-01/pompe-1
+```
+
+## Payload examples
+
+### DBIRTH
+
+```json
+{
+  "metrics": [
+    { "name": "pompe-1/etats", "dataType": "Integer" },
+    { "name": "pompe-1/defaut", "dataType": "Boolean" }
+  ]
+}
+```
+
+### DDATA
+
+```json
+{
+  "metrics": [
+    {
+      "name": "pompe-1/etats",
+      "timestamp": 1710000000000,
+      "dataType": "Integer",
+      "value": 1
+    },
+    {
+      "name": "pompe-1/defaut",
+      "timestamp": 1710000000000,
+      "dataType": "Boolean",
+      "value": false
+    }
+  ]
+}
+```
+
+## Example flow
+
+An importable example is provided in:
+
+```text
+examples/scorp-io-basic-flow.json
+```
+
+It runs in `test` mode by default, so it does not publish to the production MQTT broker.
+
+## Development
+
+```bash
+npm install
+npm test
+npm run pack:dry-run
+```
+
+## License
+
+MIT

package/examples/scorp-io-basic-flow.json

@@ -0,0 +1,124 @@
+[
+  {
+    "id": "f1f2f3f4f5f6f7f8",
+    "type": "tab",
+    "label": "SCorp-io basic example",
+    "disabled": false,
+    "info": "Example flow for @scorp-io/node-red-contrib-scorp-io. Runs in test mode by default."
+  },
+  {
+    "id": "cfg-scorp-io-example",
+    "type": "scorp-io-config",
+    "name": "SCorp-io test",
+    "clientId": "example-client",
+    "projectId": "my-project",
+    "edgeNodeId": "edge-01",
+    "mode": "test",
+    "login": ""
+  },
+  {
+    "id": "inject-pompe-1",
+    "type": "inject",
+    "z": "f1f2f3f4f5f6f7f8",
+    "name": "Sample DDATA pompe-1",
+    "props": [
+      {
+        "p": "payload"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "",
+    "payload": "{\"pompe1\":{\"etats\":1,\"defaut\":false,\"status\":3.14}}",
+    "payloadType": "json",
+    "x": 180,
+    "y": 120,
+    "wires": [
+      [
+        "scorp-device-example"
+      ]
+    ]
+  },
+  {
+    "id": "inject-birth",
+    "type": "inject",
+    "z": "f1f2f3f4f5f6f7f8",
+    "name": "Force DBIRTH",
+    "props": [
+      {
+        "p": "topic",
+        "vt": "str"
+      }
+    ],
+    "repeat": "",
+    "crontab": "",
+    "once": false,
+    "onceDelay": 0.1,
+    "topic": "birth",
+    "x": 160,
+    "y": 180,
+    "wires": [
+      [
+        "scorp-device-example"
+      ]
+    ]
+  },
+  {
+    "id": "scorp-device-example",
+    "type": "scorp-io-device",
+    "z": "f1f2f3f4f5f6f7f8",
+    "name": "Example pumps",
+    "config": "cfg-scorp-io-example",
+    "devices": [
+      {
+        "deviceId": "pompe-1",
+        "metrics": [
+          {
+            "name": "pompe-1/etats",
+            "dataType": "Integer",
+            "valuePath": "msg.payload.pompe1.etats"
+          },
+          {
+            "name": "pompe-1/defaut",
+            "dataType": "Boolean",
+            "valuePath": "msg.payload.pompe1.defaut"
+          },
+          {
+            "name": "pompe-1/status",
+            "dataType": "Float",
+            "valuePath": "msg.payload.pompe1.status"
+          }
+        ]
+      }
+    ],
+    "birthOnDeploy": true,
+    "birthPeriodic": false,
+    "birthInterval": "24h",
+    "x": 430,
+    "y": 140,
+    "wires": [
+      [
+        "debug-scorp-output"
+      ]
+    ]
+  },
+  {
+    "id": "debug-scorp-output",
+    "type": "debug",
+    "z": "f1f2f3f4f5f6f7f8",
+    "name": "SCorp-io generated message",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "true",
+    "targetType": "full",
+    "statusVal": "",
+    "statusType": "auto",
+    "x": 710,
+    "y": 140,
+    "wires": []
+  }
+]

package/locales/en-US/scorp-io.json

@@ -0,0 +1,43 @@
+{
+  "scorp-io-config": {
+    "label": {
+      "clientid": "Client ID",
+      "login": "Login",
+      "password": "Password",
+      "projectid": "Project ID",
+      "edgenodeid": "Edge Node ID"
+    },
+    "tooltip": {
+      "clientid": "Unique MQTT connection identifier",
+      "projectid": "SCorp-io project identifier",
+      "edgenodeid": "Edge node identifier"
+    },
+    "status": {
+      "connected": "Connected",
+      "disconnected": "Disconnected",
+      "connecting": "Connecting...",
+      "error": "Connection error"
+    }
+  },
+  "scorp-io-device": {
+    "label": {
+      "deviceid": "Device ID",
+      "config": "SCorp-io Config",
+      "metrics": "Metrics",
+      "metricname": "Name",
+      "metricdatatype": "Data Type",
+      "metricvalue": "Value (msg.payload path)"
+    },
+    "placeholder": {
+      "deviceid": "e.g. pompe-1",
+      "metricname": "e.g. pompe-1/etats",
+      "metricvalue": "e.g. pompe1.etats"
+    },
+    "status": {
+      "connected": "Connected",
+      "disconnected": "Disconnected",
+      "birth_sent": "DBIRTH sent",
+      "data_sent": "DDATA sent"
+    }
+  }
+}

package/locales/fr/scorp-io.json

@@ -0,0 +1,43 @@
+{
+  "scorp-io-config": {
+    "label": {
+      "clientid": "Client ID",
+      "login": "Login",
+      "password": "Mot de passe",
+      "projectid": "Project ID",
+      "edgenodeid": "Edge Node ID"
+    },
+    "tooltip": {
+      "clientid": "Identifiant unique de connexion MQTT",
+      "projectid": "Identifiant du projet SCorp-io",
+      "edgenodeid": "Identifiant du nœud edge"
+    },
+    "status": {
+      "connected": "Connecté",
+      "disconnected": "Déconnecté",
+      "connecting": "Connexion...",
+      "error": "Erreur de connexion"
+    }
+  },
+  "scorp-io-device": {
+    "label": {
+      "deviceid": "Device ID",
+      "config": "Config SCorp-io",
+      "metrics": "Métriques",
+      "metricname": "Nom",
+      "metricdatatype": "Type de données",
+      "metricvalue": "Valeur (chemin msg.payload)"
+    },
+    "placeholder": {
+      "deviceid": "ex: pompe-1",
+      "metricname": "ex: pompe-1/etats",
+      "metricvalue": "ex: pompe1.etats"
+    },
+    "status": {
+      "connected": "Connecté",
+      "disconnected": "Déconnecté",
+      "birth_sent": "DBIRTH envoyé",
+      "data_sent": "DDATA envoyé"
+    }
+  }
+}

package/nodes/scorp-io-config.html

@@ -0,0 +1,96 @@
+<script type="text/javascript">
+    RED.nodes.registerType('scorp-io-config', {
+        category: 'config',
+        defaults: {
+            name:       { value: '' },
+            clientId:   { value: '', required: true },
+            projectId:  { value: '', required: true },
+            edgeNodeId: { value: '', required: true },
+            mode:       { value: 'test' },
+            login:      { value: '' }
+        },
+        credentials: {
+            password: { type: 'password' }
+        },
+        label: function() {
+            const modeTag = this.mode === 'production' ? '🟢 PROD' : '🧪 TEST';
+            return this.name || ('SCorp-io [' + (this.projectId || '?') + '] ' + modeTag);
+        },
+        oneditprepare: function() {
+            // Pré-remplir le mot de passe depuis credentials
+            if (this.credentials && this.credentials.password) {
+                $('#node-config-input-password').val(this.credentials.password);
+            }
+            // Afficher/masquer avertissement selon mode
+            $('#node-config-input-mode').on('change', function() {
+                if ($(this).val() === 'production') {
+                    $('#scorp-mode-warning').show();
+                } else {
+                    $('#scorp-mode-warning').hide();
+                }
+            }).trigger('change');
+        },
+        oneditsave: function() {
+            // Sauvegarder le mot de passe dans credentials
+            this.credentials = this.credentials || {};
+            this.credentials.password = $('#node-config-input-password').val();
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="scorp-io-config">
+
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> Nom</label>
+        <input type="text" id="node-config-input-name" placeholder="ex: SCorp-io Production" style="width:70%">
+    </div>
+
+    <!-- MODE -->
+    <div class="form-row">
+        <label for="node-config-input-mode"><i class="fa fa-toggle-on"></i> Mode</label>
+        <select id="node-config-input-mode" style="width:70%">
+            <option value="test">🧪 Test (simulation, pas d'envoi MQTT)</option>
+            <option value="production">🟢 Production (envoi MQTT réel)</option>
+        </select>
+    </div>
+    <div id="scorp-mode-warning" class="form-tips"
+         style="display:none; background:#fff3cd; border-left:4px solid #ffc107; padding:8px; margin-bottom:10px;">
+        ⚠️ Mode <b>Production</b> activé — les messages MQTT seront envoyés au broker SCorp-io.
+    </div>
+
+    <hr/>
+    <div class="form-row">
+        <label style="width:100%;font-weight:bold;"><i class="fa fa-plug"></i> Connexion MQTT</label>
+    </div>
+    <div class="form-tips" style="margin-bottom:12px;">
+        Broker fixe : <b>broker-public-prod.scorp-io.com : 8883</b> (TLS automatique)
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-clientId"><i class="fa fa-id-card"></i> Client ID</label>
+        <input type="text" id="node-config-input-clientId" placeholder="ex: my-edge-client-01" style="width:70%">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-login"><i class="fa fa-user"></i> Login</label>
+        <input type="text" id="node-config-input-login" placeholder="Nom d'utilisateur MQTT" style="width:70%" autocomplete="off">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-password"><i class="fa fa-lock"></i> Mot de passe</label>
+        <input type="password" id="node-config-input-password" placeholder="Mot de passe MQTT" style="width:70%" autocomplete="new-password">
+    </div>
+
+    <hr/>
+    <div class="form-row">
+        <label style="width:100%;font-weight:bold;"><i class="fa fa-sitemap"></i> Identifiants SCorp-io</label>
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-projectId"><i class="fa fa-folder"></i> Project ID</label>
+        <input type="text" id="node-config-input-projectId" placeholder="ex: my-project" style="width:70%">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-edgeNodeId"><i class="fa fa-microchip"></i> Node ID</label>
+        <input type="text" id="node-config-input-edgeNodeId" placeholder="ex: edge-node-01" style="width:70%">
+    </div>
+
+</script>

package/nodes/scorp-io-config.js

@@ -0,0 +1,104 @@
+module.exports = function(RED) {
+    const mqtt = require('mqtt');
+
+    function ScorpIoConfigNode(config) {
+        RED.nodes.createNode(this, config);
+
+        this.clientId   = config.clientId;
+        this.projectId  = config.projectId;
+        this.edgeNodeId = config.edgeNodeId;
+        this.mode       = config.mode || 'test';
+        this.login      = config.login;
+        this.password   = this.credentials && this.credentials.password;
+        this.brokerUrl  = 'mqtts://broker-public-prod.scorp-io.com:8883';
+
+        this._devices   = {};
+        this.connected  = false;
+
+        const node = this;
+
+        // ── API partagée — toujours définie, mode test ou production ──────────
+
+        node.register = function(deviceNode) {
+            node._devices[deviceNode.id] = deviceNode;
+        };
+
+        node.deregister = function(deviceNode) {
+            delete node._devices[deviceNode.id];
+        };
+
+        node.publish = function(topic, payload, options, callback) {
+            // Compatibilité : publish(topic, payload, callback)
+            if (typeof options === 'function') { callback = options; options = {}; }
+            options = options || {};
+
+            if (node.mode === 'test') {
+                if (callback) callback(null);
+                return;
+            }
+            if (node.client && node.client.connected) {
+                const mqttOpts = { qos: 1, retain: !!options.retain };
+                node.client.publish(topic, JSON.stringify(payload), mqttOpts, callback);
+            } else {
+                node.warn('SCorp-io : tentative de publication hors connexion');
+                if (callback) callback(new Error('Non connecté'));
+            }
+        };
+
+        // ── Connexion MQTT — uniquement en mode production ────────────────────
+
+        if (node.mode === 'test') {
+            node.log('[MODE TEST] Connexion MQTT désactivée');
+            return;
+        }
+
+        const options = {
+            clientId:           node.clientId,
+            username:           node.login,
+            password:           node.password,
+            rejectUnauthorized: true,
+            reconnectPeriod:    5000,
+            connectTimeout:     30000
+        };
+
+        node.client = mqtt.connect(node.brokerUrl, options);
+
+        node.client.on('connect', function() {
+            node.connected = true;
+            node.log('SCorp-io connecté à ' + node.brokerUrl);
+            Object.values(node._devices).forEach(d => d.onConnected());
+        });
+
+        node.client.on('reconnect', function() {
+            node.connected = false;
+            node.log('SCorp-io reconnexion en cours...');
+            Object.values(node._devices).forEach(d => d.onConnecting());
+        });
+
+        node.client.on('error', function(err) {
+            node.connected = false;
+            node.error('SCorp-io erreur MQTT : ' + err.message);
+            Object.values(node._devices).forEach(d => d.onError(err.message));
+        });
+
+        node.client.on('offline', function() {
+            node.connected = false;
+            node.log('SCorp-io déconnecté');
+            Object.values(node._devices).forEach(d => d.onDisconnected());
+        });
+
+        node.on('close', function(done) {
+            if (node.client) {
+                node.client.end(true, {}, done);
+            } else {
+                done();
+            }
+        });
+    }
+
+    RED.nodes.registerType('scorp-io-config', ScorpIoConfigNode, {
+        credentials: {
+            password: { type: 'password' }
+        }
+    });
+};

package/nodes/scorp-io-device.html

@@ -0,0 +1,300 @@
+<script type="text/javascript">
+
+const SCORP_DATA_TYPES = [
+    'Int8','Int16','Int32','Int64',
+    'UInt8','UInt16','UInt32','UInt64',
+    'Float','Double','Boolean','String','DateTime'
+];
+
+function scorpMakeMetricRow(container, metric) {
+    metric = metric || { name: '', dataType: 'String', valuePath: '' };
+    const row = $('<div/>').css({
+        display: 'flex', gap: '4px', alignItems: 'center', width: '100%', padding: '2px 0'
+    }).appendTo(container);
+
+    $('<input/>', { type: 'text', placeholder: 'ex: pompe-1/etats', class: 'scorp-metric-name' })
+        .css({ flex: '2', minWidth: 0 }).val(metric.name || '').appendTo(row);
+
+    const sel = $('<select/>', { class: 'scorp-metric-datatype' })
+        .css({ flex: '1.3', minWidth: 0 }).appendTo(row);
+    SCORP_DATA_TYPES.forEach(function(t) {
+        $('<option/>', { value: t, text: t }).appendTo(sel);
+    });
+    sel.val(metric.dataType || 'String');
+
+    $('<input/>', { type: 'text', placeholder: 'msg.payload.pompe1.etats', class: 'scorp-metric-valuepath' })
+        .css({ flex: '2.5', minWidth: 0 }).val(metric.valuePath || '').appendTo(row);
+}
+
+function scorpMakeDeviceBlock(container, device) {
+    device = device || { deviceId: '', metrics: [] };
+
+    const block = $('<div/>').addClass('scorp-device-block').css({
+        border: '1px solid #ccc', borderRadius: '4px', marginBottom: '8px', background: '#f9f9f9'
+    }).appendTo(container);
+
+    // En-tête
+    const header = $('<div/>').css({
+        display: 'flex', alignItems: 'center', gap: '6px', padding: '6px 8px',
+        background: '#e8f4f8', borderBottom: '1px solid #ccc',
+        borderRadius: '4px 4px 0 0', cursor: 'pointer'
+    }).appendTo(block);
+
+    const toggle = $('<span/>').css({
+        fontFamily: 'monospace', fontWeight: 'bold', minWidth: '12px', color: '#555'
+    }).text('▼').appendTo(header);
+
+    $('<label/>').css({ fontWeight: 'bold', marginBottom: 0, flex: '0 0 auto' })
+        .text('Device ID :').appendTo(header);
+
+    $('<input/>', { type: 'text', placeholder: 'ex: pompe-1', class: 'scorp-device-id' })
+        .css({ flex: '1', minWidth: 0 }).val(device.deviceId || '').appendTo(header);
+
+    $('<button/>', { type: 'button' })
+        .addClass('red-ui-button red-ui-button-small')
+        .css({ marginLeft: 'auto', flexShrink: 0 })
+        .html('<i class="fa fa-trash"></i>')
+        .on('click', function(e) { e.stopPropagation(); block.remove(); })
+        .appendTo(header);
+
+    // Corps
+    const body = $('<div/>').css({ padding: '8px' }).appendTo(block);
+
+    // En-têtes colonnes
+    $('<div/>').css({
+        display: 'flex', gap: '4px',
+        fontSize: '11px', color: '#888', fontWeight: 'bold', padding: '0 0 4px 0'
+    }).html(
+        '<span style="flex:2">Nom métrique</span>' +
+        '<span style="flex:1.3">Type</span>' +
+        '<span style="flex:2.5">Chemin (depuis msg)</span>'
+    ).appendTo(body);
+
+    // editableList SANS bouton natif
+    const metricList = $('<ol/>').css({ paddingLeft: 0, marginBottom: '6px' }).appendTo(body);
+    metricList.editableList({
+        addItem: function(rowContainer, i, opt) {
+            const m = (opt && opt.name !== undefined) ? opt : { name: '', dataType: 'String', valuePath: '' };
+            scorpMakeMetricRow(rowContainer, m);
+        },
+        removable:  true,
+        sortable:   true,
+        addButton:  false   // ← supprime le bouton natif dupliqué
+    });
+
+    (device.metrics || []).forEach(function(m) { metricList.editableList('addItem', m); });
+
+    // Bouton unique "Ajouter une métrique"
+    $('<button/>', { type: 'button' })
+        .addClass('red-ui-button red-ui-button-small')
+        .html('<i class="fa fa-plus"></i> Ajouter une métrique')
+        .on('click', function() { metricList.editableList('addItem', {}); })
+        .appendTo(body);
+
+    // Toggle collapse
+    header.on('click', function(e) {
+        if ($(e.target).is('input, button, i')) return;
+        if (body.is(':visible')) { body.hide(); toggle.text('▶'); }
+        else                     { body.show(); toggle.text('▼'); }
+    });
+
+    block.data('metricList', metricList);
+    return block;
+}
+
+RED.nodes.registerType('scorp-io-device', {
+    category: 'SCorp-io',
+    color:    '#00AEEF',
+    defaults: {
+        name:           { value: '' },
+        config:         { value: '', type: 'scorp-io-config', required: true },
+        devices:        { value: [] },
+        birthOnDeploy:  { value: true  },
+        birthPeriodic:  { value: false },
+        birthInterval:  { value: '24h' }
+    },
+    inputs:  1,
+    outputs: 1,
+    icon:    'bridge.svg',
+    inputLabels:  ['data (msg.topic="birth" pour forcer DBIRTH)'],
+    outputLabels: ['debug (topic + payload)'],
+    label: function() {
+        const n = (this.devices || []).length;
+        return this.name || ('SCorp-io — ' + n + ' device' + (n > 1 ? 's' : ''));
+    },
+    labelStyle: function() { return this.name ? 'node_label_italic' : ''; },
+
+    oneditprepare: function() {
+        const node = this;
+
+        // ── Devices ──
+        const container = $('#scorp-devices-container');
+        (node.devices || []).forEach(function(d) { scorpMakeDeviceBlock(container, d); });
+        $('#scorp-add-device').on('click', function() {
+            scorpMakeDeviceBlock(container, { deviceId: '', metrics: [] });
+        });
+
+        // ── DBIRTH au déploiement ──
+        $('#scorp-birth-on-deploy').prop('checked', node.birthOnDeploy !== false);
+
+        // ── DBIRTH périodique ──
+        const periodicChk = $('#scorp-birth-periodic');
+        const intervalSel = $('#scorp-birth-interval');
+
+        periodicChk.prop('checked', !!node.birthPeriodic);
+        intervalSel.val(node.birthInterval || '24h');
+        intervalSel.prop('disabled', !node.birthPeriodic);
+
+        periodicChk.on('change', function() {
+            intervalSel.prop('disabled', !$(this).prop('checked'));
+        });
+
+        // ── Bouton forcer DBIRTH ──
+        const btn    = $('#scorp-btn-dbirth');
+        const status = $('#scorp-btn-dbirth-status');
+
+        if (!node.id) { btn.prop('disabled', true); }
+
+        btn.on('click', function() {
+            btn.prop('disabled', true);
+            status.text('Envoi…').css('color', '#aaa');
+            $.ajax({
+                method: 'POST',
+                url:    'scorp-io/dbirth/' + node.id,
+                success: function(data) {
+                    status.text('✅ DBIRTH envoyé : ' + data.devices.join(', ')).css('color', 'green');
+                    btn.prop('disabled', false);
+                },
+                error: function(xhr) {
+                    const msg = xhr.responseJSON ? xhr.responseJSON.error : xhr.statusText;
+                    status.text('❌ ' + msg).css('color', 'red');
+                    btn.prop('disabled', false);
+                }
+            });
+        });
+    },
+
+    oneditsave: function() {
+        // Devices
+        const devices = [];
+        $('#scorp-devices-container .scorp-device-block').each(function() {
+            const block    = $(this);
+            const deviceId = block.find('.scorp-device-id').val().trim();
+            if (!deviceId) return;
+            const metrics    = [];
+            const metricList = block.data('metricList');
+            if (metricList) {
+                metricList.editableList('items').each(function() {
+                    const name      = $(this).find('.scorp-metric-name').val().trim();
+                    const dataType  = $(this).find('.scorp-metric-datatype').val();
+                    const valuePath = $(this).find('.scorp-metric-valuepath').val().trim();
+                    if (name) metrics.push({ name, dataType, valuePath });
+                });
+            }
+            devices.push({ deviceId, metrics });
+        });
+        this.devices = devices;
+
+        // DBIRTH config
+        this.birthOnDeploy = $('#scorp-birth-on-deploy').prop('checked');
+        this.birthPeriodic = $('#scorp-birth-periodic').prop('checked');
+        this.birthInterval = $('#scorp-birth-interval').val();
+    }
+});
+</script>
+
+<script type="text/html" data-template-name="scorp-io-device">
+
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Nom</label>
+        <input type="text" id="node-input-name" placeholder="ex: Mes pompes">
+    </div>
+    <div class="form-row">
+        <label for="node-input-config"><i class="fa fa-cog"></i> Config</label>
+        <input type="text" id="node-input-config">
+    </div>
+
+    <hr/>
+
+    <!-- DEVICES -->
+    <div class="form-row">
+        <label style="width:100%; font-weight:bold; margin-bottom:6px;">
+            <i class="fa fa-microchip"></i> Devices
+        </label>
+        <div id="scorp-devices-container" style="width:100%;"></div>
+        <button type="button" id="scorp-add-device" class="red-ui-button" style="margin-top:6px;">
+            <i class="fa fa-plus"></i> Ajouter un device
+        </button>
+    </div>
+
+    <hr/>
+
+    <!-- STRATÉGIE DBIRTH -->
+    <div class="form-row" style="width:100%;">
+        <label style="width:100%; font-weight:bold; margin-bottom:8px;">
+            <i class="fa fa-refresh"></i> Émission DBIRTH
+        </label>
+
+        <!-- Option A : au déploiement -->
+        <div style="display:flex; align-items:center; gap:8px; margin-bottom:10px; width:100%;">
+            <input type="checkbox" id="scorp-birth-on-deploy" style="width:auto; margin:0; flex-shrink:0;">
+            <label for="scorp-birth-on-deploy" style="margin:0; font-weight:normal; flex:1;">
+                Envoyer un DBIRTH automatiquement après déploiement / redémarrage
+            </label>
+        </div>
+
+        <!-- Option B : périodique -->
+        <div style="display:flex; align-items:center; gap:8px; width:100%;">
+            <input type="checkbox" id="scorp-birth-periodic" style="width:auto; margin:0; flex-shrink:0;">
+            <label for="scorp-birth-periodic" style="margin:0; font-weight:normal;">
+                Envoyer un DBIRTH périodiquement toutes les
+            </label>
+            <select id="scorp-birth-interval" style="width:auto; flex-shrink:0;">
+                <option value="1h">1 heure</option>
+                <option value="6h">6 heures</option>
+                <option value="12h">12 heures</option>
+                <option value="24h">24 heures</option>
+                <option value="48h">48 heures</option>
+            </select>
+        </div>
+    </div>
+
+    <hr/>
+
+    <!-- BOUTON FORCER DBIRTH -->
+    <div class="form-row">
+        <label style="width:100%; font-weight:bold; margin-bottom:6px;">
+            <i class="fa fa-bolt"></i> Actions
+        </label>
+        <button type="button" id="scorp-btn-dbirth" class="red-ui-button">
+            <i class="fa fa-refresh"></i> Forcer DBIRTH maintenant
+        </button>
+        <span id="scorp-btn-dbirth-status" style="margin-left:10px; font-size:12px;"></span>
+    </div>
+
+    <hr/>
+
+    <div class="form-tips">
+        <b>Entrée :</b> message normal → <b>DDATA</b> auto &nbsp;|&nbsp;
+        <code>msg.topic = "birth"</code> → <b>DBIRTH</b><br/>
+        <b>Chemins :</b> <code>msg.payload.pompe1.etats</code> ou <code>msg.pompe.etat</code>
+    </div>
+
+</script>
+
+<script type="text/html" data-help-name="scorp-io-device">
+    <p>Nœud SCorp-io multi-devices. Publie <b>DBIRTH</b> et <b>DDATA</b> via MQTTS.</p>
+    <h3>Entrée</h3>
+    <dl class="message-properties">
+        <dt>msg.topic <span class="property-type">string</span></dt>
+        <dd><code>"birth"</code> → force DBIRTH pour tous les devices.</dd>
+        <dt>msg.payload <span class="property-type">object</span></dt>
+        <dd>Routage automatique : DDATA publié pour chaque device dont une métrique est résolvable.</dd>
+    </dl>
+    <h3>Sortie — debug</h3>
+    <dl class="message-properties">
+        <dt>msg.topic</dt><dd>Topic MQTT publié.</dd>
+        <dt>msg.payload</dt><dd>Trame publiée.</dd>
+        <dt>msg._scorp</dt><dd>type, mode, device, simulated.</dd>
+    </dl>
+</script>

package/nodes/scorp-io-device.js

@@ -0,0 +1,281 @@
+module.exports = function(RED) {
+
+    // ── resolvePath ───────────────────────────────────────────────────────────
+    // Résout un chemin depuis la racine msg
+    //   "msg.payload.pompe1.etats" → msg.payload.pompe1.etats
+    //   "msg.pompe.etat"           → msg.pompe.etat
+    //   "pompe1.etats"             → fallback sur msg.payload.pompe1.etats
+
+    function resolvePath(msg, rawPath) {
+        if (!rawPath || !msg) return undefined;
+        let path = rawPath.trim();
+        if (path.startsWith('msg.')) {
+            path = path.slice(4);
+        } else {
+            path = 'payload.' + path;
+        }
+        try {
+            return path.split('.').reduce(function(acc, key) {
+                if (acc === undefined || acc === null) return undefined;
+                return acc[key];
+            }, msg);
+        } catch(e) { return undefined; }
+    }
+
+    // ── deviceIsRelevant ──────────────────────────────────────────────────────
+    // Retourne true si au moins une métrique du device est résolvable dans msg
+
+    function deviceIsRelevant(device, msg) {
+        if (msg && msg.deviceId && msg.deviceId === device.deviceId) {
+            return true;
+        }
+        return device.metrics.some(function(m) {
+            return m.valuePath && resolvePath(msg, m.valuePath) !== undefined;
+        });
+    }
+
+    // ── buildTopic ────────────────────────────────────────────────────────────
+
+    function buildTopic(projectId, edgeNodeId, deviceId, msgType) {
+        return ['mqtts', projectId, msgType, edgeNodeId, deviceId].join('/');
+    }
+
+    // ── ScorpIoDeviceNode ─────────────────────────────────────────────────────
+
+    function ScorpIoDeviceNode(config) {
+        RED.nodes.createNode(this, config);
+
+        this.devices        = config.devices || [];
+        this.birthOnDeploy  = config.birthOnDeploy !== false; // true par défaut
+        this.birthPeriodic  = !!config.birthPeriodic;
+        this.birthInterval  = config.birthInterval || '24h';
+        this.configId       = config.config;
+        this.config         = RED.nodes.getNode(this.configId);
+
+        const node   = this;
+        const isTest = !node.config || node.config.mode === 'test';
+
+        if (!node.config) {
+            node.status({ fill: 'red', shape: 'ring', text: 'Config manquante' });
+            node.error('Nœud de configuration SCorp-io introuvable');
+            return;
+        }
+
+        // ── Constructeurs de payload ──────────────────────────────────────────
+
+        function buildDBirth(device) {
+            return {
+                metrics: device.metrics.map(m => ({
+                    name:     m.name,
+                    dataType: m.dataType
+                }))
+            };
+        }
+
+        function buildDData(device, msg) {
+            return {
+                metrics: device.metrics.map(function(m) {
+                    const value     = resolvePath(msg, m.valuePath);
+                    const timestamp = Date.now();
+                    if (value === undefined && m.valuePath) {
+                        node.warn(
+                            '[' + device.deviceId + '] Métrique "' + m.name + '" : ' +
+                            'chemin "' + m.valuePath + '" introuvable dans msg.'
+                        );
+                    }
+                    return { name: m.name, timestamp: timestamp, dataType: m.dataType, value: value };
+                })
+            };
+        }
+
+        // ── Debug output ──────────────────────────────────────────────────────
+
+        function emitDebug(msgType, deviceId, topic, payload) {
+            node.send({
+                topic:   topic,
+                payload: payload,
+                _scorp: {
+                    type:      msgType,
+                    mode:      node.config.mode,
+                    device:    deviceId,
+                    simulated: isTest
+                }
+            });
+        }
+
+        // ── Publication DBIRTH (1 device) ─────────────────────────────────────
+
+        function sendBirthForDevice(device) {
+            const topic   = buildTopic(node.config.projectId, node.config.edgeNodeId, device.deviceId, 'DBIRTH');
+            const payload = buildDBirth(device);
+
+            node.log('DBIRTH [' + device.deviceId + '] → ' + topic);
+
+            if (isTest) {
+                emitDebug('DBIRTH', device.deviceId, topic, payload);
+                return;
+            }
+
+            node.config.publish(topic, payload, { retain: true }, function(err) {
+                if (err) {
+                    node.error('Erreur DBIRTH [' + device.deviceId + '] : ' + err.message);
+                } else {
+                    node.log('DBIRTH [' + device.deviceId + '] publié');
+                    emitDebug('DBIRTH', device.deviceId, topic, payload);
+                }
+            });
+        }
+
+        // ── Publication DBIRTH (tous les devices) ─────────────────────────────
+
+        node.sendAllBirths = function() {
+            if (node.devices.length === 0) {
+                node.warn('Aucun device configuré, DBIRTH ignoré');
+                return;
+            }
+            node.devices.forEach(sendBirthForDevice);
+
+            if (isTest) {
+                node.status({ fill: 'blue', shape: 'ring', text: '🧪 DBIRTH x' + node.devices.length + ' simulé' });
+            } else {
+                node.status({ fill: 'green', shape: 'dot', text: 'DBIRTH x' + node.devices.length + ' envoyé' });
+            }
+        };
+
+        // ── Publication DDATA — routage automatique par correspondance ─────────
+        // Pour chaque device, on vérifie si au moins une métrique est résolvable
+        // dans le msg. Si oui → DDATA publié pour ce device.
+        // Si aucun device matche → warn.
+
+        node.sendDataAuto = function(msg) {
+            const matched = node.devices.filter(d => deviceIsRelevant(d, msg));
+
+            if (matched.length === 0) {
+                node.warn(
+                    'Aucun device ne correspond au msg reçu. ' +
+                    'Vérifier les chemins de métriques configurés. ' +
+                    'msg.payload : ' + JSON.stringify(msg.payload)
+                );
+                return;
+            }
+
+            matched.forEach(function(device) {
+                const topic = buildTopic(node.config.projectId, node.config.edgeNodeId, device.deviceId, 'DDATA');
+                const data  = buildDData(device, msg);
+
+                node.log('DDATA [' + device.deviceId + '] → ' + topic);
+
+                if (isTest) {
+                    node.status({ fill: 'blue', shape: 'dot', text: '🧪 DDATA [' + device.deviceId + '] simulé' });
+                    emitDebug('DDATA', device.deviceId, topic, data);
+                    return;
+                }
+
+                node.config.publish(topic, data, { retain: false }, function(err) {
+                    if (err) {
+                        node.error('Erreur DDATA [' + device.deviceId + '] : ' + err.message);
+                        node.status({ fill: 'red', shape: 'dot', text: 'Erreur DDATA' });
+                    } else {
+                        node.status({ fill: 'green', shape: 'dot', text: 'DDATA [' + device.deviceId + '] envoyé' });
+                        emitDebug('DDATA', device.deviceId, topic, data);
+                    }
+                });
+            });
+        };
+
+        // ── États connexion ───────────────────────────────────────────────────
+
+        node.onConnected = function() {
+            node.status({ fill: 'green', shape: 'ring', text: 'Connecté' });
+            if (node.birthOnDeploy) node.sendAllBirths();
+        };
+
+        node.onConnecting = function() {
+            node.status({ fill: 'yellow', shape: 'ring', text: 'Connexion...' });
+        };
+
+        node.onDisconnected = function() {
+            node.status({ fill: 'red', shape: 'ring', text: 'Déconnecté' });
+        };
+
+        node.onError = function(errMsg) {
+            node.status({ fill: 'red', shape: 'dot', text: 'Erreur: ' + errMsg });
+        };
+
+        // ── Init ──────────────────────────────────────────────────────────────
+
+        node.config.register(node);
+
+        if (isTest) {
+            const deviceLabel = node.devices.length + ' device' + (node.devices.length > 1 ? 's' : '');
+            node.status({ fill: 'blue', shape: 'ring', text: '🧪 Test — ' + deviceLabel });
+            if (node.birthOnDeploy) node.sendAllBirths();
+        } else if (node.config.client && node.config.client.connected) {
+            node.onConnected();
+        } else {
+            node.status({ fill: 'yellow', shape: 'ring', text: 'Connexion...' });
+        }
+
+        // ── DBIRTH périodique ─────────────────────────────────────────────────
+
+        const INTERVAL_MAP = {
+            '1h':  3600000,
+            '6h':  21600000,
+            '12h': 43200000,
+            '24h': 86400000,
+            '48h': 172800000
+        };
+
+        if (node.birthPeriodic) {
+            const ms = INTERVAL_MAP[node.birthInterval] || INTERVAL_MAP['24h'];
+            node._birthTimer = setInterval(function() {
+                node.log('DBIRTH périodique (' + node.birthInterval + ')');
+                node.sendAllBirths();
+            }, ms);
+            node.log('DBIRTH périodique activé : toutes les ' + node.birthInterval);
+        }
+
+        // ── Entrée ────────────────────────────────────────────────────────────
+        // msg.topic === 'birth' → DBIRTH pour tous les devices
+        // sinon                 → DDATA routage automatique
+
+        node.on('input', function(msg, send, done) {
+            if (msg.topic === 'birth' || msg._inputPort === 1) {
+                node.sendAllBirths();
+            } else {
+                node.sendDataAuto(msg);
+            }
+            done();
+        });
+
+        node.on('close', function(done) {
+            if (node._birthTimer) {
+                clearInterval(node._birthTimer);
+                node._birthTimer = null;
+            }
+            node.config.deregister(node);
+            done();
+        });
+    }
+
+    RED.nodes.registerType('scorp-io-device', ScorpIoDeviceNode);
+
+    // ── Endpoint HTTP admin — bouton DBIRTH depuis l'UI ───────────────────────
+    // POST /scorp-io/dbirth/:nodeId
+
+    RED.httpAdmin.post('/scorp-io/dbirth/:nodeId', function(req, res) {
+        const node = RED.nodes.getNode(req.params.nodeId);
+        if (!node) {
+            return res.status(404).json({ error: 'Nœud introuvable : ' + req.params.nodeId });
+        }
+        if (typeof node.sendAllBirths !== 'function') {
+            return res.status(400).json({ error: 'Ce nœud ne supporte pas sendAllBirths' });
+        }
+        try {
+            node.sendAllBirths();
+            res.json({ ok: true, devices: (node.devices || []).map(d => d.deviceId) });
+        } catch(e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "node-red-contrib-scorp-io",
+  "version": "0.1.0",
+  "description": "Node-RED nodes for SCorp-io MQTTS integration with DBIRTH and DDATA messages.",
+  "keywords": [
+    "node-red",
+    "node-red-contrib",
+    "scorp-io",
+    "mqtt",
+    "mqtts",
+    "iot",
+    "industrial"
+  ],
+  "author": "SCorp-io",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/SCORPIO-JRB/node-red-contrib-scorp-io.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SCORPIO-JRB/node-red-contrib-scorp-io/issues"
+  },
+  "homepage": "https://github.com/SCORPIO-JRB/node-red-contrib-scorp-io#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "nodes/",
+    "locales/",
+    "examples/",
+    "README.md",
+    "LICENSE"
+  ],
+  "node-red": {
+    "version": ">=3.0.0",
+    "nodes": {
+      "scorp-io-config": "nodes/scorp-io-config.js",
+      "scorp-io-device": "nodes/scorp-io-device.js"
+    }
+  },
+  "dependencies": {
+    "mqtt": "^5.3.4"
+  },
+  "devDependencies": {
+    "mocha": "^10.4.0",
+    "node-red": "^3.1.15",
+    "node-red-node-test-helper": "^0.3.4",
+    "should": "^13.2.3"
+  },
+  "scripts": {
+    "test": "mocha test/**/*_spec.js --timeout 5000",
+    "test:helpers": "mocha test/scorp-io-helpers_spec.js --timeout 5000",
+    "test:config": "mocha test/scorp-io-config_spec.js --timeout 5000",
+    "test:device": "mocha test/scorp-io-device_spec.js --timeout 5000",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}