# promise/no-multiple-resolved

> Disallow paths that call `resolve` or `reject` more than once in a `new Promise()` executor

A promise settles once. Every later call to `resolve` or `reject` is ignored without an error, and the code around it still runs. A second call on the same path usually means a missing `return` or `else`.

The rule checks the function passed to `new Promise()` and each function inside it, one function at a time.

{/* Generated by src/codegen/lint-rule-docs.ts. Do not edit this section. */}

## Configure

Off by default. To turn it on:

```toml bunfig.toml
[lint.rules]
"promise/no-multiple-resolved" = "error" # or "warn"
```

{/* End of the generated section. */}

## Examples

Reported:

{/* bad */}
```js
function readConfig(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, "utf8", (err, text) => {
      if (err) {
        reject(err);
      }
      resolve(text); // also runs after reject(err)
    });
  });
}
```

Not reported:

{/* good */}
```js
function readConfig(path) {
  return new Promise((resolve, reject) => {
    fs.readFile(path, "utf8", (err, text) => {
      if (err) {
        reject(err);
        return;
      }
      resolve(text);
    });
  });
}
```

A `reject` in a `catch` block is fine if nothing after `resolve` in the `try` can throw:

{/* good */}
```js
new Promise((resolve, reject) => {
  try {
    resolve(JSON.parse(text));
  } catch (err) {
    reject(err);
  }
});
```

{/* bad */}
```js
new Promise((resolve, reject) => {
  try {
    resolve(JSON.parse(text));
    log("parsed"); // if this throws, reject runs after resolve
  } catch (err) {
    reject(err);
  }
});
```