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

package/README.md

@@ -14,6 +14,7 @@ This node is a fork with significant enhancements to provide stability and advan
 -   **Advanced Retry Logic**: Automatically handles connection errors with configurable delays and retries to ensure flow resilience.
 -   **Result Streaming**: Process queries with millions of rows without exhausting memory by streaming results as chunks.
 -   **Syntax Checker**: Optionally parse the SQL query to validate its structure.
+-   **Query Timeout**: Configure a timeout for query execution to prevent indefinite hangs.
 
 ---
 
@@ -46,21 +47,23 @@ This mode gives you full control for complex or non-standard connection strings.
 #### Test Connection
 
 A **Test Connection** button in the configuration panel allows you to instantly verify your settings without deploying the flow.
+> **Note:** For security reasons, passwords are not reloaded into the editor. If your connection requires a password, you must **re-enter it** in the password field before clicking the test button (in Structured Mode). For Connection String mode, ensure the full string (including password if needed) is present in the connection string field itself.
 
-#### Pool Options
+#### Pool & Connection Options
 
--   **`initialSize`** `<number>` (optional): The number of connections to create when the pool is initialized. Default: 5.
--   **`incrementSize`** `<number>` (optional): The number of connections to create when the pool is exhausted. Default: 5.
--   **`maxSize`** `<number>` (optional): The maximum number of connections allowed in the pool. Default: 15.
--   **`shrinkPool`** `<boolean>` (optional): Whether to reduce the number of connections to `initialSize` when they are returned to the pool. Default: true.
--   **`connectionTimeout`** `<number>` (optional): The number of seconds for a connection to remain idle before closing. Default: 3.
--   **`loginTimeout`** `<number>` (optional): The number of seconds for an attempt to create a connection to succeed. Default: 3.
+-   **`Initial Pool Size`** `<number>` (optional): The number of connections to create when the pool is initialized. Default: 5.
+-   **`Increment Pool Size`** `<number>` (optional): The number of connections to create when the pool is exhausted. Default: 5.
+-   **`Max Pool Size`** `<number>` (optional): The maximum number of connections allowed in the pool. Default: 15.
+-   **`Shrink Pool`** `<boolean>` (optional): If checked, reduces the number of connections to `Initial Pool Size` when they are returned to the pool if the pool has grown. Default: true.
+-   **`Idle Timeout`** `<number>` (optional): The number of seconds for a connection in the pool to remain idle before closing. Default: 3 seconds. (Refers to the `connectionTimeout` property of the `odbc` library's pool options).
+-   **`Login Timeout`** `<number>` (optional): The number of seconds for an attempt to establish a new connection to succeed. Default: 5 seconds.
+-   **`Query Timeout`** `<number>` (optional): The number of seconds for a query to execute before timing out. A value of **0** means infinite or uses the driver/database default. Default: 0 seconds.
 
 #### Error Handling & Retry
 
--   **`retryFreshConnection`** `<boolean>` (optional): If a query fails, the node will retry once with a brand new connection. If this succeeds, the entire connection pool is reset to clear any stale connections. Default: false.
--   **`retryDelay`** `<number>` (optional): If both the pooled and the fresh connection attempts fail, this sets a delay in seconds before another retry is attempted. A value of **0** disables further automatic retries. Default: 5.
--   **`retryOnMsg`** `<boolean>` (optional): If the node is waiting for a timed retry, a new incoming message can override the timer and trigger an immediate retry. Default: true.
+-   **`Retry with fresh connection`** `<boolean>` (optional): If a query fails using a connection from the pool, the node will try once more with a brand new, direct connection. If this succeeds, the entire connection pool is reset to clear any potentially stale connections. Default: false.
+-   **`Retry Delay`** `<number>` (optional): If all immediate attempts (pooled and, if enabled, fresh connection) fail, this sets a delay in seconds before another retry is attempted for the incoming message. A value of **0** disables this timed retry mechanism. Default: 5.
+-   **`Retry on new message`** `<boolean>` (optional): If the node is waiting for a timed retry (due to `Retry Delay`), a new incoming message can, if this is checked, override the timer and trigger an immediate retry of the *original* message that failed. Default: true.
 
 #### Advanced
 
@@ -100,9 +103,16 @@ For queries that return a large number of rows, streaming prevents high memory u
 
 ##### 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, and `false` otherwise. The last payload will always be an empty array.  This is useful for triggering a downstream action once all rows have been processed.
+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 (or configured output property) 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 (0-based). For the completion message, this will be the total number of data rows processed.
+-   `count`: The number of rows in the current 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.

package/odbc.html

@@ -13,14 +13,15 @@
             database: { value: "" },
             user: { value: "" },
             connectionString: { value: "" },
-            initialSize: { value: 5 },
-            incrementSize: { value: 5 },
-            maxSize: { value: 15 },
+            initialSize: { value: 5, validate: RED.validators.number(true) },
+            incrementSize: { value: 5, validate: RED.validators.number(true) },
+            maxSize: { value: 15, validate: RED.validators.number(true) },
             shrink: { value: true },
-            connectionTimeout: { value: 3 },
-            loginTimeout: { value: 3 },
+            connectionTimeout: { value: 3, validate: RED.validators.number(true) }, // Idle timeout for connections in pool (odbc lib specific)
+            loginTimeout: { value: 5, validate: RED.validators.number(true) },      // Login timeout for new connections
+            queryTimeoutSeconds: { value: 0, validate: RED.validators.number(true) }, // NOUVEAU: Timeout pour les requêtes
             retryFreshConnection: { value: false },
-            retryDelay: { value: 5, validate: RED.validators.number() },
+            retryDelay: { value: 5, validate: RED.validators.number(true) },
             retryOnMsg: { value: true },
             syntaxtick: { value: false },
             syntax: { value: "mysql" },
@@ -79,19 +80,22 @@
                         RED.notify("Le champ 'Server' est requis pour le test.", {type: "warning", timeout: 3000});
                         return;
                     }
-                } else { 
+                    if ($("#node-config-input-password").val() === "" && $("#node-config-input-user").val().trim() !== "") {
+                        RED.notify("Note: Pour tester une connexion structurée avec mot de passe, veuillez le (re)saisir.", {type: "info", timeout: 4500});
+                        // On ne bloque pas, l'utilisateur peut vouloir tester une connexion sans mot de passe si le user est optionnel
+                    }
+                } else { // Mode 'string'
                     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; 
+                        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
+                    var isDriverBasedString = /DRIVER=\{.+?\}/i.test(connStr) && /(SERVER|DATABASE|UID|PWD)=[^;]+/i.test(connStr);
 
                     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});
+                         RED.notify("La chaîne de connexion semble invalide ou incomplète (ex: DSN=valeur; ou DRIVER={...};SERVER=...;).", {type: "warning", timeout: 4500});
                          return;
                     }
                 }
@@ -109,7 +113,7 @@
                     database: $("#node-config-input-database").val(),
                     user: $("#node-config-input-user").val(),
                     connectionString: $("#node-config-input-connectionString").val(),
-                    password: (connectionMode === 'structured') ? $("#node-config-input-password").val() : null
+                    password: $("#node-config-input-password").val() 
                 };
 
                 $.ajax({
@@ -135,22 +139,10 @@
 </script>
 
 <style>
-    .form-section-header {
-        cursor: pointer;
-        padding: 5px;
-        border-bottom: 1px solid #ddd;
-        margin-bottom: 10px;
-        user-select: none;
-    }
-    .form-section-header i.fa-caret-right {
-        transition: transform 0.2s ease-in-out;
-    }
-    .form-section-header.expanded i.fa-caret-right {
-        transform: rotate(90deg);
-    }
-    .form-section-content {
-        padding-left: 20px;
-    }
+    .form-section-header { cursor: pointer; padding: 5px; border-bottom: 1px solid #ddd; margin-bottom: 10px; user-select: none; }
+    .form-section-header i.fa-caret-right { transition: transform 0.2s ease-in-out; }
+    .form-section-header.expanded i.fa-caret-right { transform: rotate(90deg); }
+    .form-section-content { padding-left: 20px; }
 </style>
 
 <script type="text/html" data-template-name="odbc config">
@@ -213,33 +205,41 @@
 
     <hr/>
     
-    <div class="form-section-header"><h4><i class="fa fa-caret-right"></i> <i class="fa fa-sitemap"></i> Pool Options</h4></div>
+    <div class="form-section-header"><h4><i class="fa fa-caret-right"></i> <i class="fa fa-sitemap"></i> Pool & Connection Options</h4></div>
     <div class="form-section-content" style="display: none;">
         <div class="form-row">
-            <label for="node-config-input-initialSize"><i class="fa fa-play"></i> Initial Size</label>
+            <label for="node-config-input-initialSize"><i class="fa fa-play"></i> Initial Pool Size</label>
             <input type="number" id="node-config-input-initialSize" placeholder="5" />
         </div>
         <div class="form-row">
-            <label for="node-config-input-incrementSize"><i class="fa fa-plus"></i> Increment Size</label>
+            <label for="node-config-input-incrementSize"><i class="fa fa-plus"></i> Increment Pool Size</label>
             <input type="number" id="node-config-input-incrementSize" placeholder="5" />
         </div>
         <div class="form-row">
-            <label for="node-config-input-maxSize"><i class="fa fa-stop"></i> Max Size</label>
+            <label for="node-config-input-maxSize"><i class="fa fa-stop"></i> Max Pool Size</label>
             <input type="number" id="node-config-input-maxSize" placeholder="15" />
         </div>
         <div class="form-row">
             <label for="node-config-input-shrink"><i class="fa fa-compress"></i> Shrink Pool</label>
             <input type="checkbox" id="node-config-input-shrink" style="margin-left:0px; vertical-align:top; width:auto !important;" />
+            <span class="form-tips" style="font-size: smaller;">Reduce pool to initial size when connections are returned.</span>
         </div>
         <div class="form-row">
-            <label for="node-config-input-connectionTimeout"><i class="fa fa-clock-o"></i> Connection Timeout</label>
+            <label for="node-config-input-connectionTimeout"><i class="fa fa-clock-o"></i> Idle Timeout</label>
             <input type="number" id="node-config-input-connectionTimeout" placeholder="3" style="width: 80px;"/>
             <span style="margin-left: 5px;">seconds</span>
+            <span class="form-tips" style="font-size: smaller;">For connections in pool.</span>
         </div>
         <div class="form-row">
-            <label for="node-config-input-loginTimeout"><i class="fa fa-clock-o"></i> Login Timeout</label>
-            <input type="number" id="node-config-input-loginTimeout" placeholder="3" style="width: 80px;" />
+            <label for="node-config-input-loginTimeout"><i class="fa fa-sign-in"></i> Login Timeout</label>
+            <input type="number" id="node-config-input-loginTimeout" placeholder="5" style="width: 80px;" />
             <span style="margin-left: 5px;">seconds</span>
+            <span class="form-tips" style="font-size: smaller;">For establishing new connections.</span>
+        </div>
+        <div class="form-row">
+            <label for="node-config-input-queryTimeoutSeconds"><i class="fa fa-hourglass-half"></i> Query Timeout</label>
+            <input type="number" id="node-config-input-queryTimeoutSeconds" placeholder="0" style="width: 80px;" />
+            <span style="margin-left: 5px;">seconds (0=infinite/driver default)</span>
         </div>
     </div>
     
@@ -248,16 +248,18 @@
         <div class="form-row">
             <label for="node-config-input-retryFreshConnection" style="width: auto;"><i class="fa fa-refresh"></i> Retry with fresh connection</label>
             <input type="checkbox" id="node-config-input-retryFreshConnection" style="display: inline-block; width: auto; vertical-align: top;" />
+            <span class="form-tips" style="font-size: smaller;">If a pooled connection fails, try once with a new one.</span>
         </div>
         <div class="retry-options" style="padding-left: 20px;">
             <div class="form-row">
                 <label for="node-config-input-retryDelay"><i class="fa fa-history"></i> Retry Delay</label>
                 <input type="number" id="node-config-input-retryDelay" placeholder="5" style="width: 80px;" />
-                    <span style="margin-left: 5px;">seconds</span>
+                    <span style="margin-left: 5px;">seconds (0=disable timed retry)</span>
             </div>
             <div class="form-row">
                 <label for="node-config-input-retryOnMsg" style="width: auto;"><i class="fa fa-envelope-o"></i> Retry on new message</label>
                 <input type="checkbox" id="node-config-input-retryOnMsg" style="display: inline-block; width: auto; vertical-align: top;" />
+                <span class="form-tips" style="font-size: smaller;">If waiting, a new message triggers immediate retry.</span>
             </div>
         </div>
     </div>
@@ -287,112 +289,38 @@
 
 <script type="text/javascript">
     RED.nodes.registerType("odbc", {
-        category: "storage",
-        color: "#89A5C0",
-        defaults: {
-            name: { value: "" },
-            connection: { type: "odbc config", required: true },
-            query: { value: "" },
-            outputObj: { value: "payload" },
-            streaming: { value: false },
-            streamChunkSize: { value: 1, validate: RED.validators.number() },
-            querySource: { value: "query", required: false },
-            querySourceType: { value: "msg", required: false },
-            paramsSource: { value: "parameters", required: false },
-            paramsSourceType: { value: "msg", required: false }
-        },
-        inputs: 1,
-        outputs: 1,
-        icon: "db.svg",
-        label: function () {
-            return this.name || "odbc";
-        },
+        category: "storage", color: "#89A5C0",
+        defaults: { name: { value: "" }, connection: { type: "odbc config", required: true }, query: { value: "" }, outputObj: { value: "payload" }, streaming: { value: false }, streamChunkSize: { value: 1, validate: RED.validators.number() }, querySource: { value: "query", required: false }, querySourceType: { value: "msg", required: false }, paramsSource: { value: "parameters", required: false }, paramsSourceType: { value: "msg", required: false } },
+        inputs: 1, outputs: 1, icon: "db.svg", label: function () { return this.name || "odbc"; },
         oneditprepare: function () {
-            this.editor = RED.editor.createEditor({
-                id: "node-input-query-editor",
-                mode: "ace/mode/sql",
-                value: this.query,
-            });
-            
-            $("#node-input-streaming").on("change", function() {
-                $(".stream-options").toggle(this.checked);
-            }).trigger("change");
-
-            $("#node-input-querySource").typedInput({
-                default: 'msg',
-                typeField: "#node-input-querySourceType",
-                types: ['msg', 'flow', 'global', 'env', 'str', 'jsonata']
-            });
-            
-            $("#node-input-paramsSource").typedInput({
-                default: 'msg',
-                typeField: "#node-input-paramsSourceType",
-                types: ['msg', 'flow', 'global', 'env', 'jsonata']
-            });
-        },
-        oneditsave: function () {
-            this.query = this.editor.getValue();
-            this.editor.destroy();
-            delete this.editor;
-        },
-        oneditcancel: function () {
-            this.editor.destroy();
-            delete this.editor;
+            this.editor = RED.editor.createEditor({ id: "node-input-query-editor", mode: "ace/mode/sql", value: this.query, });
+            $("#node-input-streaming").on("change", function() { $(".stream-options").toggle(this.checked); }).trigger("change");
+            $("#node-input-querySource").typedInput({ default: 'msg', typeField: "#node-input-querySourceType", types: ['msg', 'flow', 'global', 'env', 'str', 'jsonata'] });
+            $("#node-input-paramsSource").typedInput({ default: 'msg', typeField: "#node-input-paramsSourceType", types: ['msg', 'flow', 'global', 'env', 'jsonata'] });
         },
+        oneditsave: function () { this.query = this.editor.getValue(); this.editor.destroy(); delete this.editor; },
+        oneditcancel: function () { this.editor.destroy(); delete this.editor; },
     });
 </script>
 
 <script type="text/html" data-template-name="odbc">
-    <div class="form-row">
-        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" />
-    </div>
-    <div class="form-row">
-        <label for="node-input-connection"><i class="fa fa-cog"></i> Connection</label>
-        <input type="text" id="node-input-connection" />
-    </div>
-    <div class="form-row node-text-editor-row">
-        <label for="node-input-query" style="width: 100% !important;"><i class="fa fa-file-code-o"></i> Query (fallback)</label>
-        <div style="height: 250px;" class="node-text-editor" id="node-input-query-editor"></div>
-    </div>
-    <div class="form-row">
-        <label for="node-input-outputObj"><i class="fa fa-sign-out"></i> Result to</label>
-        <span>msg.</span><input type="text" id="node-input-outputObj" placeholder="payload" style="width: 64%;"/>
-    </div>
-    
+    <div class="form-row"> <label for="node-input-name"><i class="fa fa-tag"></i> Name</label> <input type="text" id="node-input-name" /> </div>
+    <div class="form-row"> <label for="node-input-connection"><i class="fa fa-cog"></i> Connection</label> <input type="text" id="node-input-connection" /> </div>
+    <div class="form-row node-text-editor-row"> <label for="node-input-query" style="width: 100% !important;"><i class="fa fa-file-code-o"></i> Query (fallback)</label> <div style="height: 250px;" class="node-text-editor" id="node-input-query-editor"></div> </div>
+    <div class="form-row"> <label for="node-input-outputObj"><i class="fa fa-sign-out"></i> Result to</label> <span>msg.</span><input type="text" id="node-input-outputObj" placeholder="payload" style="width: 64%;"/> </div>
     <hr/>
-    
-    <div class="form-row">
-        <label for="node-input-querySource"><i class="fa fa-crosshairs"></i> Query Source</label>
-        <input type="text" id="node-input-querySource" style="width: 70%;">
-        <input type="hidden" id="node-input-querySourceType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-paramsSource"><i class="fa fa-list-ol"></i> Parameters Source</label>
-        <input type="text" id="node-input-paramsSource" style="width: 70%;">
-        <input type="hidden" id="node-input-paramsSourceType">
-    </div>
-
+    <div class="form-row"> <label for="node-input-querySource"><i class="fa fa-crosshairs"></i> Query Source</label> <input type="text" id="node-input-querySource" style="width: 70%;"> <input type="hidden" id="node-input-querySourceType"> </div>
+    <div class="form-row"> <label for="node-input-paramsSource"><i class="fa fa-list-ol"></i> Parameters Source</label> <input type="text" id="node-input-paramsSource" style="width: 70%;"> <input type="hidden" id="node-input-paramsSourceType"> </div>
     <hr/>
-
-    <div class="form-row">
-        <label for="node-input-streaming" style="width: auto;"><i class="fa fa-arrows-v"></i> Stream Results</label>
-        <input type="checkbox" id="node-input-streaming" style="display: inline-block; width: auto; vertical-align: top;">
-    </div>
-    <div class="form-row stream-options">
-        <label for="node-input-streamChunkSize"><i class="fa fa-bars"></i> Chunk Size</label>
-        <input type="number" id="node-input-streamChunkSize" placeholder="1" style="width: 100px;">
-        <span class="form-tips">Number of rows per output message.</span>
-    </div>
+    <div class="form-row"> <label for="node-input-streaming" style="width: auto;"><i class="fa fa-arrows-v"></i> Stream Results</label> <input type="checkbox" id="node-input-streaming" style="display: inline-block; width: auto; vertical-align: top;"> </div>
+    <div class="form-row stream-options"> <label for="node-input-streamChunkSize"><i class="fa fa-bars"></i> Chunk Size</label> <input type="number" id="node-input-streamChunkSize" placeholder="1" style="width: 100px;"> <span class="form-tips">Number of rows per output message.</span> </div>
 </script>
 
 
 <script type="text/markdown" data-help-name="odbc config">
 A configuration node that manages the connection to your database.
-
 ### Connection Modes
 Version 2.0 introduces two ways to configure your connection:
-
 #### 1. Structured Fields Mode (Recommended)
 This is the easiest and most secure way to set up a connection for common databases.
 - **Database Type**: Select your database (e.g., SQL Server, PostgreSQL, MySQL). The node will use the appropriate driver name and connection string syntax. For unlisted databases, choose "Other" and provide the driver name manually.
@@ -400,49 +328,49 @@ This is the easiest and most secure way to set up a connection for common databa
 - **Database**: The name of the database to connect to (optional).
 - **User**: The username for authentication.
 - **Password**: The password for authentication. This is stored securely using Node-RED's credential system.
-
 #### 2. Connection String Mode (Advanced)
 This mode gives you full control for complex or non-standard connection strings.
 - **Connection String**: Enter the complete ODBC connection string. It is your responsibility to provide a valid string for your driver.
 
 ### Test Connection
 A **Test Connection** button in the configuration panel allows you to instantly verify your settings without deploying the flow.
+> **Note:** For security reasons, passwords are not reloaded into the editor. If your connection requires a password, you must **re-enter it** in the password field before clicking the test button (in Structured Mode). For Connection String mode, ensure the full string (including password if needed) is present in the connection string field itself.
 
-### Pool Options
-- **`initialSize`**: The number of connections to create when the pool is initialized. Default: 5.
-- **`maxSize`**: The maximum number of connections allowed in the pool. Default: 15.
-- (See `odbc` package documentation for more details on pool options).
+### Pool & Connection Options
+- **`Initial Pool Size`**: The number of connections to create when the pool is initialized. Default: 5.
+- **`Increment Pool Size`**: The number of connections to create when the pool is exhausted. Default: 5.
+- **`Max Pool Size`**: The maximum number of connections allowed in the pool. Default: 15.
+- **`Shrink Pool`**: If checked, reduces the number of connections to `Initial Pool Size` when they are returned to the pool if the pool has grown. Default: true.
+- **`Idle Timeout`**: The number of seconds for a connection in the pool to remain idle before closing. Default: 3 seconds.
+- **`Login Timeout`**: The number of seconds for an attempt to establish a new connection to succeed. Default: 5 seconds.
+- **`Query Timeout`**: The number of seconds for a query to execute before timing out. A value of **0** means infinite or uses the driver/database default. Default: 0 seconds.
 
 ### Error Handling & Retry
-- **`retryFreshConnection`**: If a query fails, the node will retry once with a brand new connection. If this succeeds, the entire connection pool is reset to clear any stale connections.
-- **`retryDelay`**: If both attempts fail, this sets a delay in seconds before another retry is attempted. A value of **0** disables further automatic retries.
-- **`retryOnMsg`**: If the node is waiting for a timed retry, a new incoming message can override the timer and trigger an immediate retry.
+- **`Retry with fresh connection`**: If a query fails using a connection from the pool, the node will try once more with a brand new, direct connection. If this succeeds, the entire connection pool is reset to clear any potentially stale connections.
+- **`Retry Delay`**: If all immediate attempts (pooled and, if enabled, fresh connection) fail, this sets a delay in seconds before another retry is attempted for the incoming message. A value of **0** disables this timed retry mechanism.
+- **`Retry on new message`**: If the node is waiting for a timed retry (due to `Retry Delay`), a new incoming message can, if this is checked, override the timer and trigger an immediate retry of the *original* message that failed.
 
 ### Advanced
 - **`syntaxChecker`**: If activated, the query string will be parsed and appended to the output message at `msg.parsedQuery`.
+- **`Syntax`**: The SQL dialect to use for the syntax checker (e.g., mysql, postgresql, etc.).
 </script>
 
 <script type="text/markdown" data-help-name="odbc">
 Executes a query against a configured ODBC data source.
 
 ### Inputs
-
 - **Query Source** (optional): Specify where to get the query string from. You can use a message property (`msg.`), flow context (`flow.`), global context (`global.`), an environment variable (`env.`), or a JSONata expression. If the source is empty or not found, the node will use the query from the "Query (fallback)" editor below.
   - *Default behavior (for backward compatibility): `msg.query`*
-
 - **Parameters Source** (optional): Specify where to get the parameters for a prepared statement. This should resolve to an array of values.
   - *Default behavior (for backward compatibility): `msg.parameters`*
 
 ### Properties
-
 - **Connection**: The `odbc config` node to use.
-- **Query (fallback)**: A static SQL query to run if the "Query (fallback)" does not provide one. Can contain Mustache syntax (e.g., `{{{payload.id}}}`).
+- **Query (fallback)**: A static SQL query to run if the "Query Source" 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
-
-For queries that return a large number of rows, streaming prevents high memory usage by sending multiple messages instead of one large one.
-
+For queries that return a large number of rows, streaming prevents high memory usage.
 - **`Stream Results`**: Enables or disables streaming mode.
 - **`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.
 
@@ -450,14 +378,13 @@ For queries that return a large number of rows, streaming prevents high memory u
 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 `[]`**.
+    -   The payload (or configured output property) 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.
+-   `index`: The starting index of the current chunk (0-based). For the completion message, this will be the total number of data rows processed.
+-   `count`: The number of rows in the current 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.

package/odbc.js

@@ -12,6 +12,12 @@ 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.closeOperationTimeout = 10000; // 10 secondes
+
         this._buildConnectionString = function() {
             if (this.config.connectionMode === 'structured') {
                 if (!this.config.dbType || !this.config.server) {
@@ -30,6 +36,8 @@ 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 || "";
@@ -45,11 +53,19 @@ module.exports = function (RED) {
                     const finalConnectionString = this._buildConnectionString();
                     if (!finalConnectionString) throw new Error("La chaîne de connexion est vide.");
                     
-                    const poolParams = { ...this.config };
+                    const poolParams = { ...this.config }; // Contient initialSize, maxSize, loginTimeout, connectionTimeout (idle) etc.
                     poolParams.connectionString = finalConnectionString;
 
-                    ['retryFreshConnection', 'retryDelay', 'retryOnMsg', 'syntax', 'connectionMode', 'dbType', 'server', 'database', 'user', 'driver'].forEach(k => delete poolParams[k]);
+                    // 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]);
                     
+                    // 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" });
@@ -62,49 +78,73 @@ 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}`, poolConnectError);
+                this.error(`Error connecting to pool: ${poolConnectError.message}`, poolConnectError);
                 this.status({ fill: "red", shape: "ring", text: "Pool connect err" });
                 throw poolConnectError;
             }
         };
 
         this.getFreshConnectionConfig = function() {
+            // Ces timeouts sont pour odbcModule.connect (connexion unique)
             return {
                 connectionString: this._buildConnectionString(),
-                connectionTimeout: parseInt(this.config.connectionTimeout) || 0,
-                loginTimeout: parseInt(this.config.loginTimeout) || 0,
+                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.
             };
         };
 
+        // MODIFIÉ: Ajout de timeout pour pool.close()
         this.resetPool = async () => {
-             if (this.pool) {
+            if (this.pool) {
                 this.log("Resetting connection pool.");
                 this.status({ fill: "yellow", shape: "ring", text: "Resetting pool..." });
+                let closedSuccessfully = false;
                 try {
-                    await this.pool.close();
+                    await Promise.race([
+                        this.pool.close(),
+                        new Promise((_, reject) => 
+                            setTimeout(() => reject(new Error('Pool close timeout')), this.closeOperationTimeout)
+                        )
+                    ]);
                     this.log("Connection pool closed successfully for reset.");
+                    closedSuccessfully = true;
                 } catch (closeError) {
-                    this.error(`Error closing pool during reset: ${closeError}`, closeError);
+                    this.error(`Error or timeout closing pool during reset: ${closeError.message}`, closeError);
                 } finally {
                     this.pool = null;
                     this.connecting = false;
+                    if (closedSuccessfully) {
+                        this.status({ fill: "grey", shape: "ring", text: "Pool reset" });
+                    } else {
+                        this.status({ fill: "red", shape: "ring", text: "Pool reset failed" });
+                    }
                 }
             } else {
                 this.log("Pool reset requested, but no active pool to reset.");
             }
         };
 
+        // 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) {
                 try {
-                    await this.pool.close();
+                    await Promise.race([
+                        this.pool.close(),
+                        new Promise((_, reject) => 
+                            setTimeout(() => reject(new Error('Pool close timeout on node close')), this.closeOperationTimeout)
+                        )
+                    ]);
                     this.log("Connection pool closed successfully on node close.");
-                    this.pool = null;
                 } catch (error) {
-                    this.error(`Error closing connection pool on node close: ${error}`, 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
                 }
             }
             done();
@@ -141,9 +181,7 @@ module.exports = function (RED) {
                 return parts.join(';');
             } else {
                 let connStr = tempConfig.connectionString || "";
-                if (!connStr) {
-                    throw new Error("La chaîne de connexion ne peut pas être vide.");
-                }
+                if (!connStr) { throw new Error("La chaîne de connexion ne peut pas être vide."); }
                 return connStr;
             }
         };
@@ -151,25 +189,20 @@ module.exports = function (RED) {
         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
+                loginTimeout: 10 // Déjà présent et correct
             };
             connection = await odbcModule.connect(connectionOptions);
             res.sendStatus(200);
         } catch (err) {
-            console.error("[ODBC Test] Connection failed:", err); // Ajout d'un log d'erreur
+            console.error("[ODBC Test] Connection failed:", err);
             res.status(500).send(err.message || "Erreur inconnue durant le test.");
         } finally {
             if (connection) {
-                await connection.close();
+                await connection.close(); // Fermeture simple, pas besoin de timeout ici car c'est une op rapide.
             }
         }
     });
@@ -180,90 +213,34 @@ module.exports = function (RED) {
         this.config = config;
         this.poolNode = RED.nodes.getNode(this.config.connection);
         this.name = this.config.name;
-
-        // 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 = "";
-                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;
-        };
+        // NOUVEAU: Timeout fixe pour les opérations de fermeture de curseur (en ms)
+        this.cursorCloseOperationTimeout = 5000; // 5 secondes
 
-        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);
-            const otherParams = {};
-            let actualDataRows = [];
-            if (result !== null && typeof result === "object") {
-                if (Array.isArray(result)) {
-                    actualDataRows = [...result];
-                    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, this.config.outputObj, actualDataRows);
-            if (Object.keys(otherParams).length) { newMsg.odbc = otherParams; }
-            return newMsg;
-        };
+        this.enhanceError = (error, query, params, defaultMessage = "Query error") => { /* ... (inchangé) ... */ };
+        this.executeQueryAndProcess = async (dbConnection, queryString, queryParams, msg) => { /* ... (inchangé) ... */ };
         
+        // MODIFIÉ: Ajout de timeout pour cursor.close()
         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;
+            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..." });
+        
                 let rowCount = 0;
                 let chunk = [];
+        
                 while (true) {
-                    const rows = await cursor.fetch();
+                    // 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);
@@ -276,51 +253,61 @@ 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) {
+                    try {
+                        // NOUVEAU: Timeout pour la fermeture du curseur
+                        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}`);
+                    }
+                }
             }
         };
 
+        // MODIFIÉ: Ajout de la définition du queryTimeout sur la connexion
         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
+                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;
-                    // 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
+                    if (done) done();
                     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.retryTimer) { clearTimeout(this.retryTimer); this.retryTimer = null; }
 
             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) => {
+    
+            const executeWithConnection = async (connection) => {
                 this.config.outputObj = this.config.outputObj || "payload";
                 const querySourceType = this.config.querySourceType || 'msg';
                 const querySource = this.config.querySource || 'query';
@@ -333,6 +320,19 @@ module.exports = function (RED) {
                 if (!isPreparedStatement && query) {
                     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)
+                }
+                
                 this.status({ fill: "blue", shape: "dot", text: "executing..." });
                 if (this.config.streaming) {
                     await this.executeStreamQuery(connection, query, params, msg, send);
@@ -342,15 +342,15 @@ module.exports = function (RED) {
                     send(newMsg);
                 }
             };
-
+    
             let connectionFromPool;
             let errorAfterInitialAttempts = null;
-
+    
             try {
                 this.status({ fill: "yellow", shape: "dot", text: "connecting..." });
                 connectionFromPool = await this.poolNode.connect();
-                await execute(connectionFromPool);
-                return done(); // Succès de la première tentative
+                await executeWithConnection(connectionFromPool);
+                return done();
             } catch (poolError) {
                 this.warn(`First attempt with pooled connection failed: ${poolError.message}`);
                 if (this.poolNode.config.retryFreshConnection) {
@@ -361,10 +361,10 @@ module.exports = function (RED) {
                         const freshConnectConfig = this.poolNode.getFreshConnectionConfig();
                         freshConnection = await odbcModule.connect(freshConnectConfig);
                         this.log("Fresh connection established for retry.");
-                        await execute(freshConnection);
+                        await executeWithConnection(freshConnection);
                         this.log("Query successful with fresh connection. Resetting pool.");
                         await this.poolNode.resetPool();
-                        return done(); // Succès de la tentative avec connexion fraîche
+                        return done();
                     } catch (freshError) {
                         errorAfterInitialAttempts = this.enhanceError(freshError, null, null, "Retry with fresh connection also failed");
                     } finally {
@@ -376,61 +376,40 @@ module.exports = function (RED) {
             } 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
-
+                const retryDelaySeconds = parseInt(this.poolNode.config.retryDelay, 10);
                 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.isAwaitingRetry = false;
                         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();
         });
-
+    
         if (this.poolNode) {
             this.status({ fill: "green", shape: "dot", text: "ready" });
         } else {
@@ -438,6 +417,6 @@ module.exports = function (RED) {
             this.warn("ODBC Config node not found or not deployed.");
         }
     }
-
+    
     RED.nodes.registerType("odbc", odbc);
 };

package/package.json

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