@celerispay/hazelcast-client 3.12.7-3 → 3.12.7-5

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.js

@@ -280,20 +280,32 @@ var ClusterService = /** @class */ (function () {
         this.client.getConnectionManager().forceCleanupDeadConnections();
         // Clear partition information
         this.client.getPartitionService().clearPartitionTable();
-        // 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;
-        });
+        // IMPORTANT: Unblock all down addresses before attempting reconnection.
+        // We must clear BOTH blocklists:
+        //   1. this.downAddresses  — ClusterService-level block (checked by tryConnectingToAddresses)
+        //   2. failedConnections   — ClientConnectionManager-level block (checked by getOrConnect)
+        // We delay by 200ms to let any in-flight async destroyConnection() calls finish,
+        // because destroyConnection() re-adds the address to failedConnections after we clear it.
+        // Clearing both right before connectToCluster() ensures neither blocklist interferes.
+        this.logger.info('ClusterService', '🔓 SINGLE-NODE RESET: Scheduling reconnection after brief stabilization delay...');
+        setTimeout(function () {
+            // Clear both blocklists right before attempting reconnection
+            _this.downAddresses.clear();
+            _this.client.getConnectionManager().clearFailedConnections();
+            _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;
+            });
+        }, 200);
     };
     /**
      * Handles multi-node failover - preserves existing logic
@@ -806,21 +818,35 @@ var ClusterService = /** @class */ (function () {
         }
         // Remove from down addresses to allow connection attempt
         this.downAddresses.delete(addressStr);
-        this.logger.debug('ClusterService', "Attempting reconnection to " + addressStr);
-        // Attempt to establish connection (not as owner, just as regular member connection)
-        this.client.getConnectionManager().getOrConnect(address, false)
+        // Determine whether to connect as owner.
+        // If we have no owner connection (e.g. after a single-node restart), we must
+        // authenticate as owner so the server assigns fresh UUIDs. Connecting as a
+        // non-owner with null UUIDs will always be rejected by the server.
+        var needsOwner = !this.ownerConnection || !this.ownerConnection.isHealthy();
+        var connectAsOwner = needsOwner;
+        this.logger.info('ClusterService', "Attempting reconnection to " + addressStr + " (asOwner=" + connectAsOwner + ", needsOwner=" + needsOwner + ")");
+        this.client.getConnectionManager().getOrConnect(address, connectAsOwner)
             .then(function (connection) {
             _this.logger.info('ClusterService', "Successfully reconnected to " + addressStr);
-            // Only evaluate ownership change if we don't have an owner or current owner is unhealthy
-            if (!_this.ownerConnection || !_this.ownerConnection.isHealthy()) {
-                _this.logger.info('ClusterService', "Evaluating ownership change for " + addressStr);
-                _this.evaluateOwnershipChange(address, connection);
+            if (connectAsOwner) {
+                // We authenticated as owner — make it official and re-register membership listener
+                connection.setAuthenticatedAsOwner(true);
+                _this.ownerConnection = connection;
+                _this.logger.info('ClusterService', "Promoted " + addressStr + " to owner after reconnection");
+                // Re-register membership listener so member events resume
+                return _this.initMembershipListener().then(function () {
+                    _this.logger.info('ClusterService', "Membership listener re-registered after reconnection to " + addressStr);
+                    _this.client.getPartitionService().refresh();
+                }).catch(function (err) {
+                    _this.logger.warn('ClusterService', "Failed to re-register membership listener after reconnection: " + err.message);
+                    _this.client.getPartitionService().refresh();
+                });
             }
             else {
+                // Non-owner: evaluate if ownership should change (multi-node case)
                 _this.logger.debug('ClusterService', "Keeping " + addressStr + " as member connection, current owner is healthy");
+                _this.client.getPartitionService().refresh();
             }
-            // Trigger partition service refresh to update routing information
-            _this.client.getPartitionService().refresh();
         }).catch(function (error) {
             _this.logger.warn('ClusterService', "Reconnection attempt to " + addressStr + " failed:", error);
             // Mark the address as down again, but with a shorter block duration for reconnection attempts

package/package.json

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