eslint-plugin-effector 0.1.2 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## v0.3.0
+
+- Add new rule: `no-useless-methods` ([PR #41](https://github.com/effector/eslint-plugin/pull/41))
+- Add new rule: `no-ambiguity-target` ([PR #42](https://github.com/effector/eslint-plugin/pull/42))
+- Add possibility to configure store's naming convention — suffix of prefix ([PR #37](https://github.com/effector/eslint-plugin/pull/37) by @ilyaryabchinski)
+
+## v0.2.0
+
+- Add tests against Effector 22
+- Specify supported Node.JS versions
+- Add new rule: `prefer-sample-over-forward-with-mapping` ([PR #34](https://github.com/igorkamyshev/eslint-plugin-effector/pull/34))
+
+## v0.1.4
+
+- Exclude test-coverage report from npm-package
+- Fixed SyntaxError in `no-unnecessary-duplication` suggestions ([PR #28](https://github.com/igorkamyshev/eslint-plugin-effector/pull/28))
+
+## v0.1.3
+
+- Fixed false-positive in `no-unnecessary-duplication` with composite `clock`/`source` ([PR #22](https://github.com/igorkamyshev/eslint-plugin-effector/pull/22))
+- Fixed TypeError in `enforce-store-naming-convention` ([PR #25](https://github.com/igorkamyshev/eslint-plugin-effector/pull/25))
+- Fixed false-positive in `enforce-effect-naming-convention` with `combine` ([PR #26](https://github.com/igorkamyshev/eslint-plugin-effector/pull/26))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Igor Kamyshev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,11 +2,11 @@
 
 Enforcing best practices for [Effector](http://effector.dev/)
 
-> This plugin can use TypeScript for more precise results, but JavaScript is supported too.
+> This plugin uses TypeScript for more precise results, but JavaScript is supported too.
 
 ## Installation
 
-You'll first need to install [ESLint](http://eslint.org):
+First, install [ESLint](http://eslint.org):
 
 ```
 $ yarn add -D eslint
@@ -45,3 +45,6 @@ To configure individual rules:
 - [effector/enforce-effect-naming-convention](/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md)
 - [effector/no-getState](/rules/no-getState/no-getState.md)
 - [effector/no-unnecessary-duplication](/rules/no-unnecessary-duplication/no-unnecessary-duplication.md)
+- [effector/no-useless-methods](/rules/no-useless-methods/no-useless-methods.md)
+- [effector/no-ambiguity-target](/rules/no-ambiguity-target/no-ambiguity-target.md)
+- [effector/prefer-sample-over-forward-with-mapping](/rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping.md)

package/config/recommended.js

@@ -3,6 +3,9 @@ module.exports = {
     "effector/enforce-store-naming-convention": "error",
     "effector/enforce-effect-naming-convention": "error",
     "effector/no-getState": "error",
+    "effector/no-useless-methods": "error",
     "effector/no-unnecessary-duplication": "warn",
+    "effector/prefer-sample-over-forward-with-mapping": "warn",
+    "effector/no-ambiguity-target": "warn",
   },
 };

package/index.js

@@ -4,8 +4,11 @@ module.exports = {
     "enforce-effect-naming-convention": require("./rules/enforce-effect-naming-convention/enforce-effect-naming-convention"),
     "no-getState": require("./rules/no-getState/no-getState"),
     "no-unnecessary-duplication": require("./rules/no-unnecessary-duplication/no-unnecessary-duplication"),
+    "prefer-sample-over-forward-with-mapping": require("./rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping"),
+    "no-useless-methods": require("./rules/no-useless-methods/no-useless-methods"),
+    "no-ambiguity-target": require("./rules/no-ambiguity-target/no-ambiguity-target"),
   },
   configs: {
     recommended: require("./config/recommended"),
-  },
+  }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Enforcing best practices for Effector",
   "main": "index.js",
   "author": "Igor Kamyshev <igor@kamyshev.me>",
@@ -11,10 +11,13 @@
   "publishConfig": {
     "access": "public"
   },
+  "engines": {
+    "node": "^14 || ^16"
+  },
   "devDependencies": {
     "@typescript-eslint/experimental-utils": "^4.29.3",
     "@typescript-eslint/parser": "^4.29.3",
-    "effector": "^21.8.12",
+    "effector": "^22.0.0",
     "eslint": "^7.32.0",
     "glob": "^7.1.7",
     "jest": "^27.1.0",
@@ -23,5 +26,8 @@
   "peerDependencies": {
     "effector": "*",
     "eslint": "*"
+  },
+  "dependencies": {
+    "prettier": "^2.3.2"
   }
-}
+}

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

@@ -55,7 +55,7 @@ module.exports = {
       },
       CallExpression(node) {
         // Effect creation with method
-        const EFFECT_CREATION_METHODS = ["createEffect", "attach", "combine"];
+        const EFFECT_CREATION_METHODS = ["createEffect", "attach"];
         for (const method of EFFECT_CREATION_METHODS) {
           const localMethod = importedFromEffector.get(method);
           if (!localMethod) {

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

@@ -1,3 +1,11 @@
-# Enforces naming convention for Effector-effects (`effector/enforce-effect-naming-convention`)
+# effector/enforce-effect-naming-convention
 
 Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with effect. Your effect should be distingueshed by a suffix `Fx`. For example, `fetchUserInfoFx` is a effect, `fetchUserInfo` is not.
+
+```ts
+// 👍 nice name
+const fetchNameFx = createEffect();
+
+// 👎 bad name
+const fetchName = createEffect();
+```

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

@@ -1,25 +1,32 @@
 const {
   extractImportedFromEffector,
 } = require("../../utils/extract-imported-from-effector");
+const { isStoreNameValid } = require("../../utils/is-store-name-valid");
+const { validateStoreNameConvention } = require("../../utils/validate-store-name-convention");
+const { getStoreNameConvention } = require("../../utils/get-store-name-convention");
+const { getCorrectedStoreName } = require("../../utils/get-corrected-store-name");
 
 module.exports = {
   meta: {
     type: "problem",
     docs: {
       description:
-        "Enforce $ as a prefix for any store created by Effector methods",
+          "Enforce $ as a prefix or postfix for any store created by Effector methods",
       category: "Naming",
       recommended: true,
     },
     messages: {
       invalidName:
-        'Store "{{ storeName }}" should be named with prefix, rename it to "${{ storeName }}"',
-      renameStore: 'Rename "{{ storeName }}" to "${{ storeName }}"',
+          'Store "{{ storeName }}" should be named with {{ storeNameConvention }}, rename it to "{{ correctedStoreName }}"',
+      renameStore: 'Rename "{{ storeName }}" to "{{ correctedStoreName }}"',
     },
     schema: [],
   },
   create(context) {
-    const parserServices = context.parserServices;
+    const { parserServices } = context;
+
+    validateStoreNameConvention(context);
+
     // TypeScript-way
     if (parserServices.hasFullTypeInformation) {
       return {
@@ -29,8 +36,8 @@ module.exports = {
           const type = checker.getTypeAtLocation(originalNode.initializer);
 
           const isEffectorStore =
-            type?.symbol?.escapedName === "Store" &&
-            type?.symbol?.parent?.escapedName?.includes("effector");
+              type?.symbol?.escapedName === "Store" &&
+              type?.symbol?.parent?.escapedName?.includes("effector");
 
           if (!isEffectorStore) {
             return;
@@ -38,11 +45,15 @@ module.exports = {
 
           const storeName = node.id.name;
 
-          if (storeName?.startsWith("$")) {
+          if (isStoreNameValid(storeName, context)) {
             return;
           }
 
-          reportStoreNameConventionViolation({ context, node, storeName });
+          reportStoreNameConventionViolation({
+            context,
+            node,
+            storeName
+          });
         },
       };
     }
@@ -68,46 +79,50 @@ module.exports = {
           }
 
           const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
+              node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             continue;
           }
 
           const storeName = node.parent.id.name;
-          if (storeName.startsWith("$")) {
+
+          if (isStoreNameValid(storeName, context)) {
             continue;
           }
 
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName,
+            storeName
           });
           return;
         }
 
         // Store creation with .map
         if (node.callee?.property?.name === "map") {
-          const objectIsEffectorStore = node.callee.object.name.startsWith("$");
-          if (!objectIsEffectorStore) {
+          const storeNameCreatedFromMap = node.callee?.object?.name;
+
+          if (!isStoreNameValid(storeNameCreatedFromMap, context)) {
             return;
           }
 
           const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
+              node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             return;
           }
 
           const storeName = node.parent.id.name;
-          if (storeName.startsWith("$")) {
+
+          if (isStoreNameValid(storeName, context)) {
             return;
           }
 
+
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName,
+            storeName
           });
           return;
         }
@@ -115,23 +130,24 @@ module.exports = {
         // Store creation in domain
         const STORE_IN_DOMAIN_CREATION_METHODS = ["createStore", "store"];
         if (
-          STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
+            STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
         ) {
           const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
+              node.parent.type === "VariableDeclarator";
           if (!resultSavedInVariable) {
             return;
           }
 
           const storeName = node.parent.id.name;
-          if (storeName.startsWith("$")) {
+
+          if (isStoreNameValid(storeName, context)) {
             return;
           }
 
           reportStoreNameConventionViolation({
             context,
             node: node.parent,
-            storeName,
+            storeName
           });
           return;
         }
@@ -141,20 +157,27 @@ module.exports = {
 };
 
 function reportStoreNameConventionViolation({ context, node, storeName }) {
+
+  const storeNameConvention = getStoreNameConvention(context);
+  const correctedStoreName = getCorrectedStoreName(storeName, context);
+
   context.report({
     node,
     messageId: "invalidName",
     data: {
       storeName,
+      correctedStoreName,
+      storeNameConvention
     },
     suggest: [
       {
         messageId: "renameStore",
         data: { storeName },
         fix(fixer) {
-          return fixer.insertTextBeforeRange(node.range, "$");
+          return fixer.replaceTextRange(node.id.range, correctedStoreName);
         },
       },
     ],
   });
 }
+

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

@@ -1,3 +1,44 @@
-# Enforces naming convention for Effector-stores a codebase (`effector/enforce-store-naming-convention`)
+# effector/enforce-store-naming-convention
 
-Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable with store. Your stores should be distingueshed by a prefix $. For example, `$name` is a store,`name` is not.
+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: {
+    "effector/enforce-store-naming-convention": "error",
+  },
+};
+```
+Prefix convention will be enforced:
+```ts
+// 👍 nice name
+const $name = createStore(null);
+
+// 👎 bad name
+const name = createStrore(null);
+```
+## Postfix convention
+
+When configured as:
+```js
+module.exports = {
+  rules: {
+    "effector/enforce-store-naming-convention": "error",
+  },
+  settings: {
+    effector: {
+      storeNameConvention: "postfix"
+    }
+  }
+};
+```
+Postfix convention will be enforced:
+```ts
+// 👍 nice name
+const name$ = createStore(null);
+
+// 👎 bad name
+const name = createStrore(null);
+```

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

@@ -0,0 +1,71 @@
+const {
+  extractImportedFromEffector,
+} = require("../../utils/extract-imported-from-effector");
+const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids ambiguity targets in `sample` and `guard`",
+      category: "Quality",
+      recommended: true,
+    },
+    messages: {
+      ambiguityTarget:
+        "Method `{{ methodName }}` returns `target` and assigns the result to a variable. Consider removing one of them.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFromEffector(importedFromEffector, node);
+      },
+      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 configHasTarget = node?.arguments?.[0]?.properties?.some(
+            (prop) => prop?.key.name === "target"
+          );
+          if (!configHasTarget) {
+            continue;
+          }
+
+          const resultAssignedInVariable = traverseParentByType(
+            node,
+            "VariableDeclarator"
+          );
+          const resultPartOfChain = traverseParentByType(
+            node,
+            "ObjectExpression"
+          );
+
+          if (resultAssignedInVariable || resultPartOfChain) {
+            context.report({
+              node,
+              messageId: "ambiguityTarget",
+              data: {
+                methodName: node?.callee?.name,
+              },
+            });
+
+            continue;
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,12 @@
+# effector/no-ambiguity-target
+
+Call of `gaurd`/`sample` with `target` and variable assignment is ambiguity. One of them should be omitted from source code.
+
+```ts
+// 👎 should be rewritten
+const result = guard({ clock: trigger, filter: Boolean, target });
+
+// 👍 makes sense
+guard({ clock: trigger, filter: Boolean, target });
+const result = target;
+```

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

@@ -1,6 +1,7 @@
 const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+  traverseNestedObjectNode,
+} = require("../../utils/traverse-nested-object-node");
+const { isStoreNameValid } = require("../../utils/is-store-name-valid");
 
 module.exports = {
   meta: {
@@ -17,7 +18,7 @@ module.exports = {
     schema: [],
   },
   create(context) {
-    const parserServices = context.parserServices;
+    const { parserServices } = context;
 
     return {
       CallExpression(node) {
@@ -26,7 +27,7 @@ module.exports = {
           return;
         }
 
-        const object = traverseNestedObject(node.callee?.object);
+        const object = traverseNestedObjectNode(node.callee?.object);
         const objectName = object?.name;
 
         if (!objectName) {
@@ -51,7 +52,7 @@ module.exports = {
         }
         // JavaScript-way
         else {
-          const isEffectorStore = objectName.startsWith("$");
+          const isEffectorStore = isStoreNameValid(objectName, context);
           if (!isEffectorStore) {
             return;
           }
@@ -72,11 +73,3 @@ function reportGetStateCall({ context, node, storeName }) {
     },
   });
 }
-
-function traverseNestedObject(node) {
-  if (node.type === "MemberExpression") {
-    return traverseNestedObject(node.property);
-  }
-
-  return node;
-}

package/rules/no-getState/no-getState.md

@@ -1,3 +1,20 @@
-# Forbids `.getState` calls on any Effector store (`effector/no-getState`)
+# effector/no-getState
 
 `.getState` gives rise to difficult to debug imperative code and kind of race condition. Prefer declarative `sample` to pass data from store and `attach` for effects.
+
+```ts
+const $username = createStore(null);
+const userLoggedIn = createEvent();
+
+// 👍 good solution
+const fetchUserCommentsFx = createEffect((name) => /* ... */);
+sample({ source: $username, clock: userLoggedIn, target: fetchUserCommentsFx });
+
+// 👎 bad solution
+const fetchUserCommentsInBadWayFx = createEffect(() => {
+    const name = $username.getState();
+
+    /* ... */
+});
+forward({ from: userLoggedIn, to: fetchUserCommentsInBadWayFx });
+```

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

@@ -1,6 +1,7 @@
 const {
   extractImportedFromEffector,
 } = require("../../utils/extract-imported-from-effector");
+const { areNodesSameInText } = require("../../utils/are-nodes-same-in-text");
 
 module.exports = {
   meta: {
@@ -20,6 +21,8 @@ module.exports = {
   },
   create(context) {
     const importedFromEffector = new Map();
+    const sourceCode = context.getSourceCode();
+
     return {
       ImportDeclaration(node) {
         extractImportedFromEffector(importedFromEffector, node);
@@ -49,8 +52,10 @@ module.exports = {
             return;
           }
 
-          const sameSourceAndClock =
-            params?.source?.value?.name === params?.clock?.value?.name;
+          const sameSourceAndClock = areNodesSameInText({
+            context,
+            nodes: [params.source?.value, params.clock?.value],
+          });
           if (!sameSourceAndClock) {
             return;
           }

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

@@ -1,4 +1,4 @@
-# Forbids same `clock` and `source` inside method config (`effector/no-unnecessary-duplication`)
+# effector/no-unnecessary-duplication
 
 Same `clock`/`source` in `sample` and `guard` don't make sense, any of these fields can be omitted in this case.
 
@@ -6,7 +6,7 @@ Same `clock`/`source` in `sample` and `guard` don't make sense, any of these fie
 const $data = createStore(null);
 
 // 👎 can be simplified
-const target = sample({
+const target1 = sample({
   source: $data,
   clock: $data,
   fn(data) {
@@ -15,15 +15,15 @@ const target = sample({
 });
 
 // 👍 better
-const target = sample({
+const target2 = sample({
   source: $data,
   fn(data) {
     return data.length;
   },
 });
 
-// 👍 also possible
-const target = sample({
+// 👍 also nice solution
+const target3 = sample({
   clock: $data,
   fn(data) {
     return data.length;