WebSocket On Event callback

[jeffery30162]

Does this support callback functionality using websockets similar to express?

Express Example:
socket.on('data', (data, out_data) => { if(data && data.event) handleData(socket, data, out_data); });

If not, what is the best way to achieve this kind of client await response code flow?

Thanks

[e3dio]

app.ws('/',{
   message: async (ws, message) => {
      const response = await doAsync(message)
      ws.send(response)
   }
})

[jeffery30162]

app.ws('/',{
   message: async (ws, message) => {
      const response = await doAsync(message)
      ws.send(response)
   }
})

Thanks for the quick reply but isn't this is just sending a message back to the client? I am looking for a callback type functionality for I can handle the response within the same code scope as the request:
Client example:
wsocket.send(JSON.stringify({ event : event , data : data}), (response) => { console.log('response received from server', response); });

[e3dio]

You are talking about a protocol on top of Websocket where a sent message gets linked to a specific response, you build this yourself by sending a Message ID with the message, the response message includes the Message ID so the client knows what message the response is linked to. This is not standard Websocket protocol, it something you are supposed to implement yourself if you need request/response type messaging, but is very easy to do as I described

[jeffery30162]

Do you think that addEventListener removeEventListener is viable?

SERVER:
socket.send(JSON.stringify({ event : event+'-response', data : true }));

CLIENT:
`private async sendServerWithReponse(event ,data, timeout = 3000) {
return new Promise( async (resolve, reject) => {
let timer;

        var responseHandler = (message) => {
            if(!message.data) { return; }
            var packet = JSON.parse(message.data);
            if(packet.event!=(event+'-response')) { return; }
            this.internal_connection.removeEventListener('message', responseHandler);
            clearTimeout(timer);
            resolve(packet.data);
        }

        this.internal_connection.send(JSON.stringify({ event : event , data : data}));
        this.internal_connection.addEventListener('message', responseHandler);

        timer = setTimeout(() => {
            reject('No Response From Server');
            this.internal_connection.removeEventListener('message', responseHandler);
        }, timeout);
  
    });
}`

[e3dio]

For example here is request/response implementation with JSON and Promise syntax, very easy to set up:

// send message on client
const response = await send({abc:123})

// client setup
let messageID=0
const sentMessages=new Map()
const send=(data,timeout=5000)=>{
   let t,id=++messageID
   ws.send(JSON.stringify({id,data}))
   return new Promise((resolve,reject)=>{
      sentMessages.set(id,{resolve,reject})
      t=setTimeout(()=>reject('timeout'),timeout)
   }).finally(()=>{clearTimeout(t);sentMessages.delete(id)})
}
ws.onmessage=e=>{
   const message=JSON.parse(e.data)
   sentMessages.get(message.id)?.resolve(message.data)
}

// server
app.ws('/',{
   message:(ws,message)=>{
      const request=JSON.parse(Buffer.from(message).toString())
      const response={id:request.id,data:'xyz'}
      ws.send(JSON.stringify(response))
   }
})

[trasherdk]

By the way. If you are looking for a more Express like experience, while still getting the uWepSockets performance,
there is HyperExpress: High Performance Node.js Webserver

[trasherdk]

Yeah, I didn't dive that deep into the hyper thingy, but was pointing to the express like experience 😃