refactor: improve WebSocket health monitoring implementation

- Use constants for health check thresholds
- Simplify keepAliveTimestamp logic per PR feedback
- Improve type safety with proper storage interface
- Clean up code formatting and linting

Co-authored-by: bobbor <bobbor@github.com>

Author: anivar

packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts

@@ -51,25 +51,33 @@ import {
 } from './appsyncUrl';
 import { awsRealTimeHeaderBasedAuth } from './authHeaders';
 
-// Platform-safe AsyncStorage import
-let AsyncStorage: Pick<KeyValueStorageInterface, 'setItem' | 'getItem'> | null;
+// Storage key for persistent keep-alive tracking
+const KEEP_ALIVE_STORAGE_KEY = 'AWS_AMPLIFY_LAST_KEEP_ALIVE';
+
+// Platform-safe storage implementation
+let platformStorage: Pick<
+	KeyValueStorageInterface,
+	'setItem' | 'getItem'
+> | null = null;
+
 try {
 	// Try to import AsyncStorage for React Native (optional dependency)
-	// eslint-disable-next-line import/no-extraneous-dependencies
-	AsyncStorage = require('@react-native-async-storage/async-storage').default;
+	const AsyncStorage =
+		// eslint-disable-next-line import/no-extraneous-dependencies
+		require('@react-native-async-storage/async-storage').default;
+	platformStorage = AsyncStorage;
 } catch (e) {
 	// Fallback for web/other platforms - use localStorage if available
-	AsyncStorage =
-		typeof localStorage !== 'undefined'
-			? {
-					setItem: (key: string, value: string) => {
-						localStorage.setItem(key, value);
+	if (typeof localStorage !== 'undefined') {
+		platformStorage = {
+			setItem: (key: string, value: string) => {
+				localStorage.setItem(key, value);
 
-						return Promise.resolve();
-					},
-					getItem: (key: string) => Promise.resolve(localStorage.getItem(key)),
-				}
-			: null;
+				return Promise.resolve();
+			},
+			getItem: (key: string) => Promise.resolve(localStorage.getItem(key)),
+		};
+	}
 }
 
 const dispatchApiEvent = (payload: HubPayload) => {
@@ -706,13 +714,12 @@ export abstract class AWSWebSocketProvider {
 			this.maintainKeepAlive();
 
 			// Persist keep-alive timestamp for cross-session tracking
-			if (AsyncStorage) {
-				AsyncStorage.setItem(
-					'AWS_AMPLIFY_LAST_KEEP_ALIVE',
-					`${Date.now()}`,
-				).catch(error => {
-					this.logger.warn('Failed to persist keep-alive timestamp:', error);
-				});
+			if (platformStorage) {
+				platformStorage
+					.setItem(KEEP_ALIVE_STORAGE_KEY, `${Date.now()}`)
+					.catch(error => {
+						this.logger.warn('Failed to persist keep-alive timestamp:', error);
+					});
 			}
 
 			return;
@@ -1066,18 +1073,14 @@ export abstract class AWSWebSocketProvider {
 	 * Get current WebSocket health state
 	 */
 	getConnectionHealth(): WebSocketHealthState {
-		const timeSinceLastKeepAlive = this.keepAliveTimestamp
-			? Date.now() - this.keepAliveTimestamp
-			: undefined;
+		const timeSinceLastKeepAlive = Date.now() - this.keepAliveTimestamp;
 
 		const isHealthy =
 			this.connectionState === ConnectionState.Connected &&
-			this.keepAliveTimestamp &&
-			timeSinceLastKeepAlive !== undefined &&
-			timeSinceLastKeepAlive < 65000; // 65 second threshold
+			timeSinceLastKeepAlive < DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT;
 
 		return {
-			isHealthy: Boolean(isHealthy),
+			isHealthy,
 			connectionState: this.connectionState || ConnectionState.Disconnected,
 			lastKeepAliveTime: this.keepAliveTimestamp,
 			timeSinceLastKeepAlive,
@@ -1088,16 +1091,16 @@ export abstract class AWSWebSocketProvider {
 	 * Get persistent WebSocket health state (survives app restarts)
 	 */
 	async getPersistentConnectionHealth(): Promise<WebSocketHealthState> {
-		let persistentKeepAliveTime: number | undefined;
+		let persistentKeepAliveTime = 0;
 
 		// Try to get persistent keep-alive timestamp
-		if (AsyncStorage) {
+		if (platformStorage) {
 			try {
-				const persistentKeepAlive = await AsyncStorage.getItem(
-					'AWS_AMPLIFY_LAST_KEEP_ALIVE',
+				const persistentKeepAlive = await platformStorage.getItem(
+					KEEP_ALIVE_STORAGE_KEY,
 				);
 				if (persistentKeepAlive) {
-					persistentKeepAliveTime = Number(persistentKeepAlive);
+					persistentKeepAliveTime = Number(persistentKeepAlive) || 0;
 				}
 			} catch (error) {
 				this.logger.warn(
@@ -1108,26 +1111,25 @@ export abstract class AWSWebSocketProvider {
 		}
 
 		// Use the more recent timestamp (in-memory vs persistent)
-		const lastKeepAliveTime =
-			Math.max(this.keepAliveTimestamp || 0, persistentKeepAliveTime || 0) ||
-			undefined;
+		const lastKeepAliveTime = Math.max(
+			this.keepAliveTimestamp,
+			persistentKeepAliveTime,
+		);
 
-		const timeSinceLastKeepAlive = lastKeepAliveTime
-			? Date.now() - lastKeepAliveTime
-			: undefined;
+		const timeSinceLastKeepAlive =
+			lastKeepAliveTime > 0 ? Date.now() - lastKeepAliveTime : Infinity; // If no keep-alive has been received, treat as unhealthy
 
 		// Health check includes persistent data
 		const isHealthy =
 			this.connectionState === ConnectionState.Connected &&
-			lastKeepAliveTime &&
-			timeSinceLastKeepAlive !== undefined &&
-			timeSinceLastKeepAlive < 65000; // 65 second threshold
+			timeSinceLastKeepAlive < DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT;
 
 		return {
-			isHealthy: Boolean(isHealthy),
+			isHealthy,
 			connectionState: this.connectionState || ConnectionState.Disconnected,
-			lastKeepAliveTime,
-			timeSinceLastKeepAlive,
+			lastKeepAliveTime: lastKeepAliveTime > 0 ? lastKeepAliveTime : undefined,
+			timeSinceLastKeepAlive:
+				lastKeepAliveTime > 0 ? timeSinceLastKeepAlive : undefined,
 		};
 	}