eslint-plugin-crisp 1.7.8 → 1.7.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-crisp",
-  "version": "1.7.8",
+  "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,47 @@ 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);
+
+  if (
+    !node ||
+    node.type !== "LogicalExpression" ||
+    (node.operator !== "||" && node.operator !== "??")
+  ) {
+    return false;
+  }
+
+  const isOperandValid = (operand) => {
+    operand = unwrapTransparentExpression(operand);
+
+    return (
+      operand.type === "Literal" ||
+      isEmptyLiteral(operand) ||
+      isReference(operand) ||
+      isFallback(operand)
+    );
+  };
+
+  return isReference(node.left) || isFallback(node.left)
+    ? isOperandValid(node.right)
+    : false;
+}
+
+// Checks a logger argument value is a reference, a fallback or an object of those
+function isAllowedValue(node) {
+  return isReference(node) || isFallback(node) || isReferenceObject(node);
+}
+
 // Checks an inline object only contains references (no computed values)
 function isReferenceObject(node) {
   node = unwrapTransparentExpression(node);
@@ -115,10 +156,65 @@ function isReferenceObject(node) {
       return false;
     }
 
-    return isReference(property.value) || isReferenceObject(property.value);
+    return isAllowedValue(property.value);
   });
 }
 
+// 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",
@@ -132,7 +228,7 @@ export default {
       message:
         "Logger messages must be single-line, double-quoted string literals.",
       reference:
-        "Logger interpolation arguments must be references or inline objects of references, not computed expressions."
+        "Logger interpolation arguments must be references, fallbacks (`||`, `??`) or inline objects of those, not computed expressions."
     }
   },
 
@@ -145,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 (
@@ -161,7 +262,7 @@ export default {
         }
 
         for (const value of values) {
-          if (!isReference(value) && !isReferenceObject(value)) {
+          if (!isAllowedValue(value)) {
             context.report({
               node: value,
               messageId: "reference"

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

@@ -15,6 +15,16 @@ ruleTester.run("logger-arguments", rule, {
   value
 );`,
     "App.logger.info(\"This intentionally long logger message may exceed the usual source line length when necessary.\");",
+    "App.logger.debug(\"Loaded value: %s\", value || \"default\");",
+    "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);",
@@ -80,7 +90,15 @@ ruleTester.run("logger-arguments", rule, {
       ]
     },
     {
-      code: "App.logger.debug(\"Loaded value: %s\", value || \"default\");",
+      code: "App.logger.debug(\"Loaded value: %s\", value || compute());",
+      errors: [
+        {
+          messageId: "reference"
+        }
+      ]
+    },
+    {
+      code: "App.logger.debug(\"Loaded value: %s\", value && \"default\");",
       errors: [
         {
           messageId: "reference"
@@ -111,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: [
@@ -120,7 +154,7 @@ ruleTester.run("logger-arguments", rule, {
       ]
     },
     {
-      code: "App.logger.debug(\"Values: %s / %s\", values.join(\", \"), fallback || \"none\");",
+      code: "App.logger.debug(\"Values: %s / %s\", values.join(\", \"), fallback || compute());",
       errors: [
         {
           messageId: "reference"