eslint-plugin-crisp 1.7.9 → 1.7.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-crisp",
-  "version": "1.7.9",
+  "version": "1.7.10",
   "description": "Custom ESLint Rules for Crisp",
   "author": "Crisp IM SAS",
   "main": "index.js",

package/rules/logger-arguments.js

@@ -94,6 +94,14 @@ function isReference(node) {
   );
 }
 
+// Checks an empty object or array literal (eg. `{}` or `[]`)
+function isEmptyLiteral(node) {
+  return (
+    (node.type === "ObjectExpression" && node.properties.length === 0) ||
+    (node.type === "ArrayExpression" && node.elements.length === 0)
+  );
+}
+
 // Checks a fallback expression like `value || "none"` or `value ?? other`
 function isFallback(node) {
   node = unwrapTransparentExpression(node);
@@ -111,6 +119,7 @@ function isFallback(node) {
 
     return (
       operand.type === "Literal" ||
+      isEmptyLiteral(operand) ||
       isReference(operand) ||
       isFallback(operand)
     );
@@ -151,6 +160,61 @@ function isReferenceObject(node) {
   });
 }
 
+// Checks a node is a `logger.levels.<level>` member expression
+function isLevelsReference(node) {
+  node = unwrapTransparentExpression(node);
+
+  return (
+    Boolean(node) &&
+    node.type === "MemberExpression" &&
+    node.object.type === "MemberExpression" &&
+    getPropertyName(node.object) === "levels" &&
+    node.object.object.type === "MemberExpression" &&
+    getPropertyName(node.object.object) === "logger"
+  );
+}
+
+// Checks a condition tests a logger level (eg. `logger.levels.error === true && x`)
+function isLevelCheck(node) {
+  node = unwrapTransparentExpression(node);
+
+  if (!node) {
+    return false;
+  }
+
+  if (node.type === "LogicalExpression" && node.operator === "&&") {
+    return isLevelCheck(node.left) || isLevelCheck(node.right);
+  }
+
+  if (
+    node.type === "BinaryExpression" &&
+    (node.operator === "===" || node.operator === "==")
+  ) {
+    return isLevelsReference(node.left) || isLevelsReference(node.right);
+  }
+
+  return isLevelsReference(node);
+}
+
+// Checks a node is inside the consequent of a logger level guard
+function isGuarded(ancestors, node) {
+  const chain = [...ancestors, node];
+
+  for (let index = chain.length - 2; index >= 0; index--) {
+    const ancestor = chain[index];
+
+    if (
+      ancestor.type === "IfStatement" &&
+      chain[index + 1] === ancestor.consequent &&
+      isLevelCheck(ancestor.test)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 export default {
   meta: {
     type: "suggestion",
@@ -177,6 +241,11 @@ export default {
           return;
         }
 
+        // Guarded by a log level check: computed values are allowed
+        if (isGuarded(sourceCode.getAncestors(node), node)) {
+          return;
+        }
+
         const [message, ...values] = node.arguments;
 
         if (

package/tests/rules/logger-arguments.test.js

@@ -19,6 +19,12 @@ ruleTester.run("logger-arguments", rule, {
     "App.logger.debug(\"Loaded value: %s\", this.value ?? \"none\");",
     "App.logger.debug(\"Loaded value: %s\", first || second || \"none\");",
     "App.logger.debug(\"Loaded value: %s\", { user: userId || \"none\" });",
+    "if (App.logger.levels.error === true) { App.logger.error(\"Purge failed: %s\", buckets.join(\", \"), error); }",
+    "if (App.logger.levels.warn === true) { App.logger.warn(fn_log_format()); }",
+    "if (App.logger.levels.error === true && other) { if (x) { App.logger.error(\"Slow: %s\", a + b); } }",
+    "if (this._app.logger.levels.debug) { this._app.logger.debug(\"Count: %s\", list.length + 1); }",
+    "App.logger.error(\"Failed\", { params: (request.params || {}) });",
+    "App.logger.error(\"Failed: %s\", list || []);",
     "App.logger.warn(\"Shutting down\", { bufferedCount });",
     "App.logger.warn(\"Shutting down\", { count: this.count, ...meta });",
     "App.logger.warn(\"Shutting down\", { nested: { bufferedCount } }, logMeta);",
@@ -123,6 +129,22 @@ ruleTester.run("logger-arguments", rule, {
         }
       ]
     },
+    {
+      code: "if (App.logger.levels.error === true) {} else { App.logger.error(\"Purge: %s\", buckets.join(\", \")); }",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "if (enabled) { App.logger.error(\"Purge: %s\", buckets.join(\", \")); }",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
     {
       code: "App.logger.debug(\"Retry count: %s\", 3);",
       errors: [