@flecoufle/node-red-linky 1.3.0 → 1.4.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.4.2 - 20260125
+github action
+
+## 1.4.1 - 20260125
+add publishConfig registry
+
+## 1.4.0 - 20260124
+add options_api_daily_limit
+
 ## 1.3.0 - 20250321
 add debug option
 

package/README.md

@@ -1,44 +1,122 @@
 # node-red-linky
-Retreive linky power consumption and production from <a href="https://github.com/bokub/conso-api#readme">bokub/conso-api</a>
 
-See Enedis API documentation on <a href="https://datahub-enedis.fr/services-api/data-connect/documentation/">data-connect</a>
+Package Node-RED **Linky** pour récupérer les données de **consommation** et **production** d'énergie via l'API Enedis.
 
-## consumption usage
-- <b>Récupération de la consommation énergétique quotidienne</b>: <code>daily_consumption</code>
+## Installation
 
-Permet de récupérer la consommation énergétique quotidienne de la période demandée [start;end[ en Wh pour le point de livraison renseigné et la personne titulaire authentifiée, ou dont l’indentifiant est donné en paramètre.
+Via la palette l'éditeur: @flecoufle/node-red-linky
 
-Chaque valeur est datée.
-Un appel peut porter sur des données datant au maximum de 36 mois et 15 jours avant la date d’appel.
+ou via npm:
+```bash
+npm install @flecoufle/node-red-linky
+```
 
-- <b>Récupération de la courbe de charge en soutirage</b>: <code>consumption_load_curve</code>
+## Prérequis
 
-Permet de récupérer la courbe de charge en soutirage sur l’intervalle [start;end[ pour le point de livraison renseigné et la personne titulaire authentifiée, ou dont l’indentifiant est donné en paramètre.
+- **Node.js**: >= 14.0.0
+- **Node-RED**: >= 0.17.0
+- **Dépendances**:
+  - `got` 13.0.0
 
-La profondeur de données disponible en un appel est d’une semaine.
-Les valeurs retournées sont des puissances moyennes de consommation en W sur l’intervalle de mesure du compteur (par défaut 30mn).
-Chaque valeur est horodatée.
-La courbe de charge s’obtient sur des journées complètes de minuit à minuit du jour suivant en heures locales.
-Un appel peut porter sur des données datant au maximum de 24 mois et 15 jours avant la date d’appel.
+## Mise en oeuvre
+- Obtenir un accès API (le token) à votre compteur: [API Conso](https://github.com/bokub/conso-api#readme) vous redirigera vers [https://conso.boris.sh](https://conso.boris.sh/)
+- [Exemples](examples/Examples.json) d'utilisation du noeud node-red-linky une fois le noeud installé
+- [Documentation](https://datahub-enedis.fr/services-api/data-connect/documentation/) de Enedis API Data-Connect (pour information uniquement)
+  
+## ⚠️ Important - Mise en cache des appels
 
-- <b>Récupération de la puissance maximale soutirée quotidienne</b>: <code>consumption_max_power</code>
+À partir de la version **1.4.0**, le node limite les appels pour respecter les quotas de l'API et éviter le bannissement de votre IP, une mise en cache est mise en place pour permettre la continuité de service. Cette fonction est appliquée par requête unique (l'API sous-jacente elle-même renvoie déjà des données qui ne changent pas, donc cette fonction ne modifie en rien les informations retournées). 
 
-Permet de récupérer la puissance maximale soutirée quotidienne de la période demandée [start;end[, en VA pour le point de livraison renseigné et la personne titulaire authentifiée, ou dont l’indentifiant est donné en paramètre.
+Pour les utilisateurs des versions antérieures: **veuillez mettre à jour** pour bénéficier de cette protection.
 
-Chaque valeur est datée.
-Un appel peut porter sur des données datant au maximum de 36 mois et 15 jours avant la date d’appel.
+## Configuration et Paramètres
 
-## production usage
-- <b>Récupération de la production énergétique quotidienne</b>: <code>daily_production</code>
+### Paramètres obligatoires (peuvent être passés via le payload)
 
-Permet de récupérer la production énergétique quotidienne de la période demandée pour le point de livraison renseigné et la personne titulaire authentifiée, ou dont l’indentifiant est donné en paramètre sur la période demandée [start;end[ en Wh. Un appel peut porter sur des données datant au maximum de 36 mois et 15 jours avant la date d’appel.
+| Paramètre | Type | Description |
+|-----------|------|-------------|
+| `type` | string | Type de mesure (daily_consumption, daily_production, consumption_load_curve, consumption_max_power, production_load_curve) |
+| `token` | string | Token d'authentification Enedis (via le payload ou noeud ou config) |
+| `prm` | string | Point de livraison (numéro PRM) (via le payload ou noeud ou config)|
+| `start` | string | Date de début (format YYYY-MM-DD) |
+| `end` | string | Date de fin (format YYYY-MM-DD) |
 
-- <b>Récupération de la courbe de charge de production</b>: <code>production_load_curve</code>
+### Paramètres optionnels (uniquement via le payload)
 
-Permet de récupérer la courbe de charge de production sur l’intervalle [start;end[ pour le point de livraison renseigné et la personne titulaire authentifiée, ou dont l’indentifiant est donné en paramètre.
+| Paramètre | Type | Défaut | Description |
+|-----------|------|--------|-------------|
+| `options_api_daily_limit` | number | 3 | Limite d'appels par jour pour une requête identique |
+| `options_retry_limit` | number | 2 | Nombre de tentatives en cas d'erreur |
+| `options_timeout_lookup` | number | 500 | Timeout lookup DNS (ms) |
+| `options_timeout_connect` | number | 500 | Timeout connexion (ms) |
+| `options_timeout_secureconnect` | number | 500 | Timeout connexion sécurisée (ms) |
+| `options_timeout_socket` | number | 5000 | Timeout socket (ms) |
+| `options_timeout_send` | number | 10000 | Timeout envoi (ms) |
+| `options_timeout_response` | number | 10000 | Timeout réponse (ms) |
+| `random_delay` | number | 5000 | Délai aléatoire avant exécution (ms) |
+| `endpoint` | string | https://conso.boris.sh/api/ | Endpoint API à utiliser |
+| `debug` | boolean | false | Afficher les détails de débogage dans les logs |
 
-La profondeur de données disponible en un appel est d’une semaine.
-Les valeurs retournées sont des puissances moyennes de production en W sur l’intervalle de mesure du compteur (par défaut 30mn).
-Chaque valeur est horodatée.
-La courbe de charge s’obtient sur des journées complètes de minuit à minuit du jour suivant en heures locales.
-Un appel peut porter sur des données datant au maximum de 24 mois et 15 jours avant la date d’appel.
+## Types d'API disponibles
+
+### Consommation
+
+- **`daily_consumption`** - Récupération de la consommation énergétique quotidienne
+  - Période demandée [start;end[ en Wh
+  - Historique: jusqu'à 36 mois et 15 jours avant la date d'appel
+  - Chaque valeur est datée
+
+- **`consumption_load_curve`** - Récupération de la courbe de charge en soutirage
+  - Intervalle [start;end[ 
+  - Profondeur: une semaine maximum par appel
+  - Valeurs: puissances moyennes de consommation en W (intervalle par défaut 30mn)
+  - Historique: jusqu'à 24 mois et 15 jours avant la date d'appel
+  - Journées complètes de minuit à minuit (heures locales)
+
+- **`consumption_max_power`** - Récupération de la puissance maximale soutirée quotidienne
+  - Période demandée [start;end[ en VA
+  - Historique: jusqu'à 36 mois et 15 jours avant la date d'appel
+  - Chaque valeur est datée
+
+### Production
+
+- **`daily_production`** - Récupération de la production énergétique quotidienne
+  - Période demandée [start;end[ en Wh
+  - Historique: jusqu'à 36 mois et 15 jours avant la date d'appel
+  - Chaque valeur est datée
+
+- **`production_load_curve`** - Récupération de la courbe de charge de production
+  - Intervalle [start;end[
+  - Profondeur: une semaine maximum par appel
+  - Valeurs: puissances moyennes de production en W (intervalle par défaut 30mn)
+  - Historique: jusqu'à 24 mois et 15 jours avant la date d'appel
+  - Journées complètes de minuit à minuit (heures locales)
+
+## Limitation quotidienne des appels et système de cache
+
+Un système de limitation quotidienne est mis en place pour éviter les appels API excessifs pour une même requête identique. **Les réponses sont mises en cache**, permettant de servir les données en cache quand la limite est atteinte.
+Cette fonctionnalité permet d'éviter le blocage d'IP, voir "Conseils d'utilisation" sur [Conso API](https://github.com/bokub/conso-api?tab=readme-ov-file#conseils-dutilisation)
+
+### Fonctionnement de la limitation
+
+- **Limite par défaut**: 3 appels par jour pour une requête identique
+- **Configuration**: La limite peut être ajustée via le paramètre `options_api_daily_limit` (en cas de besoin spécifique peut être modifiée, attention au risque de bannissement)
+- **Signature de requête**: Chaque requête est identifiée par une signature unique (hash SHA256) et **mis en cache** (cache de votre instance Node-RED dans une variable de contexte du noeud, donc reste chez vous) basée sur:
+  - Le jour de l'appel
+  - Le type d'API (`type`)
+  - Le point de livraison (`prm`)
+  - Les dates de début et fin (`start`, `end`)
+  - L'endpoint API (`endpoint`)
+  - Les configurations de timeout
+  - La limite de retry
+  
+  Donc tout sauf `debug`
+
+- **Réinitialisation automatique**: Le compteur se réinitialise automatiquement chaque jour à minuit
+
+### Comportement avec cache
+
+- **Appel réussi**: La réponse est automatiquement mise en cache avec la signature de la requête
+- **Limite atteinte**:
+  - Une réponse en cache est retournée (statut du noeud: **jaune**)
+  - Si aucune réponse n'a pu être mise en cache (statut du noeud: **rouge**) cas de l'API en erreurs successives "_Daily limit of X calls for this request reached. No cache available._" sera affiché dans le log

package/linky/linky.html

@@ -108,17 +108,19 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 "prm": PRM set in payload or in node property
 "start": start date in RFC 3339 format ("YYYY-MM-DD")
 "end": end date in RFC 3339 format ("YYYY-MM-DD")
-"options_retry_limit": got option in ms(default 2)
+"options_api_daily_limit": daily limit of calls for identical request (default 3)
+"options_retry_limit": got option (default 2)
 "options_timeout_lookup": got option in ms(default 500)
 "options_timeout_connect": got option in ms(default 500)
 "options_timeout_secureconnect": got option in ms(default 500) 
 "options_timeout_socket": got option in ms(default 5000)
-"options_timeout_send": got option in ms(default 1000)
-"options_timeout_response": got option in ms(default 1000)
+"options_timeout_send": got option in ms(default 10000)
+"options_timeout_response": got option in ms(default 10000)
 "random_delay": fetch after a random delay in ms (default 5000)
 "endpoint": endpoint api (default "https://conso.boris.sh/api/")
 "debug": debug mode (default false)
 </code></pre></p>
+        <p><strong>🔄 Système de Cache:</strong> Les réponses réussies sont automatiquement mises en cache. Si la limite quotidienne est atteinte pour une requête identique, la réponse en cache est retournée (statut jaune) au lieu d'une erreur.</p>
         Available types are: <code>"daily_consumption"</code>, <code>"consumption_load_curve"</code>, <code>"consumption_max_power"</code> in consumption<br/>
         <code>"daily_production"</code>, <code>"production_load_curve"</code> in production
     </dl>

package/linky/linky.js

@@ -23,14 +23,90 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 module.exports = async function (RED) {
     const { got } = await import('got');
+    const crypto = await import('crypto');
 
     const nodeStatus = {
         WAIT: "Waiting...",
-        FETCH: "Fetching...",
-        OK: "OK",
-        ERROR: "Error"
+        FETCH: "Fetching..."
     };
 
+    // Fonction pour obtenir la clé du jour (YYYY-MM-DD)
+    function getTodayKey() {
+        return new Date().toISOString().split('T')[0];
+    }
+
+    // Fonction pour créer une clé unique basée sur les paramètres de la requête
+    function createRequestSignature(params, options) {
+        // Créer un objet avec les paramètres pertinents pour la requête
+        const requestIdentifier = {
+            day: getTodayKey(), // Inclure le jour pour avoir une signature par jour
+            type: params.type,
+            prm: params.prm,
+            start: params.start,
+            end: params.end,
+            endpoint: params.endpoint,
+            // Inclure les timeouts pour distinguer les requêtes avec configs différentes
+            timeout: {
+                lookup: params.options_timeout_lookup,
+                connect: params.options_timeout_connect,
+                secureConnect: params.options_timeout_secureconnect,
+                socket: params.options_timeout_socket,
+                send: params.options_timeout_send,
+                response: params.options_timeout_response
+            },
+            retry_limit: params.options_retry_limit
+        };
+        
+        // Créer un hash SHA256 pour avoir une clé courte et unique
+        const hash = crypto.createHash('sha256');
+        hash.update(JSON.stringify(requestIdentifier));
+        return hash.digest('hex').substring(0, 16); // Utiliser les 16 premiers caractères
+    }
+
+    // Fonction pour obtenir/réinitialiser le compteur si nécessaire
+    function getOrResetRequestCounter(node, requestSignature) {
+        const today = getTodayKey();
+        let requestHistory = node.context().get('requestHistory') || {};
+        
+        if (!requestHistory[requestSignature]) {
+            requestHistory[requestSignature] = {
+                date: today,
+                count: 0
+            };
+        } else if (requestHistory[requestSignature].date !== today) {
+            // Nouveau jour, réinitialiser
+            requestHistory[requestSignature] = {
+                date: today,
+                count: 0
+            };
+        }
+        
+        node.context().set('requestHistory', requestHistory);
+        return requestHistory[requestSignature];
+    }
+
+    // Fonction pour incrémenter et retourner le nouveau count pour une requête spécifique
+    function incrementAndGetRequestCount(node, requestSignature) {
+        let requestCounter = getOrResetRequestCounter(node, requestSignature);
+        requestCounter.count++;
+        let requestHistory = node.context().get('requestHistory');
+        requestHistory[requestSignature] = requestCounter;
+        node.context().set('requestHistory', requestHistory);
+        return requestCounter.count;
+    }
+
+    // Fonction pour obtenir les infos du compteur avec détails
+    function getRequestCounterInfo(node, requestSignature, dailyLimit) {
+        const requestCounter = getOrResetRequestCounter(node, requestSignature);
+        return {
+            count: requestCounter.count,
+            date: requestCounter.date,
+            signature: requestSignature,
+            remaining: Math.max(0, dailyLimit - requestCounter.count),
+            isLimited: requestCounter.count >= dailyLimit
+        };
+    }
+
     function LinkyMetering(config) {
         RED.nodes.createNode(this, config);
         var node = this;
@@ -45,16 +121,17 @@ module.exports = async function (RED) {
                 "prm": msg.payload?.prm || node.credentials?.prm || node.config?.prm || '',
                 "start": msg.payload?.start || '',
                 "end": msg.payload?.end || '',
-                "options_retry_limit": msg.payload?.options_retry_limit || 2,
-                "options_timeout_lookup": msg.payload?.options_timeout_lookup || 500,
-                "options_timeout_connect": msg.payload?.options_timeout_connect || 500,
-                "options_timeout_secureconnect": msg.payload?.options_timeout_secureconnect || 500,
-                "options_timeout_socket": msg.payload?.options_timeout_socket || 5000,
-                "options_timeout_send": msg.payload?.options_timeout_send || 10000,
-                "options_timeout_response": msg.payload?.options_timeout_response || 10000,
-                "random_delay": msg.payload?.random_delay || 5000,
+                "options_api_daily_limit": msg.payload?.options_api_daily_limit || 3,
+                "options_retry_limit": msg.payload?.options_retry_limit ?? 2,
+                "options_timeout_lookup": msg.payload?.options_timeout_lookup ?? 500,
+                "options_timeout_connect": msg.payload?.options_timeout_connect ?? 500,
+                "options_timeout_secureconnect": msg.payload?.options_timeout_secureconnect ?? 500,
+                "options_timeout_socket": msg.payload?.options_timeout_socket ?? 5000,
+                "options_timeout_send": msg.payload?.options_timeout_send ?? 10000,
+                "options_timeout_response": msg.payload?.options_timeout_response ?? 10000,
+                "random_delay": msg.payload?.random_delay ?? 5000,
                 "endpoint": msg.payload?.endpoint || 'https://conso.boris.sh/api/',
-                "debug": msg.payload?.debug === true || msg.payload?.debug == "true"
+                "debug": String(msg.payload?.debug).toLowerCase() === "true"
             }
 
             const options = {
@@ -78,82 +155,145 @@ module.exports = async function (RED) {
                 }
             };
 
-            !_p.type ? (done ? done('api type not set (ex. daily_consumption) see documentation') : node.error('api type not set (ex. daily_consumption) see documentation')) : null;
-            !_p.token ? (done ? done('token not set') : node.error('token not set')) : null;
-            !_p.prm ? (done ? done('PRM not set') : node.error('PRM not set')) : null;
-            !_p.start ? (done ? done('start not set') : node.error('start not set')) : null;
-            !_p.end ? (done ? done('end not set') : node.error('end not set')) : null;
-
-            if (_p.type && _p.token && _p.prm && _p.start && _p.end) {
-                let wait = Math.floor(Math.random() * _p.random_delay);
-                let msg_wait = nodeStatus.WAIT + Math.ceil(wait / 1000) + 's';
-                node.status({ fill: 'grey', shape: 'ring', text: msg_wait });
-                setTimeout(() => {
-                    node.status({ fill: 'grey', shape: 'ring', text: nodeStatus.FETCH });
-                    let request;
-                    try {
-                        let url = new URL(_p.endpoint);
-                        url.pathname += _p.type;
-                        url.search = new URLSearchParams({
-                            prm: _p.prm,
-                            start: _p.start,
-                            end: _p.end
-                        }).toString();
-                        request = url.toString();
-                    } catch (err) {
-                        node.status({ fill: 'red', shape: 'ring', text: 'error' });
-                        if (done) {
-                            done('url ' + err);
-                        } else {
-                            node.error('url ' + err);
-                        }
+            if (!_p.type) {
+                const err = 'api type not set (ex. daily_consumption) see documentation';
+                done ? done(err) : node.error(err, msg);
+                return;
+            }
+            if (!_p.token) {
+                const err = 'token not set';
+                done ? done(err) : node.error(err, msg);
+                return;
+            }
+            if (!_p.prm) {
+                const err = 'PRM not set';
+                done ? done(err) : node.error(err, msg);
+                return;
+            }
+            if (!_p.start) {
+                const err = 'start not set';
+                done ? done(err) : node.error(err, msg);
+                return;
+            }
+            if (!_p.end) {
+                const err = 'end not set';
+                done ? done(err) : node.error(err, msg);
+                return;
+            }
+
+            // Créer une signature unique de la requête
+            const requestSignature = createRequestSignature(_p, options);
+            
+            // Vérifier si cette requête spécifique a dépassé la limite
+            const counterInfo = getRequestCounterInfo(node, requestSignature, _p.options_api_daily_limit);
+            if (counterInfo.isLimited) {
+                // Récupérer la réponse en cache
+                let responseCache = node.context().get('responseCache') || {};
+                const cachedResponse = responseCache[requestSignature];
+                
+                if (cachedResponse) {
+                    // Retourner la réponse en cache
+                    const statusMsg = `Limit reached - Returning cached response (${counterInfo.count}/${_p.options_api_daily_limit}) - Sig: ${requestSignature}`;
+                    node.status({ fill: 'yellow', shape: 'ring', text: statusMsg });
+                    msg.payload = cachedResponse;
+                    node.send(msg);
+                    if (done) done();
+                } else {
+                    // Pas de cache disponible
+                    const statusMsg = `Error limit reached (${counterInfo.count}/${_p.options_api_daily_limit}) - Sig: ${requestSignature}`;
+                    node.status({ fill: 'red', shape: 'ring', text: statusMsg });
+                    const errorMsg = `Daily limit of ${_p.options_api_daily_limit} calls for this request reached. No cache available.`;
+                    node.error(errorMsg, msg);
+                    if (done) done(errorMsg);
+                }
+                return;
+            }
+
+            // Incrémenter le compteur pour cette requête spécifique MAINTENANT (avant l'appel)
+            const newCount = incrementAndGetRequestCount(node, requestSignature);
+            const remaining = _p.options_api_daily_limit - newCount;
+            _p.debug && node.warn(`Request ${requestSignature} - Call ${newCount}/${_p.options_api_daily_limit} - Remaining: ${remaining}`);
+
+            let wait = Math.floor(Math.random() * _p.random_delay);
+            let msg_wait = nodeStatus.WAIT + Math.ceil(wait / 1000) + 's';
+            node.status({ fill: 'grey', shape: 'ring', text: msg_wait });
+            setTimeout(() => {
+                node.status({ fill: 'grey', shape: 'ring', text: nodeStatus.FETCH });
+                let request;
+                try {
+                    let url = new URL(_p.endpoint);
+                    url.pathname = url.pathname.replace(/\/$/, '') + '/' + _p.type;
+                    url.search = new URLSearchParams({
+                        prm: _p.prm,
+                        start: _p.start,
+                        end: _p.end
+                    }).toString();
+                    request = url.toString();
+                } catch (err) {
+                    node.status({ fill: 'red', shape: 'ring', text: 'error' });
+                    if (done) {
+                        done('url ' + err);
+                    } else {
+                        node.error('url ' + err);
                     }
+                }
+
+                _p.debug && request && node.warn('Request URL:' + request);
+                if (_p.debug && options) {
+                    const debugOptions = { ...options, headers: { ...options.headers } };
+                    if (debugOptions.headers && debugOptions.headers['Authorization']) {
+                        debugOptions.headers['Authorization'] = 'Bearer [HIDDEN]';
+                    }
+                    node.warn('Options:' + JSON.stringify(debugOptions));
+                }
+
+                request && options && got(request, options)
+                    .then(res => {
+                        if (res.statusCode == '200') {
+                            try {
+                                msg.payload = JSON.parse(res.body);
+                                
+                                // Stocker la réponse en cache
+                                let responseCache = node.context().get('responseCache') || {};
+                                responseCache[requestSignature] = msg.payload;
+                                node.context().set('responseCache', responseCache);
+                                
+                                node.send(msg);
+                                node.status({ fill: 'blue', shape: 'dot', text: 'OK' });
 
-                    _p.debug && request && node.warn('Request URL:' + request);
-                    _p.debug && options && node.warn('Options:' + JSON.stringify(options));
-
-                    request && options && got(request, options)
-                        .then(res => {
-                            if (res.statusCode == '200') {
-                                try {
-                                    msg.payload = JSON.parse(res.body);
-                                    node.send(msg);
-                                    node.status({ fill: 'blue', shape: 'dot', text: 'OK' });
-
-                                    setTimeout(() => {
-                                        node.status({});
-                                        if (done) {
-                                            done();
-                                        }
-                                    }, 1000);
-                                } catch (err) {
-                                    node.status({ fill: 'red', shape: 'ring', text: 'error' });
+                                setTimeout(() => {
+                                    node.status({});
                                     if (done) {
-                                        done('parsing ' + err);
-                                    } else {
-                                        node.error('parsing ' + err, msg);
+                                        done();
                                     }
-                                }
-                            } else {
-                                node.status({ fill: 'red', shape: 'ring', text: res.statusCode });
+                                }, 1000);
+                            } catch (err) {
+                                node.status({ fill: 'red', shape: 'ring', text: 'error' });
                                 if (done) {
-                                    done(`statusCode ${res.statusCode}`);
+                                    done('parsing ' + err);
                                 } else {
-                                    node.error(`statusCode ${res.statusCode}`, msg);
+                                    node.error('parsing ' + err, msg);
                                 }
                             }
-                        })
-                        .catch(err => {
-                            node.status({ fill: 'red', shape: 'ring', text: 'error' });
-
+                        } else {
+                            node.status({ fill: 'red', shape: 'ring', text: res.statusCode });
                             if (done) {
-                                done(err);
+                                done(`statusCode ${res.statusCode}`);
                             } else {
-                                node.error(err, msg);
+                                node.error(`statusCode ${res.statusCode}`, msg);
                             }
-                        });
-                }, wait);
-            }
+                        }
+                    })
+                    .catch(err => {
+                        node.status({ fill: 'red', shape: 'ring', text: 'error' });
+
+                        if (done) {
+                            done(err);
+                        } else {
+                            node.error(err, msg);
+                        }
+                    });
+            }, wait);
         })
     }
     RED.nodes.registerType("linky-api", LinkyMetering, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flecoufle/node-red-linky",
-  "version": "1.3.0",
-  "description": "Retrieve Linky power consumption",
+  "version": "1.4.2",
+  "description": "Récupérer de Linky les données de consommation et production d'énergie via l'API Enedis",
   "main": "linky/linky.js",
   "publishConfig": {
     "access": "public"