@bigbinary/eslint-plugin-neeto 1.1.21 → 1.1.23

package/README.md

@@ -46,6 +46,9 @@ module.exports = {
 
 ## Exported rules
 
+
+- [use-classnames-for-dynamic-classes](./docs/src/rules/use-classnames-for-dynamic-classes.md)
+- [use-use-mutation-with-invalidation-hook](./docs/src/rules/use-use-mutation-with-invalidation-hook.md)
 - [no-withT-for-smart-components](./docs/src/rules/no-withT-for-smart-components.md)
 - [no-large-functions-inside-jsx](./docs/src/rules/no-large-functions-inside-jsx.md)
 - [use-standard-date-time-formats](./docs/src/rules/use-standard-date-time-formats.md)

package/dist/index.js

@@ -42,6 +42,8 @@
   var commonResolve$2 = loadJS$2("node_modules/@bigbinary/neeto-commons-frontend/configs/webpack/resolve.js");
   var resolve$2 = ramda.mergeDeepLeft(projectResolve$2, commonResolve$2);
   var rules = {
+    "@bigbinary/neeto/use-classnames-for-dynamic-classes": "error",
+    "@bigbinary/neeto/use-use-mutation-with-invalidation-hook": "error",
     "@bigbinary/neeto/no-withT-for-smart-components": "error",
     "@bigbinary/neeto/no-large-functions-inside-jsx": "error",
     "@bigbinary/neeto/use-standard-date-time-formats": "error",
@@ -549,6 +551,8 @@
   var NO_WITH_T_IN_SMART_COMPONENTS = '"withT" HOC should only be used in dumb components. "useTranslation" hook should be used here.';
   var USE_STANDARD_DATE_TIME_FORMATS = 'Use "dateFormat/timeFormat" from "@bigbinary/neeto-commons-frontend/utils" instead. Refer: https://github.com/bigbinary/neeto-commons-frontend/blob/main/docs/utils/README.md#dateformattimeformat';
   var MOVE_SPREAD_ATTRIBUTES_TO_TOP = "Move spread attribute to top";
+  var USE_USE_MUTATION_WITH_INVALIDATION = "Use useMutationWithInvalidation from 'neetocommons/react-utils'";
+  var USE_CLASSNAMES_PACKAGE = "Use classnames package for dynamic classes";
 
   var PACKAGES_TO_CHECK = ["@bigbinary/neeto-molecules", "@bigbinary/neetoui", "@bigbinary/neeto-commons-frontend"];
 
@@ -5368,7 +5372,7 @@
   };
 
   //import { } from "neetocommons/react-utils";
-  var REACT_UTILS_IMPORT_PATTERN$1 = {
+  var REACT_UTILS_IMPORT_PATTERN$2 = {
     type: TYPES.IMPORT_DECLARATION,
     source: {
       type: TYPES.LITERAL,
@@ -5478,7 +5482,7 @@
             context: context,
             fixer: fixer,
             functions: ["handleMetaClick"],
-            importPattern: REACT_UTILS_IMPORT_PATTERN$1
+            importPattern: REACT_UTILS_IMPORT_PATTERN$2
           });
           if (importStatement) fixerArray.push(importStatement);
           return fixerArray;
@@ -6648,7 +6652,7 @@
     var restOfString = inputString.slice(position + 1);
     return firstCharacter + textToInsert + restOfString;
   };
-  var reportError = function reportError(_ref) {
+  var reportError$1 = function reportError(_ref) {
     var context = _ref.context,
       node = _ref.node,
       arrowFunctionExpression = _ref.arrowFunctionExpression,
@@ -6689,7 +6693,7 @@
           componentDeclaration = node;
           if (!pure.matches(WITH_T_HOC_PATTERN, node)) return;
           var arrowFunctionExpression = node.declarations[0].init.arguments[0];
-          reportError({
+          reportError$1({
             context: context,
             node: node,
             arrowFunctionExpression: arrowFunctionExpression
@@ -6698,7 +6702,7 @@
         ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
           if (!pure.matches(EXPORTED_WITH_T_PATTERN, node)) return;
           if (!pure.matches(SMART_COMPONENT_PATTERN, componentDeclaration)) return;
-          reportError({
+          reportError$1({
             context: context,
             node: node,
             arrowFunctionExpression: componentDeclaration.declarations[0].init,
@@ -8412,6 +8416,99 @@
     }
   };
 
+  // className={isPending ? "opacity-30" : "opacity-0"}
+  // className={isPending && "opacity-30"}
+  var CONDITIONAL_CLASSNAMES_PATTERN = {
+    name: {
+      type: TYPES.JSX_IDENTIFIER,
+      name: "className"
+    },
+    value: {
+      type: TYPES.JSX_EXPRESSION_CONTAINER,
+      expression: {
+        type: ramda.includes(ramda.__, [TYPES.LOGICAL_EXPRESSION, TYPES.CONDITIONAL_EXPRESSION, TYPES.TEMPLATE_LITERAL])
+      }
+    }
+  };
+
+  // import classnames from "classnames";
+  var CLASSNAMES_IMPORT_PATTERN = {
+    type: TYPES.IMPORT_DECLARATION,
+    source: {
+      type: TYPES.LITERAL,
+      value: "classnames"
+    },
+    specifiers: pure.existsBy({
+      type: TYPES.IMPORT_DEFAULT_SPECIFIER,
+      local: {
+        type: TYPES.IDENTIFIER,
+        name: "classnames"
+      }
+    })
+  };
+
+  // ${isPending && "opacity-30"}
+  // ${isPending ? "opacity-30" : "opacity-0"}
+  var CONDITIONAL_EXPRESSION_PATTERN = {
+    expressions: [{
+      type: ramda.includes(ramda.__, [TYPES.LOGICAL_EXPRESSION, TYPES.CONDITIONAL_EXPRESSION])
+    }]
+  };
+
+  var getFixString = function getFixString(context, expressionNode) {
+    if (expressionNode.type === TYPES.LOGICAL_EXPRESSION) {
+      var left = context.getSourceCode().getText(expressionNode.left);
+      var right = context.getSourceCode().getText(expressionNode.right);
+      return "classnames({ ".concat(right, ": ").concat(left, " })");
+    }
+    var test = context.getSourceCode().getText(expressionNode.test);
+    var consequent = context.getSourceCode().getText(expressionNode.consequent);
+    var alternate = context.getSourceCode().getText(expressionNode.alternate);
+    return "classnames({".concat(consequent, ": ").concat(test, ", ").concat(alternate, ": !(").concat(test, ")})");
+  };
+
+  var useClassnamesForDynamicClasses = {
+    meta: {
+      type: "error",
+      docs: {
+        url: "https://github.com/bigbinary/eslint-plugin-neeto/blob/main/docs/src/rules/use-classnames-for-dynamic-classes.md",
+        description: "Enforce use of classnames for dynamic classes"
+      },
+      fixable: "code"
+    },
+    create: function create(context) {
+      return {
+        JSXAttribute: function JSXAttribute(node) {
+          if (!pure.matches(CONDITIONAL_CLASSNAMES_PATTERN, node)) return;
+          var expressionNode = node.value.expression;
+          if (expressionNode.type === TYPES.TEMPLATE_LITERAL) {
+            if (pure.matches(CONDITIONAL_EXPRESSION_PATTERN, expressionNode)) {
+              context.report({
+                node: node,
+                message: USE_CLASSNAMES_PACKAGE
+              });
+            }
+            return;
+          }
+          context.report({
+            node: node,
+            message: USE_CLASSNAMES_PACKAGE,
+            fix: function fix(fixer) {
+              var fixString = getFixString(context, expressionNode);
+              var fixerArray = [fixer.replaceText(expressionNode, fixString)];
+              var importExists = pure.existsBy(CLASSNAMES_IMPORT_PATTERN, getAllImports(node));
+              if (!importExists) {
+                var addImport = fixer.insertTextBefore(context.getAncestors()[0], 'import classnames from "classnames";\n');
+                fixerArray.push(addImport);
+              }
+              return fixerArray;
+            }
+          });
+        }
+      };
+    }
+  };
+
   var IMPORT_SOURCES = {
     "neeto-commons-frontend/constants": ["neetocommons/constants", "@bigbinary/neeto-commons-frontend/constants"],
     "neeto-team-members-frontend": ["neetoteam", "@bigbinary/neeto-team-members-frontend"]
@@ -26298,6 +26395,268 @@
     }
   };
 
+  var ONSUCCESS_OPTION = {
+    type: TYPES.PROPERTY,
+    key: {
+      name: "onSuccess"
+    }
+  };
+
+  // keysToInvalidate: [...]
+  var KEYS_TO_INVALIDATE_OPTION = {
+    type: TYPES.PROPERTY,
+    key: {
+      name: "keysToInvalidate"
+    }
+  };
+
+  // {
+  //   onSuccess: (...) => {....},
+  //   ...,
+  // });
+  var OPTIONS = {
+    type: TYPES.OBJECT_EXPRESSION,
+    properties: pure.existsBy(ONSUCCESS_OPTION)
+  };
+
+  // useMutation(api.update, {
+  //   onSuccess: (...) => {....},
+  //   ...,
+  // });
+  var USE_MUTATION_HOOK_WITH_ONSUCCESS = {
+    callee: {
+      type: TYPES.IDENTIFIER,
+      name: ramda.includes(ramda.__, ["useMutation", "useMutationWithInvalidation"])
+    },
+    arguments: pure.existsBy(OPTIONS)
+  };
+
+  // useMutation(api.update, {
+  //   onSuccess: (...) => {....queryClient....},
+  //   ...,
+  // });
+  var INVALIDATION_PATTERN = {
+    type: TYPES.EXPRESSION_STATEMENT,
+    expression: {
+      type: TYPES.CALL_EXPRESSION,
+      callee: {
+        type: TYPES.MEMBER_EXPRESSION,
+        object: {
+          type: TYPES.IDENTIFIER,
+          name: "queryClient"
+        }
+      }
+    }
+  };
+
+  // () => queryClient.invalidateQueries(CUSTOMERS)
+  var SINGLE_INVALIDATION_PATTERN = {
+    type: TYPES.CALL_EXPRESSION,
+    callee: {
+      type: TYPES.MEMBER_EXPRESSION,
+      object: {
+        type: TYPES.IDENTIFIER,
+        name: "queryClient"
+      },
+      property: {
+        type: TYPES.IDENTIFIER,
+        name: "invalidateQueries"
+      }
+    }
+  };
+
+  // import { useMutationWithInvalidation } from "neetocommons/react-utils";
+  var USE_MUTATION_WITH_INVALIDATION_IMPORT_PATTERN = {
+    type: TYPES.IMPORT_DECLARATION,
+    specifiers: pure.existsBy({
+      type: TYPES.IMPORT_SPECIFIER,
+      imported: {
+        type: TYPES.IDENTIFIER,
+        name: "useMutationWithInvalidation"
+      }
+    }),
+    source: {
+      type: TYPES.LITERAL,
+      value: "neetocommons/react-utils"
+    }
+  };
+
+  //import { } from "neetocommons/react-utils";
+  var REACT_UTILS_IMPORT_PATTERN$1 = {
+    type: TYPES.IMPORT_DECLARATION,
+    source: {
+      type: TYPES.LITERAL,
+      value: "neetocommons/react-utils"
+    },
+    specifiers: [{
+      type: TYPES.IMPORT_SPECIFIER
+    }]
+  };
+
+  // queryClient.setQueryData(...);
+  var OTHER_QUERY_CLIENT_USAGE_PATTERN = {
+    callee: {
+      property: {
+        type: TYPES.IDENTIFIER,
+        name: pure.isNot("invalidateQueries")
+      }
+    }
+  };
+
+  var reportError = function reportError(context, node) {
+    context.report({
+      node: node,
+      message: USE_USE_MUTATION_WITH_INVALIDATION
+    });
+  };
+  var getInitialFixerArray = function getInitialFixerArray(_ref) {
+    var node = _ref.node,
+      context = _ref.context,
+      fixer = _ref.fixer,
+      mutationOptions = _ref.mutationOptions,
+      existingKeysToInvalidate = _ref.existingKeysToInvalidate,
+      keys = _ref.keys,
+      importExists = _ref.importExists;
+    var replaceCallee = fixer.replaceText(node.callee, "useMutationWithInvalidation");
+    var indentLevel = context.getSourceCode().getFirstToken(mutationOptions.properties[0]).loc.start.column;
+    var addKeysToInvalidate;
+    if (existingKeysToInvalidate) {
+      addKeysToInvalidate = fixer.insertTextAfter(ramda.last(existingKeysToInvalidate.value.elements), ",".concat(keys));
+    } else {
+      addKeysToInvalidate = fixer.insertTextBefore(mutationOptions.properties[0], "keysToInvalidate: [".concat(keys, "],\n").concat(" ".repeat(indentLevel)));
+    }
+    var fixerArray = [replaceCallee, addKeysToInvalidate];
+    if (!importExists) {
+      var addImport = addFunctionImport({
+        context: context,
+        fixer: fixer,
+        functions: ["useMutationWithInvalidation"],
+        importPattern: REACT_UTILS_IMPORT_PATTERN$1
+      });
+      fixerArray.push(addImport);
+    }
+    return fixerArray;
+  };
+  var getRemoveCommaFix = function getRemoveCommaFix(context, fixer, onSuccess) {
+    var tokenAfter = context.getTokenAfter(onSuccess);
+    return tokenAfter.value === "," ? fixer.remove(tokenAfter) : null;
+  };
+  var getVariables = function getVariables(context, params) {
+    var _params$arguments$0$e;
+    var variables = (_params$arguments$0$e = params.arguments[0].elements) === null || _params$arguments$0$e === void 0 ? void 0 : _params$arguments$0$e.filter(function (element) {
+      return element.type !== TYPES.LITERAL && /[a-z]/.test(context.getSourceCode().getText(element));
+    });
+    if (!params.arguments[0].elements && /[a-z]/.test(context.getSourceCode().getText(params.arguments[0]))) {
+      variables = params.arguments[0];
+    }
+    return variables;
+  };
+
+  var useUseMutationWithInvalidationHook = {
+    meta: {
+      type: "problem",
+      docs: {
+        url: "https://github.com/bigbinary/eslint-plugin-neeto/blob/main/docs/src/rules/use-use-mutation-with-invalidation-hook.md",
+        description: "Enforce use of useMutationWithInvalidation"
+      },
+      fixable: "code"
+    },
+    create: function create(context) {
+      return {
+        CallExpression: function CallExpression(node) {
+          if (!pure.matches(USE_MUTATION_HOOK_WITH_ONSUCCESS, node)) return;
+          var mutationOptions = pure.findBy({
+            type: TYPES.OBJECT_EXPRESSION
+          }, node.arguments);
+          var onSuccess = pure.findBy(ONSUCCESS_OPTION, mutationOptions.properties);
+          var existingKeysToInvalidate = pure.findBy(KEYS_TO_INVALIDATE_OPTION, mutationOptions.properties);
+          if (!onSuccess.value.body) return;
+          var importExists = pure.existsBy(USE_MUTATION_WITH_INVALIDATION_IMPORT_PATTERN, getAllImports(node));
+          if (onSuccess.value.body.type === TYPES.CALL_EXPRESSION) {
+            var params = onSuccess.value.body;
+            if (!pure.matches(SINGLE_INVALIDATION_PATTERN, params)) return;
+            var variables = getVariables(context, params);
+            if (pure.isPresent(variables)) {
+              reportError(context, node);
+            } else {
+              context.report({
+                node: node,
+                message: USE_USE_MUTATION_WITH_INVALIDATION,
+                fix: function fix(fixer) {
+                  var fixerArray = getInitialFixerArray({
+                    node: node,
+                    context: context,
+                    fixer: fixer,
+                    mutationOptions: mutationOptions,
+                    existingKeysToInvalidate: existingKeysToInvalidate,
+                    keys: context.getSourceCode().getText(params.arguments[0]),
+                    importExists: importExists
+                  });
+                  var removeInvalidations = fixer.remove(onSuccess);
+                  fixerArray.push(removeInvalidations);
+                  var removeComma = getRemoveCommaFix(context, fixer, onSuccess);
+                  if (removeComma) fixerArray.push(removeComma);
+                  return fixerArray;
+                }
+              });
+            }
+          } else if (onSuccess.value.body.type === TYPES.BLOCK_STATEMENT) {
+            var _params = onSuccess.value.body.body;
+            var invalidations = pure._filterBy(INVALIDATION_PATTERN, _params);
+            if (pure.isNotPresent(invalidations)) return;
+            var otherOptions = pure._removeBy(INVALIDATION_PATTERN, _params);
+            var queryClientInOtherOptions = otherOptions === null || otherOptions === void 0 ? void 0 : otherOptions.find(function (item) {
+              return context.getSourceCode().getText(item).includes("queryClient");
+            });
+            if (queryClientInOtherOptions || pure.findBy(OTHER_QUERY_CLIENT_USAGE_PATTERN, ramda.pluck("expression", invalidations))) {
+              return;
+            }
+            var invalidationsWithoutVariables = invalidations.filter(function (item) {
+              var variables = getVariables(context, item.expression);
+              return pure.isNotPresent(variables);
+            });
+            if (pure.isNotPresent(invalidationsWithoutVariables)) {
+              reportError(context, node);
+            } else {
+              var keys = ramda.pluck("expression", invalidationsWithoutVariables).flatMap(function (item) {
+                return item.arguments.map(function (arg) {
+                  return context.getSourceCode().getText(arg);
+                });
+              });
+              context.report({
+                node: node,
+                message: USE_USE_MUTATION_WITH_INVALIDATION,
+                fix: function fix(fixer) {
+                  var fixerArray = getInitialFixerArray({
+                    node: node,
+                    context: context,
+                    fixer: fixer,
+                    mutationOptions: mutationOptions,
+                    existingKeysToInvalidate: existingKeysToInvalidate,
+                    keys: keys.join(", "),
+                    importExists: importExists
+                  });
+                  if (_params.length === invalidationsWithoutVariables.length) {
+                    var _removeInvalidations = fixer.remove(onSuccess);
+                    fixerArray.push(_removeInvalidations);
+                    var removeComma = getRemoveCommaFix(context, fixer, onSuccess);
+                    if (removeComma) fixerArray.push(removeComma);
+                    return fixerArray;
+                  }
+                  var removeInvalidations = invalidationsWithoutVariables.map(function (item) {
+                    return fixer.remove(item);
+                  });
+                  fixerArray.push.apply(fixerArray, _toConsumableArray(removeInvalidations));
+                  return fixerArray;
+                }
+              });
+            }
+          }
+        }
+      };
+    }
+  };
+
   var useWebpackAlias = {
     meta: {
       type: "suggestion",
@@ -26881,6 +27240,8 @@
 
   var index = {
     rules: {
+      "use-classnames-for-dynamic-classes": useClassnamesForDynamicClasses,
+      "use-use-mutation-with-invalidation-hook": useUseMutationWithInvalidationHook,
       "no-withT-for-smart-components": noWithTForSmartComponents,
       "no-large-functions-inside-jsx": noLargeFunctionsInsideJsx,
       "use-standard-date-time-formats": useStandardDateTimeFormats,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigbinary/eslint-plugin-neeto",
-  "version": "1.1.21",
+  "version": "1.1.23",
   "main": "dist/index.js",
   "license": "UNLICENSED",
   "scripts": {