node.js How to get express.post to wait for the net.client.data event

Question

How to have express.post to wait for a response from a socket created using net client? net here means the package require("net")

Architecture

browser <-> express with built in unix domain client <-> some unix domain server

My express server serves the front end as usual. Sometimes, it gets information from other services running on the same machine. These services are outside my control. I use net to create a client to connect with them and this works fine.

Tried approaches

All the usual answers about express.post using, for example, a promise, are not applicable because they wait for a reply on the function you call.

For example. fs.readFile will return something related to the completion of fs.readFile and this can easily be promisified using the examples on the internet.

Node.js promise request return

https://www.intuz.com/blog/promises-in-node-js-with-examples

https://dzone.com/articles/how-to-interact-with-a-database-using-promises-in

https://www.turtle-techies.com/using-promises-with-express-js/

The problem However, with net, the reply comes from somewhere else. client.write is the method for sending. This method just returns true, not the response from the server.

We become aware of the response at the client.data event and I can't figure how to get a promise to watch the client.data event to fulfill the promise.

My best attempt Using turtle-techies as an example (all above are similar though differing syntax):

const readFilePromise = (filename) => new Promise((resolve, reject) => {
    fs.readFile(filename, 'utf-8', (err, data) => {
        if (err) {
            reject(err);
        } else {
            resolve(data);
        }
    });
});

const app = express();
//call the promisified long-running function. ONLY works if the function returns the data you need. client.write does not.
app.post('/get-file', (req, res) => {
    readFilePromise('important_file.txt')
        .then(data => res.end(data))
        .catch(err => res.end(`could not serve data: ${err}`))
});

Now I try rewriting the promisified function or method to suit net.client:

var net = require('net');
var socketName = '/tmp/dp.sock';
var client = net.createConnection(socketName);

client.on("connect", function() {
     client.write('client on connect');
});

client.on("data", function(data) {
     console.log("client.on data: ", data.toString());
     //I don't see a way to get a handle here on express.post req,res so
     // I think the answer lies elswhere. Anyway, it would be messy to put it here.
});

client.on('close', function() {
     console.log('client on close');
});
//========= end of client building ===========

//========= promisified client.write =========
const readFilePromise = (filename) => new Promise((resolve, reject) => {
    client.write('my message'); //This just returns true which I don't care about
    //now what to do here to become aware of client.ondata and handle its data?
});

I have a feeling the answer is in front of my face.

Answer 1

The answer is here: https://techbrij.com/node-js-tcp-server-client-promisify

In principle, wrap the client creation and client.write in a new class in which you can then do any promisification you like.

In case the link breaks, here's what they say (modified by me to be for unix domain socket; techbrij.com did tcp)

//in a module.js file
const net = require('net');
const DEF_socketName = '/tmp/echo.sock';

class Client {
 constructor(socketName = '/tmp/echo.sock') {
  this.socket = new net.createConnection(socketName);
  this.address = socketName || DEF_socketName;
  this.init();
 }
 
 init() {
  var client = this;
    client.socket.on("connect", function() {
         client.socket.write('hello from unix client!');
    });

    client.socket.on("data", function(data) {  //approahch 1 here we delete the function def and simply put dodata
         console.log("client.on data: ", data.toString());
         //client.destroy();
    });


    client.socket.on('close', function() {
         console.log('Connection closed');
    });
 }
 
 sendMessage(message) {
    console.log('client.sendMessage: ' + message);
    var client = this;
    return new Promise((resolve, reject) => {

    client.socket.write(message);
 
    client.socket.on('data', (data) => {
     resolve(data);
     if (data.toString().endsWith('exit')) {
      client.socket.destroy();
     }
    });
 
   client.socket.on('error', (err) => {
    reject(err);
   });
 
  });
 }
}
module.exports = Client;

Then in a client.js file:

const Client = require('./client_mod');
const client = new Client();
client.sendMessage('A')
.then((data)=> { console.log(`Received: ${data}`);  return client.sendMessage('B');} )
.then((data)=> { console.log(`Received: ${data}`);  return client.sendMessage('C');} )
.then((data)=> { console.log(`Received: ${data}`);  return client.sendMessage('exit');} )
.catch((err) =>{ console.error(err); })