q

I have a simple node module which connects to a database and has several functions to receive data, for example this function: dbConnection.js: import mysql from 'mysql'; const connection = mysql.createConnection({ host: 'localhost', user: 'user', password: 'password', database: 'db' }); export default { getUsers(callback) { connection.connect(() => { connection.query('SELECT * FROM Users', (err, result) => { if (!err){ callback(result); } }); }); } }; The module would be called this way from a different node module: app.js: import dbCon from './dbConnection.js'; dbCon.getUsers(console.log); I

I want to perform an operation repeatedly, with an increasing timeout between each operation, until it succeeds or a certain amount of time elapses. How do I structure this with promises in Q? Benjamin Gruenbaum All the answers here are really complicated in my opinion. Kos has the right idea but you can shorten the code by writing more idiomatic promise code: function retry(operation, delay) { return operation().catch(function(reason) { return Q.delay(delay).then(retry.bind(null, operation, delay * 2)); }); } And with comments: function retry(operation, delay) { return operation(). // run the

I have seen Chaining an arbitrary number of promises in Q ; my question is different. How can I make a variable number of calls, each of which returns asynchronously, in order? The scenario is a set of HTTP requests, the number and type of which is determined by the results of the first HTTP request. I'd like to do this simply. I have also seen this answer which suggests something like this: var q = require('q'), itemsToProcess = ["one", "two", "three", "four", "five"]; function getDeferredResult(prevResult) { return (function (someResult) { var deferred = q.defer(); // any async function

I have an array of integer ids, such as var a=[1,2,3,4,5] and I have a need to perform asynchronous remote calls for each of these ids. Each call is a WebAPI request performed using $resource and presented as promise. I need to create a function that takes array of these IDs, then initializes recursive promises chain. The chain should result in consequential webapi calls for each of IDs, one by one. These calls should not be parallel but chained. The function in question returns itself a "main" promise that should be resolved or rejected based on result of asynchronous web calls. That is, if

I'm studying the promises pattern and using kriskowal's q for node.js, having this snippet: var deferred = Q.defer(); try { messageData = JSON.parse(message); } catch (e) { global.logger.warn('Error parsing JSON message.'); deferred.reject(e); } ... if (some_reason) deferred.resolve(something); ... return deferred.promise; What if both the parser fails and some_reason is true? Will the execution procede from rejecting through resolving and both promise's method be called at different times, thus generating a bug? Should i avoid to call reject/resolve multiple times? Since promises can only

In the promise library Q , you can do the following to sequentially chain promises: var items = ['one', 'two', 'three']; var chain = Q(); items.forEach(function (el) { chain = chain.then(foo(el)); }); return chain; however, the following doesn't work with $q : var items = ['one', 'two', 'three']; var chain = $q(); items.forEach(function (el) { chain = chain.then(foo(el)); }); return chain; Redgeoff, your own answer is the way I used to translate an array into a chained series of promises. The emergent de facto pattern is as follows : function doAsyncSeries(arr) { return arr.reduce(function