eslint-plugin-effector 0.5.1 → 0.7.0

package/.nvmrc

@@ -0,0 +1 @@
+16.10.0

package/README.md

@@ -39,34 +39,43 @@ To configure individual rules:
 }
 ```
 
-### Available presets
+### Available rules by preset
 
 #### plugin:effector/recommended
 
 This preset is recommended for most projects.
 
-#### plugin:effector/scope
-
-This preset is recommended for projects that use [Fork API](https://effector.dev/docs/api/effector/scope). You can read more about Fork API in [an article](https://dev.to/effector/the-best-part-of-effector-4c27).
-
-#### plugin:effector/react
-
-This preset is recommended for projects that use [React](https://reactjs.org) with Effector.
-
-### Supported rules
-
 - [effector/enforce-store-naming-convention](rules/enforce-store-naming-convention/enforce-store-naming-convention.md)
 - [effector/enforce-effect-naming-convention](rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md)
 - [effector/no-getState](rules/no-getState/no-getState.md)
-- [effector/no-unnecessary-duplication](rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
 - [effector/no-useless-methods](rules/no-useless-methods/no-useless-methods.md)
-- [effector/no-ambiguity-target](rules/no-ambiguity-target/no-ambiguity-target.md)
+- [effector/no-unnecessary-duplication](rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
 - [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
+- [effector/no-ambiguity-target](rules/no-ambiguity-target/no-ambiguity-target.md)
 - [effector/no-watch](rules/no-watch/no-watch.md)
 - [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
 - [effector/no-duplicate-on](rules/no-duplicate-on/no-duplicate-on.md)
+- [effector/keep-options-order](rules/keep-options-order/keep-options-order.md)
+
+#### plugin:effector/scope
+
+This preset is recommended for projects that use [Fork API](https://effector.dev/docs/api/effector/scope). You can read more about Fork API in [an article](https://dev.to/effector/the-best-part-of-effector-4c27).
+
 - [effector/strict-effect-handlers](rules/strict-effect-handlers/strict-effect-handlers.md)
+
+#### plugin:effector/react
+
+This preset is recommended for projects that use [React](https://reactjs.org) with Effector.
+
 - [effector/enforce-gate-naming-convention](rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md)
+- [effector/mandatory-useEvent](rules/mandatory-useEvent/mandatory-useEvent.md)
+
+#### plugin:effector/future
+
+This preset contains rules wich enforce _future-effector_ code-style.
+
+- [effector/no-forward](rules/no-forward/no-forward.md)
+- [effector/no-guard](rules/no-guard/no-guard.md)
 
 ## Maintenance
 

package/config/future.js

@@ -0,0 +1,7 @@
+module.exports = {
+  rules: {
+    "effector/prefer-sample-over-forward-with-mapping": "off",
+    "effector/no-forward": "warn",
+    "effector/no-guard": "warn",
+  },
+};

package/config/react.js

@@ -1,5 +1,6 @@
 module.exports = {
   rules: {
     "effector/enforce-gate-naming-convention": "error",
+    "effector/mandatory-useEvent": "error",
   },
 };

package/config/recommended.js

@@ -10,5 +10,6 @@ module.exports = {
     "effector/no-watch": "warn",
     "effector/no-unnecessary-combination": "warn",
     "effector/no-duplicate-on": "error",
+    "effector/keep-options-order": "warn",
   },
 };

package/index.js

@@ -12,10 +12,15 @@ module.exports = {
     "no-duplicate-on": require("./rules/no-duplicate-on/no-duplicate-on"),
     "strict-effect-handlers": require("./rules/strict-effect-handlers/strict-effect-handlers"),
     "enforce-gate-naming-convention": require("./rules/enforce-gate-naming-convention/enforce-gate-naming-convention"),
+    "keep-options-order": require("./rules/keep-options-order/keep-options-order"),
+    "no-forward": require("./rules/no-forward/no-forward"),
+    "no-guard": require("./rules/no-guard/no-guard"),
+    "mandatory-useEvent": require("./rules/mandatory-useEvent/mandatory-useEvent"),
   },
   configs: {
     recommended: require("./config/recommended"),
     scope: require("./config/scope"),
     react: require("./config/react"),
+    future: require("./config/future"),
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Enforcing best practices for Effector",
   "keywords": [
     "eslint",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "engines": {
-    "node": "^14 || ^16"
+    "node": "^14 || ^16 || ^18"
   },
   "peerDependencies": {
     "effector": "*",

package/rules/keep-options-order/config.js

@@ -0,0 +1,3 @@
+const correctOrder = ["clock", "source", "filter", "fn", "target"];
+
+module.exports = { correctOrder };

package/rules/keep-options-order/keep-options-order.js

@@ -0,0 +1,107 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { buildObjectInText } = require("../../utils/builders");
+
+const { correctOrder } = require("./config");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce options order for Effector methods",
+      category: "Style",
+      recommended: true,
+      url: createLinkToRule("keep-options-order"),
+    },
+    messages: {
+      invalidOrder: `Order of options should be ${makeTag(
+        correctOrder
+      )}, but found {{ incorrectOrderTag }}`,
+      changeOrder: "Sort options",
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        // Effect creation with method
+        const OPTIONS_METHODS = ["sample", "guard"];
+        for (const method of OPTIONS_METHODS) {
+          const localMethod = importedFromEffector.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorMethods = node.callee.name === localMethod;
+          if (!isEffectorMethods) {
+            continue;
+          }
+
+          const configNode = node?.arguments?.[0];
+          const optionsNodes = configNode?.properties;
+
+          const optionsOrder = optionsNodes?.map((prop) => prop?.key.name);
+
+          const idealOrder = filteredCorrectOrder(optionsOrder);
+
+          if (isCorrectOrder(optionsOrder, idealOrder)) {
+            continue;
+          }
+
+          context.report({
+            node,
+            messageId: "invalidOrder",
+            data: {
+              incorrectOrderTag: makeTag(optionsOrder),
+            },
+            suggest: [
+              {
+                messageId: "changeOrder",
+                fix(fixer) {
+                  const newConfig = buildObjectInText.fromArrayOfNodes({
+                    properties: sortNodesByName(optionsNodes, idealOrder),
+                    context,
+                  });
+
+                  return fixer.replaceText(configNode, newConfig);
+                },
+              },
+            ],
+          });
+        }
+      },
+    };
+  },
+};
+
+function makeTag(order) {
+  return order.join("->");
+}
+
+function isCorrectOrder(checkOrder, idealOrder) {
+  return idealOrder.every((refItem, index) => checkOrder?.[index] === refItem);
+}
+
+function filteredCorrectOrder(checkOrder) {
+  return correctOrder.filter((item) => checkOrder?.includes(item));
+}
+
+function sortNodesByName(nodes, nameOrder) {
+  const newNodes = [];
+
+  for (const name of nameOrder) {
+    const node = nodes.find((node) => node?.key.name === name);
+    newNodes.push(node);
+  }
+
+  return newNodes;
+}

package/rules/mandatory-useEvent/mandatory-useEvent.js

@@ -0,0 +1,63 @@
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { isInsideReactComponent } = require("../../utils/react");
+const { nodeTypeIs } = require("../../utils/node-type-is");
+const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Forbids `Event` and `Effect` usage without `useEvent` in React components.",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("mandatory-useEvent"),
+    },
+    messages: {
+      useEventNeeded:
+        "{{ unitName }} must be wrapped with `useEvent` from `effector-react` before usage inside React components",
+    },
+    schema: [],
+  },
+  create(context) {
+    const parserServices = context.parserServices;
+
+    // TypeScript-only rule, since units can be imported from anywhere
+    if (parserServices.hasFullTypeInformation) {
+      return {
+        Identifier(node) {
+          if (isInsideReactComponent(node)) {
+            if (
+              nodeTypeIs.effect({ node, context }) ||
+              nodeTypeIs.event({ node, context })
+            ) {
+              if (!isInsideUseEventCall({ node, context })) {
+                context.report({
+                  node,
+                  messageId: "useEventNeeded",
+                  data: {
+                    unitName: node.name,
+                  },
+                });
+              }
+            }
+          }
+        },
+      };
+    }
+
+    return {};
+  },
+};
+
+function isInsideUseEventCall({ node, context }) {
+  const calleeParentNode = traverseParentByType(node.parent, "CallExpression");
+
+  if (!calleeParentNode?.callee) return false;
+
+  return nodeTypeIs.effectorReactHook({
+    node: calleeParentNode.callee,
+    context,
+    hook: ["useEvent", "useUnit"],
+  });
+}

package/rules/no-ambiguity-target/no-ambiguity-target.js

@@ -1,6 +1,7 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -29,46 +30,42 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
-        for (const method of POSSIBLE_USELESS_METHODS) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
+        if (
+          method.isNot(["sample", "guard"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
+        const configHasTarget = node?.arguments?.[0]?.properties?.some(
+          (prop) => prop?.key.name === "target"
+        );
+        if (!configHasTarget) {
+          return;
+        }
 
-          const configHasTarget = node?.arguments?.[0]?.properties?.some(
-            (prop) => prop?.key.name === "target"
-          );
-          if (!configHasTarget) {
-            continue;
-          }
+        const resultAssignedInVariable = traverseParentByType(
+          node,
+          "VariableDeclarator",
+          { stopOnTypes: ["BlockStatement"] }
+        );
+        const resultPartOfChain = traverseParentByType(
+          node,
+          "ObjectExpression"
+        );
 
-          const resultAssignedInVariable = traverseParentByType(
-            node,
-            "VariableDeclarator",
-            { stopOnTypes: ["BlockStatement"] }
-          );
-          const resultPartOfChain = traverseParentByType(
+        if (resultAssignedInVariable || resultPartOfChain) {
+          context.report({
             node,
-            "ObjectExpression"
-          );
-
-          if (resultAssignedInVariable || resultPartOfChain) {
-            context.report({
-              node,
-              messageId: "ambiguityTarget",
-              data: {
-                methodName: node?.callee?.name,
-              },
-            });
+            messageId: "ambiguityTarget",
+            data: {
+              methodName: node?.callee?.name,
+            },
+          });
 
-            continue;
-          }
+          return;
         }
       },
     };

package/rules/no-duplicate-on/no-duplicate-on.js

@@ -1,5 +1,8 @@
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
 const { getNestedObjectName } = require("../../utils/get-nested-object-name");
+const {
+  traverseNestedObjectNode,
+} = require("../../utils/traverse-nested-object-node");
 const { is } = require("../../utils/is");
 
 module.exports = {
@@ -56,7 +59,9 @@ module.exports = {
 
     return {
       'CallExpression[callee.property.name="on"]'(node) {
-        const storeObject = getNestedCallee(node) ?? getAssignedVariable(node);
+        const storeObject = traverseNestedObjectNode(
+          getNestedCallee(node) ?? getAssignedVariable(node)
+        );
         const storeName = getStoreName(storeObject);
 
         if (!is.store({ context, node: storeObject })) {
@@ -96,6 +101,10 @@ module.exports = {
 };
 
 function normalizePossibleArrayNode(node) {
+  if (!node) {
+    return [];
+  }
+
   if (node.type === "ArrayExpression") {
     return node.elements;
   }

package/rules/no-forward/no-forward.js

@@ -0,0 +1,73 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const { replaceForwardBySample } = require("../../utils/replace-by-sample");
+const { extractConfig } = require("../../utils/extract-config");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer `sample` over `forward`",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-forward"),
+    },
+    messages: {
+      noForward:
+        "Instead of `forward` you can use `sample`, it is more extendable.",
+      replaceWithSample: "Repalce `forward` with `sample`.",
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const importNodes = new Map();
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          nodeMap: importNodes,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        if (
+          method.isNot("forward", {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
+
+        const forwardConfig = extractConfig(["from", "to"], { node });
+
+        if (!forwardConfig.from || !forwardConfig.to) {
+          return;
+        }
+
+        context.report({
+          messageId: "noForward",
+          node,
+          suggest: [
+            {
+              messageId: "replaceWithSample",
+              *fix(fixer) {
+                yield* replaceForwardBySample(forwardConfig, {
+                  fixer,
+                  node,
+                  context,
+                  importNodes,
+                });
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+};

package/rules/no-guard/no-guard.js

@@ -0,0 +1,78 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const { replaceGuardBySample } = require("../../utils/replace-by-sample");
+const { extractConfig } = require("../../utils/extract-config");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer `sample` over `guard`",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-guard"),
+    },
+    messages: {
+      noGuard:
+        "Instead of `guard` you can use `sample`, it is more extendable.",
+      replaceWithSample: "Repalce `guard` with `sample`.",
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const importNodes = new Map();
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          nodeMap: importNodes,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        if (
+          method.isNot("guard", {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
+
+        const guardConfig = extractConfig(
+          ["source", "clock", "target", "filter"],
+          {
+            node,
+          }
+        );
+
+        if (!guardConfig.clock || !guardConfig.filter) {
+          return;
+        }
+
+        context.report({
+          messageId: "noGuard",
+          node,
+          suggest: [
+            {
+              messageId: "replaceWithSample",
+              *fix(fixer) {
+                yield* replaceGuardBySample(guardConfig, {
+                  fixer,
+                  node,
+                  context,
+                  importNodes,
+                });
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+};

package/rules/no-unnecessary-combination/no-unnecessary-combination.js

@@ -1,5 +1,6 @@
 const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -29,16 +30,10 @@ module.exports = {
         });
       },
       CallExpression(node) {
-        const METHODS_WITH_POSSIBLE_UNNECESSARY_COMBINATION = [
-          "sample",
-          "guard",
-          "forward",
-        ];
-
         const CONFIG_ARG_PROPERTIES = ["source", "clock", "from"];
 
-        function toLocalMethod(method) {
-          return importedFromEffector.get(method);
+        function toLocalMethod(methodName) {
+          return importedFromEffector.get(methodName);
         }
 
         const UNNECESSARY_METHODS = {
@@ -47,48 +42,45 @@ module.exports = {
           from: ["merge"].map(toLocalMethod).filter(Boolean),
         };
 
-        for (const method of METHODS_WITH_POSSIBLE_UNNECESSARY_COMBINATION) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
+        if (
+          method.isNot(["sample", "guard", "forward"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
+        const candidates =
+          node?.arguments?.[0]?.properties?.filter((n) =>
+            CONFIG_ARG_PROPERTIES.includes(n.key.name)
+          ) ?? [];
 
-          const candidates =
-            node?.arguments?.[0]?.properties?.filter((n) =>
-              CONFIG_ARG_PROPERTIES.includes(n.key.name)
-            ) ?? [];
+        if (candidates.length === 0) {
+          return;
+        }
 
-          if (candidates.length === 0) {
+        for (const candidate of candidates) {
+          const candidateName = candidate?.value?.callee?.name;
+          const argProp = candidate?.key?.name;
+          if (!candidateName || !argProp) {
             continue;
           }
 
-          for (const candidate of candidates) {
-            const candidateName = candidate?.value?.callee?.name;
-            const argProp = candidate?.key?.name;
-            if (!candidateName || !argProp) {
-              continue;
-            }
-
-            const localUnnecessaryMethods = UNNECESSARY_METHODS[argProp];
-
-            const UnnecessaryMethodIsEffectorMethod =
-              localUnnecessaryMethods.some((m) => m === candidateName);
+          const localUnnecessaryMethods = UNNECESSARY_METHODS[argProp];
 
-            if (!UnnecessaryMethodIsEffectorMethod) {
-              continue;
-            }
+          const UnnecessaryMethodIsEffectorMethod =
+            localUnnecessaryMethods.some((m) => m === candidateName);
 
-            context.report({
-              node: candidate?.value,
-              messageId: "unnecessaryCombination",
-              data: { methodName: candidateName },
-            });
+          if (!UnnecessaryMethodIsEffectorMethod) {
+            continue;
           }
+
+          context.report({
+            node: candidate?.value,
+            messageId: "unnecessaryCombination",
+            data: { methodName: candidateName },
+          });
         }
       },
     };