Only emit event 'x' to clients that explicitly listen for it

[ChrisKatsaras]

Currently, I'm dealing with an issue where I have a room with socket connections and I only want to emit event 'x' to socket connections that are explicitly listening to it on the client.

I've noticed that regardless of whether or not the client is listening for it, it still gets sent over the wire. (It doesn't get handled, but I can still see it being sent over the wire in my console).

To give a bit more detail, given the example room with socket connections:

connection 1
connection 2
connection 3

If only connection 3 is listening for event 'x', I would just want connection 3 to receive event 'x'

Right now, all receive the event while connection 3 is the only one that explicitly handles it.

Am I missing something or is it not possible to emit an event to a room of connections and have it filtered down?
Any help is greatly appreciated :)

[darrachequesne]

For your use case, I think the best solution is to use the rooms to implement subscriptions:

Client-side:

socket.on("connect", () => {
  socket.emit("subscribe", "event x");
});

Server-side:

io.on("connection", (socket) => {
  socket.on("subscribe", (topic) => {
    socket.join(topic);
  });

  // and then later
  io.to("event x").emit("hello", "only to subscribers");
});

[ChrisKatsaras]

@darrachequesne this is what I originally thought to implement too! However, it seems like a large amount of overhead in a large scale system and a lot of state management. And we have to send additional data from the client to the server. I was hoping there was a more sophisticated approach but I think you're right that this would work to achieve what I want.

Maybe this is a good idea for an upcoming version of socket.io (having the ability on the server to determine which events a socket is subscribing to)

Thanks for the quick response

[ChrisKatsaras]

To give more details on my situation. I want to introduce versioned events to my system, which meant I only want to send the version of the event that the client is subscribing to e.g event-x_V1 vs event-x_V2. Right now, emitting those events as is will send both over the wire. I think you're room suggestion is feasible but I was really hoping that socket.io was sophisticated enough to tell that the client was subscribing to event event-x_V2 and only receive that version 😓

[darrachequesne]

I was really hoping that socket.io was sophisticated enough to tell that the client was subscribing to event event-x_V2 and only receive that version

We're open to suggestions! Do you have a particular API in mind?

As a workaround, you should be able to gather the name of the events the client is listening to:

const eventNames = Object.keys(socket._callbacks).map(ev => ev.substring(1));

And send them in the handshake?

[ChrisKatsaras]

Just to clarify, the line of code above can be done on the server? I inspected the socket connections on thhe server and I don't see any property called _callbacks, sadly. I'm using socket.io 2.X currently (limited by what NestJS uses)

Thanks for all the feedback btw @darrachequesne ! I really appreciate it :D

[darrachequesne]

No, it's for the client side (we use the following implementation: https://github.com/component/emitter/).

On the server-side, the socket instance is an actual Node.js EventEmitter, so you should be able to call socket.eventNames():

io.on("connection", (socket) => {
  socket.on("event1", () => {});
  socket.on("event2", () => {});

  console.log(socket.eventNames()); // prints ["event1", "event2"]
});

Reference: https://nodejs.org/api/events.html#events_emitter_eventnames