@celerispay/hazelcast-client 3.12.7-4 → 3.12.7-6

package/lib/invocation/ClientConnectionManager.d.ts

@@ -139,6 +139,13 @@ export declare class ClientConnectionManager extends EventEmitter {
      * Clears all stored credentials - used for single-node cluster reset
      */
     clearAllCredentials(): void;
+    /**
+     * Clears the failed connections blocklist so previously failed addresses
+     * can be retried immediately. Called after a cluster reset to ensure
+     * async destroyConnection() calls don't re-block addresses that were
+     * just unblocked for reconnection.
+     */
+    clearFailedConnections(): void;
     /**
      * Handles authentication errors by clearing failed connections and allowing retry
      * @param address The address that had authentication issues

package/lib/invocation/ClientConnectionManager.js

@@ -137,8 +137,10 @@ var ClientConnectionManager = /** @class */ (function (_super) {
             _this.failedConnections.delete(address.toString());
             return connection;
         }).catch(function (error) {
-            // Check if it's an authentication error
-            var isAuthError = error.message && (error.message.includes('Invalid Credentials') ||
+            // Check if it's an authentication error.
+            // error.message may be null when the server sends a null-message protocol error
+            // (e.g. ReferenceError: null from ErrorFactory), so we check for null explicitly.
+            var isAuthError = (error.message == null) || (error.message.includes('Invalid Credentials') ||
                 error.message.includes('authentication') ||
                 error.message.includes('credentials'));
             if (isAuthError) {
@@ -486,6 +488,17 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         this.failedConnections.clear();
         this.logger.info('ClientConnectionManager', '✅ All credentials cleared, ready for fresh authentication');
     };
+    /**
+     * Clears the failed connections blocklist so previously failed addresses
+     * can be retried immediately. Called after a cluster reset to ensure
+     * async destroyConnection() calls don't re-block addresses that were
+     * just unblocked for reconnection.
+     */
+    ClientConnectionManager.prototype.clearFailedConnections = function () {
+        var count = this.failedConnections.size;
+        this.failedConnections.clear();
+        this.logger.info('ClientConnectionManager', "\uD83D\uDD13 Cleared " + count + " failed connection entries, all addresses unblocked");
+    };
     /**
      * Handles authentication errors by clearing failed connections and allowing retry
      * @param address The address that had authentication issues

package/lib/invocation/ClusterService.d.ts

@@ -98,9 +98,20 @@ export declare class ClusterService {
     private onHeartbeatStopped(connection);
     private triggerFailover();
     /**
-     * Handles single-node cluster reset - treats node restart as fresh cluster
+     * Handles single-node node loss. Tears down all state immediately and starts
+     * a TCP probe loop. Only once the port accepts a raw TCP connection do we
+     * attempt the full Hazelcast handshake — eliminating the race between
+     * destroyConnection() re-adding failedConnections and our attempts to clear them.
      */
     private handleSingleNodeClusterReset();
+    /**
+     * Probes the single-node address with a raw TCP socket every probeIntervalMs.
+     * When the port responds (connect event), destroys the probe socket and
+     * calls connectToCluster() to perform the full Hazelcast authentication.
+     * If connectToCluster() fails (server still warming up), retries the probe.
+     * Stops if the client is shut down.
+     */
+    private startSingleNodeProbeLoop(address);
     /**
      * Handles multi-node failover - preserves existing logic
      */

package/lib/invocation/ClusterService.js

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var net = require("net");
 var Promise = require("bluebird");
 var ClientAddMembershipListenerCodec_1 = require("../codec/ClientAddMembershipListenerCodec");
 var ClientInfo_1 = require("../ClientInfo");
@@ -264,43 +265,78 @@ var ClusterService = /** @class */ (function () {
         }
     };
     /**
-     * Handles single-node cluster reset - treats node restart as fresh cluster
+     * Handles single-node node loss. Tears down all state immediately and starts
+     * a TCP probe loop. Only once the port accepts a raw TCP connection do we
+     * attempt the full Hazelcast handshake — eliminating the race between
+     * destroyConnection() re-adding failedConnections and our attempts to clear them.
      */
     ClusterService.prototype.handleSingleNodeClusterReset = function () {
-        var _this = this;
-        this.logger.info('ClusterService', '🧹 SINGLE-NODE RESET: Clearing all credentials and state...');
-        // Clear all stored credentials - node restart means fresh cluster
-        this.client.getConnectionManager().clearAllCredentials();
-        // Reset client UUIDs - will be assigned fresh by server
+        this.logger.info('ClusterService', 'SINGLE-NODE: Node lost. Tearing down state and starting TCP probe loop.');
+        // Full state teardown
         this.uuid = null;
         this.ownerUuid = null;
-        // Log state before reset
-        this.logCurrentState();
-        // Force cleanup of all dead connections
+        this.members = [];
+        this.client.getConnectionManager().clearAllCredentials();
+        this.client.getConnectionManager().clearFailedConnections();
         this.client.getConnectionManager().forceCleanupDeadConnections();
-        // Clear partition information
         this.client.getPartitionService().clearPartitionTable();
-        // IMPORTANT: Unblock all down addresses before attempting reconnection.
-        // The address was just marked as down by onConnectionClosed/onHeartbeatStopped,
-        // but connectToCluster() skips blocked addresses — so without clearing the block
-        // it will immediately fail with "Unable to connect to any address".
-        // clearAllCredentials() already clears failedConnections inside ConnectionManager.
-        this.logger.info('ClusterService', '🔓 SINGLE-NODE RESET: Unblocking all addresses for fresh reconnection...');
         this.downAddresses.clear();
-        // Direct reconnection without waiting for member events
-        this.logger.info('ClusterService', '🔄 SINGLE-NODE RESET: Attempting direct reconnection...');
-        this.connectToCluster()
-            .then(function () {
-            _this.logger.info('ClusterService', '✅ Single-node cluster reset completed successfully');
-            _this.logCurrentState();
-        })
-            .catch(function (error) {
-            _this.logger.error('ClusterService', 'Single-node cluster reset failed', error);
-            _this.logCurrentState();
-        })
-            .finally(function () {
-            _this.failoverInProgress = false;
-        });
+        // Start probing — reconnect only when the port actually accepts TCP
+        var address = this.knownAddresses[0];
+        this.startSingleNodeProbeLoop(address);
+    };
+    /**
+     * Probes the single-node address with a raw TCP socket every probeIntervalMs.
+     * When the port responds (connect event), destroys the probe socket and
+     * calls connectToCluster() to perform the full Hazelcast authentication.
+     * If connectToCluster() fails (server still warming up), retries the probe.
+     * Stops if the client is shut down.
+     */
+    ClusterService.prototype.startSingleNodeProbeLoop = function (address) {
+        var _this = this;
+        var probeIntervalMs = 3000;
+        var host = address.host;
+        var port = address.port;
+        this.logger.info('ClusterService', "SINGLE-NODE PROBE: Waiting for " + host + ":" + port + " to accept connections (probing every " + probeIntervalMs + "ms)...");
+        var attempt = function () {
+            if (!_this.client.getLifecycleService().isRunning()) {
+                _this.logger.info('ClusterService', 'SINGLE-NODE PROBE: Client is shutting down, stopping probe loop.');
+                _this.failoverInProgress = false;
+                return;
+            }
+            var socket = net.createConnection({ host: host, port: port });
+            socket.once('connect', function () {
+                socket.destroy();
+                _this.logger.info('ClusterService', "SINGLE-NODE PROBE: " + host + ":" + port + " is accepting connections. Reinitialising Hazelcast connection...");
+                // Clear both blocklists right before connecting — destroyConnection()
+                // may have re-added the address to failedConnections since the teardown above.
+                _this.downAddresses.clear();
+                _this.client.getConnectionManager().clearFailedConnections();
+                _this.connectToCluster()
+                    .then(function () {
+                    _this.logger.info('ClusterService', 'SINGLE-NODE: Reconnected successfully.');
+                    _this.logCurrentState();
+                    _this.failoverInProgress = false;
+                })
+                    .catch(function (err) {
+                    _this.logger.warn('ClusterService', "SINGLE-NODE: connectToCluster failed after probe success (" + err.message + "). Retrying probe...");
+                    // Server accepted TCP but Hazelcast not fully ready yet — probe again
+                    _this.downAddresses.clear();
+                    _this.client.getConnectionManager().clearFailedConnections();
+                    setTimeout(attempt, probeIntervalMs);
+                });
+            });
+            socket.once('error', function () {
+                socket.destroy();
+                setTimeout(attempt, probeIntervalMs);
+            });
+            // Guard against hung sockets that produce neither connect nor error
+            socket.setTimeout(2000, function () {
+                socket.destroy();
+                setTimeout(attempt, probeIntervalMs);
+            });
+        };
+        attempt();
     };
     /**
      * Handles multi-node failover - preserves existing logic

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celerispay/hazelcast-client",
-  "version": "3.12.7-4",
+  "version": "3.12.7-6",
   "description": "Hazelcast - open source In-Memory Data Grid - client for NodeJS with critical connection failover fixes",
   "main": "./lib/index.js",
   "scripts": {