@giact/eslint-plugin-async-protect
v3.0.1
Published
Protects against missing await keywords on async functions
Downloads
2
Maintainers
Readme
@giact/eslint-plugin-async-protect
Async functions are great, especially when combined with the await
keyword. That being said it isn't always obvious whether a function is asynchronous or not. It is also relatively easy to forget to stick an await
on a function. These can cause dome difficult to locate bugs and can waste significant time.
This plugin tries to prevent some of these problems. The other major benefit is because this encourages a naming convention, these rules can apply across different files.
This ESLint plugin enforces the following:
- functions defined with the
async
keyword should have anAsync
suffix on the name - calls to functions with an
Async
suffix on the name should be called withawait
Installation
Package: https://www.npmjs.com/package/@giact/eslint-plugin-async-protect
Assuming that you already have ESLint installed, simply run:
npm install --save-dev @giact/eslint-plugin-async-protect
Configuration
Within your .eslintrc
file you need to include the plugin, and specify the level the rules should apply:
{
"plugins": [
"async-protect"
],
"rules": {
"async-protect/async-suffix": "error",
"async-protect/async-await": ["warn", { "checkMissingAwait": true, "checkExtraAwait": true }],
}
}
The general recommendation is to use warn
for the async-await
rule. This is because for 3rd party code you do not have control over function names, and the plugin may complain at extraneous await
keywords.
The async-await
rule has two options:
checkMissingAwait
: Checks if functions with anAsync
suffix are called with anawait
orreturn
(default:true
).checkExtraAwait
: Checks if functions without anAsync
suffix are called without anawait
orreturn
(default:true
).
You can set these options to true
or false
according to your requirements.
Rules
async-suffix
This rule enforces that async
functions have an Async
suffix to their name. Functions not defined as async
should not have the suffix. Here are some examples:
valid
const fooAsync = async function() {}
async function fooAsync() {}
class Bar {
async fooAsync() {}
foo() {}
}
function foo() {}
const foo = function() {}
invalid
const foo = async function() {}
async function foo() {}
class Bar {
async foo() {} // invalid
fooAsync() {} // invalid
}
function fooAsync() {}
const fooAsync = function() {}
async-await
This rule enforces that all functions with an Async
suffix on their name should be called with an await
or return
if checkMissingAwait
is enabled, and that functions without the suffix should not be called with an await
or return
if checkExtraAwait
is enabled.
There are times when you may wish for an async
function to run in the background, or where you need to call 3rd party code that doesn't follow the async-suffix
naming convention. In that case use // eslint-disable-line async-protect/async-await
to disable the rule for that line.
valid
await fooAsync();
return fooAsync();
const result = await fooAsync();
const result = (await fooAsync()).result;
const result = await foo().bar().bazAsync();
const result = foo();
invalid
fooAsync();
const result = fooAsync();
const result = fooAsync().result;
const result = foo().bar().bazAsync();
const result = await foo();
Remember that the valid and invalid examples may vary based on the checkMissingAwait
and checkExtraAwait
options provided in the configuration.