Websocket Broadcasting

const WebSocket = require('ws');

const server = new WebSocket.Server({ port: 8080 });

function broadcast(data, exclude = null) {
  const message = JSON.stringify(data);
  server.clients.forEach((client) => {
    if (client !== exclude && client.readyState === WebSocket.OPEN) {
      client.send(message);
    }
  });
}

server.on('connection', (ws, req) => {
  // Send welcome only to this client
  ws.send(JSON.stringify({
    type: 'welcome',
    clientCount: server.clients.size,
  }));

  // Broadcast to all except sender
  ws.on('message', (message) => {
    const data = JSON.parse(message);
    broadcast(data, ws);
  });
});

// Periodic global broadcasts
setInterval(() => {
  broadcast({
    type: 'heartbeat',
    timestamp: Date.now(),
    clientCount: server.clients.size,
  });
}, 5000);

const WebSocket = require('ws');
const server = new WebSocket.Server({ port: 8080 });

const subscriptions = new Map();

server.on('connection', (ws) => {
  ws.subscriptions = new Set();

  ws.on('message', (message) => {
    const data = JSON.parse(message);

    switch (data.type) {
      case 'subscribe':
        ws.subscriptions.add(data.topic);
        if (!subscriptions.has(data.topic)) {
          subscriptions.set(data.topic, new Set());
        }
        subscriptions.get(data.topic).add(ws);
        break;

      case 'unsubscribe':
        ws.subscriptions.delete(data.topic);
        subscriptions.get(data.topic)?.delete(ws);
        break;

      case 'publish':
        // Match against subscriptions with wildcards
        const topic = data.topic;
        subscriptions.forEach((subscribers, pattern) => {
          if (matchTopic(pattern, topic)) {
            subscribers.forEach((client) => {
              if (client.readyState === WebSocket.OPEN) {
                client.send(JSON.stringify({
                  topic,
                  payload: data.payload,
                }));
              }
            });
          }
        });
        break;
    }
  });
});

function matchTopic(pattern, topic) {
  const regex = new RegExp(
    '^' + pattern.replace(/\+/g, '[^/]+').replace(/#/g, '.*') + '$'
  );
  return regex.test(topic);
}

// Example: subscribe to 'sensors/+/temperature'
// This matches 'sensors/room1/temperature', 'sensors/room2/temperature'

const { Server } = require('socket.io');
const io = new Server(3000);

io.on('connection', (socket) => {
  // 1. Send to sender only
  socket.emit('personal', { message: 'Only for you' });

  // 2. Send to all clients except sender
  socket.broadcast.emit('broadcast', {
    from: socket.id,
    message: 'Everyone except sender',
  });

  // 3. Send to all clients in room except sender
  socket.to('room-1').emit('room-event', {
    message: 'Room members except sender',
  });

  // 4. Send to all clients including sender
  io.emit('global', { message: 'Every connected client' });

  // 5. Send to all in room including sender
  io.to('room-1').emit('room-global', { message: 'All in room' });

  // 6. Send to specific socket(s)
  io.to('socket-id-123').emit('direct', { message: 'Direct message' });

  // 7. Send with exclusion
  socket.broadcast.to('room-1').emit('room-broadcast', {
    message: 'Room members except sender',
  });

  // 8. Volatile messages (not guaranteed delivery)
  socket.volatile.emit('position-update', {
    x: Math.random(),
    y: Math.random(),
  });
});