eslint-plugin-effector 0.3.1 → 0.5.0

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

@@ -0,0 +1,128 @@
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { getNestedObjectName } = require("../../utils/get-nested-object-name");
+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 = 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.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-duplicate-on/no-duplicate-on.md

@@ -0,0 +1,16 @@
+# effector/no-duplicate-on
+
+Disallows duplcates `on`-handlers on particular store.
+
+```ts
+const increment = createEvent();
+
+// 👍 all explicitly
+const $goodCounter = createStore(0).on(increment, (counter) => counter + 1);
+
+// 👎 so, which handler should we choose?
+// it's better to remove one of them
+const $badCounter = createStore(0)
+  .on(increment, (counter) => counter + 1)
+  .on(increment, (counter) => counter + 2);
+```

package/rules/no-getState/no-getState.js

@@ -1,7 +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: {
@@ -10,6 +11,7 @@ module.exports = {
       description: "Forbids `.getState` calls on any Effector store",
       category: "Quality",
       recommended: true,
+      url: createLinkToRule("no-getState"),
     },
     messages: {
       abusiveCall:
@@ -18,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

@@ -0,0 +1,96 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Forbids unnecessary combinations in `clock`, `source` and `forward`",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-unnecessary-combination"),
+    },
+    messages: {
+      unnecessaryCombination:
+        "Method {{ methodName }} is used under the hood, you can omit it.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(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);
+        }
+
+        const UNNECESSARY_METHODS = {
+          source: ["combine", "merge"].map(toLocalMethod).filter(Boolean),
+          clock: ["merge"].map(toLocalMethod).filter(Boolean),
+          from: ["merge"].map(toLocalMethod).filter(Boolean),
+        };
+
+        for (const method of METHODS_WITH_POSSIBLE_UNNECESSARY_COMBINATION) {
+          const localMethod = importedFromEffector.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorMethod = node?.callee?.name === localMethod;
+          if (!isEffectorMethod) {
+            continue;
+          }
+
+          const candidates =
+            node?.arguments?.[0]?.properties?.filter((n) =>
+              CONFIG_ARG_PROPERTIES.includes(n.key.name)
+            ) ?? [];
+
+          if (candidates.length === 0) {
+            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);
+
+            if (!UnnecessaryMethodIsEffectorMethod) {
+              continue;
+            }
+
+            context.report({
+              node: candidate?.value,
+              messageId: "unnecessaryCombination",
+              data: { methodName: candidateName },
+            });
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,25 @@
+# effector/no-unnecessary-combination
+
+Call of `combine`/`merge` in `clock`/`source` is unnecessary. It can be omitted from source code.
+
+```ts
+// 👎 can be simplified
+const badEventOne = guard({
+  clock: combine($store1, $store2),
+  filter: $filter,
+});
+const badEventOne = guard({
+  clock: combine($store1, $store2, (store1, store2) => ({
+    x: store1,
+    y: store2,
+  })),
+  filter: $filter,
+});
+
+// 👍 better
+const goodEventOne = guard({ clock: [$store1, $store2], filter: $filter });
+const goodEventTwo = guard({
+  clock: { x: $store1, x: $store2 },
+  filter: $filter,
+});
+```

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

@@ -1,7 +1,6 @@
-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");
 
 module.exports = {
   meta: {
@@ -10,6 +9,7 @@ module.exports = {
       description: "Forbids unnecessary duplication in `clock` and `source`",
       category: "Quality",
       recommended: true,
+      url: createLinkToRule("no-unnecessary-duplication"),
     },
     messages: {
       unnecessaryDuplication:
@@ -18,14 +18,18 @@ module.exports = {
       removeSource: "Remove `source`",
     },
     schema: [],
+    hasSuggestions: true,
   },
   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"];

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

@@ -1,7 +1,6 @@
-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");
 
 module.exports = {
   meta: {
@@ -10,6 +9,7 @@ module.exports = {
       description: "Forbids useless calls of `sample` and `guard`",
       category: "Quality",
       recommended: true,
+      url: createLinkToRule("no-useless-methods"),
     },
     messages: {
       uselessMethod:
@@ -22,7 +22,11 @@ module.exports = {
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         const POSSIBLE_USELESS_METHODS = ["sample", "guard"];
@@ -68,6 +72,16 @@ module.exports = {
             continue;
           }
 
+          const resultIsWatched = node?.parent?.property?.name === "watch";
+          if (resultIsWatched) {
+            continue;
+          }
+
+          const resultIsArgument = node?.parent?.type === "CallExpression";
+          if (resultIsArgument) {
+            continue;
+          }
+
           context.report({
             node,
             messageId: "uselessMethod",

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

@@ -0,0 +1,53 @@
+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: {
+    type: "suggestion",
+    docs: {
+      description: "Avoid `.watch` calls on any Effector unit or operator",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-watch"),
+    },
+    messages: {
+      abusiveCall:
+        "Method `.watch` leads to imperative code. Try to replace it with operators (`sample`, `guard`, etc) or use the `target` parameter of the operators.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const { parserServices } = context;
+    if (!parserServices.hasFullTypeInformation) {
+      // JavaScript-way https://github.com/effector/eslint-plugin/issues/48#issuecomment-931107829
+      return {};
+    }
+
+    return {
+      'CallExpression[callee.property.name="watch"]'(node) {
+        const object = traverseNestedObjectNode(node.callee?.object);
+
+        const isEffectorUnit = nodeTypeIs.unit({
+          node: object,
+          context,
+        });
+
+        if (!isEffectorUnit) {
+          return;
+        }
+
+        reportWatchCall({ context, node });
+      },
+    };
+  },
+};
+
+function reportWatchCall({ context, node }) {
+  context.report({
+    node,
+    messageId: "abusiveCall",
+  });
+}

package/rules/no-watch/no-watch.md

@@ -0,0 +1,42 @@
+# effector/no-watch
+
+Method `.watch` leads to imperative code. Try replacing it with operators (`forward`, `sample`, etc) or use the `target` parameter of the operators.
+
+> Caution! This rule only works on projects using TypeScript.
+
+```ts
+const myFx = createEffect();
+const myEvent = createEvent();
+const $awesome = createStore();
+
+// 👍 good solutions
+forward({
+  from: myFx.finally,
+  to: myEvent,
+});
+
+guard({
+  clock: myEvent,
+  filter: Boolean,
+  target: myFx,
+});
+
+sample({
+  from: $awesome.updates,
+  fn: identity,
+  to: myEvent,
+});
+
+// 👎 bad solutions
+myFx.finally.watch(myEvent);
+
+myEvent.watch((payload) => {
+  if (Boolean(payload)) {
+    myFx(payload);
+  }
+});
+
+$awesome.updates.watch((data) => {
+  myEvent(identity(data));
+});
+```

package/rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.js

@@ -1,9 +1,8 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
 
 module.exports = {
   meta: {
@@ -12,6 +11,7 @@ module.exports = {
       description: "Prefer `sample` over `forward` with `.map`/`.prepend`",
       category: "Quality",
       recommended: true,
+      url: createLinkToRule("prefer-sample-over-forward-with-mapping"),
     },
     messages: {
       overMap:
@@ -26,7 +26,11 @@ module.exports = {
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         const localMethod = importedFromEffector.get("forward");

package/rules/strict-effect-handlers/strict-effect-handlers.js

@@ -0,0 +1,74 @@
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { is } = require("../../utils/is");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Forbids mix of async functions and effects calls in effect handlers.",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("strict-effect-handlers"),
+    },
+    messages: {
+      mixedCallsInHandler:
+        "Handler of effect `{{ effectName }}` can lead to scope loosing in Fork API.",
+      mixedCallsInFunction:
+        "Function `{{ functionName }}` can lead to scope loosing in Fork API.",
+    },
+    schema: [],
+  },
+  create(context) {
+    function onEffectHandler(node) {
+      if (!node.body?.body) {
+        return;
+      }
+
+      const calledNodes = node.body.body
+        .filter((bodyNode) => bodyNode.expression?.type === "AwaitExpression")
+        .map((awaitNode) => ({
+          node: awaitNode.expression.argument.callee,
+          context,
+        }));
+
+      const hasEffects = calledNodes.some(is.effect);
+      const hasRegularAsyncFunctions = calledNodes.some(is.not.effect);
+
+      const hasError = hasEffects && hasRegularAsyncFunctions;
+
+      if (!hasError) {
+        return;
+      }
+
+      const isEffectHandler = is.effect({
+        node: node.parent?.parent,
+        context,
+      });
+
+      if (isEffectHandler) {
+        const effectName = node.parent?.parent?.id?.name ?? "Unknown";
+
+        context.report({
+          node: node.parent,
+          messageId: "mixedCallsInHandler",
+          data: { effectName },
+        });
+      } else {
+        const functionName = node.id?.name ?? "Unknown";
+
+        context.report({
+          node,
+          messageId: "mixedCallsInFunction",
+          data: { functionName },
+        });
+      }
+    }
+
+    return {
+      ArrowFunctionExpression: onEffectHandler,
+      FunctionExpression: onEffectHandler,
+      FunctionDeclaration: onEffectHandler,
+    };
+  },
+};

package/rules/strict-effect-handlers/strict-effect-handlers.md

@@ -0,0 +1,38 @@
+# effector/strict-effect-handlers
+
+[Related documentation](https://effector.dev/docs/api/effector/scope#imperative-effects-calls-with-scope)
+
+When effect calls another effects then it should call only effects, not common async functions and effect calls should have await:
+
+```ts
+// 👍 effect without inner effects:
+const delayFx = createEffect(async () => {
+  await new Promise((rs) => setTimeout(rs, 80));
+});
+```
+
+```ts
+const authUserFx = createEffect();
+const sendMessageFx = createEffect();
+
+// 👍 effect with inner effects
+const sendWithAuthFx = createEffect(async () => {
+  await authUserFx();
+  await delayFx();
+  await sendMessageFx();
+});
+```
+
+```ts
+// 👎 effect with inner effects and common async functions
+
+const sendWithAuthFx = createEffect(async () => {
+  await authUserFx();
+  //WRONG! wrap that in effect
+  await new Promise((rs) => setTimeout(rs, 80));
+  //context lost
+  await sendMessageFx();
+});
+```
+
+So, any effect might either call another effects or perform some async computations but not both.

package/rules/tsconfig.json

@@ -1,9 +1,10 @@
 {
   "compilerOptions": {
     "isolatedModules": true,
+    "esModuleInterop": true,
     "module": "commonjs",
     "lib": ["es2017", "es2019"],
     "baseUrl": "./"
   },
-  "include": ["./**/examples/*.ts"]
+  "include": ["./**/examples/**/*.ts"]
 }

package/utils/create-link-to-rule.js

@@ -0,0 +1,5 @@
+function createLinkToRule(name) {
+  return `https://github.com/effector/eslint-plugin/blob/master/rules/${name}/${name}.md`;
+}
+
+module.exports = { createLinkToRule };