Odtnhj

I'm building a trading bot which sometimes requires to make multiple calls to the Exchange's API (e.g. refresh N charts after reconnect). I'd like to have these calls time-spaced so I don't end up flooding the API (I still don't want to discard any call I need to make, so debounce/throttle is not what I'm looking for). Like this:

Source: [update chart 1, update chart 2, ..., update chart N]

Observable: [update chart 1 -> wait 1 second -> update chart 2 -> wait 1 second -> ... -> update chart N]

I'd expect this observable to complete in N - 1 seconds.

How can I build such Observable?
(I'm using rxjs ^6.3.3)

Note: I was exploring the idea of having a callAPI Subject wrapping all calls to the API and delay them somehow, but I can't figure this either.

Thanks.-

Update: Ok, I ended up using Bottleneck, like this:

const limiter = new Bottleneck(
 minTime: 1000
)

Then: chartsToReset.map(async (chart) => await limiter.schedule(() => exchangeAPI.updateChart(chart)))

You may want to look at interval RxJS creation function in combination with mergeMap operator along these lines

const updates = ['chart1', 'chart2', 'chart3'];

// this function simulates fetching of data for the chart
function getUpdatedChartData(chartName: string) 
 return of(chart: chartName, data: [chartName + ' 1', chartName + ' 2', chartName + ' 3']).pipe(
 delay(Math.random() * 2000)
 )


const theObservableIWantToBuild = interval(1000).pipe(
 take(updates.length),
 mergeMap(i => getUpdatedChartData(updates[i]).pipe(
 tap(chartData => 
 console.log(JSON.stringify(chartData, null, 3)) 
 // do something with chart data)
 ),
 map(() => updates[i])
 )),
)

You may see that in the simulated function getUpdatedChartData I have added a delay, just to make it slightly more realistic.

As a general rule, Subjects are required in a relatively limited number of cases. Any time you think you need to use a Subject, ask yourself if there is not an equivalent solution which requires simply using operators.

You could use a function that has a Promise + setTimeout and a recursive function (something along the lines of):

var runQueries = function(source) 
 if (source.length > 0) 
 runQuery(source[0]).then(() => runQueries(source.slice(1));
 else 
 console.log('done!')
 

// this is just pseudo code...
var runQuery = function(item) 
 //var promise = new Promise
 //run code
 // setTimeout for 1000 to resolve promise
 // return promise

Promise documentation on MDN

edit

If the iterating function is non-destructive with the array, and you and a properties queryRunning and queries (or something) you could do (I haven't used rxjs, so you'd have to modify code slightly for that format):

var next = function(query) 
 // queries and queryRunning are properties on the thing doing these calls
 queries.push(query);
 if (!queryRunning) 
 runQueries();
 

var runQueries = function() 
 if (queries.length > 0) 
 queryRunning = true;
 runQuery(queries.shift()).then(() => runQueries();
 else 
 queryRunning = false;
 console.log('done!')
 

// this is just pseudo code...
var runQuery = function(query) 
 var promise1 = new Promise(function(resolve, reject) 
 setTimeout(function() 
 resolve('complete');
 , 1000);
 );
 //run code to handle query
 return promise1;