refactor(WebSocket): migrate from SSE to WebSocket for real-time messaging

- Replaced SSEClient with WSClient for handling real-time messaging.
- Updated ProcessMessageUseCase to initialize WebSocket listeners.
- Refactored messageService to prioritize WebSocket for sending messages, with fallback to HTTP.
- Removed sseService and adjusted imports across the application to utilize wsService.
- Enhanced message handling and connection management for improved performance and reliability.

src/data/datasources/WSClient.ts

@@ -1,10 +1,10 @@
 /**
- * SSEClient - SSE连接管理
- * 只负责SSE连接管理，提供事件驱动架构
+ * WSClient - WebSocket连接管理
+ * 只负责WebSocket连接管理，提供事件驱动架构
  */
 
 import {
-  sseService,
+  wsService,
   WSChatMessage,
   WSGroupChatMessage,
   WSReadMessage,
@@ -14,13 +14,13 @@ import {
   WSGroupTypingMessage,
   WSGroupNoticeMessage,
   WSMessageType,
-} from '../../services/sseService';
+} from '../../services/wsService';
 
 // 事件处理器类型
 type EventHandler<T> = (data: T) => void;
 
-// SSE事件类型
-export interface SSEEvents {
+// WS事件类型
+export interface WSEvents {
   'chat': WSChatMessage;
   'group_message': WSGroupChatMessage;
   'read': WSReadMessage;
@@ -34,65 +34,65 @@ export interface SSEEvents {
   'error': Error;
 }
 
-export type SSEEventType = keyof SSEEvents;
+export type WSEventType = keyof WSEvents;
 
-class SSEClient {
-  private handlers: Map<SSEEventType, Set<EventHandler<any>>> = new Map();
+class WSClient {
+  private handlers: Map<WSEventType, Set<EventHandler<any>>> = new Map();
   private unsubscribeFns: Array<() => void> = [];
   private isInitialized = false;
 
   /**
-   * 初始化SSE监听
+   * 初始化WebSocket监听
    */
   initialize(): void {
     if (this.isInitialized) return;
 
     // 监听私聊消息
-    const unsubChat = sseService.on('chat', (message) => {
+    const unsubChat = wsService.on('chat', (message) => {
       this.emit('chat', message);
     });
 
     // 监听群聊消息
-    const unsubGroupMessage = sseService.on('group_message', (message) => {
+    const unsubGroupMessage = wsService.on('group_message', (message) => {
       this.emit('group_message', message);
     });
 
     // 监听私聊已读回执
-    const unsubRead = sseService.on('read', (message) => {
+    const unsubRead = wsService.on('read', (message) => {
       this.emit('read', message);
     });
 
     // 监听群聊已读回执
-    const unsubGroupRead = sseService.on('group_read', (message) => {
+    const unsubGroupRead = wsService.on('group_read', (message) => {
       this.emit('group_read', message);
     });
 
     // 监听私聊消息撤回
-    const unsubRecall = sseService.on('recall', (message) => {
+    const unsubRecall = wsService.on('recall', (message) => {
       this.emit('recall', message);
     });
 
     // 监听群聊消息撤回
-    const unsubGroupRecall = sseService.on('group_recall', (message) => {
+    const unsubGroupRecall = wsService.on('group_recall', (message) => {
       this.emit('group_recall', message);
     });
 
     // 监听群聊输入状态
-    const unsubGroupTyping = sseService.on('group_typing', (message) => {
+    const unsubGroupTyping = wsService.on('group_typing', (message) => {
       this.emit('group_typing', message);
     });
 
     // 监听群通知
-    const unsubGroupNotice = sseService.on('group_notice', (message) => {
+    const unsubGroupNotice = wsService.on('group_notice', (message) => {
       this.emit('group_notice', message);
     });
 
     // 监听连接状态
-    const unsubConnect = sseService.onConnect(() => {
+    const unsubConnect = wsService.onConnect(() => {
       this.emit('connected', undefined);
     });
 
-    const unsubDisconnect = sseService.onDisconnect(() => {
+    const unsubDisconnect = wsService.onDisconnect(() => {
       this.emit('disconnected', undefined);
     });
 
@@ -113,7 +113,7 @@ class SSEClient {
   }
 
   /**
-   * 销毁SSE监听
+   * 销毁WebSocket监听
    */
   destroy(): void {
     this.unsubscribeFns.forEach((fn) => fn());
@@ -125,9 +125,9 @@ class SSEClient {
   /**
    * 订阅事件
    */
-  on<T extends SSEEventType>(
+  on<T extends WSEventType>(
     event: T,
-    handler: EventHandler<SSEEvents[T]>
+    handler: EventHandler<WSEvents[T]>
   ): () => void {
     if (!this.handlers.has(event)) {
       this.handlers.set(event, new Set());
@@ -142,9 +142,9 @@ class SSEClient {
   /**
    * 触发事件
    */
-  private emit<T extends SSEEventType>(
+  private emit<T extends WSEventType>(
     event: T,
-    data: SSEEvents[T]
+    data: WSEvents[T]
   ): void {
     const handlers = this.handlers.get(event);
     if (handlers) {
@@ -152,7 +152,7 @@ class SSEClient {
         try {
           handler(data);
         } catch (error) {
-          console.error(`[SSEClient] 事件处理器执行失败: ${event}`, error);
+          console.error(`[WSClient] 事件处理器执行失败: ${event}`, error);
         }
       });
     }
@@ -162,23 +162,23 @@ class SSEClient {
    * 检查连接状态
    */
   isConnected(): boolean {
-    return sseService.isConnected();
+    return wsService.isConnected();
   }
 
   /**
-   * 启动SSE连接
+   * 启动WebSocket连接
    */
   async connect(): Promise<boolean> {
-    return sseService.start();
+    return wsService.start();
   }
 
   /**
-   * 断开SSE连接
+   * 断开WebSocket连接
    */
   disconnect(): void {
-    sseService.stop();
+    wsService.stop();
   }
 }
 
-export const sseClient = new SSEClient();
-export default sseClient;
+export const wsClient = new WSClient();
+export default wsClient;