How to make JavaScript execution wait for socket.on function response?

You can't "make Javascript wait" for an asynchronous event to occur. That is not how Javascript works. It is an event driven architecture that simply doesn't work that way.

Plus, there is no way to directly return a value from a function when that value is obtained through some sort of asynchronous operation. The function will return long before the value is ready. You can see the details of why this is so and some of the options here in this canonical answer about that general topic.

The modern way to handle an asynchronous result is to return a promise that will be resolved when your event occurs and the caller can then use that promise to get the eventual result.

function bar(data, timeout = 10000) {
    return new Promise((resolve, reject) => {
        let timer;

        socket.emit('message', data);

        function responseHandler(message) {
            // resolve promise with the value we got
            resolve(message);
            clearTimeout(timer);
        }

        socket.once('msg', responseHandler); 

        // set timeout so if a response is not received within a 
        // reasonable amount of time, the promise will reject
        timer = setTimeout(() => {
            reject(new Error("timeout waiting for msg"));
            socket.removeListener('msg', responseHandler);
        }, timeout);

    });
}

bar().then(message => {
   // you can use message here and only in here
});

What I've shown here is a little more advanced version that also implements a timeout so if the response is not received in some amount of time, the promise will reject. This is to try to avoid creating a promise that might just hang out forever, never getting a response and thus never resolving.

Note: If you're implementing some sort of request/response using socket.io, you can get a direct response from your first message which is a better way to use socket.io for a response to a particular request. Yo can see how the ack callback option works for socket.emit() here in the doc. To use it, you need cooperation from both ends of the connection. You send a message and specify an ack callback. The receiver of the message then provides some ack data which your ack callback will receive. This will be a direct response to your message with no chance for it to get confused if there are other requests of the same message also being made at the time. For request/response in socket.io this is the preferred architecture. To show you a complete code example of how to implement it, we would have to see the other end of your code that receives the socket.io message event.

OK, now that you've shown the other end of the connection, you should probably use the ack response feature of socket.io:

function bar(timeout = 10000) {
    return new Promise((resolve, reject) => {
        console.log("client sending message 'test'");
        socket.emit('message', 'test', function(response) {
            console.log("client got ack response", response);
            resolve(response);
        });
    });
}

bar().then(message => {
   // you can use message here and only in here
   console.log("response from bar(): ", message);
});

Server side:

var io = require('socket.io').listen(server);

io.sockets.on('connection', function (socket) {
    socket.on('message', function(message, ackCallback) {
        console.log("server received message", message);
        var result = 'test value'
        console.log("server sending back result", result);
        ackCallback(result);    
    });  
});

P.S. Your server-side code showed a username argument here:

io.sockets.on('connection', function(socket, username) {

There is no such username argument passed to that event handler so I'm not sure where you got that from. Your code didn't show actually using that so I just removed it (because it is invalid anyway).