ADD new frontend
This commit is contained in:
Urtzi Alfaro
423
frontend/src/hooks/api/useWebSocket.ts
Normal file
423
frontend/src/hooks/api/useWebSocket.ts
Normal file
@@ -0,0 +1,423 @@
|
||||
/**
|
||||
* 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,
|
||||
};
|
||||
};
|
||||
Reference in New Issue
Block a user