@bkmj/node-red-contrib-odbcmj 2.2.0 → 2.2.2

package/odbc.html

@@ -71,12 +71,36 @@
 
             $('#node-config-test-connection').on('click', function() {
                 var button = $(this);
+                var connectionMode = $("#node-config-input-connectionMode").val();
+
+                if (connectionMode === 'structured') {
+                    var server = $("#node-config-input-server").val().trim();
+                    if (!server) {
+                        RED.notify("Le champ 'Server' est requis pour le test.", {type: "warning", timeout: 3000});
+                        return;
+                    }
+                } else { 
+                    var connStr = $("#node-config-input-connectionString").val().trim();
+                    if (!connStr) {
+                        RED.notify("La chaîne de connexion est requise pour le test.", {type: "warning", timeout: 3000});
+                        return; 
+                    }
+                    // Nouvelle validation :
+                    // Elle est invalide SEULEMENT si elle ne contient PAS de DSN ET qu'elle ne respecte PAS l'ancien critère pour les chaînes DSN-less.
+                    var isDsnString = /DSN=[^;]+/i.test(connStr);
+                    var isDriverBasedString = /DRIVER=\{.+?\}/i.test(connStr) && /(SERVER|DATABASE|UID|PWD)=/i.test(connStr); // Un peu plus complet
+
+                    if (!isDsnString && !isDriverBasedString) {
+                         RED.notify("La chaîne de connexion semble invalide ou incomplète (ex: DSN=value; ou DRIVER={...};SERVER=...;).", {type: "warning", timeout: 4000});
+                         return;
+                    }
+                }
+
                 var originalText = "Test Connection";
                 var icon = button.find("i");
                 icon.removeClass('fa-bolt').addClass('fa-spinner fa-spin');
                 button.text(' Testing...').prop('disabled', true);
                 
-                var connectionMode = $("#node-config-input-connectionMode").val();
                 var configData = {
                     connectionMode: connectionMode,
                     dbType: $("#node-config-input-dbType").val(),
@@ -272,7 +296,6 @@
             outputObj: { value: "payload" },
             streaming: { value: false },
             streamChunkSize: { value: 1, validate: RED.validators.number() },
-            // Nouveaux `defaults` pour les Typed Inputs
             querySource: { value: "query", required: false },
             querySourceType: { value: "msg", required: false },
             paramsSource: { value: "parameters", required: false },
@@ -295,7 +318,6 @@
                 $(".stream-options").toggle(this.checked);
             }).trigger("change");
 
-            // Initialisation des Typed Inputs
             $("#node-input-querySource").typedInput({
                 default: 'msg',
                 typeField: "#node-input-querySourceType",
@@ -414,7 +436,7 @@ Executes a query against a configured ODBC data source.
 ### Properties
 
 - **Connection**: The `odbc config` node to use.
-- **Query (fallback)**: A static SQL query to run if the "Query Source" does not provide one. Can contain Mustache syntax (e.g., `{{{payload.id}}}`).
+- **Query (fallback)**: A static SQL query to run if the "Query (fallback)" does not provide one. Can contain Mustache syntax (e.g., `{{{payload.id}}}`).
 - **Result to**: The `msg` property where the query result will be stored. Default: `payload`.
 
 ### Streaming Results
@@ -425,10 +447,18 @@ For queries that return a large number of rows, streaming prevents high memory u
 - **`Chunk Size`**: The number of rows to include in each output message. A value of `1` means one message will be sent for every single row.
 
 #### Streaming Output Format
-When streaming is active, each output message will contain:
-- A payload (or the configured output property) containing an array of rows for the current chunk.
-- A `msg.odbc_stream` object with metadata for tracking progress:
-    - `index`: The starting index of the current chunk (e.g., 0, 100, 200...).
-    - `count`: The number of rows in the current chunk.
-    - `complete`: A boolean that is `true` only on the very last message of the stream, useful for triggering a final action.  The last payload will always be an empty array.
+When streaming is active, the node sends messages in sequence:
+
+1.  **Data Messages**: One or more messages where the payload (or the configured output property) contains an array of rows for the current chunk. For these messages, `msg.odbc_stream.complete` will be **`false`**.
+
+2.  **Completion Message**: A single, final message indicating the end of the stream. For this message:
+    -   The payload will be an **empty array `[]`**.
+    -   `msg.odbc_stream.complete` will be **`true`**.
+
+The `msg.odbc_stream` object contains metadata for tracking:
+-   `index`: The starting index of the current chunk. For the completion message, this will be the total number of rows processed.
+-   `count`: The number of rows in the chunk. This will be `0` for the completion message.
+-   `complete`: The boolean flag (`true`/`false`).
+
+This pattern ensures you can reliably trigger a final action (like closing a file or calculating an aggregate) only when the message with `complete: true` is received.
 </script>

package/odbc.js

@@ -12,7 +12,6 @@ module.exports = function (RED) {
         
         this.credentials = RED.nodes.getCredentials(this.id);
 
-        // Cette fonction est maintenant cruciale pour le mode streaming
         this._buildConnectionString = function() {
             if (this.config.connectionMode === 'structured') {
                 if (!this.config.dbType || !this.config.server) {
@@ -119,9 +118,61 @@ module.exports = function (RED) {
     });
 
     RED.httpAdmin.post("/odbc_config/:id/test", RED.auth.needsPermission("odbc.write"), async function(req, res) {
-        // ... (Pas de changement dans cette section)
-    });
+        const tempConfig = req.body;
+
+        const buildTestConnectionString = () => {
+            if (tempConfig.connectionMode === 'structured') {
+                if (!tempConfig.dbType || !tempConfig.server) {
+                    throw new Error("En mode structuré, le type de base de données et le serveur sont requis.");
+                }
+                let driver;
+                let parts = [];
+                switch (tempConfig.dbType) {
+                    case 'sqlserver': driver = 'ODBC Driver 17 for SQL Server'; break;
+                    case 'postgresql': driver = 'PostgreSQL Unicode'; break;
+                    case 'mysql': driver = 'MySQL ODBC 8.0 Unicode Driver'; break;
+                    default: driver = tempConfig.driver || ''; break;
+                }
+                if(driver) parts.unshift(`DRIVER={${driver}}`);
+                parts.push(`SERVER=${tempConfig.server}`);
+                if (tempConfig.database) parts.push(`DATABASE=${tempConfig.database}`);
+                if (tempConfig.user) parts.push(`UID=${tempConfig.user}`);
+                if (tempConfig.password) parts.push(`PWD=${tempConfig.password}`);
+                return parts.join(';');
+            } else {
+                let connStr = tempConfig.connectionString || "";
+                if (!connStr) {
+                    throw new Error("La chaîne de connexion ne peut pas être vide.");
+                }
+                return connStr;
+            }
+        };
+
+        let connection;
+        try {
+            const testConnectionString = buildTestConnectionString();
+            
+            // ==============================================================
+            // LIGNE DE DÉBOGAGE AJOUTÉE
+            // ==============================================================
+            console.log("[ODBC Test] Attempting to connect with string:", testConnectionString);
+            // ==============================================================
 
+            const connectionOptions = {
+                connectionString: testConnectionString,
+                loginTimeout: 10
+            };
+            connection = await odbcModule.connect(connectionOptions);
+            res.sendStatus(200);
+        } catch (err) {
+            console.error("[ODBC Test] Connection failed:", err); // Ajout d'un log d'erreur
+            res.status(500).send(err.message || "Erreur inconnue durant le test.");
+        } finally {
+            if (connection) {
+                await connection.close();
+            }
+        }
+    });
 
     // --- ODBC Query Node ---
     function odbc(config) {
@@ -130,7 +181,10 @@ module.exports = function (RED) {
         this.poolNode = RED.nodes.getNode(this.config.connection);
         this.name = this.config.name;
 
-        // ... (enhanceError et executeQueryAndProcess restent inchangés)
+        // Propriétés pour la logique de retry temporisée
+        this.isAwaitingRetry = false;
+        this.retryTimer = null;
+
         this.enhanceError = (error, query, params, defaultMessage = "Query error") => {
             const queryContext = (() => {
                 let s = "";
@@ -154,6 +208,7 @@ module.exports = function (RED) {
         };
 
         this.executeQueryAndProcess = async (dbConnection, queryString, queryParams, msg) => {
+            // ... (contenu de cette fonction inchangé par rapport à la dernière version)
             const result = await dbConnection.query(queryString, queryParams);
             if (typeof result === "undefined") { throw new Error("Query returned undefined."); }
             const newMsg = RED.util.cloneMessage(msg);
@@ -195,25 +250,20 @@ module.exports = function (RED) {
             if (Object.keys(otherParams).length) { newMsg.odbc = otherParams; }
             return newMsg;
         };
-
+        
         this.executeStreamQuery = async (dbConnection, queryString, queryParams, msg, send) => {
+            // ... (contenu de cette fonction inchangé par rapport à la dernière version avec le message de complétion final)
             const chunkSize = parseInt(this.config.streamChunkSize) || 1;
-            const fetchSize = chunkSize > 100 ? 100 : chunkSize; // Optimisation du fetch
+            const fetchSize = chunkSize > 100 ? 100 : chunkSize;
             let cursor;
-        
             try {
                 cursor = await dbConnection.query(queryString, queryParams, { cursor: true, fetchSize: fetchSize });
                 this.status({ fill: "blue", shape: "dot", text: "streaming rows..." });
-        
                 let rowCount = 0;
                 let chunk = [];
-        
                 while (true) {
                     const rows = await cursor.fetch();
-                    if (!rows || rows.length === 0) {
-                        break;
-                    }
-        
+                    if (!rows || rows.length === 0) { break; }
                     for (const row of rows) {
                         rowCount++;
                         chunk.push(row);
@@ -226,51 +276,63 @@ module.exports = function (RED) {
                         }
                     }
                 }
-        
                 if (chunk.length > 0) {
                     const newMsg = RED.util.cloneMessage(msg);
                     objPath.set(newMsg, this.config.outputObj, chunk);
                     newMsg.odbc_stream = { index: rowCount - chunk.length, count: chunk.length, complete: false };
                     send(newMsg);
                 }
-        
                 const finalMsg = RED.util.cloneMessage(msg);
                 objPath.set(finalMsg, this.config.outputObj, []);
                 finalMsg.odbc_stream = { index: rowCount, count: 0, complete: true };
                 send(finalMsg);
-        
                 this.status({ fill: "green", shape: "dot", text: `success (${rowCount} rows)` });
-        
             } finally {
-                if (cursor) {
-                    await cursor.close();
-                }
+                if (cursor) await cursor.close();
             }
         };
 
         this.on("input", async (msg, send, done) => {
+            // --- NOUVEAU : GESTION DE retryOnMsg ---
+            if (this.isAwaitingRetry) {
+                if (this.poolNode && this.poolNode.config.retryOnMsg === true) { // s'assurer que c'est bien un booléen true
+                    this.log("New message received, overriding retry timer and attempting query now.");
+                    clearTimeout(this.retryTimer);
+                    this.retryTimer = null;
+                    this.isAwaitingRetry = false;
+                    // Laisser l'exécution se poursuivre
+                } else {
+                    this.warn("Node is in a retry-wait state. New message ignored as per configuration.");
+                    if (done) done(); // Terminer le traitement pour CE message
+                    return;
+                }
+            }
+            // S'assurer que les états de retry sont propres si on n'est pas dans un retry forcé par un nouveau message
+            this.isAwaitingRetry = false;
+            if(this.retryTimer) {
+                clearTimeout(this.retryTimer);
+                this.retryTimer = null;
+            }
+            // --- FIN DE LA GESTION DE retryOnMsg ---
+
             if (!this.poolNode) {
+                this.status({ fill: "red", shape: "ring", text: "No config node" });
                 return done(new Error("ODBC Config node not properly configured."));
             }
 
             const execute = async (connection) => {
                 this.config.outputObj = this.config.outputObj || "payload";
-                
                 const querySourceType = this.config.querySourceType || 'msg';
                 const querySource = this.config.querySource || 'query';
                 const paramsSourceType = this.config.paramsSourceType || 'msg';
                 const paramsSource = this.config.paramsSource || 'parameters';
-                
                 const params = await new Promise(resolve => RED.util.evaluateNodeProperty(paramsSource, paramsSourceType, this, msg, (err, val) => resolve(err ? undefined : val)));
                 let query = await new Promise(resolve => RED.util.evaluateNodeProperty(querySource, querySourceType, this, msg, (err, val) => resolve(err ? undefined : (val || this.config.query || ""))));
-                
                 if (!query) throw new Error("No query to execute");
-
                 const isPreparedStatement = params || (query && query.includes("?"));
                 if (!isPreparedStatement && query) {
                     query = mustache.render(query, msg);
                 }
-                
                 this.status({ fill: "blue", shape: "dot", text: "executing..." });
                 if (this.config.streaming) {
                     await this.executeStreamQuery(connection, query, params, msg, send);
@@ -282,11 +344,13 @@ module.exports = function (RED) {
             };
 
             let connectionFromPool;
+            let errorAfterInitialAttempts = null;
+
             try {
                 this.status({ fill: "yellow", shape: "dot", text: "connecting..." });
                 connectionFromPool = await this.poolNode.connect();
                 await execute(connectionFromPool);
-                return done();
+                return done(); // Succès de la première tentative
             } catch (poolError) {
                 this.warn(`First attempt with pooled connection failed: ${poolError.message}`);
                 if (this.poolNode.config.retryFreshConnection) {
@@ -300,23 +364,69 @@ module.exports = function (RED) {
                         await execute(freshConnection);
                         this.log("Query successful with fresh connection. Resetting pool.");
                         await this.poolNode.resetPool();
-                        return done();
+                        return done(); // Succès de la tentative avec connexion fraîche
                     } catch (freshError) {
-                        this.status({ fill: "red", shape: "ring", text: "retry failed" });
-                        return done(this.enhanceError(freshError, null, null, "Retry with fresh connection also failed"));
+                        errorAfterInitialAttempts = this.enhanceError(freshError, null, null, "Retry with fresh connection also failed");
                     } finally {
                         if (freshConnection) await freshConnection.close();
                     }
                 } else {
-                    this.status({ fill: "red", shape: "ring", text: "query error" });
-                    return done(this.enhanceError(poolError));
+                    errorAfterInitialAttempts = this.enhanceError(poolError);
                 }
             } finally {
                 if (connectionFromPool) await connectionFromPool.close();
             }
+
+            // --- NOUVEAU : GESTION DE retryDelay ---
+            if (errorAfterInitialAttempts) {
+                const retryDelaySeconds = parseInt(this.poolNode.config.retryDelay, 10); // S'assurer que c'est un nombre
+
+                if (retryDelaySeconds > 0) {
+                    this.warn(`Query failed. Scheduling retry in ${retryDelaySeconds} seconds. Error: ${errorAfterInitialAttempts.message}`);
+                    this.status({ fill: "red", shape: "ring", text: `Retry in ${retryDelaySeconds}s...` });
+                    this.isAwaitingRetry = true;
+                    
+                    // Important: `this.receive(msg)` ne peut pas être appelé directement dans un `setTimeout`
+                    // sans s'assurer que `this` est correctement lié. Utiliser une arrow function ou .bind(this).
+                    // De plus, `this.receive` est une méthode non documentée pour réinjecter un message.
+                    // La méthode standard pour retenter est que le nœud se renvoie le message à lui-même.
+                    // Pour cela, le `done()` de l'invocation actuelle doit être appelé.
+                    
+                    this.retryTimer = setTimeout(() => {
+                        this.isAwaitingRetry = false; // Prêt pour une nouvelle tentative
+                        this.retryTimer = null;
+                        this.log(`Retry timer expired for message. Re-emitting for node ${this.id || this.name}.`);
+                        // Réinjecter le message pour une nouvelle tentative de traitement.
+                        // Le message original `msg` est utilisé.
+                        this.receive(msg); 
+                    }, retryDelaySeconds * 1000);
+                    
+                    // L'invocation actuelle du message se termine ici, sans erreur si un retry est planifié.
+                    // L'erreur sera gérée par la prochaine invocation si elle échoue à nouveau.
+                    if (done) return done();
+
+                } else {
+                    // Pas de retryDelay configuré ou il est à 0. C'est une défaillance définitive pour CE message.
+                    this.status({ fill: "red", shape: "ring", text: "query error" });
+                    if (done) return done(errorAfterInitialAttempts);
+                }
+            } else {
+                // Normalement, on ne devrait pas arriver ici si done() a été appelé après un succès.
+                // C'est une sécurité.
+                if (done) return done();
+            }
+            // --- FIN DE LA GESTION DE retryDelay ---
         });
         
         this.on("close", (done) => {
+            // --- NOUVEAU : Nettoyage du timer ---
+            if (this.retryTimer) {
+                clearTimeout(this.retryTimer);
+                this.retryTimer = null;
+                this.isAwaitingRetry = false;
+                this.log("Cleared pending retry timer on node close/redeploy.");
+            }
+            // --- FIN DU NETTOYAGE ---
             this.status({});
             done();
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bkmj/node-red-contrib-odbcmj",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "A powerful Node-RED node to connect to any ODBC data source, with connection pooling, advanced retry logic, and result streaming.",
   "keywords": [
     "node-red",