@bkmj/node-red-contrib-odbcmj 2.3.0 → 2.3.1

package/odbc.js

@@ -12,10 +12,11 @@ module.exports = function (RED) {
         
         this.credentials = RED.nodes.getCredentials(this.id);
 
-        // NOUVEAU: Timeout par défaut pour les requêtes (0 = infini/défaut du driver)
-        // Sera configurable dans le .html plus tard
-        this.config.queryTimeoutSeconds = parseInt(config.queryTimeoutSeconds, 10) || 0; 
-        // NOUVEAU: Timeout fixe pour les opérations de fermeture (en ms)
+        this.config.queryTimeoutSeconds = parseInt(config.queryTimeoutSeconds, 10);
+        if (isNaN(this.config.queryTimeoutSeconds) || this.config.queryTimeoutSeconds < 0) {
+            this.config.queryTimeoutSeconds = 0; 
+        }
+        
         this.closeOperationTimeout = 10000; // 10 secondes
 
         this._buildConnectionString = function() {
@@ -36,8 +37,6 @@ module.exports = function (RED) {
                 if (this.config.database) parts.push(`DATABASE=${this.config.database}`);
                 if (this.config.user) parts.push(`UID=${this.config.user}`);
                 if (this.credentials && this.credentials.password) parts.push(`PWD=${this.credentials.password}`);
-                // NOUVEAU: Potentiellement ajouter des options de timeout ici si le driver les supporte dans la CS
-                // Exemple (non standard, dépend du driver): if (this.config.loginTimeout > 0) parts.push(`LoginTimeout=${this.config.loginTimeout}`);
                 return parts.join(';');
             } else {
                 let connStr = this.config.connectionString || "";
@@ -53,19 +52,18 @@ module.exports = function (RED) {
                     const finalConnectionString = this._buildConnectionString();
                     if (!finalConnectionString) throw new Error("La chaîne de connexion est vide.");
                     
-                    const poolParams = { ...this.config }; // Contient initialSize, maxSize, loginTimeout, connectionTimeout (idle) etc.
-                    poolParams.connectionString = finalConnectionString;
-
-                    // Supprimer les clés non reconnues par odbc.pool ou spécifiques à notre nœud
-                    ['retryFreshConnection', 'retryDelay', 'retryOnMsg', 'syntax', 'connectionMode', 
-                     'dbType', 'server', 'database', 'user', 'driver', 'queryTimeoutSeconds', 'name', 'id', 'type', '_users', 'z', 'x', 'y', 'wires']
-                     .forEach(k => delete poolParams[k]);
+                    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,
+                        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
+                    };
+                    
+                    Object.keys(poolParams).forEach(key => poolParams[key] === undefined && delete poolParams[key]);
                     
-                    // NOUVEAU: Debug des paramètres du pool
-                    // this.log(`Initializing pool with params: ${JSON.stringify(poolParams)}`);
-
-                    // Potentiel point de blocage si odbcModule.pool() ne gère pas bien les erreurs de driver/connexion
-                    // Il n'y a pas de timeout direct pour odbcModule.pool() lui-même
                     this.pool = await odbcModule.pool(poolParams);
                     this.connecting = false;
                     this.status({ fill: "green", shape: "dot", text: "Pool ready" });
@@ -78,8 +76,6 @@ module.exports = function (RED) {
                 }
             }
             try {
-                // odbc.pool.connect() peut aussi théoriquement bloquer, mais devrait utiliser
-                // les timeouts des connexions individuelles ou le connectionTimeout du pool (pour l'attente d'une connexion dispo)
                 return await this.pool.connect();
             } catch (poolConnectError) {
                 this.error(`Error connecting to pool: ${poolConnectError.message}`, poolConnectError);
@@ -89,16 +85,13 @@ module.exports = function (RED) {
         };
 
         this.getFreshConnectionConfig = function() {
-            // Ces timeouts sont pour odbcModule.connect (connexion unique)
             return {
                 connectionString: this._buildConnectionString(),
-                connectionTimeout: 0, // Pour une connexion unique, on ne veut pas qu'elle se ferme automatiquement après un idle time.
-                                      // Le `connectionTimeout` de node-odbc connect est "Number of seconds for the connection to be open before it is automatically closed."
-                loginTimeout: parseInt(this.config.loginTimeout, 10) || 5, // Timeout pour l'établissement de la connexion. 5s par défaut.
+                connectionTimeout: 0, 
+                loginTimeout: parseInt(this.config.loginTimeout, 10) || 5,
             };
         };
 
-        // MODIFIÉ: Ajout de timeout pour pool.close()
         this.resetPool = async () => {
             if (this.pool) {
                 this.log("Resetting connection pool.");
@@ -129,7 +122,6 @@ module.exports = function (RED) {
             }
         };
 
-        // MODIFIÉ: Ajout de timeout pour pool.close()
         this.on("close", async (removed, done) => {
             this.log("Closing ODBC config node. Attempting to close pool.");
             if (this.pool) {
@@ -144,7 +136,7 @@ module.exports = function (RED) {
                 } catch (error) {
                     this.error(`Error or timeout closing connection pool on node close: ${error.message}`, error);
                 } finally {
-                    this.pool = null; // S'assurer que le pool est marqué comme null
+                    this.pool = null; 
                 }
             }
             done();
@@ -189,20 +181,20 @@ module.exports = function (RED) {
         let connection;
         try {
             const testConnectionString = buildTestConnectionString();
-            console.log("[ODBC Test] Attempting to connect with string:", testConnectionString);
+            // console.log("[ODBC Test] Attempting to connect with string:", testConnectionString); // Conservé pour debug si besoin
             
             const connectionOptions = {
                 connectionString: testConnectionString,
-                loginTimeout: 10 // Déjà présent et correct
+                loginTimeout: 10 
             };
             connection = await odbcModule.connect(connectionOptions);
             res.sendStatus(200);
         } catch (err) {
-            console.error("[ODBC Test] Connection failed:", err);
+            // console.error("[ODBC Test] Connection failed:", err); // Conservé pour debug si besoin
             res.status(500).send(err.message || "Erreur inconnue durant le test.");
         } finally {
             if (connection) {
-                await connection.close(); // Fermeture simple, pas besoin de timeout ici car c'est une op rapide.
+                await connection.close(); 
             }
         }
     });
@@ -215,21 +207,95 @@ module.exports = function (RED) {
         this.name = this.config.name;
         this.isAwaitingRetry = false;
         this.retryTimer = null;
+        this.cursorCloseOperationTimeout = 5000;
 
-        // NOUVEAU: Timeout fixe pour les opérations de fermeture de curseur (en ms)
-        this.cursorCloseOperationTimeout = 5000; // 5 secondes
+        this.enhanceError = (error, query, params, defaultMessage = "Query error") => {
+            const queryContext = (() => {
+                let s = "";
+                if (query || params) {
+                    s += " {";
+                    if (query) s += `"query": '${query.substring(0, 100)}${query.length > 100 ? "..." : ""}'`;
+                    if (params) s += `, "params": '${JSON.stringify(params)}'`;
+                    s += "}";
+                    return s;
+                }
+                return "";
+            })();
+            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 (query) finalError.query = query;
+            if (params) finalError.params = params;
+            return finalError;
+        };
+
+        // MODIFIÉ : Nettoyage des objets de résultat
+        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"; // Utiliser la propriété configurée ou 'payload' par défaut
+            const otherParams = {};
+            let actualDataRows = [];
 
-        this.enhanceError = (error, query, params, defaultMessage = "Query error") => { /* ... (inchangé) ... */ };
-        this.executeQueryAndProcess = async (dbConnection, queryString, queryParams, msg) => { /* ... (inchangé) ... */ };
+            if (result !== null && typeof result === "object") {
+                if (Array.isArray(result)) {
+                    actualDataRows = result.map(row => {
+                        if (typeof row === 'object' && row !== null) {
+                            return { ...row }; // Copie superficielle pour "nettoyer" l'objet
+                        }
+                        return 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;
+                    }
+                }
+            }
+            
+            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) {
+                    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; }
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+
+            objPath.set(newMsg, outputProperty, actualDataRows);
+            if (Object.keys(otherParams).length) { newMsg.odbc = otherParams; }
+            return newMsg;
+        };
         
-        // MODIFIÉ: Ajout de timeout pour cursor.close()
         this.executeStreamQuery = async (dbConnection, queryString, queryParams, msg, send) => {
             const chunkSize = parseInt(this.config.streamChunkSize) || 1;
             const fetchSize = chunkSize > 100 ? 100 : chunkSize; 
             let cursor;
         
             try {
-                // dbConnection.query() utilisera le dbConnection.queryTimeout défini plus bas
                 cursor = await dbConnection.query(queryString, queryParams, { cursor: true, fetchSize: fetchSize });
                 this.status({ fill: "blue", shape: "dot", text: "streaming rows..." });
         
@@ -237,16 +303,17 @@ module.exports = function (RED) {
                 let chunk = [];
         
                 while (true) {
-                    // cursor.fetch() pourrait aussi théoriquement bloquer, mais c'est plus rare si la requête initiale a fonctionné
                     const rows = await cursor.fetch(); 
                     if (!rows || rows.length === 0) { break; }
         
                     for (const row of rows) {
                         rowCount++;
-                        chunk.push(row);
+                        // Nettoyer chaque ligne aussi pour le streaming
+                        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, chunk);
+                            objPath.set(newMsg, this.config.outputObj || "payload", chunk);
                             newMsg.odbc_stream = { index: rowCount - chunk.length, count: chunk.length, complete: false };
                             send(newMsg);
                             chunk = [];
@@ -256,13 +323,13 @@ module.exports = function (RED) {
         
                 if (chunk.length > 0) {
                     const newMsg = RED.util.cloneMessage(msg);
-                    objPath.set(newMsg, this.config.outputObj, chunk);
+                    objPath.set(newMsg, this.config.outputObj || "payload", 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, []);
+                objPath.set(finalMsg, this.config.outputObj || "payload", []);
                 finalMsg.odbc_stream = { index: rowCount, count: 0, complete: true };
                 send(finalMsg);
         
@@ -271,7 +338,6 @@ module.exports = function (RED) {
             } finally {
                 if (cursor) {
                     try {
-                        // NOUVEAU: Timeout pour la fermeture du curseur
                         await Promise.race([
                             cursor.close(),
                             new Promise((_, reject) => 
@@ -285,7 +351,6 @@ module.exports = function (RED) {
             }
         };
 
-        // MODIFIÉ: Ajout de la définition du queryTimeout sur la connexion
         this.on("input", async (msg, send, done) => {
             if (this.isAwaitingRetry) {
                 if (this.poolNode && this.poolNode.config.retryOnMsg === true) {
@@ -308,7 +373,8 @@ module.exports = function (RED) {
             }
     
             const executeWithConnection = async (connection) => {
-                this.config.outputObj = this.config.outputObj || "payload";
+                const outputProperty = this.config.outputObj || "payload"; // S'assurer que outputProperty est défini
+                
                 const querySourceType = this.config.querySourceType || 'msg';
                 const querySource = this.config.querySource || 'query';
                 const paramsSourceType = this.config.paramsSourceType || 'msg';
@@ -321,16 +387,14 @@ module.exports = function (RED) {
                     query = mustache.render(query, msg);
                 }
 
-                // NOUVEAU: Appliquer le queryTimeout à la connexion avant exécution
                 if (this.poolNode.config.queryTimeoutSeconds > 0) {
                     try {
                         connection.queryTimeout = parseInt(this.poolNode.config.queryTimeoutSeconds, 10);
-                        // this.log(`Query timeout set to ${connection.queryTimeout}s for this execution.`);
                     } catch (e) {
                         this.warn(`Could not set queryTimeout on connection: ${e.message}`);
                     }
                 } else {
-                     connection.queryTimeout = 0; // Assurer le reset au défaut du driver (infini)
+                     connection.queryTimeout = 0; 
                 }
                 
                 this.status({ fill: "blue", shape: "dot", text: "executing..." });
@@ -349,10 +413,23 @@ module.exports = function (RED) {
             try {
                 this.status({ fill: "yellow", shape: "dot", text: "connecting..." });
                 connectionFromPool = await this.poolNode.connect();
+                //this.log("[ODBC Node] DEBUG: Avant executeWithConnection (pooled)"); // Logs de debug
                 await executeWithConnection(connectionFromPool);
+                //this.log("[ODBC Node] DEBUG: Après executeWithConnection (pooled), avant fermeture et done()");
+                
+                // Fermer la connexion avant d'appeler done() dans le chemin de succès principal
+                if (connectionFromPool) { 
+                    await connectionFromPool.close(); 
+                    connectionFromPool = null; 
+                }
                 return done();
             } catch (poolError) {
+                if (connectionFromPool) { 
+                    try { await connectionFromPool.close(); } catch(e) { this.warn("Error closing pool connection in poolError catch: " + e.message); }
+                    connectionFromPool = null;
+                }
                 this.warn(`First attempt with pooled connection failed: ${poolError.message}`);
+
                 if (this.poolNode.config.retryFreshConnection) {
                     this.warn("Attempting retry with a fresh connection.");
                     this.status({ fill: "yellow", shape: "dot", text: "Retrying (fresh)..." });
@@ -361,21 +438,28 @@ module.exports = function (RED) {
                         const freshConnectConfig = this.poolNode.getFreshConnectionConfig();
                         freshConnection = await odbcModule.connect(freshConnectConfig);
                         this.log("Fresh connection established for retry.");
+                        //this.log("[ODBC Node] DEBUG: Avant executeWithConnection (fresh)");
                         await executeWithConnection(freshConnection);
-                        this.log("Query successful with fresh connection. Resetting pool.");
+                        //this.log("[ODBC Node] DEBUG: Après executeWithConnection (fresh), avant resetPool et done()");
                         await this.poolNode.resetPool();
+                        
+                        if (freshConnection) { 
+                            await freshConnection.close(); 
+                            freshConnection = null; 
+                        }
                         return done();
                     } catch (freshError) {
                         errorAfterInitialAttempts = this.enhanceError(freshError, null, null, "Retry with fresh connection also failed");
                     } finally {
-                        if (freshConnection) await freshConnection.close();
+                        if (freshConnection) {
+                            try { await freshConnection.close(); } catch(e) { this.warn("Error closing fresh connection in finally: " + e.message); }
+                        }
                     }
                 } else {
                     errorAfterInitialAttempts = this.enhanceError(poolError);
                 }
-            } finally {
-                if (connectionFromPool) await connectionFromPool.close();
-            }
+            } 
+            // Le 'finally' qui fermait connectionFromPool est retiré ici car géré dans chaque chemin
     
             if (errorAfterInitialAttempts) {
                 const retryDelaySeconds = parseInt(this.poolNode.config.retryDelay, 10);
@@ -395,6 +479,9 @@ module.exports = function (RED) {
                     if (done) return done(errorAfterInitialAttempts);
                 }
             } else {
+                // Si on arrive ici SANS errorAfterInitialAttempts, c'est que done() aurait dû être appelé.
+                // C'est une situation anormale, mais assurons-nous que done() soit appelé.
+                // this.log("[ODBC Node] DEBUG: Atteint la fin de on('input') sans erreur signalée et done() non appelé plus tôt. Appel de done().");
                 if (done) return done();
             }
         });

package/package.json

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