The eslint-plugin-promise package is an ESLint plugin that enforces best practices and common idioms for dealing with promises in JavaScript. It provides a set of rules that catch common mistakes and enforce conventions when working with promises.

What are eslint-plugin-promise's main functionalities?

Avoiding creation of new promises outside of utility libraries

This rule ensures that the executor function of a new Promise has the parameters named 'resolve' and 'reject'.

/* eslint promise/param-names: 'error' */
new Promise((resolve, reject) => { /* executor function */ });

Ensuring that each time a then() is applied to a promise, a catch() is applied as well

This rule enforces the use of catch() on unhandled promises.

/* eslint promise/catch-or-return: 'error' */
promise.then(function(data) {
  // handle data
}).catch(function(error) {
  // handle error
});

Enforcing the return of a promise in certain contexts

This rule ensures that promise chains always return a value, preventing silent failures and unhandled rejections.

/* eslint promise/always-return: 'error' */
function foo() {
  return doSomething().then(function() {
    // do something else
    return 'result';
  });
}

Other packages similar to eslint-plugin-promise

Readme

Source

eslint-plugin-promise

Enforce best practices for JavaScript promises.

Installation

You'll first need to install ESLint:

$ npm install 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.

Usage

Add promise to the plugins section of your .eslintrc.json 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",
    "promise/no-new-statics": "error",
    "promise/no-return-in-finally": "warn",
    "promise/valid-params": "warn"
  }
}

or start with the recommended rule set:

{
  "extends": ["plugin:promise/recommended"]
}

Rules

rule	description	recommended	fixable
`catch-or-return`	Enforces the use of `catch()` on un-returned promises.	:bangbang:
`no-return-wrap`	Avoid wrapping values in `Promise.resolve` or `Promise.reject` when not needed.	:bangbang:
`param-names`	Enforce consistent param names and ordering when creating new promises.	:bangbang:
`always-return`	Return inside each `then()` to create readable and reusable Promise chains.	:bangbang:
`no-native`	In an ES5 environment, make sure to create a `Promise` constructor before using.
`no-nesting`	Avoid nested `then()` or `catch()` statements	:warning:
`no-promise-in-callback`	Avoid using promises inside of callbacks	:warning:
`no-callback-in-promise`	Avoid calling `cb()` inside of a `then()` (use nodeify instead)	:warning:
`avoid-new`	Avoid creating `new` promises outside of utility libs (use pify instead)
`no-new-statics`	Avoid calling `new` on a Promise static method	:bangbang:	:wrench:
`no-return-in-finally`	Disallow return statements in `finally()`	:warning:
`valid-params`	Ensures the proper number of arguments are passed to Promise functions	:warning:
`prefer-await-to-then`	Prefer `await` to `then()`/`catch()`/`finally()` for reading Promise values	:seven:
`prefer-await-to-callbacks`	Prefer async/await to the callback pattern	:seven:
`no-multiple-resolved`	Disallow creating new promises with paths that resolve multiple times

Key

icon	description
:bangbang:	Reports as error in recommended configuration
:warning:	Reports as warning in recommended configuration
:seven:	ES2017 Async Await rules
:wrench:	Rule is fixable with `eslint --fix`

Maintainers

Jamund Ferguson - @xjamundx
Macklin Underdown - @macklinu
Aadit M Shah - @aaditmshah

License

Keywords

FAQs

What is eslint-plugin-promise?

Is eslint-plugin-promise popular?

Is eslint-plugin-promise well maintained?

Last updated on 19 Oct 2022

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install