WebSockets vs Polling

WebSocket server and client implementation in TypeScript

import { WebSocketServer, WebSocket } from 'ws';
import http from 'http';

interface ClientMessage {
  type: 'subscribe' | 'unsubscribe';
  channel: string;
}

const server = http.createServer();
const wss = new WebSocketServer({ server });
const channels = new Map<string, Set<WebSocket>>();

wss.on('connection', (ws: WebSocket, req) => {
  // Authenticate via token in query string (headers not accessible on WS upgrade)
  const token = new URL(req.url!, 'ws://localhost').searchParams.get('token');
  if (!verifyToken(token)) { ws.close(1008, 'Unauthorized'); return; }

  ws.on('message', (data) => {
    const msg: ClientMessage = JSON.parse(data.toString());
    if (msg.type === 'subscribe') {
      const subscribers = channels.get(msg.channel) ?? new Set();
      subscribers.add(ws);
      channels.set(msg.channel, subscribers);
    }
  });

  ws.on('close', () => {
    channels.forEach(subs => subs.delete(ws)); // Cleanup all subscriptions
  });
});

// Broadcast to all subscribers of a channel
function broadcast(channel: string, payload: unknown): void {
  const subscribers = channels.get(channel) ?? new Set();
  const message = JSON.stringify(payload);
  subscribers.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(message);
    }
  });
}

server.listen(3001);

WebSocket connections are stateful; the server must track subscribers and clean up on close. In a multi-server deployment, subscriptions must be coordinated via Redis Pub/Sub (using ioredis publish/subscribe) so a message broadcast on server A reaches clients connected to server B.

Server-Sent Events for one-way push in TypeScript

import { Request, Response } from 'express';

export function sseEndpoint(req: Request, res: Response): void {
  // SSE requires specific headers
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.flushHeaders(); // Send headers immediately; begin stream

  // Send a heartbeat every 30s to prevent proxy/firewall timeouts
  const heartbeat = setInterval(() => {
    res.write(': heartbeat

'); // Comment line in SSE protocol
  }, 30000);

  // Subscribe to events and push to client
  function sendEvent(eventType: string, data: unknown) {
    res.write('event: ' + eventType + '
');
    res.write('data: ' + JSON.stringify(data) + '

');
  }

  const subscription = eventBus.on('order.status.changed', (event) => {
    if (event.userId === (req as any).user.sub) {
      sendEvent('order-update', event);
    }
  });

  req.on('close', () => {
    clearInterval(heartbeat);
    subscription.unsubscribe();
  });
}

SSE is simpler than WebSockets for server-to-client-only push: it uses plain HTTP, works through proxies without special configuration, reconnects automatically via the browser EventSource API, and supports event IDs for resuming after disconnection. Use WebSockets only when bidirectional communication is needed.