eslint-plugin-effector 0.4.2 → 0.5.0

package/README.md

@@ -25,7 +25,7 @@ Add `effector` to the plugins section of your `.eslintrc` configuration file. Yo
 ```json
 {
   "plugins": ["effector"],
-  "extends": ["plugin:effector/recommended"]
+  "extends": ["plugin:effector/recommended", "plugin:effector/scope"]
 }
 ```
 
@@ -39,7 +39,21 @@ To configure individual rules:
 }
 ```
 
-## Supported Rules
+### Available presets
+
+#### 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)
@@ -50,6 +64,9 @@ To configure individual rules:
 - [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.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/strict-effect-handlers](rules/strict-effect-handlers/strict-effect-handlers.md)
+- [effector/enforce-gate-naming-convention](rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md)
 
 ## Maintenance
 
@@ -57,7 +74,7 @@ To configure individual rules:
 
 1. Bump `version` in [package.json](package.json)
 2. Fill [CHANGELOG.md](CHANGELOG.md)
-3. Commit changes by `git commin -m "Release X.X.X"`
+3. Commit changes by `git commit -m "Release X.X.X"`
 4. Create git tag for release by `git tag -a vX.X.X -m "vX.X.X"`
 5. Push changes to remote by `git push --follow-tags`
 6. Release package to registry by `yarn clean-publish`

package/config/react.js

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

package/config/recommended.js

@@ -9,5 +9,6 @@ module.exports = {
     "effector/no-ambiguity-target": "warn",
     "effector/no-watch": "warn",
     "effector/no-unnecessary-combination": "warn",
+    "effector/no-duplicate-on": "error",
   },
 };

package/config/scope.js

@@ -0,0 +1,5 @@
+module.exports = {
+  rules: {
+    "effector/strict-effect-handlers": "error",
+  },
+};

package/index.js

@@ -9,8 +9,13 @@ module.exports = {
     "no-ambiguity-target": require("./rules/no-ambiguity-target/no-ambiguity-target"),
     "no-watch": require("./rules/no-watch/no-watch"),
     "no-unnecessary-combination": require("./rules/no-unnecessary-combination/no-unnecessary-combination"),
+    "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"),
   },
   configs: {
     recommended: require("./config/recommended"),
+    scope: require("./config/scope"),
+    react: require("./config/react"),
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Enforcing best practices for Effector",
   "keywords": [
     "eslint",
@@ -24,5 +24,8 @@
   },
   "dependencies": {
     "prettier": "^2.3.2"
+  },
+  "nano-staged": {
+    "*.{js,ts,md}": "prettier --write"
   }
 }

package/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.js

@@ -1,7 +1,7 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { nodeTypeIs } = require("../../utils/node-type-is");
+const { namingOf } = require("../../utils/naming");
 
 module.exports = {
   meta: {
@@ -27,13 +27,10 @@ module.exports = {
     if (parserServices.hasFullTypeInformation) {
       return {
         VariableDeclarator(node) {
-          const checker = parserServices.program.getTypeChecker();
-          const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-          const type = checker.getTypeAtLocation(originalNode.initializer);
-
-          const isEffectorEffect =
-            type?.symbol?.escapedName === "Effect" &&
-            type?.symbol?.parent?.escapedName?.includes("effector");
+          const isEffectorEffect = nodeTypeIs.effect({
+            node,
+            context,
+          });
 
           if (!isEffectorEffect) {
             return;
@@ -41,11 +38,9 @@ module.exports = {
 
           const effectName = node.id.name;
 
-          if (effectName?.endsWith("Fx")) {
-            return;
+          if (namingOf.effect.isInvalid({ name: effectName })) {
+            reportEffectNameConventionViolation({ context, node, effectName });
           }
-
-          reportEffectNameConventionViolation({ context, node, effectName });
         },
       };
     }
@@ -54,7 +49,11 @@ module.exports = {
     const importedFromEffector = new Map();
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         // Effect creation with method
@@ -77,7 +76,7 @@ module.exports = {
           }
 
           const effectName = node.parent.id.name;
-          if (effectName.endsWith("Fx")) {
+          if (namingOf.effect.isValid({ name: effectName })) {
             continue;
           }
 
@@ -101,7 +100,7 @@ module.exports = {
           }
 
           const effectName = node.parent.id.name;
-          if (effectName.endsWith("Fx")) {
+          if (namingOf.effect.isValid({ name: effectName })) {
             return;
           }
 

package/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.js

@@ -0,0 +1,114 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { nodeTypeIs } = require("../../utils/node-type-is");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { namingOf } = require("../../utils/naming");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce first capital letter for gate naming",
+      category: "Naming",
+      recommended: true,
+      url: createLinkToRule("enforce-gate-naming-convention"),
+    },
+    messages: {
+      invalidName:
+        'Gate "{{ gateName }}" should be named with first capital letter, rename it to "{{ correctedGateName }}"',
+      renameGate: 'Rename "{{ gateName }}" to "{{ correctedGateName }}"',
+    },
+    schema: [],
+    hasSuggestions: true,
+  },
+  create(context) {
+    const parserServices = context.parserServices;
+    // TypeScript-way
+    if (parserServices.hasFullTypeInformation) {
+      return {
+        VariableDeclarator(node) {
+          const isEffectorGate = nodeTypeIs.gate({
+            node,
+            context,
+          });
+
+          if (!isEffectorGate) {
+            return;
+          }
+
+          const gateName = node.id.name;
+
+          if (namingOf.gate.isInvalid({ name: gateName })) {
+            reportGateNameConventionViolation({ context, node, gateName });
+          }
+        },
+      };
+    }
+
+    // JavaScript-way
+    const importedFromEffectorReact = new Map();
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffectorReact,
+          node,
+          packageName: "effector-react",
+        });
+      },
+      CallExpression(node) {
+        // Effect creation with method
+        const GATE_CREATION_METHODS = ["createGate"];
+        for (const method of GATE_CREATION_METHODS) {
+          const localMethod = importedFromEffectorReact.get(method);
+          if (!localMethod) {
+            continue;
+          }
+
+          const isEffectorGateCreation = node.callee.name === localMethod;
+          if (!isEffectorGateCreation) {
+            continue;
+          }
+
+          const resultSavedInVariable =
+            node.parent.type === "VariableDeclarator";
+          if (!resultSavedInVariable) {
+            continue;
+          }
+
+          const gateName = node.parent.id.name;
+          if (namingOf.gate.isValid({ name: gateName })) {
+            continue;
+          }
+
+          reportGateNameConventionViolation({
+            context,
+            node: node.parent,
+            gateName,
+          });
+        }
+      },
+    };
+  },
+};
+
+function reportGateNameConventionViolation({ context, node, gateName }) {
+  const [firstChar, ...restChars] = gateName.split("");
+  const correctedGateName = [firstChar.toUpperCase(), ...restChars].join("");
+
+  context.report({
+    node,
+    messageId: "invalidName",
+    data: {
+      gateName,
+      correctedGateName,
+    },
+    suggest: [
+      {
+        messageId: "renameGate",
+        data: { gateName, correctedGateName },
+        fix(fixer) {
+          return fixer.replaceTextRange(node.id.range, correctedGateName);
+        },
+      },
+    ],
+  });
+}

package/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md

@@ -0,0 +1,11 @@
+# effector/enforce-gate-naming-convention
+
+Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with gate. Every gate is a react-component, so it should be named as regular react-compoent.
+
+```ts
+// 👍 nice name
+const MyFavoritePageGate = createGate();
+
+// 👎 bad name
+const otherFavoritePageGate = createGate();
+```

package/rules/enforce-store-naming-convention/enforce-store-naming-convention.js

@@ -1,7 +1,5 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
-const { isStoreNameValid } = require("../../utils/is-store-name-valid");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { namingOf } = require("../../utils/naming");
 const {
   validateStoreNameConvention,
 } = require("../../utils/validate-store-name-convention");
@@ -12,6 +10,7 @@ const {
   getCorrectedStoreName,
 } = require("../../utils/get-corrected-store-name");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { nodeTypeIs } = require("../../utils/node-type-is");
 
 module.exports = {
   meta: {
@@ -40,13 +39,10 @@ module.exports = {
     if (parserServices.hasFullTypeInformation) {
       return {
         VariableDeclarator(node) {
-          const checker = parserServices.program.getTypeChecker();
-          const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-          const type = checker.getTypeAtLocation(originalNode.initializer);
-
-          const isEffectorStore =
-            type?.symbol?.escapedName === "Store" &&
-            type?.symbol?.parent?.escapedName?.includes("effector");
+          const isEffectorStore = nodeTypeIs.store({
+            node,
+            context,
+          });
 
           if (!isEffectorStore) {
             return;
@@ -54,15 +50,13 @@ module.exports = {
 
           const storeName = node.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
-            return;
+          if (namingOf.store.isInvalid({ name: storeName, context })) {
+            reportStoreNameConventionViolation({
+              context,
+              node,
+              storeName,
+            });
           }
-
-          reportStoreNameConventionViolation({
-            context,
-            node,
-            storeName,
-          });
         },
       };
     }
@@ -71,7 +65,11 @@ module.exports = {
     const importedFromEffector = new Map();
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         // Store creation with method
@@ -95,7 +93,7 @@ module.exports = {
 
           const storeName = node.parent.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
+          if (namingOf.store.isValid({ name: storeName, context })) {
             continue;
           }
 
@@ -111,7 +109,9 @@ module.exports = {
         if (node.callee?.property?.name === "map") {
           const storeNameCreatedFromMap = node.callee?.object?.name;
 
-          if (!isStoreNameValid(storeNameCreatedFromMap, context)) {
+          if (
+            namingOf.store.isInvalid({ name: storeNameCreatedFromMap, context })
+          ) {
             return;
           }
 
@@ -123,7 +123,7 @@ module.exports = {
 
           const storeName = node.parent.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
+          if (namingOf.store.isValid({ name: storeName, context })) {
             return;
           }
 
@@ -148,7 +148,7 @@ module.exports = {
 
           const storeName = node.parent.id.name;
 
-          if (isStoreNameValid(storeName, context)) {
+          if (namingOf.store.isValid({ name: storeName, context })) {
             return;
           }
 
@@ -179,7 +179,7 @@ function reportStoreNameConventionViolation({ context, node, storeName }) {
     suggest: [
       {
         messageId: "renameStore",
-        data: { storeName },
+        data: { storeName, correctedStoreName },
         fix(fixer) {
           return fixer.replaceTextRange(node.id.range, correctedStoreName);
         },

package/rules/enforce-store-naming-convention/enforce-store-naming-convention.md

@@ -3,7 +3,9 @@
 Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with store. Depending on the configuration your stores should be distinguished by a prefix or a postfix $. Enforces prefix convention by default.
 
 ## Prefix convention
+
 When configured as:
+
 ```js
 module.exports = {
   rules: {
@@ -11,7 +13,9 @@ module.exports = {
   },
 };
 ```
+
 Prefix convention will be enforced:
+
 ```ts
 // 👍 nice name
 const $name = createStore(null);
@@ -19,9 +23,11 @@ const $name = createStore(null);
 // 👎 bad name
 const name = createStore(null);
 ```
+
 ## Postfix convention
 
 When configured as:
+
 ```js
 module.exports = {
   rules: {
@@ -29,12 +35,14 @@ module.exports = {
   },
   settings: {
     effector: {
-      storeNameConvention: "postfix"
-    }
-  }
+      storeNameConvention: "postfix",
+    },
+  },
 };
 ```
+
 Postfix convention will be enforced:
+
 ```ts
 // 👍 nice name
 const name$ = createStore(null);

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

@@ -1,6 +1,4 @@
-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");
 
@@ -24,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"];

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,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,6 +1,4 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
 
 module.exports = {
@@ -24,7 +22,11 @@ module.exports = {
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
         const METHODS_WITH_POSSIBLE_UNNECESSARY_COMBINATION = [

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

@@ -4,11 +4,22 @@ Call of `combine`/`merge` in `clock`/`source` is unnecessary. It can be omitted
 
 ```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 });
+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 });
+const goodEventTwo = guard({
+  clock: { x: $store1, x: $store2 },
+  filter: $filter,
+});
 ```
-

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

@@ -1,6 +1,4 @@
-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");
 
@@ -24,11 +22,14 @@ 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"];

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

@@ -1,6 +1,4 @@
-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");
 
@@ -24,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"];

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;

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

@@ -1,6 +1,4 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
@@ -28,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,6 +1,7 @@
 {
   "compilerOptions": {
     "isolatedModules": true,
+    "esModuleInterop": true,
     "module": "commonjs",
     "lib": ["es2017", "es2019"],
     "baseUrl": "./"

package/utils/extract-imported-from.js

@@ -0,0 +1,9 @@
+function extractImportedFrom({ importMap, node, packageName }) {
+  if (node.source.value === packageName) {
+    for (const s of node.specifiers) {
+      importMap.set(s.imported.name, s.local.name);
+    }
+  }
+}
+
+module.exports = { extractImportedFrom };

package/utils/get-corrected-store-name.js

@@ -1,23 +1,21 @@
 const { getStoreNameConvention } = require("./get-store-name-convention");
 
 function getCorrectedStoreName(storeName, context) {
-    const storeNameConvention = getStoreNameConvention(context);
+  const storeNameConvention = getStoreNameConvention(context);
 
-    // handle edge case
-    if (storeName.startsWith("$") && storeName.endsWith("$")) {
-
-        if (storeNameConvention === "prefix") {
-            return `$${storeName.slice(0, -1)}`;
-        } else {
-            return `${storeName.slice(1)}$`;
-        }
+  // handle edge case
+  if (storeName.startsWith("$") && storeName.endsWith("$")) {
+    if (storeNameConvention === "prefix") {
+      return `$${storeName.slice(0, -1)}`;
+    } else {
+      return `${storeName.slice(1)}$`;
     }
+  }
 
-    const correctedStoreName = storeNameConvention === "prefix"
-        ? `$${storeName}`
-        : `${storeName}$`;
+  const correctedStoreName =
+    storeNameConvention === "prefix" ? `$${storeName}` : `${storeName}$`;
 
-    return correctedStoreName;
+  return correctedStoreName;
 }
 
-module.exports = { getCorrectedStoreName };
+module.exports = { getCorrectedStoreName };

package/utils/get-nested-object-name.js

@@ -0,0 +1,18 @@
+function getNestedObjectName(node) {
+  let root = node;
+  let name = "";
+
+  while (root.type === "MemberExpression") {
+    name = `${root.property.name}.${name}`;
+    root = root.object;
+  }
+
+  if (root.type === "Identifier") {
+    name = `${root.name}.${name}`;
+  }
+
+  // Remove last dot
+  return name.slice(0, -1);
+}
+
+module.exports = { getNestedObjectName };

package/utils/get-store-name-convention.js

@@ -1,6 +1,6 @@
 function getStoreNameConvention(context) {
-    // prefix convention is default
-    return context.settings.effector?.storeNameConvention || "prefix";
+  // prefix convention is default
+  return context.settings.effector?.storeNameConvention || "prefix";
 }
 
-module.exports = { getStoreNameConvention };
+module.exports = { getStoreNameConvention };

package/utils/is.js

@@ -0,0 +1,30 @@
+const { nodeTypeIs } = require("./node-type-is");
+const { namingOf } = require("./naming");
+
+function isSomething({ isValidNaming, isTypeCorrect }) {
+  return ({ node, context }) => {
+    if (context.parserServices.hasFullTypeInformation) {
+      return isTypeCorrect({ node, context });
+    }
+
+    return isValidNaming({ name: node?.name ?? node?.id?.name, context });
+  };
+}
+
+const isStore = isSomething({
+  isTypeCorrect: nodeTypeIs.store,
+  isValidNaming: namingOf.store.isValid,
+});
+
+const isEffect = isSomething({
+  isTypeCorrect: nodeTypeIs.effect,
+  isValidNaming: namingOf.effect.isValid,
+});
+
+const is = {
+  store: (opts) => isStore(opts),
+  effect: (opts) => isEffect(opts),
+  not: { store: (opts) => !isStore(opts), effect: (opts) => !isEffect(opts) },
+};
+
+module.exports = { is };

package/utils/naming.js

@@ -0,0 +1,47 @@
+const { getStoreNameConvention } = require("./get-store-name-convention");
+
+function isEffectNameValid({ name }) {
+  return Boolean(name?.endsWith("Fx"));
+}
+
+function isGateNameValid({ name }) {
+  const [firstChar] = name.split("");
+
+  return Boolean(firstChar?.toUpperCase() === firstChar);
+}
+
+function isStoreNameValid({ name, context }) {
+  const storeNameConvention = getStoreNameConvention(context);
+
+  // validate edge case
+  if (name?.startsWith("$") && name?.endsWith("$")) {
+    return false;
+  }
+
+  if (storeNameConvention === "prefix" && name?.startsWith("$")) {
+    return true;
+  }
+
+  if (storeNameConvention === "postfix" && name?.endsWith("$")) {
+    return true;
+  }
+
+  return false;
+}
+
+const namingOf = {
+  effect: {
+    isValid: (opts) => isEffectNameValid(opts),
+    isInvalid: (opts) => !isEffectNameValid(opts),
+  },
+  store: {
+    isValid: (opts) => isStoreNameValid(opts),
+    isInvalid: (opts) => !isStoreNameValid(opts),
+  },
+  gate: {
+    isValid: (opts) => isGateNameValid(opts),
+    isInvalid: (opts) => !isGateNameValid(opts),
+  },
+};
+
+module.exports = { namingOf };

package/utils/node-type-is.js

@@ -0,0 +1,55 @@
+function hasType({ node, possibleTypes, context, from }) {
+  const checker = context.parserServices.program.getTypeChecker();
+  const originalNode = context.parserServices.esTreeNodeToTSNodeMap.get(node);
+  const type = checker.getTypeAtLocation(
+    originalNode?.initializer ?? originalNode
+  );
+
+  const symbol = type?.symbol ?? type?.aliasSymbol;
+
+  return (
+    possibleTypes.includes(symbol?.escapedName) &&
+    Boolean(symbol?.parent?.escapedName?.includes(from))
+  );
+}
+
+const nodeTypeIs = {
+  effect: (opts) =>
+    hasType({ ...opts, possibleTypes: ["Effect"], from: "effector" }),
+  store: (opts) =>
+    hasType({ ...opts, possibleTypes: ["Store"], from: "effector" }),
+  event: (opts) =>
+    hasType({ ...opts, possibleTypes: ["Event"], from: "effector" }),
+  unit: (opts) =>
+    hasType({
+      ...opts,
+      possibleTypes: ["Effect", "Store", "Event"],
+      from: "effector",
+    }),
+  gate: (opts) =>
+    hasType({ ...opts, possibleTypes: ["Gate"], from: "effector-react" }),
+  not: {
+    effect: (opts) =>
+      !hasType({
+        ...opts,
+        possibleTypes: ["Effect"],
+        from: "effector",
+      }),
+    store: (opts) =>
+      !hasType({ ...opts, possibleTypes: ["Store"], from: "effector" }),
+    event: (opts) =>
+      !hasType({ ...opts, possibleTypes: ["Event"], from: "effector" }),
+    unit: (opts) =>
+      !hasType({
+        ...opts,
+        possibleTypes: ["Effect", "Store", "Event"],
+        from: "effector",
+      }),
+    gate: (opts) =>
+      !hasType({ ...opts, possibleTypes: ["Gate"], from: "effector-react" }),
+  },
+};
+
+module.exports = {
+  nodeTypeIs,
+};

package/utils/validate-store-name-convention.js

@@ -1,13 +1,13 @@
 const { getStoreNameConvention } = require("./get-store-name-convention");
 
 function validateStoreNameConvention(context) {
-    const storeNameConvention = getStoreNameConvention(context);
+  const storeNameConvention = getStoreNameConvention(context);
 
-    if (storeNameConvention !== "prefix" && storeNameConvention !== "postfix") {
-        throw new Error(
-            "Invalid Configuration of effector-plugin-eslint/enforce-store-naming-convention. The value should be equal to prefix or postfix."
-        );
-    }
+  if (storeNameConvention !== "prefix" && storeNameConvention !== "postfix") {
+    throw new Error(
+      "Invalid Configuration of effector-plugin-eslint/enforce-store-naming-convention. The value should be equal to prefix or postfix."
+    );
+  }
 }
 
-module.exports = { validateStoreNameConvention };
+module.exports = { validateStoreNameConvention };

package/utils/extract-imported-from-effector.js

@@ -1,8 +0,0 @@
-function extractImportedFromEffector(importedFromEffector, node) {
-  if (node.source.value === "effector") {
-    for (const s of node.specifiers) {
-      importedFromEffector.set(s.imported.name, s.local.name);
-    }
-  }
-}
-module.exports = { extractImportedFromEffector };

package/utils/is-store-name-valid.js

@@ -1,22 +0,0 @@
-const { getStoreNameConvention } = require("./get-store-name-convention");
-
-function isStoreNameValid(storeName, context) {
-    const storeNameConvention = getStoreNameConvention(context);
-
-    // validate edge case
-    if (storeName?.startsWith("$") && storeName?.endsWith("$")) {
-        return false
-    }
-
-    if (storeNameConvention === "prefix" && storeName?.startsWith("$")) {
-        return true;
-    }
-
-    if (storeNameConvention === "postfix" && storeName?.endsWith("$")) {
-        return true;
-    }
-
-    return false;
-}
-
-module.exports = { isStoreNameValid };