openWa / dashboard /src /hooks /useWebSocket.ts
harsh
Deploy: Initial commit without binaries
525d39f
Raw History Blame Contribute Delete
5.72 kB
import { useEffect, useRef, useCallback, useState } from 'react';
import { io, Socket } from 'socket.io-client';
interface SessionStatusEvent {
sessionId: string;
status: string;
timestamp: string;
}
interface QRCodeEvent {
sessionId: string;
qrCode: string;
timestamp: string;
}
interface MessageEvent {
sessionId: string;
message: Record<string, unknown>;
timestamp: string;
}
interface MessageAckEvent {
sessionId: string;
messageId: string;
ack: number;
ackName: string;
chatId?: string;
timestamp: string;
}
interface MessageReactionEvent {
sessionId: string;
messageId: string;
chatId: string;
reaction: string;
senderId: string;
reactions: Record<string, string>;
timestamp: string;
}
interface MessageRevokedEvent {
sessionId: string;
id: string;
chatId: string;
from: string;
to: string;
body: string;
type: string;
timestamp: number;
}
interface WebSocketEvents {
onSessionStatus?: (event: SessionStatusEvent) => void;
onQRCode?: (event: QRCodeEvent) => void;
onMessage?: (event: MessageEvent) => void;
onMessageAck?: (event: MessageAckEvent) => void;
onMessageReaction?: (event: MessageReactionEvent) => void;
onMessageRevoked?: (event: MessageRevokedEvent) => void;
}
// Shape of the server -> client event envelope produced by the NestJS gateway.
interface ServerEventEnvelope {
type: string;
timestamp: string;
payload?: {
event: string;
sessionId: string;
data: Record<string, unknown>;
};
}
// Use current origin for WebSocket (goes through nginx proxy in Docker)
// Falls back to env var or localhost for development
const SOCKET_URL = import.meta.env.VITE_WS_URL || window.location.origin;
export function useWebSocket(events: WebSocketEvents = {}) {
const socketRef = useRef<Socket | null>(null);
const [isConnected, setIsConnected] = useState(false);
const connect = useCallback(() => {
if (socketRef.current?.connected) return;
// Get API key from sessionStorage (same as api.ts)
const apiKey = sessionStorage.getItem('openwa_api_key');
if (!apiKey) {
console.warn('[WebSocket] No API key found, skipping connection');
return;
}
socketRef.current = io(`${SOCKET_URL}/events`, {
autoConnect: true,
reconnection: true,
reconnectionAttempts: 5,
reconnectionDelay: 1000,
auth: {
apiKey,
},
extraHeaders: {
'X-API-Key': apiKey,
},
query: {
apiKey,
},
});
socketRef.current.on('connect', () => {
setIsConnected(true);
});
socketRef.current.on('disconnect', () => {
setIsConnected(false);
});
socketRef.current.on('connect_error', error => {
console.warn('[WebSocket] Connection error:', error.message);
});
}, []);
const subscribe = useCallback((sessionId: string, eventsList: string[]) => {
if (socketRef.current?.connected) {
socketRef.current.emit('message', {
type: 'subscribe',
sessionId,
events: eventsList,
});
}
}, []);
const unsubscribe = useCallback((sessionId: string) => {
if (socketRef.current?.connected) {
socketRef.current.emit('message', {
type: 'unsubscribe',
sessionId,
});
}
}, []);
useEffect(() => {
connect();
return () => {
if (socketRef.current) {
socketRef.current.disconnect();
socketRef.current = null;
}
};
}, [connect]);
// Register the single envelope handler and fan out to the typed callbacks.
useEffect(() => {
if (!socketRef.current) return;
const socket = socketRef.current;
const handleIncomingMessage = (msg: ServerEventEnvelope) => {
if (!msg || msg.type !== 'event' || !msg.payload) return;
const { event, sessionId, data } = msg.payload;
switch (event) {
case 'session.status':
events.onSessionStatus?.({ sessionId, status: String(data.status), timestamp: msg.timestamp });
break;
case 'session.qr':
events.onQRCode?.({ sessionId, qrCode: String(data.qrCode), timestamp: msg.timestamp });
break;
case 'message.received':
case 'message.sent':
events.onMessage?.({ sessionId, message: data, timestamp: msg.timestamp });
break;
case 'message.ack':
events.onMessageAck?.({
sessionId,
messageId: String(data.messageId),
ack: Number(data.ack),
ackName: String(data.ackName),
chatId: data.chatId as string | undefined,
timestamp: msg.timestamp,
});
break;
case 'message.reaction':
events.onMessageReaction?.({
sessionId,
messageId: String(data.messageId),
chatId: String(data.chatId),
reaction: String(data.reaction),
senderId: String(data.senderId),
reactions: (data.reactions as Record<string, string>) || {},
timestamp: msg.timestamp,
});
break;
case 'message.revoked':
events.onMessageRevoked?.({
sessionId,
id: String(data.id),
chatId: String(data.chatId),
from: String(data.from),
to: String(data.to),
body: String(data.body ?? ''),
type: String(data.type),
timestamp: Number(data.timestamp),
});
break;
default:
break;
}
};
socket.on('message', handleIncomingMessage);
return () => {
socket.off('message', handleIncomingMessage);
};
}, [events]);
return { isConnected, subscribe, unsubscribe };
}