@celerispay/hazelcast-client 3.12.5-1 → 3.12.5-10

package/lib/PartitionService.d.ts

@@ -11,9 +11,6 @@ export declare class PartitionService {
     private logger;
     private lastRefreshTime;
     private readonly minRefreshInterval;
-    private refreshInProgress;
-    private readonly maxRefreshRetries;
-    private refreshRetryCount;
     constructor(client: HazelcastClient);
     initialize(): Promise<void>;
     shutdown(): void;

package/lib/PartitionService.js

@@ -23,9 +23,6 @@ var PartitionService = /** @class */ (function () {
         this.partitionMap = {};
         this.lastRefreshTime = 0;
         this.minRefreshInterval = 2000; // Minimum 2 seconds between refreshes
-        this.refreshInProgress = false;
-        this.maxRefreshRetries = 3;
-        this.refreshRetryCount = 0;
         this.client = client;
         this.logger = client.getLoggingService().getLogger();
         this.isShutdown = false;
@@ -37,7 +34,6 @@ var PartitionService = /** @class */ (function () {
     PartitionService.prototype.shutdown = function () {
         clearInterval(this.partitionRefreshTask);
         this.isShutdown = true;
-        this.refreshInProgress = false;
     };
     /**
      * Clears the partition table, forcing a refresh on next operation
@@ -47,7 +43,6 @@ var PartitionService = /** @class */ (function () {
         this.partitionMap = {};
         this.partitionCount = 0;
         this.lastRefreshTime = 0;
-        this.refreshRetryCount = 0;
     };
     /**
      * Refreshes the internal partition table.
@@ -62,16 +57,11 @@ var PartitionService = /** @class */ (function () {
             this.logger.debug('PartitionService', 'Skipping refresh, too soon since last refresh');
             return Promise.resolve();
         }
-        if (this.refreshInProgress) {
-            this.logger.debug('PartitionService', 'Refresh already in progress, skipping');
-            return Promise.resolve();
-        }
         var ownerConnection = this.client.getClusterService().getOwnerConnection();
         if (ownerConnection == null) {
             this.logger.warn('PartitionService', 'Cannot refresh partitions, no owner connection available');
             return Promise.resolve();
         }
-        this.refreshInProgress = true;
         var clientMessage = GetPartitionsCodec.encodeRequest();
         return this.client.getInvocationService()
             .invokeOnConnection(ownerConnection, clientMessage)
@@ -80,21 +70,12 @@ var PartitionService = /** @class */ (function () {
             _this.partitionMap = receivedPartitionMap;
             _this.partitionCount = Object.keys(_this.partitionMap).length;
             _this.lastRefreshTime = now;
-            _this.refreshRetryCount = 0; // Reset retry count on success
             _this.logger.debug('PartitionService', "Refreshed partition table with " + _this.partitionCount + " partitions");
         }).catch(function (e) {
             if (_this.client.getLifecycleService().isRunning()) {
                 _this.logger.warn('PartitionService', 'Error while fetching cluster partition table from '
-                    + _this.client.getClusterService().ownerUuid, e);
-                // Increment retry count and clear table if too many failures
-                _this.refreshRetryCount++;
-                if (_this.refreshRetryCount >= _this.maxRefreshRetries) {
-                    _this.logger.error('PartitionService', "Max refresh retries (" + _this.maxRefreshRetries + ") exceeded, clearing partition table");
-                    _this.clearPartitionTable();
-                }
+                    + _this.client.getClusterService().ownerUuid || 'unknown', e);
             }
-        }).finally(function () {
-            _this.refreshInProgress = false;
         });
     };
     /**

package/lib/invocation/ClientConnection.d.ts

@@ -46,7 +46,12 @@ export declare class ClientConnection {
     private readonly socket;
     private readonly writer;
     private readonly reader;
+    private readonly logger;
     constructor(client: HazelcastClient, address: Address, socket: net.Socket);
+    /**
+     * Sets up socket event handlers for proper connection state tracking
+     */
+    private setupSocketEventHandlers();
     /**
      * Returns the address of local port that is associated with this connection.
      * @returns
@@ -65,7 +70,16 @@ export declare class ClientConnection {
      * Closes this connection.
      */
     close(): void;
+    /**
+     * Checks if the connection is alive and healthy
+     * @returns true if connection is alive, false otherwise
+     */
     isAlive(): boolean;
+    /**
+     * Performs a more thorough health check of the connection
+     * @returns true if connection is healthy, false otherwise
+     */
+    isHealthy(): boolean;
     isHeartbeating(): boolean;
     setHeartbeating(heartbeating: boolean): void;
     isAuthenticatedAsOwner(): boolean;

package/lib/invocation/ClientConnection.js

@@ -217,7 +217,36 @@ var ClientConnection = /** @class */ (function () {
             _this.lastWriteTimeMillis = Date.now();
         });
         this.reader = new FrameReader();
+        this.logger = client.getLoggingService().getLogger();
+        // Add socket event handlers for proper connection state tracking
+        this.setupSocketEventHandlers();
     }
+    /**
+     * Sets up socket event handlers for proper connection state tracking
+     */
+    ClientConnection.prototype.setupSocketEventHandlers = function () {
+        var _this = this;
+        // Handle socket close events
+        this.socket.on('close', function () {
+            _this.closedTime = Date.now();
+            _this.logger.debug('ClientConnection', "Socket closed for " + _this.address.toString());
+        });
+        // Handle socket end events
+        this.socket.on('end', function () {
+            _this.closedTime = Date.now();
+            _this.logger.debug('ClientConnection', "Socket ended by remote for " + _this.address.toString());
+        });
+        // Handle socket errors
+        this.socket.on('error', function (error) {
+            _this.logger.warn('ClientConnection', "Socket error for " + _this.address.toString() + ":", error);
+            // Don't set closedTime here as the socket might still be usable
+        });
+        // Handle socket timeout
+        this.socket.on('timeout', function () {
+            _this.logger.warn('ClientConnection', "Socket timeout for " + _this.address.toString());
+            // Don't set closedTime here as the socket might still be usable
+        });
+    };
     /**
      * Returns the address of local port that is associated with this connection.
      * @returns
@@ -254,8 +283,43 @@ var ClientConnection = /** @class */ (function () {
         this.socket.end();
         this.closedTime = Date.now();
     };
+    /**
+     * Checks if the connection is alive and healthy
+     * @returns true if connection is alive, false otherwise
+     */
     ClientConnection.prototype.isAlive = function () {
-        return this.closedTime === 0;
+        // Check if we've explicitly closed the connection
+        if (this.closedTime !== 0) {
+            return false;
+        }
+        // Check if the underlying socket is still connected
+        if (!this.socket || this.socket.destroyed) {
+            return false;
+        }
+        // Check if the socket is writable (indicates it's still connected)
+        if (!this.socket.writable) {
+            return false;
+        }
+        // Check if we've received data recently (within last 30 seconds)
+        var now = Date.now();
+        var lastReadThreshold = 30000; // 30 seconds
+        if (this.lastReadTimeMillis > 0 && (now - this.lastReadTimeMillis) > lastReadThreshold) {
+            // If we haven't received data for a while, the connection might be stale
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Performs a more thorough health check of the connection
+     * @returns true if connection is healthy, false otherwise
+     */
+    ClientConnection.prototype.isHealthy = function () {
+        if (!this.isAlive()) {
+            return false;
+        }
+        // Additional health checks can be added here
+        // For now, just check if we're still heartbeating
+        return this.isHeartbeating();
     };
     ClientConnection.prototype.isHeartbeating = function () {
         return this.heartbeating;

package/lib/invocation/ClientConnectionManager.d.ts

@@ -36,6 +36,37 @@ export declare class ClientConnectionManager extends EventEmitter {
     getActiveConnections(): {
         [address: string]: ClientConnection;
     };
+    /**
+     * Checks if we already have a connection to the given address
+     * @param address The address to check
+     * @returns true if connection exists and is healthy, false otherwise
+     */
+    hasConnection(address: Address): boolean;
+    /**
+     * Forces cleanup of all dead connections
+     * This is useful during failover to prevent connection leakage
+     */
+    forceCleanupDeadConnections(): void;
+    /**
+     * Gets an existing connection to a specific address if it exists
+     * @param address The address to check for existing connection
+     * @returns The existing connection or undefined if none exists
+     */
+    getConnection(address: Address): ClientConnection | undefined;
+    /**
+     * Gets all established connections
+     * @returns Object containing all established connections
+     */
+    getEstablishedConnections(): {
+        [address: string]: ClientConnection;
+    };
+    /**
+     * Gets all pending connections
+     * @returns Object containing all pending connections
+     */
+    getPendingConnections(): {
+        [address: string]: Promise.Resolver<ClientConnection>;
+    };
     /**
      * Returns the {@link ClientConnection} with given {@link Address}. If there is no such connection established,
      * it first connects to the address and then return the {@link ClientConnection}.
@@ -51,9 +82,14 @@ export declare class ClientConnectionManager extends EventEmitter {
     destroyConnection(address: Address): void;
     /**
      * Cleans up all connections to a specific address during failover
-     * @param address
+     * @param address The address to cleanup
      */
     cleanupConnectionsForFailover(address: Address): void;
+    /**
+     * Handles authentication errors by clearing failed connections and allowing retry
+     * @param address The address that had authentication issues
+     */
+    handleAuthenticationError(address: Address): void;
     shutdown(): void;
     private triggerConnect(address, asOwner);
     private connectTLSSocket(address, configOpts);

package/lib/invocation/ClientConnectionManager.js

@@ -98,6 +98,17 @@ var ClientConnectionManager = /** @class */ (function (_super) {
                 _this.destroyConnection(connection.getAddress());
             }
         });
+        // Log current connection state
+        var activeConnections = Object.keys(this.establishedConnections).length;
+        var pendingConnections = Object.keys(this.pendingConnections).length;
+        var failedConnections = this.failedConnections.size;
+        this.logger.debug('ClientConnectionManager', "Connection State - Active: " + activeConnections + ", Pending: " + pendingConnections + ", Failed: " + failedConnections);
+        if (activeConnections > 0) {
+            Object.keys(this.establishedConnections).forEach(function (addressStr) {
+                var connection = _this.establishedConnections[addressStr];
+                _this.logger.debug('ClientConnectionManager', "Connection to " + addressStr + ": Alive=" + connection.isAlive() + ", Owner=" + connection.isAuthenticatedAsOwner());
+            });
+        }
     };
     ClientConnectionManager.prototype.checkConnectionHealth = function () {
         // Use Object.keys() instead of Object.values() for compatibility
@@ -112,8 +123,8 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         }
     };
     ClientConnectionManager.prototype.isConnectionHealthy = function (connection) {
-        // Only check if connection is alive - isAuthenticated() method doesn't exist
-        return connection.isAlive();
+        // Use the improved health check method
+        return connection.isHealthy();
     };
     ClientConnectionManager.prototype.retryConnection = function (address, asOwner, retryCount) {
         var _this = this;
@@ -122,11 +133,21 @@ 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') ||
+                error.message.includes('authentication') ||
+                error.message.includes('credentials'));
+            if (isAuthError) {
+                _this.logger.error('ClientConnectionManager', "Authentication failed for " + address.toString() + ", not retrying: " + error.message);
+                // Handle authentication errors specially
+                _this.handleAuthenticationError(address);
+                throw error;
+            }
             if (retryCount < _this.maxConnectionRetries) {
                 _this.logger.warn('ClientConnectionManager', "Connection attempt " + (retryCount + 1) + " failed for " + address.toString() + ", retrying in " + _this.connectionRetryDelay + "ms");
-                return new Promise(function (resolve) {
+                return new Promise(function (resolve, reject) {
                     setTimeout(function () {
-                        _this.retryConnection(address, asOwner, retryCount + 1).then(resolve).catch(resolve);
+                        _this.retryConnection(address, asOwner, retryCount + 1).then(resolve).catch(reject);
                     }, _this.connectionRetryDelay);
                 });
             }
@@ -160,6 +181,73 @@ var ClientConnectionManager = /** @class */ (function (_super) {
     ClientConnectionManager.prototype.getActiveConnections = function () {
         return this.establishedConnections;
     };
+    /**
+     * Checks if we already have a connection to the given address
+     * @param address The address to check
+     * @returns true if connection exists and is healthy, false otherwise
+     */
+    ClientConnectionManager.prototype.hasConnection = function (address) {
+        var addressStr = address.toString();
+        var connection = this.establishedConnections[addressStr];
+        return connection && connection.isAlive();
+    };
+    /**
+     * Forces cleanup of all dead connections
+     * This is useful during failover to prevent connection leakage
+     */
+    ClientConnectionManager.prototype.forceCleanupDeadConnections = function () {
+        var _this = this;
+        this.logger.info('ClientConnectionManager', 'Forcing cleanup of all dead connections');
+        var addressesToRemove = [];
+        // Check all established connections
+        Object.keys(this.establishedConnections).forEach(function (addressStr) {
+            var connection = _this.establishedConnections[addressStr];
+            if (connection && !connection.isHealthy()) {
+                _this.logger.warn('ClientConnectionManager', "Found dead connection to " + addressStr + ", marking for cleanup");
+                addressesToRemove.push(addressStr);
+            }
+        });
+        // Remove dead connections
+        addressesToRemove.forEach(function (addressStr) {
+            var connection = _this.establishedConnections[addressStr];
+            if (connection) {
+                _this.destroyConnection(connection.getAddress());
+            }
+        });
+        // Also clean up any pending connections that might be stuck
+        Object.keys(this.pendingConnections).forEach(function (addressStr) {
+            var pendingConnection = _this.pendingConnections[addressStr];
+            if (pendingConnection) {
+                _this.logger.warn('ClientConnectionManager', "Cleaning up stuck pending connection to " + addressStr);
+                pendingConnection.reject(new Error('Connection cleanup forced'));
+                delete _this.pendingConnections[addressStr];
+            }
+        });
+        this.logger.info('ClientConnectionManager', "Cleanup completed. Removed " + addressesToRemove.length + " dead connections");
+    };
+    /**
+     * Gets an existing connection to a specific address if it exists
+     * @param address The address to check for existing connection
+     * @returns The existing connection or undefined if none exists
+     */
+    ClientConnectionManager.prototype.getConnection = function (address) {
+        var addressStr = address.toString();
+        return this.establishedConnections[addressStr];
+    };
+    /**
+     * Gets all established connections
+     * @returns Object containing all established connections
+     */
+    ClientConnectionManager.prototype.getEstablishedConnections = function () {
+        return this.establishedConnections;
+    };
+    /**
+     * Gets all pending connections
+     * @returns Object containing all pending connections
+     */
+    ClientConnectionManager.prototype.getPendingConnections = function () {
+        return this.pendingConnections;
+    };
     /**
      * Returns the {@link ClientConnection} with given {@link Address}. If there is no such connection established,
      * it first connects to the address and then return the {@link ClientConnection}.
@@ -195,6 +283,13 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         this.pendingConnections[addressIndex] = connectionResolver;
         this.retryConnection(address, asOwner)
             .then(function (clientConnection) {
+            // Safety check: ensure we got a proper ClientConnection
+            if (!clientConnection || typeof clientConnection.getAddress !== 'function') {
+                var error = new Error("Invalid connection object returned: " + typeof clientConnection);
+                _this.logger.error('ClientConnectionManager', error.message);
+                connectionResolver.reject(error);
+                return;
+            }
             _this.establishedConnections[clientConnection.getAddress().toString()] = clientConnection;
             _this.onConnectionOpened(clientConnection);
             connectionResolver.resolve(clientConnection);
@@ -243,7 +338,7 @@ var ClientConnectionManager = /** @class */ (function (_super) {
     };
     /**
      * Cleans up all connections to a specific address during failover
-     * @param address
+     * @param address The address to cleanup
      */
     ClientConnectionManager.prototype.cleanupConnectionsForFailover = function (address) {
         var addressStr = address.toString();
@@ -253,6 +348,27 @@ var ClientConnectionManager = /** @class */ (function (_super) {
         // Remove from failed connections to allow reconnection after failover
         this.failedConnections.delete(addressStr);
     };
+    /**
+     * Handles authentication errors by clearing failed connections and allowing retry
+     * @param address The address that had authentication issues
+     */
+    ClientConnectionManager.prototype.handleAuthenticationError = function (address) {
+        var addressStr = address.toString();
+        this.logger.warn('ClientConnectionManager', "Handling authentication error for " + addressStr);
+        // Clear from failed connections to allow retry with fresh credentials
+        this.failedConnections.delete(addressStr);
+        // Also clear any established connections to this address
+        if (this.establishedConnections.hasOwnProperty(addressStr)) {
+            this.logger.info('ClientConnectionManager', "Clearing established connection to " + addressStr + " due to auth error");
+            this.destroyConnection(address);
+        }
+        // Clear any pending connections
+        if (this.pendingConnections.hasOwnProperty(addressStr)) {
+            this.logger.info('ClientConnectionManager', "Clearing pending connection to " + addressStr + " due to auth error");
+            this.pendingConnections[addressStr].reject(new Error('Authentication error, connection cleared'));
+            delete this.pendingConnections[addressStr];
+        }
+    };
     ClientConnectionManager.prototype.shutdown = function () {
         if (this.connectionHealthCheckInterval) {
             clearInterval(this.connectionHealthCheckInterval);

package/lib/invocation/ClusterService.d.ts

@@ -47,6 +47,10 @@ export declare class ClusterService {
      */
     connectToCluster(): Promise<void>;
     getPossibleMemberAddresses(): Promise<string[]>;
+    /**
+     * Returns the owner connection if available
+     */
+    getOwnerConnection(): ClientConnection | null;
     /**
      * Returns the list of members in the cluster.
      * @returns
@@ -63,11 +67,6 @@ export declare class ClusterService {
      * @returns {ClientInfo}
      */
     getClientInfo(): ClientInfo;
-    /**
-     * Returns the connection associated with owner node of this client.
-     * @returns {ClientConnection}
-     */
-    getOwnerConnection(): ClientConnection;
     /**
      * Adds MembershipListener to listen for membership updates. There is no check for duplicate registrations,
      * so if you register the listener twice, it will get events twice.
@@ -87,6 +86,10 @@ export declare class ClusterService {
     private onConnectionClosed(connection);
     private onHeartbeatStopped(connection);
     private triggerFailover();
+    /**
+     * Attempts emergency recovery when failover fails
+     */
+    private attemptEmergencyRecovery();
     private isAddressKnownDown(address);
     private markAddressAsDown(address);
     private getDownAddressesInfo();
@@ -98,7 +101,15 @@ export declare class ClusterService {
     private handleMemberAttributeChange(uuid, key, operationType, value);
     private memberAdded(member);
     private memberRemoved(member);
+    /**
+     * Logs the current state for debugging purposes
+     */
+    private logCurrentState();
     private startReconnectionTask();
+    /**
+     * Starts a periodic task to log the current state for debugging
+     */
+    private startStateLoggingTask();
     private attemptReconnectionToFailedNodes();
     /**
      * Attempts to establish a connection to a specific address

package/lib/invocation/ClusterService.js

@@ -50,13 +50,14 @@ var ClusterService = /** @class */ (function () {
         this.lastFailoverAttempt = 0;
         this.failoverCooldown = 5000; // 5 seconds cooldown between failover attempts
         this.downAddresses = new Map(); // address -> timestamp when marked down
-        this.addressBlockDuration = 30000; // 30 seconds block duration for down addresses
+        this.addressBlockDuration = 15000; // Reduced from 30000ms to 15000ms
         this.reconnectionTask = null;
         this.reconnectionInterval = 10000; // 10 seconds between reconnection attempts
         this.client = client;
         this.logger = this.client.getLoggingService().getLogger();
         this.members = [];
         this.startReconnectionTask();
+        this.startStateLoggingTask();
     }
     /**
      * Starts cluster service.
@@ -102,6 +103,12 @@ var ClusterService = /** @class */ (function () {
             return Array.from(new Set(Array.from(addresses).concat(Array.from(providerAddresses))));
         });
     };
+    /**
+     * Returns the owner connection if available
+     */
+    ClusterService.prototype.getOwnerConnection = function () {
+        return this.ownerConnection;
+    };
     /**
      * Returns the list of members in the cluster.
      * @returns
@@ -143,16 +150,15 @@ var ClusterService = /** @class */ (function () {
     ClusterService.prototype.getClientInfo = function () {
         var info = new ClientInfo_1.ClientInfo();
         info.uuid = this.uuid;
-        info.localAddress = this.getOwnerConnection().getLocalAddress();
+        var ownerConnection = this.getOwnerConnection();
+        if (ownerConnection) {
+            info.localAddress = ownerConnection.getLocalAddress();
+        }
+        else {
+            info.localAddress = null;
+        }
         return info;
     };
-    /**
-     * Returns the connection associated with owner node of this client.
-     * @returns {ClientConnection}
-     */
-    ClusterService.prototype.getOwnerConnection = function () {
-        return this.ownerConnection;
-    };
     /**
      * Adds MembershipListener to listen for membership updates. There is no check for duplicate registrations,
      * so if you register the listener twice, it will get events twice.
@@ -184,7 +190,11 @@ var ClusterService = /** @class */ (function () {
             var handleAttributeChange = _this.handleMemberAttributeChange.bind(_this);
             ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.handle(m, handleMember, handleMemberList, handleAttributeChange, null);
         };
-        return this.client.getInvocationService().invokeOnConnection(this.getOwnerConnection(), request, handler)
+        var ownerConnection = this.getOwnerConnection();
+        if (!ownerConnection) {
+            return Promise.reject(new Error('Cannot initialize membership listener: no owner connection available'));
+        }
+        return this.client.getInvocationService().invokeOnConnection(ownerConnection, request, handler)
             .then(function (resp) {
             _this.logger.trace('ClusterService', 'Registered listener with id '
                 + ClientAddMembershipListenerCodec_1.ClientAddMembershipListenerCodec.decodeResponse(resp).response);
@@ -227,22 +237,64 @@ var ClusterService = /** @class */ (function () {
         this.failoverInProgress = true;
         this.lastFailoverAttempt = now;
         this.logger.info('ClusterService', 'Starting failover process...');
+        // Log state before failover
+        this.logCurrentState();
+        // Force cleanup of all dead connections to prevent leakage
+        this.client.getConnectionManager().forceCleanupDeadConnections();
         // Clear any stale partition information
         this.client.getPartitionService().clearPartitionTable();
         // Attempt to reconnect to cluster
         this.connectToCluster()
             .then(function () {
             _this.logger.info('ClusterService', 'Failover completed successfully');
+            _this.logCurrentState(); // Log state after successful failover
         })
             .catch(function (error) {
             _this.logger.error('ClusterService', 'Failover failed', error);
-            // If failover fails, shutdown the client to prevent further issues
-            _this.client.shutdown();
+            // If failover fails, try to unblock at least one address to allow recovery
+            _this.attemptEmergencyRecovery();
+            _this.logCurrentState(); // Log state after failed failover
+            // Don't shutdown immediately, give recovery a chance
         })
             .finally(function () {
             _this.failoverInProgress = false;
         });
     };
+    /**
+     * Attempts emergency recovery when failover fails
+     */
+    ClusterService.prototype.attemptEmergencyRecovery = function () {
+        var _this = this;
+        this.logger.warn('ClusterService', 'Attempting emergency recovery...');
+        // Unblock at least one address to allow recovery
+        if (this.downAddresses.size > 0) {
+            var firstBlockedAddress_1 = Array.from(this.downAddresses.keys())[0];
+            this.logger.info('ClusterService', "Emergency unblocking address " + firstBlockedAddress_1);
+            this.downAddresses.delete(firstBlockedAddress_1);
+            // Try to connect to the unblocked address
+            try {
+                var _a = firstBlockedAddress_1.split(':'), host = _a[0], portStr = _a[1];
+                var port = parseInt(portStr, 10);
+                if (host && !isNaN(port)) {
+                    var address_1 = new Address(host, port);
+                    this.logger.info('ClusterService', "Attempting emergency connection to " + firstBlockedAddress_1);
+                    // Try to connect without blocking
+                    this.client.getConnectionManager().getOrConnect(address_1, false)
+                        .then(function (connection) {
+                        _this.logger.info('ClusterService', "Emergency connection successful to " + firstBlockedAddress_1);
+                        _this.evaluateOwnershipChange(address_1, connection);
+                        _this.client.getPartitionService().refresh();
+                    })
+                        .catch(function (error) {
+                        _this.logger.warn('ClusterService', "Emergency connection failed to " + firstBlockedAddress_1 + ":", error);
+                    });
+                }
+            }
+            catch (error) {
+                this.logger.error('ClusterService', 'Error during emergency recovery:', error);
+            }
+        }
+    };
     ClusterService.prototype.isAddressKnownDown = function (address) {
         var addressStr = address.toString();
         var downTime = this.downAddresses.get(addressStr);
@@ -349,6 +401,8 @@ var ClusterService = /** @class */ (function () {
         this.members = members;
         this.client.getPartitionService().refresh();
         this.logger.info('ClusterService', 'Members received.', this.members);
+        // Log current state after member list update
+        this.logCurrentState();
         var events = this.detectMembershipEvents(prevMembers);
         for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
             var event = events_1[_i];
@@ -416,10 +470,55 @@ var ClusterService = /** @class */ (function () {
             var removedMemberList = this.members.splice(memberIndex, 1);
             assert(removedMemberList.length === 1);
         }
-        this.client.getConnectionManager().destroyConnection(member.address);
+        // Check if we have a healthy connection to this member
+        var connectionManager = this.client.getConnectionManager();
+        var existingConnection = connectionManager.getConnection(member.address);
+        if (existingConnection && existingConnection.isHealthy()) {
+            // If the connection is healthy, don't destroy it immediately
+            // This prevents unnecessary disconnections during temporary network issues
+            this.logger.info('ClusterService', "Member removed but connection is healthy: " + member.address.toString() + ", preserving connection");
+            // Only destroy if we're not in failover mode
+            if (!this.failoverInProgress) {
+                this.logger.debug('ClusterService', "Destroying healthy connection to removed member: " + member.address.toString());
+                connectionManager.destroyConnection(member.address);
+            }
+            else {
+                this.logger.debug('ClusterService', "Preserving healthy connection during failover: " + member.address.toString());
+            }
+        }
+        else {
+            // If connection is unhealthy, destroy it
+            this.logger.info('ClusterService', "Member removed with unhealthy connection: " + member.address.toString() + ", destroying connection");
+            connectionManager.destroyConnection(member.address);
+        }
         var membershipEvent = new MembershipEvent_1.MembershipEvent(member, MemberEvent.REMOVED, this.members);
         this.fireMembershipEvent(membershipEvent);
     };
+    /**
+     * Logs the current state for debugging purposes
+     */
+    ClusterService.prototype.logCurrentState = function () {
+        var _this = this;
+        var activeConnections = Object.keys(this.client.getConnectionManager().getEstablishedConnections()).length;
+        var memberCount = this.members.length;
+        var downAddressesCount = this.downAddresses.size;
+        var hasOwner = !!this.ownerConnection;
+        this.logger.info('ClusterService', "Current State - Members: " + memberCount + ", Active Connections: " + activeConnections + ", Down Addresses: " + downAddressesCount + ", Has Owner: " + hasOwner);
+        if (this.ownerConnection) {
+            this.logger.info('ClusterService', "Owner Connection: " + this.ownerConnection.getAddress().toString() + ", Alive: " + this.ownerConnection.isAlive());
+        }
+        // Log all active connections
+        var connections = this.client.getConnectionManager().getEstablishedConnections();
+        Object.keys(connections).forEach(function (addressStr) {
+            var connection = connections[addressStr];
+            _this.logger.debug('ClusterService', "Connection to " + addressStr + ": Alive=" + connection.isAlive() + ", Owner=" + connection.isAuthenticatedAsOwner());
+        });
+        // Log down addresses
+        if (downAddressesCount > 0) {
+            var downAddresses = Array.from(this.downAddresses.keys());
+            this.logger.debug('ClusterService', "Down Addresses: " + downAddresses.join(', '));
+        }
+    };
     ClusterService.prototype.startReconnectionTask = function () {
         var _this = this;
         // Periodically attempt to reconnect to previously failed addresses
@@ -427,15 +526,29 @@ var ClusterService = /** @class */ (function () {
             _this.attemptReconnectionToFailedNodes();
         }, this.reconnectionInterval);
     };
+    /**
+     * Starts a periodic task to log the current state for debugging
+     */
+    ClusterService.prototype.startStateLoggingTask = function () {
+        var _this = this;
+        // Log state every 30 seconds for debugging
+        setInterval(function () {
+            if (_this.client.getLifecycleService().isRunning()) {
+                _this.logCurrentState();
+            }
+        }, 30000);
+    };
     ClusterService.prototype.attemptReconnectionToFailedNodes = function () {
         var _this = this;
-        if (this.failoverInProgress || !this.ownerConnection) {
+        // Allow reconnection even during failover, but be more careful
+        if (this.failoverInProgress) {
+            this.logger.debug('ClusterService', 'Skipping reconnection attempt during failover');
             return;
         }
         var now = Date.now();
         var addressesToReconnect = [];
         var totalDownAddresses = this.downAddresses.size;
-        // If we have no down addresses, we can increase the reconnection interval
+        // If we have no down addresses, we can skip
         if (totalDownAddresses === 0) {
             return;
         }
@@ -449,6 +562,12 @@ var ClusterService = /** @class */ (function () {
                     var port = parseInt(portStr, 10);
                     if (host && !isNaN(port)) {
                         var address = new Address(host, port);
+                        // Check if we already have a connection to this address
+                        if (_this.client.getConnectionManager().hasConnection(address)) {
+                            _this.logger.debug('ClusterService', "Already have active connection to " + addressStr + ", removing from down addresses");
+                            _this.downAddresses.delete(addressStr);
+                            return;
+                        }
                         addressesToReconnect.push(address);
                     }
                 }
@@ -474,6 +593,8 @@ var ClusterService = /** @class */ (function () {
             });
             this.logger.debug('ClusterService', "Still waiting for " + totalDownAddresses + " addresses to unblock: " + remainingBlocked.join(', '));
         }
+        // Log current state after reconnection attempts
+        this.logCurrentState();
     };
     /**
      * Attempts to establish a connection to a specific address
@@ -482,6 +603,20 @@ var ClusterService = /** @class */ (function () {
     ClusterService.prototype.attemptReconnectionToAddress = function (address) {
         var _this = this;
         var addressStr = address.toString();
+        // Check if we already have a connection to this address
+        if (this.client.getConnectionManager().hasConnection(address)) {
+            this.logger.debug('ClusterService', "Already have active connection to " + addressStr + ", skipping reconnection");
+            this.downAddresses.delete(addressStr);
+            return;
+        }
+        // Check if we're already trying to connect to this address
+        var connectionManager = this.client.getConnectionManager();
+        var establishedConnections = connectionManager.getEstablishedConnections();
+        var pendingConnections = Object.keys(connectionManager.getPendingConnections()).length;
+        if (pendingConnections > 0) {
+            this.logger.debug('ClusterService', "Already have pending connections, skipping reconnection to " + addressStr);
+            return;
+        }
         // Remove from down addresses to allow connection attempt
         this.downAddresses.delete(addressStr);
         this.logger.debug('ClusterService', "Attempting reconnection to " + addressStr);
@@ -489,8 +624,14 @@ var ClusterService = /** @class */ (function () {
         this.client.getConnectionManager().getOrConnect(address, false)
             .then(function (connection) {
             _this.logger.info('ClusterService', "Successfully reconnected to " + addressStr);
-            // Check if this reconnected node should become the new owner
-            _this.evaluateOwnershipChange(address, connection);
+            // 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);
+            }
+            else {
+                _this.logger.debug('ClusterService', "Keeping " + addressStr + " as member connection, current owner is healthy");
+            }
             // Trigger partition service refresh to update routing information
             _this.client.getPartitionService().refresh();
         }).catch(function (error) {
@@ -518,12 +659,8 @@ var ClusterService = /** @class */ (function () {
             this.promoteToOwner(connection, address);
             return;
         }
-        // Check if this reconnected node was previously our owner (by checking if it's in our known addresses)
-        var wasPreviousOwner = this.knownAddresses.some(function (knownAddr) { return knownAddr.equals(address); });
-        if (wasPreviousOwner) {
-            this.logger.debug('ClusterService', "Reconnected node " + address.toString() + " was previously known, monitoring for ownership opportunity");
-            // Don't switch ownership immediately, but keep the connection for potential future use
-        }
+        // Don't switch ownership if current owner is healthy
+        this.logger.debug('ClusterService', "Current owner is healthy, keeping " + address.toString() + " as member connection");
     };
     /**
      * Promotes a connection to owner status
@@ -559,6 +696,18 @@ var ClusterService = /** @class */ (function () {
         var _this = this;
         var addressStr = address.toString();
         var now = Date.now();
+        // Don't block if we already have a healthy connection to this address
+        if (this.client.getConnectionManager().hasConnection(address)) {
+            this.logger.debug('ClusterService', "Not blocking " + addressStr + " as we have a healthy connection");
+            return;
+        }
+        // Don't block if this would leave us with no available nodes
+        var totalDownAddresses = this.downAddresses.size;
+        var totalMembers = this.members.length;
+        if (totalDownAddresses >= totalMembers - 1) {
+            this.logger.warn('ClusterService', "Not blocking " + addressStr + " as it would leave us with no available nodes");
+            return;
+        }
         this.downAddresses.set(addressStr, now);
         this.logger.warn('ClusterService', "Marked address " + addressStr + " as down, will be blocked for " + blockDuration + "ms");
         // Schedule cleanup of this address after block duration

package/lib/invocation/InvocationService.js

@@ -289,6 +289,10 @@ var InvocationService = /** @class */ (function () {
                     throw new Error("Still no partition owner for partition " + partitionId + " after refresh");
                 }
                 return _this.invokeOnAddress(invocation, newOwnerAddress);
+            }).catch(function (error) {
+                _this.logger.error('InvocationService', "Failed to refresh partition table for partition " + partitionId + ":", error);
+                // If partition refresh fails, reject the invocation instead of hanging
+                throw new Error("Cannot find partition owner for partition " + partitionId + ": " + error.message);
             });
         }
         return this.client.getConnectionManager().getOrConnect(ownerAddress).then(function (connection) {
@@ -301,6 +305,10 @@ var InvocationService = /** @class */ (function () {
                 return _this.client.getPartitionService().refresh().then(function () {
                     // Retry the invocation with updated partition information
                     return _this.doInvoke(invocation);
+                }).catch(function (refreshError) {
+                    _this.logger.error('InvocationService', "Failed to refresh partition table after partition owner failure:", refreshError);
+                    // If refresh fails, reject the invocation instead of hanging
+                    throw new Error("Partition owner " + ownerAddress.toString() + " unavailable and partition refresh failed: " + refreshError.message);
                 });
             }
             throw new HazelcastError_1.IOError(ownerAddress.toString() + '(partition owner) is not available.', e);

package/lib/proxy/ProxyManager.js

@@ -130,20 +130,32 @@ var ProxyManager = /** @class */ (function () {
     };
     ProxyManager.prototype.findNextAddress = function () {
         var members = this.client.getClusterService().getMembers();
+        // If no members available, return null but log the issue
+        if (!members || members.length === 0) {
+            this.logger.warn('ProxyManager', 'No cluster members available for proxy creation');
+            return null;
+        }
         var liteMember = null;
+        var dataMember = null;
         for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
             var member = members_1[_i];
             if (member != null && member.isLiteMember === false) {
-                return member.address;
+                dataMember = member;
+                break; // Prefer data members
             }
             else if (member != null && member.isLiteMember) {
                 liteMember = member;
             }
         }
-        if (liteMember != null) {
+        // Return data member if available, otherwise lite member, otherwise null
+        if (dataMember != null) {
+            return dataMember.address;
+        }
+        else if (liteMember != null) {
             return liteMember.address;
         }
         else {
+            this.logger.warn('ProxyManager', 'No valid members found for proxy creation');
             return null;
         }
     };
@@ -151,6 +163,12 @@ var ProxyManager = /** @class */ (function () {
         var _this = this;
         if (Date.now() <= deadline) {
             var address = this.findNextAddress();
+            if (!address) {
+                var error = new Error('No cluster members available for proxy creation: ' + proxyObject.getName());
+                this.logger.error('ProxyManager', error.message);
+                promise.reject(error);
+                return;
+            }
             var request = ClientCreateProxyCodec_1.ClientCreateProxyCodec.encodeRequest(proxyObject.getName(), proxyObject.getServiceName(), address);
             var invocation = new InvocationService_1.Invocation(this.client, request);
             invocation.address = address;
@@ -160,10 +178,13 @@ var ProxyManager = /** @class */ (function () {
                 if (_this.isRetryable(error)) {
                     _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() +
                         ' failed. Retrying in ' + _this.invocationRetryPauseMillis + 'ms. ' + error);
-                    setTimeout(_this.initializeProxy.bind(_this, proxyObject, promise, deadline), _this.invocationRetryPauseMillis);
+                    setTimeout(function () {
+                        _this.initializeProxy(proxyObject, promise, deadline);
+                    }, _this.invocationRetryPauseMillis);
                 }
                 else {
-                    _this.logger.warn('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
+                    _this.logger.error('ProxyManager', 'Create proxy request for ' + proxyObject.getName() + ' failed ' + error);
+                    promise.reject(error);
                 }
             });
         }

package/package.json

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