eslint-plugin-effector 0.4.2 → 0.6.0

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

@@ -0,0 +1,137 @@
+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 = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids duplicate `.on` calls on store",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-duplicate-on"),
+    },
+    messages: {
+      duplicateOn:
+        "Method `.on` is called on store `{{ storeName }}` more than once for {{ unitName }}.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const usedOns = new Map();
+
+    function isEventUsedInStoreOn(scope, storeName, unitName) {
+      const usedOnsOnScope = usedOns.get(scope);
+
+      if (!usedOnsOnScope) {
+        return false;
+      }
+
+      const usedUnits = usedOnsOnScope.get(storeName);
+
+      if (!usedUnits) {
+        return false;
+      }
+
+      return usedUnits.has(unitName);
+    }
+
+    function markUnitAsUsedInStoreOn(scope, storeName, unitNames) {
+      let usedOnsOnScope = usedOns.get(scope);
+
+      if (!usedOnsOnScope) {
+        usedOnsOnScope = new Map();
+        usedOns.set(scope, usedOnsOnScope);
+      }
+
+      let usedUnits = usedOnsOnScope.get(storeName);
+
+      if (!usedUnits) {
+        usedUnits = new Set();
+        usedOnsOnScope.set(storeName, usedUnits);
+      }
+
+      usedUnits.add(...unitNames);
+    }
+
+    return {
+      'CallExpression[callee.property.name="on"]'(node) {
+        const storeObject = traverseNestedObjectNode(
+          getNestedCallee(node) ?? getAssignedVariable(node)
+        );
+        const storeName = getStoreName(storeObject);
+
+        if (!is.store({ context, node: storeObject })) {
+          return;
+        }
+
+        const triggerObjects = normalizePossibleArrayNode(node.arguments[0]);
+        const unitNames = triggerObjects.map(getNestedObjectName);
+
+        const scope = context.getScope();
+
+        for (const unitName of unitNames) {
+          const unitAlreadyUsed = isEventUsedInStoreOn(
+            scope,
+            storeName,
+            unitName
+          );
+
+          if (unitAlreadyUsed) {
+            context.report({
+              node,
+              messageId: "duplicateOn",
+              data: {
+                storeName,
+                unitName,
+              },
+            });
+
+            return;
+          }
+        }
+
+        markUnitAsUsedInStoreOn(scope, storeName, unitNames);
+      },
+    };
+  },
+};
+
+function normalizePossibleArrayNode(node) {
+  if (!node) {
+    return [];
+  }
+
+  if (node.type === "ArrayExpression") {
+    return node.elements;
+  }
+
+  return [node];
+}
+
+function getNestedCallee(node) {
+  const { callee } = node;
+
+  if (callee.object?.type === "CallExpression") {
+    return getNestedCallee(callee.object);
+  }
+
+  return callee.object;
+}
+
+function getAssignedVariable(node) {
+  const { parent } = node;
+
+  if (parent.type === "VariableDeclarator") {
+    return parent;
+  }
+
+  return getAssignedVariable(parent);
+}
+
+function getStoreName(node) {
+  return node?.name ?? node?.id?.name;
+}

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

@@ -0,0 +1,77 @@
+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");
+
+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 = {
+          from: node.arguments?.[0]?.properties.find(
+            (n) => n.key?.name === "from"
+          ),
+          to: node.arguments?.[0]?.properties.find((n) => n.key?.name === "to"),
+        };
+
+        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-getState/no-getState.js

@@ -1,8 +1,8 @@
 const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
-const { isStoreNameValid } = require("../../utils/is-store-name-valid");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { is } = require("../../utils/is");
 
 module.exports = {
   meta: {
@@ -20,47 +20,20 @@ module.exports = {
     schema: [],
   },
   create(context) {
-    const { parserServices } = context;
-
     return {
-      CallExpression(node) {
-        const methodName = node.callee?.property?.name;
-        if (methodName !== "getState") {
-          return;
-        }
+      'CallExpression[callee.property.name="getState"]'(node) {
+        const storeNode = traverseNestedObjectNode(node.callee?.object);
 
-        const object = traverseNestedObjectNode(node.callee?.object);
-        const objectName = object?.name;
+        const isEffectorStore = is.store({
+          context,
+          node: storeNode,
+        });
 
-        if (!objectName) {
+        if (!isEffectorStore) {
           return;
         }
 
-        // TypeScript-way
-        if (parserServices.hasFullTypeInformation) {
-          const checker = parserServices.program.getTypeChecker();
-          const originalNode = parserServices.esTreeNodeToTSNodeMap.get(object);
-          const type = checker.getTypeAtLocation(originalNode);
-
-          const isEffectorStore =
-            type?.symbol?.escapedName === "Store" &&
-            type?.symbol?.parent?.escapedName?.includes("effector");
-
-          if (!isEffectorStore) {
-            return;
-          }
-
-          reportGetStateCall({ context, node, storeName: objectName });
-        }
-        // JavaScript-way
-        else {
-          const isEffectorStore = isStoreNameValid(objectName, context);
-          if (!isEffectorStore) {
-            return;
-          }
-
-          reportGetStateCall({ context, node, storeName: objectName });
-        }
+        reportGetStateCall({ context, node, storeName: storeNode.name });
       },
     };
   },

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

@@ -1,7 +1,6 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -24,19 +23,17 @@ module.exports = {
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       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 = {
@@ -45,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 },
+          });
         }
       },
     };

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

@@ -1,8 +1,8 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { areNodesSameInText } = require("../../utils/are-nodes-same-in-text");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { buildObjectInText } = require("../../utils/builders");
+const { method } = require("../../utils/method");
 
 module.exports = {
   meta: {
@@ -24,52 +24,51 @@ module.exports = {
   },
   create(context) {
     const importedFromEffector = new Map();
-    const sourceCode = context.getSourceCode();
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
-        const METHODS_WITH_POSSIBLE_DUPLCATION = ["sample", "guard"];
-        for (const method of METHODS_WITH_POSSIBLE_DUPLCATION) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
-
-          const params = {
-            source: node?.arguments?.[0]?.properties?.find(
-              (n) => n.key.name === "source"
-            ),
-            clock: node?.arguments?.[0]?.properties?.find(
-              (n) => n.key.name === "clock"
-            ),
-          };
-          if (!params.source || !params.clock) {
-            return;
-          }
+        if (
+          method.isNot(["sample", "guard"], {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const sameSourceAndClock = areNodesSameInText({
-            context,
-            nodes: [params.source?.value, params.clock?.value],
-          });
-          if (!sameSourceAndClock) {
-            return;
-          }
+        const params = {
+          source: node?.arguments?.[0]?.properties?.find(
+            (n) => n.key.name === "source"
+          ),
+          clock: node?.arguments?.[0]?.properties?.find(
+            (n) => n.key.name === "clock"
+          ),
+        };
+        if (!params.source || !params.clock) {
+          return;
+        }
 
-          reportUnnecessaryDuplication({
-            context,
-            node,
-            params,
-            firstArgument: node?.arguments?.[0],
-          });
+        const sameSourceAndClock = areNodesSameInText({
+          context,
+          nodes: [params.source?.value, params.clock?.value],
+        });
+        if (!sameSourceAndClock) {
+          return;
         }
+
+        reportUnnecessaryDuplication({
+          context,
+          node,
+          params,
+          firstArgument: node?.arguments?.[0],
+        });
       },
     };
   },
@@ -85,11 +84,8 @@ function reportUnnecessaryDuplication({
     const properties = objectNode?.properties?.filter?.(
       (p) => p !== paramToExcludeNode
     );
-    const newPropertiesText = properties
-      .map((p) => context.getSourceCode().getText(p))
-      .join(", ");
 
-    return `{ ${newPropertiesText} }`;
+    return buildObjectInText.fromArrayOfNodes({ properties, context });
   }
 
   context.report({

package/rules/no-useless-methods/no-useless-methods.js

@@ -1,8 +1,7 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+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: {
@@ -24,70 +23,70 @@ module.exports = {
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
-        const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
-        for (const method of POSSIBLE_USELESS_METHODS) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorMethod = node?.callee?.name === localMethod;
-          if (!isEffectorMethod) {
-            continue;
-          }
-
-          const resultAssignedInVariable = traverseParentByType(
+        if (
+          method.isNot(["sample", "guard"], {
             node,
-            "VariableDeclarator"
-          );
-          if (resultAssignedInVariable) {
-            continue;
-          }
+            importMap: importedFromEffector,
+          })
+        ) {
+          return;
+        }
 
-          const resultReturnedFromFactory = traverseParentByType(
-            node,
-            "ReturnStatement"
-          );
-          if (resultReturnedFromFactory) {
-            continue;
-          }
+        const resultAssignedInVariable = traverseParentByType(
+          node,
+          "VariableDeclarator"
+        );
+        if (resultAssignedInVariable) {
+          return;
+        }
 
-          const resultPartOfChain = traverseParentByType(
-            node,
-            "ObjectExpression"
-          );
-          if (resultPartOfChain) {
-            continue;
-          }
+        const resultReturnedFromFactory = traverseParentByType(
+          node,
+          "ReturnStatement"
+        );
+        if (resultReturnedFromFactory) {
+          return;
+        }
 
-          const configHasTarget = node?.arguments?.[0]?.properties?.some(
-            (prop) => prop?.key.name === "target"
-          );
-          if (configHasTarget) {
-            continue;
-          }
+        const resultPartOfChain = traverseParentByType(
+          node,
+          "ObjectExpression"
+        );
+        if (resultPartOfChain) {
+          return;
+        }
 
-          const resultIsWatched = node?.parent?.property?.name === "watch";
-          if (resultIsWatched) {
-            continue;
-          }
+        const configHasTarget = node?.arguments?.[0]?.properties?.some(
+          (prop) => prop?.key.name === "target"
+        );
+        if (configHasTarget) {
+          return;
+        }
 
-          const resultIsArgument = node?.parent?.type === "CallExpression";
-          if (resultIsArgument) {
-            continue;
-          }
+        const resultIsWatched = node?.parent?.property?.name === "watch";
+        if (resultIsWatched) {
+          return;
+        }
 
-          context.report({
-            node,
-            messageId: "uselessMethod",
-            data: {
-              methodName: node?.callee?.name,
-            },
-          });
+        const resultIsArgument = node?.parent?.type === "CallExpression";
+        if (resultIsArgument) {
+          return;
         }
+
+        context.report({
+          node,
+          messageId: "uselessMethod",
+          data: {
+            methodName: node?.callee?.name,
+          },
+        });
       },
     };
   },

package/rules/no-watch/no-watch.js

@@ -2,6 +2,7 @@ const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { nodeTypeIs } = require("../../utils/node-type-is");
 
 module.exports = {
   meta: {
@@ -24,22 +25,15 @@ module.exports = {
       // JavaScript-way https://github.com/effector/eslint-plugin/issues/48#issuecomment-931107829
       return {};
     }
-    const checker = parserServices.program.getTypeChecker();
 
     return {
-      CallExpression(node) {
-        const methodName = node.callee?.property?.name;
-        if (methodName !== "watch") {
-          return;
-        }
-
+      'CallExpression[callee.property.name="watch"]'(node) {
         const object = traverseNestedObjectNode(node.callee?.object);
-        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(object);
-        const type = checker.getTypeAtLocation(originalNode);
 
-        const isEffectorUnit =
-          ["Effect", "Event", "Store"].includes(type?.symbol?.escapedName) &&
-          type?.symbol?.parent?.escapedName?.includes("effector");
+        const isEffectorUnit = nodeTypeIs.unit({
+          node: object,
+          context,
+        });
 
         if (!isEffectorUnit) {
           return;