WebSocket: полный гид по real-time коммуникации

import { WebSocketServer, WebSocket } from 'ws';

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (ws: WebSocket) => {
  console.log('New client connected');
  
  ws.on('message', (data) => {
    const message = JSON.parse(data.toString());
    
    // Рассылка всем клиентам
    wss.clients.forEach((client) => {
      if (client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify(message));
      }
    });
  });
  
  ws.on('close', () => {
    console.log('Client disconnected');
  });
});

const ws = new WebSocket('wss://api.example.com/ws');

ws.onopen = () => {
  console.log('Connected');
  ws.send(JSON.stringify({ type: 'join', room: 'general' }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Received:', data);
};

ws.onclose = () => {
  console.log('Disconnected');
  // Реализуйте reconnect логику
};

import Redis from 'ioredis';

const pub = new Redis();
const sub = new Redis();

// Подписываемся на канал
sub.subscribe('broadcast');
sub.on('message', (channel, message) => {
  // Отправляем всем локальным клиентам
  wss.clients.forEach((ws) => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(message);
    }
  });
});

// Публикуем сообщение
function broadcast(message: any) {
  pub.publish('broadcast', JSON.stringify(message));
}

class RoomManager {
  private rooms = new Map<string, Set<WebSocket>>();
  
  join(room: string, ws: WebSocket) {
    if (!this.rooms.has(room)) {
      this.rooms.set(room, new Set());
    }
    this.rooms.get(room)!.add(ws);
  }
  
  leave(room: string, ws: WebSocket) {
    this.rooms.get(room)?.delete(ws);
  }
  
  broadcast(room: string, message: any) {
    const clients = this.rooms.get(room);
    clients?.forEach((ws) => {
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(JSON.stringify(message));
      }
    });
  }
}

// Сервер: heartbeat
const interval = setInterval(() => {
  wss.clients.forEach((ws) => {
    if (!ws.isAlive) {
      return ws.terminate();
    }
    ws.isAlive = false;
    ws.ping();
  });
}, 30000);

ws.on('pong', () => {
  ws.isAlive = true;
});

class WebSocketClient {
  private ws: WebSocket | null = null;
  private reconnectAttempts = 0;
  private maxReconnectAttempts = 5;
  private reconnectDelay = 1000;
  
  connect() {
    this.ws = new WebSocket(this.url);
    
    this.ws.onclose = () => {
      if (this.reconnectAttempts < this.maxReconnectAttempts) {
        setTimeout(() => {
          this.reconnectAttempts++;
          this.connect();
        }, this.reconnectDelay * this.reconnectAttempts);
      }
    };
    
    this.ws.onopen = () => {
      this.reconnectAttempts = 0;
    };
  }
}

import jwt from 'jsonwebtoken';

wss.on('connection', (ws, req) => {
  const token = new URL(req.url!, 'http://localhost')
    .searchParams.get('token');
  
  try {
    const decoded = jwt.verify(token!, process.env.JWT_SECRET!);
    (ws as any).userId = decoded.sub;
  } catch {
    ws.close(1008, 'Invalid token');
  }
});

// Ограничение сообщений от клиента
const messageLimit = new Map<string, number>();

ws.on('message', (data) => {
  const userId = (ws as any).userId;
  const count = messageLimit.get(userId) || 0;
  
  if (count > 100) {
    ws.close(1008, 'Rate limit exceeded');
    return;
  }
  
  messageLimit.set(userId, count + 1);
});

// Клиент
const eventSource = new EventSource('/api/sse');
eventSource.onmessage = (event) => {
  console.log('Update:', JSON.parse(event.data));
};