scope management in RxJs - rxjs

Question

Here, I'm mixing both RxJS and promise-mysql..
const mysql = require('promise-mysql');
const Rx = require('rxjs/Rx');
I establish a connection with this:
var conn;
var queryString = select product_id, set_complete_in from mi_product limit 2;
var conn;
const obs = Rx.Observable.fromPromise(mysql.createConnection({
host: 'somehost',
user: 'someuser',
password: 'some password',
database: 'someday'
}));
at this point the obs is a promise that may or not be resolve.
Here I set up a series of queries.. (basically a fan out, in of queries in parallel)
const responseStream = obs
.flatMap(connection => {
conn = connection;
//submitArray is an array of IDs
var requestStream = submitArray.map(id => Rx.Observable.fromPromise(connection.query(queryString, [id])));
//run these in parallel
return Rx.Observable.forkJoin(requestStream);
});
//it's an array of arrays so flatten..
responseStream.subscribe(resp =>
{
returnValue = resp.reduce((accum, arr) => {return accum.concat(arr);}, []);
console.log('returnValue is ', JSON.stringify(returnValue));
//call back here to return the data
}
,
err => {console.log('!!!!!!err is ', err);},
() => {console.log('connection end!'); conn.end();});
this all works, but my question is how to handle the connection. As you can see, I define the connection at a higher scope so it's available in the subscribe callback. It doesn't seem very functional to call conn.end() in the subscription.. It seems like I should be handling it within the responseStream definition. Does this seem correct?

Answer 1

Your code is a little bit hard to follow, but I think your problem is that you need access to your connection, from your promise, but you won't have access to it in a completion callback without mixing up scopes. If I were implementing this feature, I would solve this by ditching the fromPromise usage and creating my own stream. When subscribers were done with my stream, I'd clean up the connection.
Rx.Observable.create( observer => {
const createConnection = mysql.createConnection({
host: 'somehost',
user: 'someuser',
password: 'some password',
database: 'someday'
});
/* forward the connection and any errors to observer */
createConnection.then( observer.next, observer.error );
return function cleanUp() {
/* end the connection when we are done */
createConnection.then( connection => connection.end() );
};
});
This ensures that any "connection close" operation is handled by the source stream, a pattern that is common and advantageous when working with observables.