423 lines
12 KiB
TypeScript
423 lines
12 KiB
TypeScript
|
/**
|
||
|
|
* WebSocket hook for real-time bidirectional communication
|
||
|
|
*/
|
||
|
|
|
||
|
|
import { useState, useEffect, useCallback, useRef } from 'react';
|
||
|
|
import { StorageService } from '../../services/api/utils/storage.service';
|
||
|
|
|
||
|
|
export interface WebSocketMessage {
|
||
|
|
id?: string;
|
||
|
|
type: string;
|
||
|
|
data: any;
|
||
|
|
timestamp: number;
|
||
|
|
}
|
||
|
|
|
||
|
|
interface WebSocketState {
|
||
|
|
isConnected: boolean;
|
||
|
|
isConnecting: boolean;
|
||
|
|
error: string | null;
|
||
|
|
messages: WebSocketMessage[];
|
||
|
|
readyState: number;
|
||
|
|
}
|
||
|
|
|
||
|
|
interface WebSocketOptions {
|
||
|
|
protocols?: string | string[];
|
||
|
|
reconnectInterval?: number;
|
||
|
|
maxReconnectAttempts?: number;
|
||
|
|
bufferSize?: number;
|
||
|
|
autoConnect?: boolean;
|
||
|
|
heartbeatInterval?: number;
|
||
|
|
messageFilters?: string[];
|
||
|
|
}
|
||
|
|
|
||
|
|
interface WebSocketActions {
|
||
|
|
connect: (url: string) => void;
|
||
|
|
disconnect: () => void;
|
||
|
|
reconnect: () => void;
|
||
|
|
send: (data: any, type?: string) => boolean;
|
||
|
|
sendMessage: (message: WebSocketMessage) => boolean;
|
||
|
|
clearMessages: () => void;
|
||
|
|
clearError: () => void;
|
||
|
|
addEventListener: (messageType: string, handler: (data: any) => void) => () => void;
|
||
|
|
}
|
||
|
|
|
||
|
|
const DEFAULT_OPTIONS: Required<WebSocketOptions> = {
|
||
|
|
protocols: [],
|
||
|
|
reconnectInterval: 3000,
|
||
|
|
maxReconnectAttempts: 10,
|
||
|
|
bufferSize: 100,
|
||
|
|
autoConnect: true,
|
||
|
|
heartbeatInterval: 30000,
|
||
|
|
messageFilters: [],
|
||
|
|
};
|
||
|
|
|
||
|
|
export const useWebSocket = (
|
||
|
|
initialUrl?: string,
|
||
|
|
options: WebSocketOptions = {}
|
||
|
|
): WebSocketState & WebSocketActions => {
|
||
|
|
const [state, setState] = useState<WebSocketState>({
|
||
|
|
isConnected: false,
|
||
|
|
isConnecting: false,
|
||
|
|
error: null,
|
||
|
|
messages: [],
|
||
|
|
readyState: WebSocket.CLOSED,
|
||
|
|
});
|
||
|
|
|
||
|
|
const webSocketRef = useRef<WebSocket | null>(null);
|
||
|
|
const urlRef = useRef<string | null>(initialUrl || null);
|
||
|
|
const reconnectTimeoutRef = useRef<number | null>(null);
|
||
|
|
const heartbeatTimeoutRef = useRef<number | null>(null);
|
||
|
|
const reconnectAttemptsRef = useRef<number>(0);
|
||
|
|
const messageHandlersRef = useRef<Map<string, Set<(data: any) => void>>>(new Map());
|
||
|
|
const messageQueueRef = useRef<WebSocketMessage[]>([]);
|
||
|
|
|
||
|
|
const config = { ...DEFAULT_OPTIONS, ...options };
|
||
|
|
const storageService = new StorageService();
|
||
|
|
|
||
|
|
// Helper function to get auth token
|
||
|
|
const getAuthToken = useCallback(() => {
|
||
|
|
const authData = storageService.getAuthData();
|
||
|
|
return authData?.access_token || null;
|
||
|
|
}, [storageService]);
|
||
|
|
|
||
|
|
// Add event listener for specific message types
|
||
|
|
const addEventListener = useCallback((messageType: string, handler: (data: any) => void) => {
|
||
|
|
if (!messageHandlersRef.current.has(messageType)) {
|
||
|
|
messageHandlersRef.current.set(messageType, new Set());
|
||
|
|
}
|
||
|
|
messageHandlersRef.current.get(messageType)!.add(handler);
|
||
|
|
|
||
|
|
// Return cleanup function
|
||
|
|
return () => {
|
||
|
|
const handlers = messageHandlersRef.current.get(messageType);
|
||
|
|
if (handlers) {
|
||
|
|
handlers.delete(handler);
|
||
|
|
if (handlers.size === 0) {
|
||
|
|
messageHandlersRef.current.delete(messageType);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Process incoming message
|
||
|
|
const processMessage = useCallback((event: MessageEvent) => {
|
||
|
|
try {
|
||
|
|
let messageData: WebSocketMessage;
|
||
|
|
|
||
|
|
try {
|
||
|
|
const parsed = JSON.parse(event.data);
|
||
|
|
messageData = {
|
||
|
|
id: parsed.id,
|
||
|
|
type: parsed.type || 'message',
|
||
|
|
data: parsed.data || parsed,
|
||
|
|
timestamp: parsed.timestamp || Date.now(),
|
||
|
|
};
|
||
|
|
} catch {
|
||
|
|
messageData = {
|
||
|
|
type: 'message',
|
||
|
|
data: event.data,
|
||
|
|
timestamp: Date.now(),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// Filter messages if messageFilters is specified
|
||
|
|
if (config.messageFilters.length > 0 && !config.messageFilters.includes(messageData.type)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
messages: [...prev.messages.slice(-(config.bufferSize - 1)), messageData],
|
||
|
|
}));
|
||
|
|
|
||
|
|
// Call registered message handlers
|
||
|
|
const handlers = messageHandlersRef.current.get(messageData.type);
|
||
|
|
if (handlers) {
|
||
|
|
handlers.forEach(handler => {
|
||
|
|
try {
|
||
|
|
handler(messageData.data);
|
||
|
|
} catch (error) {
|
||
|
|
console.error('Error in WebSocket message handler:', error);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// Call generic message handlers
|
||
|
|
const messageHandlers = messageHandlersRef.current.get('message');
|
||
|
|
if (messageHandlers && messageData.type !== 'message') {
|
||
|
|
messageHandlers.forEach(handler => {
|
||
|
|
try {
|
||
|
|
handler(messageData);
|
||
|
|
} catch (error) {
|
||
|
|
console.error('Error in WebSocket message handler:', error);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
} catch (error) {
|
||
|
|
console.error('Error processing WebSocket message:', error);
|
||
|
|
}
|
||
|
|
}, [config.messageFilters, config.bufferSize]);
|
||
|
|
|
||
|
|
// Send heartbeat/ping message
|
||
|
|
const sendHeartbeat = useCallback(() => {
|
||
|
|
if (webSocketRef.current && webSocketRef.current.readyState === WebSocket.OPEN) {
|
||
|
|
const heartbeatMessage: WebSocketMessage = {
|
||
|
|
type: 'ping',
|
||
|
|
data: { timestamp: Date.now() },
|
||
|
|
timestamp: Date.now(),
|
||
|
|
};
|
||
|
|
|
||
|
|
webSocketRef.current.send(JSON.stringify(heartbeatMessage));
|
||
|
|
}
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Setup heartbeat interval
|
||
|
|
const setupHeartbeat = useCallback(() => {
|
||
|
|
if (config.heartbeatInterval > 0) {
|
||
|
|
heartbeatTimeoutRef.current = window.setInterval(sendHeartbeat, config.heartbeatInterval);
|
||
|
|
}
|
||
|
|
}, [config.heartbeatInterval, sendHeartbeat]);
|
||
|
|
|
||
|
|
// Clear heartbeat interval
|
||
|
|
const clearHeartbeat = useCallback(() => {
|
||
|
|
if (heartbeatTimeoutRef.current) {
|
||
|
|
window.clearInterval(heartbeatTimeoutRef.current);
|
||
|
|
heartbeatTimeoutRef.current = null;
|
||
|
|
}
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Process queued messages
|
||
|
|
const processMessageQueue = useCallback(() => {
|
||
|
|
while (messageQueueRef.current.length > 0) {
|
||
|
|
const message = messageQueueRef.current.shift();
|
||
|
|
if (message && webSocketRef.current && webSocketRef.current.readyState === WebSocket.OPEN) {
|
||
|
|
webSocketRef.current.send(JSON.stringify(message));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Connect to WebSocket endpoint
|
||
|
|
const connect = useCallback((url: string) => {
|
||
|
|
if (webSocketRef.current) {
|
||
|
|
disconnect();
|
||
|
|
}
|
||
|
|
|
||
|
|
urlRef.current = url;
|
||
|
|
setState(prev => ({ ...prev, isConnecting: true, error: null }));
|
||
|
|
|
||
|
|
try {
|
||
|
|
// Build URL with auth token if available
|
||
|
|
const wsUrl = new URL(url);
|
||
|
|
const authToken = getAuthToken();
|
||
|
|
if (authToken) {
|
||
|
|
wsUrl.searchParams.set('token', authToken);
|
||
|
|
}
|
||
|
|
|
||
|
|
const webSocket = new WebSocket(
|
||
|
|
wsUrl.toString(),
|
||
|
|
Array.isArray(config.protocols) ? config.protocols : [config.protocols].filter(Boolean)
|
||
|
|
);
|
||
|
|
|
||
|
|
webSocketRef.current = webSocket;
|
||
|
|
|
||
|
|
webSocket.onopen = () => {
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
isConnected: true,
|
||
|
|
isConnecting: false,
|
||
|
|
error: null,
|
||
|
|
readyState: WebSocket.OPEN,
|
||
|
|
}));
|
||
|
|
|
||
|
|
reconnectAttemptsRef.current = 0;
|
||
|
|
|
||
|
|
// Clear reconnect timeout if it exists
|
||
|
|
if (reconnectTimeoutRef.current) {
|
||
|
|
window.clearTimeout(reconnectTimeoutRef.current);
|
||
|
|
reconnectTimeoutRef.current = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Setup heartbeat
|
||
|
|
setupHeartbeat();
|
||
|
|
|
||
|
|
// Process any queued messages
|
||
|
|
processMessageQueue();
|
||
|
|
};
|
||
|
|
|
||
|
|
webSocket.onmessage = processMessage;
|
||
|
|
|
||
|
|
webSocket.onclose = (event) => {
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
isConnected: false,
|
||
|
|
isConnecting: false,
|
||
|
|
readyState: WebSocket.CLOSED,
|
||
|
|
}));
|
||
|
|
|
||
|
|
clearHeartbeat();
|
||
|
|
|
||
|
|
// Attempt reconnection if not a clean close and within limits
|
||
|
|
if (!event.wasClean && reconnectAttemptsRef.current < config.maxReconnectAttempts) {
|
||
|
|
reconnectAttemptsRef.current += 1;
|
||
|
|
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
error: `Conexión perdida. Reintentando... (${reconnectAttemptsRef.current}/${config.maxReconnectAttempts})`,
|
||
|
|
}));
|
||
|
|
|
||
|
|
reconnectTimeoutRef.current = window.setTimeout(() => {
|
||
|
|
if (urlRef.current) {
|
||
|
|
connect(urlRef.current);
|
||
|
|
}
|
||
|
|
}, config.reconnectInterval);
|
||
|
|
} else if (reconnectAttemptsRef.current >= config.maxReconnectAttempts) {
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
error: `Máximo número de intentos de reconexión alcanzado (${config.maxReconnectAttempts})`,
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
webSocket.onerror = (error) => {
|
||
|
|
console.error('WebSocket error:', error);
|
||
|
|
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
error: 'Error de conexión WebSocket',
|
||
|
|
readyState: webSocket.readyState,
|
||
|
|
}));
|
||
|
|
};
|
||
|
|
|
||
|
|
// Update ready state periodically
|
||
|
|
const stateInterval = setInterval(() => {
|
||
|
|
if (webSocketRef.current) {
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
readyState: webSocketRef.current!.readyState,
|
||
|
|
}));
|
||
|
|
} else {
|
||
|
|
clearInterval(stateInterval);
|
||
|
|
}
|
||
|
|
}, 1000);
|
||
|
|
|
||
|
|
} catch (error) {
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
isConnecting: false,
|
||
|
|
error: 'Error al establecer conexión WebSocket',
|
||
|
|
readyState: WebSocket.CLOSED,
|
||
|
|
}));
|
||
|
|
}
|
||
|
|
}, [getAuthToken, config.protocols, config.maxReconnectAttempts, config.reconnectInterval, processMessage, setupHeartbeat, clearHeartbeat, processMessageQueue]);
|
||
|
|
|
||
|
|
// Disconnect from WebSocket
|
||
|
|
const disconnect = useCallback(() => {
|
||
|
|
if (webSocketRef.current) {
|
||
|
|
webSocketRef.current.close(1000, 'Manual disconnect');
|
||
|
|
webSocketRef.current = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (reconnectTimeoutRef.current) {
|
||
|
|
window.clearTimeout(reconnectTimeoutRef.current);
|
||
|
|
reconnectTimeoutRef.current = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
clearHeartbeat();
|
||
|
|
|
||
|
|
setState(prev => ({
|
||
|
|
...prev,
|
||
|
|
isConnected: false,
|
||
|
|
isConnecting: false,
|
||
|
|
readyState: WebSocket.CLOSED,
|
||
|
|
}));
|
||
|
|
|
||
|
|
reconnectAttemptsRef.current = 0;
|
||
|
|
}, [clearHeartbeat]);
|
||
|
|
|
||
|
|
// Reconnect to WebSocket
|
||
|
|
const reconnect = useCallback(() => {
|
||
|
|
if (urlRef.current) {
|
||
|
|
disconnect();
|
||
|
|
setTimeout(() => {
|
||
|
|
connect(urlRef.current!);
|
||
|
|
}, 100);
|
||
|
|
}
|
||
|
|
}, [connect, disconnect]);
|
||
|
|
|
||
|
|
// Send raw data
|
||
|
|
const send = useCallback((data: any, type: string = 'message'): boolean => {
|
||
|
|
const message: WebSocketMessage = {
|
||
|
|
type,
|
||
|
|
data,
|
||
|
|
timestamp: Date.now(),
|
||
|
|
};
|
||
|
|
|
||
|
|
return sendMessage(message);
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Send structured message
|
||
|
|
const sendMessage = useCallback((message: WebSocketMessage): boolean => {
|
||
|
|
if (webSocketRef.current && webSocketRef.current.readyState === WebSocket.OPEN) {
|
||
|
|
try {
|
||
|
|
webSocketRef.current.send(JSON.stringify(message));
|
||
|
|
return true;
|
||
|
|
} catch (error) {
|
||
|
|
console.error('Error sending WebSocket message:', error);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Queue message for later if not connected
|
||
|
|
messageQueueRef.current.push(message);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Clear messages buffer
|
||
|
|
const clearMessages = useCallback(() => {
|
||
|
|
setState(prev => ({ ...prev, messages: [] }));
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Clear error
|
||
|
|
const clearError = useCallback(() => {
|
||
|
|
setState(prev => ({ ...prev, error: null }));
|
||
|
|
}, []);
|
||
|
|
|
||
|
|
// Auto-connect on mount if URL provided
|
||
|
|
useEffect(() => {
|
||
|
|
if (initialUrl && config.autoConnect) {
|
||
|
|
connect(initialUrl);
|
||
|
|
}
|
||
|
|
|
||
|
|
return () => {
|
||
|
|
disconnect();
|
||
|
|
};
|
||
|
|
}, [initialUrl, config.autoConnect]);
|
||
|
|
|
||
|
|
// Cleanup on unmount
|
||
|
|
useEffect(() => {
|
||
|
|
return () => {
|
||
|
|
disconnect();
|
||
|
|
messageHandlersRef.current.clear();
|
||
|
|
messageQueueRef.current = [];
|
||
|
|
};
|
||
|
|
}, [disconnect]);
|
||
|
|
|
||
|
|
// Auto-reconnect when auth token changes
|
||
|
|
useEffect(() => {
|
||
|
|
if (state.isConnected && urlRef.current) {
|
||
|
|
reconnect();
|
||
|
|
}
|
||
|
|
}, [getAuthToken()]);
|
||
|
|
|
||
|
|
return {
|
||
|
|
...state,
|
||
|
|
connect,
|
||
|
|
disconnect,
|
||
|
|
reconnect,
|
||
|
|
send,
|
||
|
|
sendMessage,
|
||
|
|
clearMessages,
|
||
|
|
clearError,
|
||
|
|
addEventListener,
|
||
|
|
};
|
||
|
|
};
|