Define empty Bluebird promise like in Q


With Q I can define a new promise with:

var queue = q();

But with Bluebird if I do:

var queue = new Promise();

I get:

TypeError: the promise constructor requires a resolver function

How can I get the same result that I had with Q?

This is a snippet of my code:

var queue    = q()
    promises = [];
queue = queue.then(function () {
    return Main.gitControl.gitAdd(fileObj.filename, updateIndex);
});
// Here more promises are added to queue in the same way used above...
promises.push(queue);
return Promise.all(promises).then(function () {
   // ...
});
var resolver = Promise.defer();
setTimeout(function() {
    resolver.resolve(something); // Resolve the value
}, 5000);
return resolver.promise;

This line is quite often used in the documentation.

Be aware that this is usually an anti-pattern to use that. But if you know what you're doing, Promise.defer() is a way to get the resolver that is similar Q's way.

It is, however, discouraged to use this method. Bluebird has even deprecated it.

Instead, you should use this way:

return new Promise(function(resolve, reject) {
    // Your code
});

See the relevant documentation bits: Promise.defer() and new Promise().


After the update of your question, here is your issue: you're reusing the same promise to resolve several values. A promise can only be resolved once. It means you have to use Promise.defer() as many times as you have promises.

That said, after seeing more of your code, it seems you're really using anti-patterns. One advantage of using promises is error handling. For your case, you'd just need the following code:

var gitControl = Promise.promisifyAll(Main.gitControl);
var promises = [];
promises.push(gitControl.gitAddAsync(fileObj.filename, updateIndex));
return promises;

This should be enough to handle your use case. It is a lot clearer, and it also has the advantage of really handling the errors correctly.


Florian provided a good answer For the sake of your original question, there are several ways to start a chain with Bluebird.

One of the simplest is calling Promise.resolve() on nothing:

var queue = Promise.resolve(); //resolve a promise with nothing or cast a value

or

Promise.try(function(...){
    return ...//chain here
});

So you can do:

var queue    = Promise.resolve()
    promises = [];
queue = queue.then(function () {
    return Main.gitControl.gitAdd(fileObj.filename, updateIndex);
});

// Here more promises are added to queue in the same way used above...
promises.push(queue);
return Promise.all(promises).then(function () {
   // ...
});

Although, personally I'd do something like:

//arr is your array of fileObj and updateIndex

Promise.map(arr,function(f){ return Main.gitControl.gitAdd(f.filename,f.updateIndex).
    then (function(result){
        //results here
    });

I came across this as I had a method which fetches a resource on the internet and returns the content, but I want it to handle connection timeouts and retrying up to X times with delays between.

As Bluebird.defer is deprecated, I used this which does this trick:

const Promise = require('bluebird');

var fetch = function (options, promise) {
    var resolve, reject;
    if (promise) {
        resolve = promise.resolve;
        reject = promise.reject;
        promise = promise.promise;
    } else {
        promise = new Promise(function () {
            resolve = arguments[0];
            reject = arguments[1];
        });
    }
    var retry = {promise: promise, resolve: resolve, reject: reject};

    // Your logic here that you want to retry
    if (typeof options.x === 'undefined') {
        reject(new Error('X not defined'));
    } else if (options.x < 3) {
        options.x++;
        options.retryAttempt = (options.retryAttempt || 0) + 1;
        console.log(`Retrying in 1 second attempt ${options.retryAttempt}...`);
        setTimeout(() => {
            fetch(options, retry)
        }, 1000);
    } else {
        resolve(options.x);
    }

    return promise;
}

fetch({x:0})
    .then(res => {
        console.log(res);
    })
    .catch(err => {
        throw err;
    });

I find a pattern like this useful for any kind of integration testing.

const responseResolver;

const response = new Promise(resolve => {
    responseResolver = resolve;
}).then(data => {
    console.log("data: ", data);
    return data;
});

// mock some method that returns a promise (e.g. waits for a response)
service.getIceCreams = () => response;

// do some assertions while the response is pending

responseResolver("cookie dough"); // will trigger .then: "data: cookie dough"

// do some assertions now that the response is completed