@bigbinary/eslint-plugin-neeto 1.1.20 → 1.1.22

package/README.md

@@ -46,6 +46,7 @@ module.exports = {
 
 ## Exported rules
 
+- [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)
@@ -113,6 +114,7 @@ module.exports = {
 - [use-functions-and-hooks-from-neeto-commons-frontend.md](./docs/src/rules/use-functions-and-hooks-from-neeto-commons-frontend.md)
 - [zustand-use-with-immutable-actions-wrapper-inside-create](./docs/src/rules/zustand-use-with-immutable-actions-wrapper-inside-create.md)
 - [add-required-peer-dependencies](./docs/src/rules/add-required-peer-dependencies.md)
+- [move-spread-attributes-to-top-position](./docs/src/rules/move-spread-attributes-to-top-position.md)
 
 ## Other references
 

package/dist/index.js

@@ -42,6 +42,7 @@
   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-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",
@@ -151,7 +152,8 @@
     "@bigbinary/neeto/merge-spread-attributes": "error",
     "@bigbinary/neeto/props-inside-spread-attributes-should-be-sorted": "error",
     "@bigbinary/neeto/props-with-different-key-value-should-be-outside-spread-attribute": "error",
-    "@bigbinary/neeto/use-common-constants": "warn"
+    "@bigbinary/neeto/use-common-constants": "warn",
+    "@bigbinary/neeto/move-spread-attributes-to-top-position": "error"
   };
 
   var recommended = {
@@ -547,6 +549,8 @@
   var USE_WITH_T_HOC_IN_DUMB_COMPONENTS = 'Use "withT" HOC from "neeto-commons-frontend" instead of useTranslation hook in Dumb components';
   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 PACKAGES_TO_CHECK = ["@bigbinary/neeto-molecules", "@bigbinary/neetoui", "@bigbinary/neeto-commons-frontend"];
 
@@ -5366,7 +5370,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,
@@ -5476,7 +5480,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;
@@ -6646,7 +6650,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,
@@ -6687,7 +6691,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
@@ -6696,7 +6700,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,
@@ -6879,6 +6883,13 @@
       array.splice(index, 1);
     }
   };
+  var findIndexToInsert = function findIndexToInsert(endIndex, attributes) {
+    var index = endIndex - 1;
+    for (; index >= 0; --index) {
+      if (attributes[index].type === TYPES.JSX_SPREAD_ATTRIBUTE) return index + 1;
+    }
+    return index + 1;
+  };
 
   var mergeSpreadAttributes = {
     meta: {
@@ -7004,6 +7015,43 @@
     }
   };
 
+  var moveSpreadAttributesToTopPosition = {
+    meta: {
+      type: "problem",
+      docs: {
+        url: "https://github.com/bigbinary/eslint-plugin-neeto/blob/main/docs/src/rules/move-spread-attributes-to-top-position.md",
+        description: "Enforce moving spread attributes to top most position in oprning elements"
+      },
+      fixable: "code"
+    },
+    create: function create(context) {
+      return {
+        JSXSpreadAttribute: function JSXSpreadAttribute(node) {
+          var _node$argument$proper;
+          if (!pure.matches(SPREAD_ATTRIBUTE_WITH_OBJECT_EXPRESSION, node) || (_node$argument$proper = node.argument.properties) !== null && _node$argument$proper !== void 0 && _node$argument$proper.find(pure.matches(OTHER_PROPS_INSIDE_SPREAD_ATTRIBUTE))) {
+            return;
+          }
+          var attributes = node.parent.attributes;
+          var nodeIndex = pure.findIndexBy({
+            range: node.range
+          }, attributes);
+          var indexToInsert = findIndexToInsert(nodeIndex, attributes);
+          if (indexToInsert === nodeIndex) return;
+          var indentLevel = context.getSourceCode().getFirstToken(attributes[0]).loc.start.column;
+          context.report({
+            node: node,
+            message: MOVE_SPREAD_ATTRIBUTES_TO_TOP,
+            fix: function fix(fixer) {
+              var removeNode = fixer.remove(node);
+              var moveNode = fixer.insertTextBefore(attributes[indexToInsert], "".concat(context.getSourceCode().getText(node), "\n").concat(" ".repeat(indentLevel)));
+              return [moveNode, removeNode];
+            }
+          });
+        }
+      };
+    }
+  };
+
   var noRepetitionInPropKeyAndValueName = {
     meta: {
       type: "problem",
@@ -26252,6 +26300,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",
@@ -26835,6 +27145,7 @@
 
   var index = {
     rules: {
+      "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,
@@ -26901,7 +27212,8 @@
       "no-unnecessary-if-condition": noUnnecessaryIfCondition,
       "zustand-use-with-immutable-actions-wrapper-inside-create": useWithImmutableActionsWrapperInsideCreate,
       "add-required-peer-dependencies": addRequiredPeerDependencies,
-      "use-common-constants": useCommonConstants
+      "use-common-constants": useCommonConstants,
+      "move-spread-attributes-to-top-position": moveSpreadAttributesToTopPosition
     },
     configs: {
       recommended: recommended,

package/package.json

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