CHANGELOG.md

@@ -1,7 +1,8 @@
 ## 5.1.0
 
-- Included `catch()` and `finally()` in `prefer-await-to-then`
-- Added some additional tests and upgraded some dev deps
+- Included `catch()` and `finally()` in `prefer-await-to-then` #196
+- Added some additional tests and upgraded some dev deps #196
+- Exempted array methods in prefer-await-to-callbacks ([#212](https://github.com/xjamundx/eslint-plugin-promise/issues/212))
 
 ## 5.0.0
 

__tests__/no-callback-in-promise.js

@@ -17,6 +17,14 @@ ruleTester.run('no-callback-in-promise', rule, {
     'function thing(callback) { callback() }',
     'doSomething(function(err) { callback(err) })',
 
+    // TODO: support safe callbacks (see #220)
+    // 'whatever.then((err) => { process.nextTick(() => cb()) })',
+    // 'whatever.then((err) => { setImmediate(() => cb())) })',
+    // 'whatever.then((err) => setImmediate(() => cb()))',
+    // 'whatever.then((err) => process.nextTick(() => cb()))',
+    // 'whatever.then((err) => process.nextTick(cb))',
+    // 'whatever.then((err) => setImmediate(cb))',
+
     // arrow functions and other things
     'let thing = (cb) => cb()',
     'doSomething(err => cb(err))',

__tests__/prefer-await-to-callbacks.js

@@ -18,6 +18,17 @@ ruleTester.run('prefer-await-to-callbacks', rule, {
     'dbConn.on("error", err => { console.error(err) })',
     'dbConn.once("error", err => { console.error(err) })',
     'heart(something => {})',
+    'getErrors().map(error => responseTo(error))',
+    'errors.filter(err => err.status === 402)',
+    'errors.some(err => err.message.includes("Yo"))',
+    'errors.every(err => err.status === 402)',
+    'errors.filter(err => console.log(err))',
+    'const error = errors.find(err => err.stack.includes("file.js"))',
+    'this.myErrors.forEach(function(error) { log(error); })',
+    'find(errors, function(err) { return  err.type === "CoolError" })',
+    'map(errors, function(error) { return  err.type === "CoolError" })',
+    '_.find(errors, function(error) { return  err.type === "CoolError" })',
+    '_.map(errors, function(err) { return  err.type === "CoolError" })',
   ],
 
   invalid: [
@@ -58,7 +69,23 @@ ruleTester.run('prefer-await-to-callbacks', rule, {
       errors: [{ message }],
     },
     {
-      code: 'heart(function(error) {})',
+      code: `async.map(files, fs.stat, function(err, results) { if (err) throw err; });`,
+      errors: [{ message }],
+    },
+    {
+      code: `_.map(files, fs.stat, function(err, results) { if (err) throw err; });`,
+      errors: [{ message }],
+    },
+    {
+      code: `map(files, fs.stat, function(err, results) { if (err) throw err; });`,
+      errors: [{ message }],
+    },
+    {
+      code: `map(function(err, results) { if (err) throw err; });`,
+      errors: [{ message }],
+    },
+    {
+      code: `customMap(errors, (err) => err.message)`,
       errors: [{ message }],
     },
   ],

docs/rules/no-callback-in-promise.md

@@ -1,3 +1,57 @@
-# Avoid calling `cb()` inside of a `then()` (use [nodeify][] instead) (no-callback-in-promise)
+# Avoid calling `cb()` inside of a `then()` or `catch()` (no-callback-in-promise)
 
-[nodeify]: https://www.npmjs.com/package/nodeify
+As a general rule, callbacks should never be directly invoked inside a [Promise.prototype.then()] or [Promise.prototype.catch()] method. That's because your callback may be unintentionally be invoked twice. It also can be confusing to mix paradigms.
+
+Take the following example:
+
+```js
+function callback(err, data) {
+  console.log("Callback got called with:", err, data);
+  throw new Error("My error");
+}
+
+// note: passing `err.message` for demo purposes, normally you would pass `err`
+Promise.resolve()
+  .then(() => callback(null, "data"))
+  .catch(err => callback(err.message, null));
+```
+
+If you run this example, your output will look like the following:
+
+```
+Callback got called with: null data
+Callback got called with: My error null
+```
+
+**How to fix it?**
+
+Ensure that your callback invocations are wrapped by a deferred execution function such as:
+- [setImmediate()] or [process.nextTick()]: for Node.js.
+- [setTimeout()]: for Browsers and Node.js.
+
+```js
+// node.js
+Promise.resolve()
+  .then(() => setImmediate(() => callback(null, "data")))
+  .catch(err => setImmediate(() => callback(err.message, null)));
+
+// node.js and browsers
+Promise.resolve()
+  .then(() => setTimeout(() => callback(null, "data"), 0))
+  .catch(err => setTimeout(() => callback(err.message, null), 0));
+```
+
+Your output will now look like the following:
+
+```js
+Callback got called with: null data
+```
+
+Finally, if your callbacks have a Node.js signature (i.e. `callback(err, data)`), consider using [util.promsify] for promisifying your callback code instead of combining the approaches.
+
+[util.promisify]: https://nodejs.org/dist/latest/docs/api/util.html#utilpromisifyoriginal
+[Promise.prototype.then()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then
+[Promise.prototype.catch()]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
+[setImmediate()]: https://nodejs.org/docs/latest-v14.x/api/timers.html#timers_setimmediate_callback_args
+[process.nextTick()]: https://nodejs.org/docs/latest-v14.x/api/process.html#process_process_nexttick_callback_args
+[setTimeout()]: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout

package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-promise",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "Enforce best practices for JavaScript promises",
   "keywords": [
     "eslint",

rules/prefer-await-to-callbacks.js

@@ -50,6 +50,31 @@ module.exports = {
           ) {
             return
           }
+
+          // carve out exemption for map/filter/etc
+          const arrayMethods = [
+            'map',
+            'every',
+            'forEach',
+            'some',
+            'find',
+            'filter',
+          ]
+          const isLodash =
+            node.callee.object &&
+            ['lodash', 'underscore', '_'].includes(node.callee.object.name)
+          const callsArrayMethod =
+            node.callee.property &&
+            arrayMethods.includes(node.callee.property.name) &&
+            (node.arguments.length === 1 ||
+              (node.arguments.length === 2 && isLodash))
+          const isArrayMethod =
+            node.callee.name &&
+            arrayMethods.includes(node.callee.name) &&
+            node.arguments.length === 2
+          if (callsArrayMethod || isArrayMethod) return
+
+          // actually check for callbacks (I know this is the worst)
           if (
             arg.params &&
             arg.params[0] &&