Enforce best practices for JavaScript promises.
You'll first need to install ESLint:
$ npm i eslint --save-dev
Next, install eslint-plugin-promise
:
$ npm install eslint-plugin-promise --save-dev
Note: If you installed ESLint globally (using the -g
flag) then you must also install eslint-plugin-promise
globally.
Add promise
to the plugins section of your .eslintrc
configuration file. You can omit the eslint-plugin-
prefix:
{
"plugins": [
"promise"
]
}
Then configure the rules you want to use under the rules section.
{
"rules": {
"promise/always-return": "error",
"promise/no-return-wrap": "error",
"promise/param-names": "error",
"promise/catch-or-return": "error",
"promise/no-native": "off",
"promise/no-nesting": "warn",
"promise/no-promise-in-callback": "warn",
"promise/no-callback-in-promise": "warn",
"promise/avoid-new": "warn"
}
}
catch-or-return
Enforces the use ofcatch
on un-returned promises.no-return-wrap
Avoid wrapping values inPromise.resolve
orPromise.reject
when not needed.param-names
Enforce consistent param names when creating new promises.always-return
Return inside eachthen
to create readable and reusable Promise chains.no-native
In an ES5 environment, make sure to create aPromise
constructor before using.no-nesting
Avoid nested .then() or .catch() statementsno-promise-in-callback
Avoid using promises inside of callbacksno-callback-in-promise
Avoid callingcb()
inside of athen()
(use nodeify] instead)avoid-new
Avoid creatingnew
promises outside of utility libs (use pify instead)
prefer-await-to-then
Preferawait
tothen()
for reading Promise valuesprefer-await-to-callbacks
Prefer async/await to the callback pattern
Ensure that each time a then()
is applied to a promise, a
catch()
is applied as well. Exceptions are made if you are
returning that promise.
myPromise.then(doSomething).catch(errors);
myPromise.then(doSomething).then(doSomethingElse).catch(errors);
function doSomethingElse() { return myPromise.then(doSomething) }
myPromise.then(doSomething);
myPromise.then(doSomething, catchErrors); // catch() may be a little better
function doSomethingElse() { myPromise.then(doSomething) }
You can pass an { allowThen: true }
as an option to this rule
to allow for .then(null, fn)
to be used instead of catch()
at
the end of the promise chain.
You can pass a { terminationMethod: 'done' }
as an option to this rule
to require done()
instead of catch()
at the end of the promise chain.
This is useful for many non-standard Promise implementations.
You can also pass an array of methods such as
{ terminationMethod: ['catch', 'asCallback', 'finally'] }
.
This will allow any of
Promise.resolve(1).then(() => { throw new Error('oops') }).catch(logerror)
Promise.resolve(1).then(() => { throw new Error('oops') }).asCallback(cb)
Promise.resolve(1).then(() => { throw new Error('oops') }).finally(cleanUp)
Ensure that inside a then()
you make sure to return
a new promise or value.
See http://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html (rule #5)
for more info on why that's a good idea.
We also allow someone to throw
inside a then()
which is essentially the same as return Promise.reject()
.
myPromise.then((val) => val * 2));
myPromise.then(function(val) { return val * 2; });
myPromise.then(doSomething); // could be either
myPromise.then((b) => { if (b) { return "yes" } else { return "no" } });
myPromise.then(function(val) {});
myPromise.then(() => { doSomething(); });
myPromise.then((b) => { if (b) { return "yes" } else { forgotToReturn(); } });
Enforce standard parameter names for Promise constructors
new Promise(function (resolve) { ... })
new Promise(function (resolve, reject) { ... })
new Promise(function (reject, resolve) { ... }) // incorrect order
new Promise(function (ok, fail) { ... }) // non-standard parameter names
Ensures that new Promise()
is instantiated with the parameter names resolve, reject
to avoid confusion with order such as reject, resolve
. The Promise constructor uses the RevealingConstructor pattern. Using the same parameter names as the language specification makes code more uniform and easier to understand.
Ensure that Promise
is included fresh in each file instead of relying
on the existence of a native promise implementation. Helpful if you want
to use bluebird
or if you don't intend to use an ES6 Promise shim.
var Promise = require("bluebird");
var x = Promise.resolve("good");
var x = Promise.resolve("bad");
Ensure that inside a then()
or a catch()
we always return
or throw
a raw value instead of wrapping in Promise.resolve
or Promise.reject
myPromise.then(function(val) {
return val * 2;
});
myPromise.then(function(val) {
throw "bad thing";
});
myPromise.then(function(val) {
return Promise.resolve(val * 2);
});
myPromise.then(function(val) {
return Promise.reject("bad thing");
})
- (c) MMXV jden jason@denizac.org - ISC license.
- (c) 2016 Jamund Ferguson jamund@gmail.com - ISC license.