You got this this error because you've used Promise.promisify on an object, for example:
var fs = Promise.promisify(require("fs"));
Instead, use Promise.promisifyAll :
var fs = Promise.promisifyAll(require("fs"));
You got this error because you used new Promise() or new Promise(something) without passing a function as the parameter.
If you want to wrap an API with a promise manually, the correct syntax is:
function wrapWithPromise(parameter) {
return new Promise(function (resolve, reject) {
doSomethingAsync({
error:reject,
success:resolve
});
});
}
Please consider reading about new Promise and also consider checking out automatic promisification as well as Promise.method
You can get this error for several reasons:
new when creating a new promise using new Promise(resolver) syntax. This can happen when you tried to do something like:
return Promise(function(resolve,reject){
//...
})
You can correct this by doing:
return new Promise(function(resolve,reject){
//...
})
Please consider reading about new Promise and also consider checking out automatic promisification as well as Promise.method
Promise Bluebird does not support extending promises this way. Instead, see scoped prototypes.
The function being called expects a Promise, but is given something different. There are two main reasons why this may occur.
1. Working with collections (like arrays) but pass a single, non-collection element instead
Example:
function returnThree(){ return 3;}
Promise.resolve(5).map(returnThree).then(function(val){
console.log("Hello Value!",val);
});
The map operation is expecting an array here (or a promise on one) and instead gets the number 5.
function returnThree(){ return 3;}
Promise.resolve([5]).map(returnThree).then(function(val){
console.log("Hello Value!",val);
});
map is given an array with a single element (see [5] instead of 5), so this statement will work (but is bad practice).
2.return is forgotten in a 'fat' arrow / anonymous function call =>:
When debugging or performing a one-time operation on a variable before passing it to a function, a return variable is forgotten.
Example:
function nextFunction(something){ return Promise.resolve(something*3); }
myFunction()
.then(result => nextFunction(result)); // We are implicitly returning a Promise
Debugging, we want to see the value of result, so we add a console.log() line:
function nextFunction(something){ return Promise.resolve(something*3); }
myFunction().then(result => {
console.log("Debug:", result);
nextFunction(result)); // The chain is broken! We don't return anything to the .then() call
});
As this is an anonymous function call, we need to return something, which is not currently happening.
To fix, simply remember to add return in front of your promise-complying function:
function nextFunction(something){ return Promise.resolve(something*3); }
myFunction().then(result => {
console.log("Debug:", result);
return nextFunction(result)); // The anonymous function returns the function which returns the promise .then() needs
});
You are getting this error when trying to use Promise.coroutine and not passing it a generator function as a parameter. For example:
Promise.coroutine(function* () { // Note the *
var data = yield $.get("http://www.example.com");
var moreUrls = data.split("\n");
var contents = [];
for( var i = 0, len = moreUrls.length; i < len; ++i ) {
contents.push(yield $.get(moreUrls[i]));
}
return contents;
});
Please refer to the relevant section in the documentation about Generators in order to get usage instructions:
Note: Bluebird used to eagerly check for generators which caused problems with transpilers. Because of this, you might get an error similar to TypeError: Cannot read property 'next' of undefined if you pass a function instead of a generator function to Bluebird.
Promise.coroutine is built to work with generators to form C# like async/await
You passed a non-function where a function was expected.
You are getting this error because you are enabling long stack traces after a promise has already been created.
When using longStackTraces the first line in your code after requiring Bluebird should be:
Promise.config({
longStackTraces: true
});
See the API page about Promise.longStackTraces
You can get this error when you're trying to call .value or .error when inspecting a promise where the promise has not been fulfilled or rejected yet.
For example:
var p = Promise.delay(1000); p.inspect().value();
Consider using .isPending() .isFulfilled() and .isRejected() in order to inspect the promise for status.
Please consider reading more about synchronous inspection
You can get this error when you're trying to call .value or .error when inspecting a promise where the promise has not been fulfilled or rejected yet.
For example:
var p = Promise.delay(1000); p.inspect().value();
Consider using .isPending() .isFulfilled() and .isRejected() in order to inspect the promise for status.
Please consider reading more about synchronous inspection
This can happen when you are calling Promise.promisifyAll on a function and invoking it instead of passing it.
In general, the usage of Promise.promisifyAll is along the lines of var fs = Promise.promisifyAll(require("fs")).
Consider reading the section about promisification
This usually happens when you have a promise that resolves or rejects with itself.
For example: var p = Promise.delay(100).then(function(){ return p}); .
In this case, the promise resolves with itself which was is not intended.
This also happens when implementing live-updating models with a .then method that indicates when the model is "ready". A promise is a process, it starts and it ends.
Promises do not aim to solve such live updating problems directly. One option would be to use an intermediate promise - for example a .loaded property on the model that fulfills with nothing.
resolving it with itself tells it "it is done when it is done"
The .props method expects to receive an object.
For example:
Promise.props({
pictures: getPictures(),
comments: getComments(),
tweets: getTweets()
}).then(function(result){
console.log(result.tweets, result.pictures, result.comments);
});
This happens when a non object value or a promise that resolves with something that is not an object is being passed instead.
This happens when you call .some passing it a negative value or a non-integer.
One possible cause is using .indexOf which returns -1 when it doesn't find the value being searched for.
Please consider reading the API docs for .some
You are getting this error because you have tried to yield something in a coroutine without a yield handler, for example:
var coroutine = Promise.coroutine(function*(){
var bar = yield "Foo";
console.log(bar);
});
The solution is to either convert it to a promise by calling Promise.resolve on it or Promise.promisify if it's a callback:
var coroutine = Promise.coroutine(function*(){
var bar = yield Promise.resolve("Foo");
console.log(bar);
});
Or to use Promise.coroutine.addYieldHandler` to teach Promise.coroutine to accept these sort of values.
The .props method expects to receive an object.
For example:
Promise.props({
pictures: getPictures(),
comments: getComments(),
tweets: getTweets()
}).then(function(result){
console.log(result.tweets, result.pictures, result.comments);
});
This happens when a non object value or a promise that resolves with something that is not an object is being passed instead.
This error indicates you have tried to call Promise.promisifyAll on an object that already has a property with the Async suffix:
var myApi = { foo: function(cb){ ... }, fooAsync(cb) { ... }
This is because Bluebird adds the Async suffix to distinguish the original method from the promisified one, so fooAsync would have been overridden. In order to avoid this - either rename fooAsync before promisifying the API, or call Promise.promisify manually on select properties.
You may also use the custom suffix option to choose another suffix that doesn't result in conflicts.
If you find this issue in a common library please open an issue.
Bluebird supports typed and predicate .catch() calls]. However in order to use the typed/predicate catch syntax for error handling you must do one of two things.
Pass it a constructor that inherits from Error:
}).catch(ReferenceError, function(e) { // this is fine
}).catch(Array, function(e) { // arrays don't capture stack traces
This is to enable better stack trace support and to have more consistent and logical code.
Alternatively, if you provide it a predicate be sure it's a simple function:
}).catch(function(e){ return false; }, function(e) { // this catches nothing
}).catch(function(e){ return e.someProp = 5; }, function(e) { // this is fine
Please see the API docs of .catch() on how to use predicate catches.
Async scheduler is a function that takes a callback function and calls the callback function as soon as possible, but asynchronously. For example setTimeout.
By default bluebird only tries a few common async schedulers, such as setTimeout, process.nextTick and MutationObserver. However if your JavaScript runtime environment doesn't expose any of these, you will see this error.
You may use Promise.setScheduler to pass a custom scheduler that your environment supports. For example in DukTape:
Promise.setScheduler(function(fn){ // fn is what to execute
var timer = uv.new_timer.call({});
uv.timer_start(timer, 0, 0, fn); // add the function as a callback to the timer
});
© 2013–2018 Petka Antonov
Licensed under the MIT License.
http://bluebirdjs.com/docs/error-explanations.html