Noções Básicas de Tempo Real

npm install ws
npm install -D @types/ws

Use WebSocket quando:
- O cliente envia mensagens frequentemente (chat, jogos, colaboração)
- A latência deve ser < 50ms de ida e volta
- Dados binários bidirecionais (áudio, partes de arquivos)
- O estado da conexão importa (presença, indicadores de digitação)

Use SSE quando:
- O servidor envia atualizações; o cliente envia apenas via HTTP normal
- Feeds ao vivo (preços de ações, placares esportivos, logs)
- Streams de notificação
- Você quer reconexão automática do navegador

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

Use long-polling quando:
- A infraestrutura bloqueia WebSocket (proxies corporativos raros)
- Necessidade de notificação extremamente simples
- Fallback para Socket.IO (tratado automaticamente)

Ciclo de vida do WebSocket:
1. Cliente envia requisição HTTP Upgrade
2. Servidor responde 101 Switching Protocols
3. Conexão TCP persistente estabelecida
4. Frames trocados bidirecionalmente
5. Um dos lados envia frame de fechamento
6. Conexão terminada
 
Ciclo de vida do SSE:
1. Cliente abre GET HTTP (EventSource)
2. Servidor transmite text/event-stream
3. Conexão permanece aberta
4. Servidor envia linhas data:
5. Em caso de desconexão, o navegador reconecta automaticamente

// WebSocket: valide durante o upgrade
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 conexões simultâneas, planeje para:
- Sessões fixas (afinidade do balanceador de carga)
- Pub/sub do Redis para mensagens entre instâncias
- Limites de conexão por instância
- Heartbeat/ping para detectar conexões mortas
- Desligamento gracioso (notificar clientes, fechar conexões)