Conceptos Básicos en Tiempo Real

npm install ws
npm install -D @types/ws

Usa WebSocket cuando:
- El cliente envía mensajes con frecuencia (chat, juegos, colaboración)
- La latencia debe ser < 50ms de ida y vuelta
- Datos binarios bidireccionales (audio, fragmentos de archivo)
- El estado de la conexión importa (presencia, indicadores de escritura)

Usa SSE cuando:
- El servidor envía actualizaciones; el cliente solo envía a través de HTTP normal
- Feeds en vivo (precios de acciones, resultados deportivos, registros)
- Flujos de notificaciones
- Quieres reconexión automática del navegador

// Encabezados de respuesta SSE
res.writeHead(200, {
  "Content-Type": "text/event-stream",
  "Cache-Control": "no-cache",
  Connection: "keep-alive",
});
res.write("data: {\"price\": 142.50}\n\n");

Usa long-polling cuando:
- La infraestructura bloquea WebSocket (proxies corporativos raros)
- Necesidad de notificación extremadamente simple
- Alternativa para Socket.IO (manejado automáticamente)

Ciclo de vida de WebSocket:
1. El cliente envía una petición de actualización HTTP
2. El servidor responde 101 Switching Protocols
3. Se establece una conexión TCP persistente
4. Se intercambian tramas bidireccionalmente
5. Cualquiera de las partes envía una trama de cierre
6. La conexión se termina
 
Ciclo de vida de SSE:
1. El cliente abre un GET HTTP (EventSource)
2. El servidor transmite text/event-stream
3. La conexión permanece abierta
4. El servidor envía líneas data:
5. Al desconectarse, el navegador se reconecta automáticamente

// WebSocket: valida durante la actualización
server.on("upgrade", (req, socket, head) => {
  const token = new URL(req.url!, "http://localhost").searchParams.get("token");
  if (!isValid(token)) {
    socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
    socket.destroy();
    return;
  }
  wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
});

import express from "express";
import { createServer } from "node:http";
import { WebSocketServer } from "ws";
 
const app = express();
const server = createServer(app);
const wss = new WebSocketServer({ noServer: true });
 
server.on("upgrade", (req, socket, head) => {
  if (req.url?.startsWith("/ws")) {
    wss.handleUpgrade(req, socket, head, (ws) => {
      wss.emit("connection", ws, req);
    });
  }
});
 
wss.on("connection", (ws) => {
  ws.on("message", (data) => ws.send(`echo: ${data}`));
});
 
server.listen(3000);

import Fastify from "fastify";
 
const app = Fastify();
 
app.get("/events", async (req, reply) => {
  reply.raw.writeHead(200, {
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
  });
 
  const interval = setInterval(() => {
    reply.raw.write(`data: ${JSON.stringify({ time: Date.now() })}\n\n`);
  }, 1000);
 
  req.raw.on("close", () => clearInterval(interval));
});

Antes de 1000 conexiones concurrentes, planifica:
- Sesiones pegajosas (afinidad del balanceador de carga)
- Redis pub/sub para mensajería entre instancias
- Límites de conexión por instancia
- Latido/ping para detectar conexiones muertas
- Apagado elegante (notificar a los clientes, cerrar conexiones)