eslint-plugin-effector 0.4.2 → 0.6.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,17 +39,36 @@ 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)
-- [effector/no-getState](rules/no-getState/no-getState.md)
+- [effector/enforce-gate-naming-convention](rules/enforce-gate-naming-convention/enforce-gate-naming-convention.md)
 - [effector/no-unnecessary-duplication](rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
+- [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
 - [effector/no-useless-methods](rules/no-useless-methods/no-useless-methods.md)
+- [effector/no-forward](rules/no-forward/no-forward.md)
 - [effector/no-ambiguity-target](rules/no-ambiguity-target/no-ambiguity-target.md)
-- [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
+- [effector/no-duplicate-on](rules/no-duplicate-on/no-duplicate-on.md)
+- [effector/no-getState](rules/no-getState/no-getState.md)
 - [effector/no-watch](rules/no-watch/no-watch.md)
-- [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
+- [effector/prefer-sample-over-forward-with-mapping](rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)
+- [effector/strict-effect-handlers](rules/strict-effect-handlers/strict-effect-handlers.md)
+- [effector/keep-options-order](rules/keep-options-order/keep-options-order.md)
 
 ## Maintenance
 
@@ -57,7 +76,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,7 @@ module.exports = {
     "effector/no-ambiguity-target": "warn",
     "effector/no-watch": "warn",
     "effector/no-unnecessary-combination": "warn",
+    "effector/no-duplicate-on": "error",
+    "effector/keep-options-order": "warn",
   },
 };

package/config/scope.js

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

package/index.js

@@ -9,8 +9,15 @@ 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"),
+    "keep-options-order": require("./rules/keep-options-order/keep-options-order"),
+    "no-forward": require("./rules/no-forward/no-forward"),
   },
   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.6.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-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/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/no-ambiguity-target/no-ambiguity-target.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,49 +23,49 @@ 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;
-          }
+        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(
+        if (resultAssignedInVariable || resultPartOfChain) {
+          context.report({
             node,
-            "VariableDeclarator",
-            { stopOnTypes: ["BlockStatement"] }
-          );
-          const resultPartOfChain = traverseParentByType(
-            node,
-            "ObjectExpression"
-          );
-
-          if (resultAssignedInVariable || resultPartOfChain) {
-            context.report({
-              node,
-              messageId: "ambiguityTarget",
-              data: {
-                methodName: node?.callee?.name,
-              },
-            });
+            messageId: "ambiguityTarget",
+            data: {
+              methodName: node?.callee?.name,
+            },
+          });
 
-            continue;
-          }
+          return;
         }
       },
     };