ESLint Plugin

An ESLint plugin is available at @inngest/eslint-plugin, providing rules to enforce best practices when writing Inngest functions.

Getting started

Install the package using whichever package manager you'd prefer as a dev dependency.

npm install -D @inngest/eslint-plugin

Add the plugin to your ESLint configuration file with the recommended config.

  "plugins": ["@inngest"],
  "extends": ["plugin:@inngest/recommended"]

You can also manually configure each rule instead of using the plugin:@inngest/recommend config.

  "plugins": ["@inngest"],
  "rules": {
    "@inngest/await-inngest-send": "warn"

See below for a list of all rules available to configure.



You should use await or return before `inngest.send().

"@inngest/await-inngest-send": "warn" // recommended

In serverless environments, it's common that runtimes are forcibly killed once a request handler has resolved, meaning any pending promises that are not performed before that handler ends may be cancelled.

// ❌ Bad
inngest.send({ name: "some.event" });
// ✅ Good
await inngest.send({ name: "some.event" });

When not to use it

There are cases where you have deeper control of the runtime or when you'll safely await the send at a later time, in which case it's okay to turn this rule off.


Use of step.* within a function is not allowed.

"@inngest/no-nested-steps": "error" // recommended

Nesting calls is not supported and will result in an error at runtime. If your steps are nested, they're probably reliant on each other in some way. If this is the case, extract them into a separate function that runs them in sequence instead.

// ❌ Bad
await"a", async () => {
  const someValue = "...";
  await"b", () => {
    return use(someValue);
// ✅ Good
const aThenB = async () => {
  const someValue = await"a", async () => {
    return "...";

  return"b", async () => {
    return use(someValue);

await aThenB();


Do not mutate variables inside, return the result instead.

"@inngest/no-variable-mutation-in-step": "error" // recommended

Inngest executes your function multiple times over the course of a single run, memoizing state as it goes. This means that code within calls to is not called on every execution.

This can be confusing if you're using steps to update variables within the function's closure, like so:

// ❌ Bad
// THIS IS WRONG! only runs once and is skipped for future
// steps, so userID will not be defined.
let userId;

// Do NOT do this!  Instead, return data from
await"get-user", async () => {
  userId = await getRandomUserId();

console.log(userId); // undefined

Instead, make sure that any variables needed for the overall function are returned from calls to

// ✅ Good
// This is the right way to set variables within :)
const userId = await"get-user", () => getRandomUserId());

console.log(userId); // 123