@bkmj/node-red-contrib-odbcmj 2.5.0 → 2.6.0

package/odbc.js

@@ -3,7 +3,9 @@ module.exports = function (RED) {
     const mustache = require("mustache");
     const objPath = require("object-path");
 
-    // --- ODBC Configuration Node ---
+    // =========================================================================
+    // CONFIG NODE (Gère le Pool de Connexion)
+    // =========================================================================
     function poolConfig(config) {
         RED.nodes.createNode(this, config);
         this.config = config;
@@ -11,13 +13,16 @@ module.exports = function (RED) {
         this.connecting = false;
         this.credentials = RED.nodes.getCredentials(this.id);
 
+        // Validation des timeouts
         this.config.queryTimeoutSeconds = parseInt(config.queryTimeoutSeconds, 10);
         if (isNaN(this.config.queryTimeoutSeconds) || this.config.queryTimeoutSeconds < 0) {
-            this.config.queryTimeoutSeconds = 0; 
+            this.config.queryTimeoutSeconds = 0; // 0 = infini / défaut driver
         }
-        this.closeOperationTimeout = 10000; // 10 secondes
+        
+        // Timeout de sécurité interne pour forcer la fermeture si le driver pend
+        this.closeOperationTimeout = 10000; 
 
-        // NOUVEAU: Récupérer et s'assurer que l'option fireAndForgetOnClose est un booléen
+        // Option Fire-and-Forget
         this.config.fireAndForgetOnClose = config.fireAndForgetOnClose === true;
 
         this._buildConnectionString = function() {
@@ -27,13 +32,15 @@ module.exports = function (RED) {
                 }
                 let driver;
                 let parts = [];
+                // Mapping des drivers communs
                 switch (this.config.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 = this.config.driver || ''; break;
                 }
-                if(driver) parts.unshift(`DRIVER={${driver}}`);
+                
+                if(driver) parts.push(`DRIVER={${driver}}`);
                 parts.push(`SERVER=${this.config.server}`);
                 if (this.config.database) parts.push(`DATABASE=${this.config.database}`);
                 
@@ -56,20 +63,24 @@ module.exports = function (RED) {
                 try {
                     const finalConnectionString = this._buildConnectionString();
                     if (!finalConnectionString) throw new Error("La chaîne de connexion est vide.");
+
                     const poolParams = {
                         connectionString: finalConnectionString,
-                        initialSize: parseInt(this.config.initialSize, 10) || undefined,
-                        incrementSize: parseInt(this.config.incrementSize, 10) || undefined,
-                        maxSize: parseInt(this.config.maxSize, 10) || undefined,
+                        initialSize: parseInt(this.config.initialSize, 10) || 5,
+                        incrementSize: parseInt(this.config.incrementSize, 10) || 5,
+                        maxSize: parseInt(this.config.maxSize, 10) || 15,
                         shrink: typeof this.config.shrink === 'boolean' ? this.config.shrink : true,
-                        connectionTimeout: (parseInt(this.config.connectionTimeout, 10) * 1000) || undefined,
-                        loginTimeout: parseInt(this.config.loginTimeout, 10) || undefined
+                        connectionTimeout: (parseInt(this.config.connectionTimeout, 10) * 1000) || 3000,
+                        loginTimeout: parseInt(this.config.loginTimeout, 10) || 5
                     };
+                    
+                    // Nettoyage des undefined
                     Object.keys(poolParams).forEach(key => poolParams[key] === undefined && delete poolParams[key]);
+
                     this.pool = await odbcModule.pool(poolParams);
                     this.connecting = false;
                     this.status({ fill: "green", shape: "dot", text: "Pool ready" });
-                    this.log("Connection pool initialized successfully.");
+                    this.log(`Pool initialized for ${this.name || this.id}`);
                 } catch (error) {
                     this.connecting = false;
                     this.error(`Error creating connection pool: ${error.message}`, error);
@@ -77,15 +88,16 @@ module.exports = function (RED) {
                     throw error;
                 }
             }
+            // Récupération d'une connexion du pool
             try {
                 return await this.pool.connect();
             } catch (poolConnectError) {
-                this.error(`Error connecting to pool: ${poolConnectError.message}`, poolConnectError);
                 this.status({ fill: "red", shape: "ring", text: "Pool connect err" });
                 throw poolConnectError;
             }
         };
 
+        // Configuration pour une connexion "fraîche" (hors pool)
         this.getFreshConnectionConfig = function() {
             return {
                 connectionString: this._buildConnectionString(),
@@ -96,80 +108,74 @@ module.exports = function (RED) {
 
         this.resetPool = async () => {
             if (this.pool) {
-                this.log("Resetting connection pool.");
+                this.log("Resetting connection pool requested.");
                 this.status({ fill: "yellow", shape: "ring", text: "Resetting pool..." });
-                let closedSuccessfully = false;
+                
+                const oldPool = this.pool;
+                this.pool = null; // On détache immédiatement pour forcer la recréation au prochain appel
+                this.connecting = false;
+
                 try {
                     await Promise.race([
-                        this.pool.close(),
+                        oldPool.close(),
                         new Promise((_, reject) => setTimeout(() => reject(new Error('Pool close timeout')), this.closeOperationTimeout))
                     ]);
-                    this.log("Connection pool closed successfully for reset.");
-                    closedSuccessfully = true;
+                    this.log("Old connection pool closed successfully.");
                 } catch (closeError) {
-                    this.error(`Error or timeout closing pool during reset: ${closeError.message}`, closeError);
+                    this.warn(`Error closing old pool during reset: ${closeError.message}`);
                 } finally {
-                    this.pool = null;
-                    this.connecting = false;
-                    this.status({ fill: closedSuccessfully ? "grey" : "red", shape: "ring", text: closedSuccessfully ? "Pool reset" : "Pool reset failed" });
+                     this.status({ fill: "grey", shape: "ring", text: "Pool reset" });
                 }
-            } else {
-                this.log("Pool reset requested, but no active pool to reset.");
             }
         };
 
-        // MODIFIÉ pour inclure l'option fireAndForgetOnClose
         this.on("close", async (removed, done) => {
             const nodeName = this.name || this.id;
-            this.log(`[${nodeName}] Closing ODBC config node. Pool present: ${!!this.pool}. Fire-and-forget: ${this.config.fireAndForgetOnClose}`);
-    
+            
             if (this.pool) {
-                const currentPool = this.pool; 
-                this.pool = null; 
+                const currentPool = this.pool;
+                this.pool = null;
                 this.connecting = false;
-    
+                
                 const closePromise = Promise.race([
                     currentPool.close(),
-                    new Promise((_, reject) => 
-                        setTimeout(() => reject(new Error('Pool close timeout')), this.closeOperationTimeout)
-                    )
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Pool close timeout')), this.closeOperationTimeout))
                 ]);
-    
+
                 if (this.config.fireAndForgetOnClose) {
-                    this.log(`[${nodeName}] Initiating fire-and-forget pool close. Calling done() immediately.`);
+                    // FAST CLOSE: On libère Node-RED immédiatement
+                    this.log(`[${nodeName}] Fire-and-forget close initiated.`);
                     done(); 
-    
-                    closePromise
-                        .then(() => {
-                            this.log(`[${nodeName}] Background fire-and-forget pool close for ${nodeName} completed successfully.`);
-                        })
-                        .catch(error => {
-                            this.error(`[${nodeName}] Background fire-and-forget pool close for ${nodeName} failed or timed out: ${error.message}`, error);
-                        });
-                } else { 
-                    this.log(`[${nodeName}] Awaiting pool close operation...`);
+                    // On continue en arrière-plan (best effort)
+                    closePromise.catch(e => this.warn(`[${nodeName}] Background pool close error: ${e.message}`));
+                } else {
+                    // NORMAL CLOSE: On attend la fermeture propre
+                    this.log(`[${nodeName}] Closing pool...`);
                     try {
                         await closePromise;
-                        this.log(`[${nodeName}] Pool close operation completed successfully for ${nodeName}.`);
-                    } catch (error) {
-                        this.error(`[${nodeName}] Pool close operation for ${nodeName} failed or timed out: ${error.message}`, error);
+                        this.log(`[${nodeName}] Pool closed.`);
+                    } catch (e) {
+                        this.error(`[${nodeName}] Error closing pool: ${e.message}`);
                     }
-                    this.log(`[${nodeName}] Calling done() after awaiting pool close for ${nodeName}.`);
                     done();
                 }
-            } else { 
-                this.log(`[${nodeName}] No pool to close. Calling done().`);
+            } else {
                 done();
             }
         });
     }
-    RED.nodes.registerType("odbc config", poolConfig, { credentials: { password: { type: "password" } } });
 
+    RED.nodes.registerType("odbc config", poolConfig, { 
+        credentials: { password: { type: "password" } } 
+    });
+
+    // Endpoint pour le bouton "Test Connection"
     RED.httpAdmin.post("/odbc_config/:id/test", RED.auth.needsPermission("odbc.write"), async function(req, res) {
         const tempConfig = req.body;
+        // Reconstitution locale de la chaîne de connexion pour le test
         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."); }
+                if (!tempConfig.dbType || !tempConfig.server) throw new Error("Missing params.");
                 let driver;
                 let parts = [];
                 switch (tempConfig.dbType) {
@@ -178,373 +184,358 @@ module.exports = function (RED) {
                     case 'mysql': driver = 'MySQL ODBC 8.0 Unicode Driver'; break;
                     default: driver = tempConfig.driver || ''; break;
                 }
-                if(driver) parts.unshift(`DRIVER={${driver}}`);
+                if(driver) parts.push(`DRIVER={${driver}}`);
                 parts.push(`SERVER=${tempConfig.server}`);
                 if (tempConfig.database) parts.push(`DATABASE=${tempConfig.database}`);
                 if (tempConfig.user) { 
                     parts.push(`UID=${tempConfig.user}`);
-                    if (typeof tempConfig.password === 'string') { 
-                        parts.push(`PWD=${tempConfig.password}`);
-                    }
+                    if (typeof tempConfig.password === 'string') 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;
+                return tempConfig.connectionString || "";
             }
         };
+
         let connection;
         try {
-            const testConnectionString = buildTestConnectionString();
-            const connectionOptions = { connectionString: testConnectionString, loginTimeout: 10 };
-            connection = await odbcModule.connect(connectionOptions);
+            const cs = buildTestConnectionString();
+            if (!cs) throw new Error("Connection string empty");
+            // Connexion directe (sans pool) pour le test
+            connection = await odbcModule.connect({ 
+                connectionString: cs, 
+                loginTimeout: 10 
+            });
+            await connection.query("SELECT 1"); // Test SQL simple
             res.sendStatus(200);
         } catch (err) {
-            res.status(500).send(err.message || "Erreur inconnue durant le test.");
+            res.status(500).send(err.message);
         } finally {
-            if (connection) await connection.close(); 
+            if (connection) {
+                try { await connection.close(); } catch(e){}
+            }
         }
     });
 
-    // --- ODBC Query Node ---
+    // =========================================================================
+    // QUERY NODE (Le noeud fonctionnel)
+    // =========================================================================
     function odbc(config) {
         RED.nodes.createNode(this, config);
         this.config = config;
         this.poolNode = RED.nodes.getNode(this.config.connection);
         this.name = this.config.name;
+        
+        // Gestion des retry
         this.isAwaitingRetry = false;
         this.retryTimer = null;
-        this.cursorCloseOperationTimeout = 5000;
+        
+        // Contextes d'erreur
         this.currentQueryForErrorContext = null; 
         this.currentParamsForErrorContext = null;
 
-        this.enhanceError = (error, query, params, defaultMessage = "Query error") => {
+        // Helper pour enrichir les erreurs
+        this.enhanceError = (error, query, params, contextMsg) => {
             const q = query || this.currentQueryForErrorContext;
             const p = params || this.currentParamsForErrorContext;
-            const queryContext = (() => {
-                let s = "";
-                if (q || p) {
-                    s += " {";
-                    if (q) s += `"query": '${String(q).substring(0, 100)}${String(q).length > 100 ? "..." : ""}'`;
-                    if (p) s += `, "params": '${JSON.stringify(p)}'`;
-                    s += "}";
-                    return s;
-                }
-                return "";
-            })();
+            let msg = contextMsg ? `[${contextMsg}] ` : "";
+            
             let finalError;
-            if (typeof error === "object" && error !== null && error.message) { finalError = error; } 
-            else if (typeof error === "string") { finalError = new Error(error); }
-            else { finalError = new Error(defaultMessage); }
-            finalError.message = `${finalError.message}${queryContext}`;
-            if (q) finalError.query = String(q).substring(0,200);
-            if (p) finalError.params = p;
+            if (typeof error === "object" && error !== null && error.message) {
+                finalError = error;
+                finalError.message = msg + finalError.message;
+            } else {
+                finalError = new Error(msg + (error || "Unknown error"));
+            }
+            
+            if (q) finalError.query = String(q).substring(0, 500);
             return finalError;
         };
 
+        // Exécution standard (Non-streaming)
         this.executeQueryAndProcess = async (dbConnection, queryString, queryParams, msg) => {
             const result = await dbConnection.query(queryString, queryParams);
-            if (typeof result === "undefined") { throw new Error("Query returned undefined."); }
+            
             const newMsg = RED.util.cloneMessage(msg);
             const outputProperty = this.config.outputObj || "payload";
             const otherParams = {};
             let actualDataRows = [];
-            if (result !== null && typeof result === "object") {
-                if (Array.isArray(result)) {
-                    actualDataRows = result.map(row => (typeof row === 'object' && row !== null) ? { ...row } : row);
-                    for (const [key, value] of Object.entries(result)) {
-                        if (isNaN(parseInt(key))) { otherParams[key] = value; }
-                    }
-                } else {
-                    for (const [key, value] of Object.entries(result)) { otherParams[key] = value; }
+
+            // Traitement du Result Set
+            if (Array.isArray(result)) {
+                // Conversion des objets Row en objets JS purs
+                actualDataRows = result.map(row => (typeof row === 'object' && row !== null) ? { ...row } : row);
+                // Extraction des métadonnées (Statement, count, columns, etc.)
+                for (const [key, value] of Object.entries(result)) {
+                    if (isNaN(parseInt(key))) { otherParams[key] = value; }
                 }
+            } else if (typeof result === 'object' && result !== null) {
+                // Cas rares ou updates sans retour
+                for (const [key, value] of Object.entries(result)) { otherParams[key] = value; }
             }
+
+            // Gestion spécifique SQL_BIT -> Boolean
             const columnMetadata = otherParams.columns;
-            if (Array.isArray(columnMetadata) && Array.isArray(actualDataRows) && actualDataRows.length > 0) {
-                const sqlBitColumnNames = new Set();
-                columnMetadata.forEach(col => { if (col && typeof col.name === "string" && col.dataTypeName === "SQL_BIT") sqlBitColumnNames.add(col.name); });
-                if (sqlBitColumnNames.size > 0) {
+            if (Array.isArray(columnMetadata) && actualDataRows.length > 0) {
+                const sqlBitCols = columnMetadata
+                    .filter(c => c.dataTypeName === "SQL_BIT")
+                    .map(c => c.name);
+                
+                if (sqlBitCols.length > 0) {
                     actualDataRows.forEach(row => {
-                        if (typeof row === "object" && row !== null) {
-                            for (const columnName of sqlBitColumnNames) {
-                                if (row.hasOwnProperty(columnName)) {
-                                    const value = row[columnName];
-                                    if (value === "1" || value === 1) row[columnName] = true;
-                                    else if (value === "0" || value === 0) row[columnName] = false;
-                                }
-                            }
-                        }
+                        sqlBitCols.forEach(col => {
+                            if (row[col] == 1) row[col] = true;
+                            else if (row[col] == 0) row[col] = false;
+                        });
                     });
                 }
             }
+
             objPath.set(newMsg, outputProperty, actualDataRows);
+            // Ajout des métadonnées (optionnel, dans msg.odbc)
             if (Object.keys(otherParams).length) newMsg.odbc = otherParams;
+            
             return newMsg;
         };
-        
+
+        // Exécution Streaming
         this.executeStreamQuery = async (dbConnection, queryString, queryParams, msg, send) => {
             const chunkSize = parseInt(this.config.streamChunkSize) || 1;
-            const fetchSize = chunkSize > 100 ? 100 : chunkSize; 
+            // FetchSize un peu plus grand pour l'efficacité réseau
+            const fetchSize = chunkSize < 100 ? 100 : chunkSize; 
+
+            // Préparation d'un squelette de message pour éviter de tout cloner en boucle
+            const skeletonMsg = RED.util.cloneMessage(msg);
+            const outProp = this.config.outputObj || "payload";
+            // On vide le payload du squelette pour ne pas le traîner
+            objPath.set(skeletonMsg, outProp, null);
+
             let cursor;
             try {
                 cursor = await dbConnection.query(queryString, queryParams, { cursor: true, fetchSize: fetchSize });
-                this.status({ fill: "blue", shape: "dot", text: "streaming rows..." });
+                this.status({ fill: "blue", shape: "dot", text: "streaming..." });
+                
                 let rowCount = 0;
-                let chunk = [];
+                let buffer = [];
+
                 while (true) {
-                    const rows = await cursor.fetch(); 
+                    const rows = await cursor.fetch();
                     if (!rows || rows.length === 0) break;
+
                     for (const row of rows) {
                         rowCount++;
-                        const cleanRow = (typeof row === 'object' && row !== null) ? { ...row } : row;
-                        chunk.push(cleanRow);
-                        if (chunk.length >= chunkSize) {
-                            const newMsg = RED.util.cloneMessage(msg);
-                            objPath.set(newMsg, this.config.outputObj || "payload", chunk);
-                            newMsg.odbc_stream = { index: rowCount - chunk.length, count: chunk.length, complete: false };
-                            send(newMsg);
-                            chunk = [];
+                        buffer.push({ ...row }); // Copie propre de la ligne
+
+                        if (buffer.length >= chunkSize) {
+                            // Envoi du chunk
+                            const chunkMsg = RED.util.cloneMessage(skeletonMsg);
+                            objPath.set(chunkMsg, outProp, buffer);
+                            chunkMsg.odbc_stream = { index: rowCount - buffer.length, count: buffer.length, complete: false };
+                            send(chunkMsg);
+                            buffer = [];
                         }
                     }
                 }
-                if (chunk.length > 0) {
-                    const newMsg = RED.util.cloneMessage(msg);
-                    objPath.set(newMsg, this.config.outputObj || "payload", chunk);
-                    newMsg.odbc_stream = { index: rowCount - chunk.length, count: chunk.length, complete: false };
-                    send(newMsg);
+
+                // Reliquat
+                if (buffer.length > 0) {
+                    const chunkMsg = RED.util.cloneMessage(skeletonMsg);
+                    objPath.set(chunkMsg, outProp, buffer);
+                    chunkMsg.odbc_stream = { index: rowCount - buffer.length, count: buffer.length, complete: false };
+                    send(chunkMsg);
                 }
-                const finalMsg = RED.util.cloneMessage(msg);
-                objPath.set(finalMsg, this.config.outputObj || "payload", []);
+
+                // Message de fin
+                const finalMsg = RED.util.cloneMessage(skeletonMsg);
+                objPath.set(finalMsg, outProp, []);
                 finalMsg.odbc_stream = { index: rowCount, count: 0, complete: true };
                 send(finalMsg);
-                this.status({ fill: "green", shape: "dot", text: `success (${rowCount} rows)` });
-            } finally {
-                if (cursor) {
-                    try {
-                        await Promise.race([
-                            cursor.close(),
-                            new Promise((_, reject) => setTimeout(() => reject(new Error('Cursor close timeout')), this.cursorCloseOperationTimeout))
-                        ]);
-                    } catch (cursorCloseError) { this.warn(`Error or timeout closing cursor: ${cursorCloseError.message}`); }
-                }
-            }
-        };
+                
+                this.status({ fill: "green", shape: "dot", text: `done (${rowCount} rows)` });
 
-        this.testBasicConnectivity = async function(connection) {
-            if (!connection || typeof connection.query !== 'function') {
-                this.warn("Test de connectivité basique : connexion invalide fournie.");
-                return false;
-            }
-            let originalTimeout;
-            try {
-                originalTimeout = connection.queryTimeout;
-                connection.queryTimeout = 5; 
-                await connection.query("SELECT 1");
-                this.log("Test de connectivité basique (SELECT 1) : Réussi.");
-                return true;
-            } catch (testError) {
-                this.warn(`Test de connectivité basique (SELECT 1) : Échoué - ${testError.message}`);
-                return false;
             } finally {
-                if (typeof originalTimeout !== 'undefined' && connection && typeof connection.query === 'function') {
-                    try { connection.queryTimeout = originalTimeout; } 
-                    catch(e) { this.warn("Impossible de restaurer le queryTimeout original après le test de connectivité.")}
+                // Fermeture garantie du curseur
+                if (cursor) {
+                    try { await cursor.close(); } catch(e) { this.warn("Cursor close warning: " + e.message); }
                 }
             }
         };
 
+        // Récupération dynamique de la Query et des Params
         this.getRenderedQueryAndParams = async function(msg) {
-            const querySourceType = this.config.querySourceType || 'msg';
-            const querySource = this.config.querySource || 'query';
-            const paramsSourceType = this.config.paramsSourceType || 'msg';
-            const paramsSource = this.config.paramsSource || 'parameters';
-            
-            this.currentParamsForErrorContext = await new Promise(resolve => RED.util.evaluateNodeProperty(paramsSource, paramsSourceType, this, msg, (err, val) => resolve(err ? undefined : val)));
-            this.currentQueryForErrorContext = await new Promise(resolve => RED.util.evaluateNodeProperty(querySource, querySourceType, this, msg, (err, val) => resolve(err ? undefined : (val || this.config.query || ""))));
-            
-            if (!this.currentQueryForErrorContext) {
-                throw new Error("No query to execute. Please provide a query in the node's configuration or via msg." + (querySourceType === 'msg' ? querySource : 'querySource (non-msg)'));
-            }
+            const qSource = this.config.querySource || 'query';
+            const qType = this.config.querySourceType || 'msg';
+            const pSource = this.config.paramsSource || 'parameters';
+            const pType = this.config.paramsSourceType || 'msg';
+
+            const paramsVal = await new Promise((resolve, reject) => {
+                RED.util.evaluateNodeProperty(pSource, pType, this, msg, (err, res) => {
+                    if(err) resolve(undefined); else resolve(res);
+                });
+            });
+
+            const queryVal = await new Promise((resolve, reject) => {
+                RED.util.evaluateNodeProperty(qSource, qType, this, msg, (err, res) => {
+                    if(err) resolve(undefined); else resolve(res || this.config.query || "");
+                });
+            });
 
-            let finalQuery = this.currentQueryForErrorContext;
-            const isPreparedStatement = this.currentParamsForErrorContext || (finalQuery && finalQuery.includes("?"));
-            if (!isPreparedStatement && finalQuery) {
+            this.currentParamsForErrorContext = paramsVal;
+            this.currentQueryForErrorContext = queryVal;
+
+            if (!queryVal) throw new Error("No SQL query provided via config or input msg.");
+
+            let finalQuery = queryVal;
+            // Si pas de ? (paramétré) et qu'on a un msg, on tente Mustache
+            // Note: Si paramsVal existe, on suppose que c'est une requête préparée, on évite Mustache pour la sécurité
+            if (!paramsVal && finalQuery.includes("{{")) {
                 finalQuery = mustache.render(finalQuery, msg);
             }
-            return { query: finalQuery, params: this.currentParamsForErrorContext };
-        };
 
-        this.executeUserQuery = async function(connection, query, params, msg, send) {
-            const configuredTimeout = parseInt(this.poolNode.config.queryTimeoutSeconds, 10);
-            if (configuredTimeout > 0) {
-                try { connection.queryTimeout = configuredTimeout; } 
-                catch (e) { this.warn(`Could not set queryTimeout on connection: ${e.message}`); }
-            } else {
-                 connection.queryTimeout = 0; 
-            }
-            
-            this.status({ fill: "blue", shape: "dot", text: "executing..." });
-            if (this.config.streaming) {
-                await this.executeStreamQuery(connection, query, params, msg, send);
-            } else {
-                const newMsg = await this.executeQueryAndProcess(connection, query, params, msg);
-                this.status({ fill: "green", shape: "dot", text: "success" });
-                send(newMsg);
-            }
+            return { query: finalQuery, params: paramsVal };
         };
 
+        // =====================================================================
+        // LOGIQUE PRINCIPALE (SAFE PATTERN & NON-BLOCKING UI)
+        // =====================================================================
         this.on("input", async (msg, send, done) => {
-            this.currentQueryForErrorContext = null; 
-            this.currentParamsForErrorContext = null;
-
-            if (this.isAwaitingRetry) {
-                if (this.poolNode && this.poolNode.config.retryOnMsg === true) {
-                    this.log("New message received, overriding retry timer and attempting query now.");
-                    clearTimeout(this.retryTimer); this.retryTimer = null; this.isAwaitingRetry = false;
-                } else {
-                    this.warn("Node is in a retry-wait state. New message ignored.");
-                    if (done) done(); return;
-                }
-            }
+            // Nettoyage état précédent
+            if (this.retryTimer) { clearTimeout(this.retryTimer); this.retryTimer = null; }
             this.isAwaitingRetry = false;
-            if(this.retryTimer) { clearTimeout(this.retryTimer); this.retryTimer = null; }
 
             if (!this.poolNode) {
-                this.status({ fill: "red", shape: "ring", text: "No config node" });
-                return done(this.enhanceError(new Error("ODBC Config node not properly configured.")));
+                this.status({ fill: "red", shape: "ring", text: "Config missing" });
+                return done(new Error("ODBC Config node not configured"));
             }
 
-            let queryToExecute;
-            let paramsToExecute;
+            // 1. Préparation Données
+            let queryData;
             try {
-                const queryData = await this.getRenderedQueryAndParams(msg);
-                queryToExecute = queryData.query;
-                paramsToExecute = queryData.params;
-            } catch (inputValidationError) {
+                queryData = await this.getRenderedQueryAndParams(msg);
+            } catch (e) {
                 this.status({ fill: "red", shape: "ring", text: "Input Error" });
-                return done(this.enhanceError(inputValidationError)); 
+                return done(e);
             }
-            
-            let activeConnection = null; 
-            let errorForUser = null; 
-            let shouldProceedToTimedRetry = false;
-
-            try { 
-                this.status({ fill: "yellow", shape: "dot", text: "connecting (pool)..." });
-                activeConnection = await this.poolNode.connect();
-                await this.executeUserQuery(activeConnection, queryToExecute, paramsToExecute, msg, send);
-                
-                done(); 
-                
-                if (activeConnection) { 
-                    try { await activeConnection.close(); } catch(e) { this.warn("Error closing pool connection after success: " + e.message); }
-                    activeConnection = null; 
-                }
-                return; 
-
-            } catch (initialDbError) {
-                this.warn(`Initial DB attempt failed: ${initialDbError.message}`);
-                if (activeConnection) { 
-                    const connStillGood = await this.testBasicConnectivity(activeConnection);
-                    try { await activeConnection.close(); activeConnection = null; } 
-                    catch(e){ this.warn("Error closing pool conn after initial error: "+e.message); activeConnection = null; }
-                    
-                    if (connStillGood) { 
-                        this.status({ fill: "red", shape: "ring", text: "SQL error" });
-                        return done(this.enhanceError(initialDbError)); 
+
+            let connection = null;
+            let isFreshConnection = false;
+            let errorOccurred = null;
+            let shouldScheduleRetry = false;
+
+            // 2. Exécution avec bloc FINALLY pour anti-fuite
+            try {
+                // A. Obtention de la connexion
+                try {
+                    this.status({ fill: "yellow", shape: "dot", text: "connecting..." });
+                    connection = await this.poolNode.connect();
+                } catch (poolErr) {
+                    // Si le pool échoue et que l'option RetryFresh est active
+                    if (this.poolNode.config.retryFreshConnection) {
+                        this.warn("Pool connection failed, attempting fresh connection...");
+                        const freshCfg = this.poolNode.getFreshConnectionConfig();
+                        connection = await odbcModule.connect(freshCfg);
+                        isFreshConnection = true; 
+                        this.log("Fresh connection established.");
+                    } else {
+                        throw poolErr; 
                     }
                 }
+
+                // B. Configuration du Timeout (si supporté par l'objet connexion)
+                const qTimeout = parseInt(this.poolNode.config.queryTimeoutSeconds, 10);
+                if (qTimeout > 0) {
+                    connection.queryTimeout = qTimeout;
+                } else {
+                    connection.queryTimeout = 0; // Défaut
+                }
+
+                // C. Exécution (NON-BLOCKING UI)
+                this.status({ fill: "blue", shape: "dot", text: "querying..." });
                 
-                if (this.poolNode.config.retryFreshConnection) {
-                    this.warn("Attempting retry with a fresh connection.");
-                    this.status({ fill: "yellow", shape: "dot", text: "Retrying (fresh)..." });
-                    try {
-                        const freshConnectConfig = this.poolNode.getFreshConnectionConfig();
-                        activeConnection = await odbcModule.connect(freshConnectConfig);
-                        this.log("Fresh connection established.");
+                // FORCE UI REFRESH: On rend la main à l'Event Loop pour afficher "querying"
+                // avant que le driver ODBC (C++) ne bloque le thread lors de la préparation.
+                await new Promise(resolve => setImmediate(resolve));
 
-                        const freshConnGood = await this.testBasicConnectivity(activeConnection);
-                        if (!freshConnGood) {
-                            errorForUser = this.enhanceError(new Error("Basic connectivity (SELECT 1) failed on fresh connection."), null, null, "Fresh Connection Test Failed");
-                            shouldProceedToTimedRetry = true;
-                            throw errorForUser; 
-                        }
-                        
-                        await this.executeUserQuery(activeConnection, queryToExecute, paramsToExecute, msg, send);
-                        
-                        this.log("Query successful with fresh connection. Resetting pool.");
-                        done();
-                        
-                        await this.poolNode.resetPool();
-                        if (activeConnection) { 
-                            try { await activeConnection.close(); } catch(e) { this.warn("Error closing fresh connection after success: " + e.message); }
-                            activeConnection = null; 
-                        }
-                        return; 
-
-                    } catch (freshErrorOrConnectivityFail) {
-                        if (activeConnection) { try { await activeConnection.close(); activeConnection = null; } catch(e){this.warn("Error closing fresh conn after error: "+e.message);} }
-                        
-                        if (shouldProceedToTimedRetry) { 
-                            // errorForUser est déjà l'erreur de test de connectivité et sera utilisé ci-dessous
-                        } else { 
-                            this.status({ fill: "red", shape: "ring", text: "SQL error (on retry)" });
-                            return done(this.enhanceError(freshErrorOrConnectivityFail));
+                if (this.config.streaming) {
+                    await this.executeStreamQuery(connection, queryData.query, queryData.params, msg, send);
+                } else {
+                    const resultMsg = await this.executeQueryAndProcess(connection, queryData.query, queryData.params, msg);
+                    send(resultMsg);
+                    this.status({ fill: "green", shape: "dot", text: "success" });
+                }
+
+                // D. Si on a réussi avec une Fresh Connection, le pool est probablement cassé, on le reset
+                if (isFreshConnection) {
+                    this.poolNode.resetPool(); 
+                }
+
+                done(); // Succès
+
+            } catch (err) {
+                errorOccurred = err;
+                // Analyse de l'erreur pour voir si c'est une erreur de connexion (réseau)
+                const isConnectionError = err.message && (
+                    err.message.match(/connection|network|timeout|communication|link|provider/i) 
+                    || (err.odbcErrors && err.odbcErrors.length > 0)
+                );
+
+                if (isConnectionError || this.poolNode.config.retryFreshConnection) {
+                    shouldScheduleRetry = true;
+                }
+            } finally {
+                // E. NETTOYAGE CRITIQUE (Le "Fix" principal)
+                if (connection) {
+                    try {
+                        // Si c'était une connexion du pool, on réinitialise le timeout pour ne pas polluer le pool
+                        if (!isFreshConnection) {
+                            connection.queryTimeout = 0; 
                         }
+                        await connection.close();
+                    } catch (closeErr) {
+                        this.warn("Error ensuring connection closed: " + closeErr.message);
                     }
-                } else { 
-                    errorForUser = this.enhanceError(initialDbError, null, null, "Connection Error (no fresh retry)");
-                    shouldProceedToTimedRetry = true;
                 }
             }
-            
-            if (activeConnection) {
-                try { await activeConnection.close(); } catch(e) { this.warn("Final cleanup: Error closing activeConnection: " + e.message); }
-                activeConnection = null;
-            }
-            
-            if (shouldProceedToTimedRetry && errorForUser) {
-                const retryDelaySeconds = parseInt(this.poolNode.config.retryDelay, 10);
-                if (retryDelaySeconds > 0) {
-                    this.warn(`Connection issue. Scheduling retry in ${retryDelaySeconds}s. Error: ${errorForUser.message}`);
-                    this.status({ fill: "red", shape: "ring", text: `Retry in ${retryDelaySeconds}s...` });
+
+            // 3. Gestion post-exécution des erreurs et Retry
+            if (errorOccurred) {
+                const retryDelay = parseInt(this.poolNode.config.retryDelay, 10);
+
+                if (shouldScheduleRetry && retryDelay > 0) {
+                    this.warn(`Query failed (${errorOccurred.message}). Retrying in ${retryDelay}s...`);
+                    this.status({ fill: "red", shape: "ring", text: `Retry in ${retryDelay}s` });
+                    
                     this.isAwaitingRetry = true;
                     this.retryTimer = setTimeout(() => {
-                        this.isAwaitingRetry = false; this.retryTimer = null;
-                        this.log(`Retry timer expired. Re-emitting message for node ${this.id || this.name}.`);
-                        this.receive(msg); 
-                    }, retryDelaySeconds * 1000);
-                    return done(); 
-                } else { 
-                    this.status({ fill: "red", shape: "ring", text: "Connection Error" });
-                    return done(errorForUser);
+                        this.isAwaitingRetry = false;
+                        this.log("Retry timer expired. Re-processing message.");
+                        this.emit("input", msg, send, done); 
+                    }, retryDelay * 1000);
+                    
+                    done(); 
+                } else {
+                    this.status({ fill: "red", shape: "dot", text: "Error" });
+                    done(this.enhanceError(errorOccurred));
                 }
-            } else if (errorForUser) { 
-                 this.status({ fill: "red", shape: "ring", text: "Error (No Timed Retry)" });
-                 return done(errorForUser);
-            } else {
-                 this.log("[ODBC Node] DEBUG: Reached end of on('input') path. Calling done().");
-                 return done();
             }
         });
-        
+
         this.on("close", (done) => {
             if (this.retryTimer) {
-                clearTimeout(this.retryTimer); this.retryTimer = null; this.isAwaitingRetry = false;
-                this.log("Cleared pending retry timer on node close/redeploy.");
+                clearTimeout(this.retryTimer);
+                this.retryTimer = null;
             }
             this.status({});
             done();
         });
-    
+
+        // Status initial
         if (this.poolNode) {
             this.status({ fill: "green", shape: "dot", text: "ready" });
         } else {
-            this.status({ fill: "red", shape: "ring", text: "No config node" });
-            this.warn("ODBC Config node not found or not deployed.");
+            this.status({ fill: "red", shape: "ring", text: "No config" });
         }
     }
-    
+
     RED.nodes.registerType("odbc", odbc);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bkmj/node-red-contrib-odbcmj",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "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",