Add rule no-inline-units

config/recommended.js

@@ -11,5 +11,6 @@ module.exports = {
     "effector/no-unnecessary-combination": "warn",
     "effector/no-duplicate-on": "error",
     "effector/keep-options-order": "warn",
+    "effector/no-inline-units": "error",
   },
 };

index.js

@@ -15,6 +15,7 @@ module.exports = {
     "keep-options-order": require("./rules/keep-options-order/keep-options-order"),
     "no-forward": require("./rules/no-forward/no-forward"),
     "no-guard": require("./rules/no-guard/no-guard"),
+    "no-inline-units": require("./rules/no-inline-units/no-inline-units"),
   },
   configs: {
     recommended: require("./config/recommended"),

rules/no-forward/no-forward.js

@@ -16,7 +16,7 @@ module.exports = {
     messages: {
       noForward:
         "Instead of `forward` you can use `sample`, it is more extendable.",
-      replaceWithSample: "Repalce `forward` with `sample`.",
+      replaceWithSample: "Replace `forward` with `sample`.",
     },
     schema: [],
     hasSuggestions: true,

rules/no-inline-units/no-inline-units.js

@@ -0,0 +1,84 @@
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+
+const METHODS = [
+  "forward",
+  "sample",
+  "guard",
+  "attach",
+  "merge",
+  "combine",
+  "createApi",
+];
+
+const UNIT_CREATORS = ["createStore", "createEvent", "createEffect"];
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbids to use inline units in methods",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("no-inline-units"),
+    },
+    messages: {
+      noInlineUnits:
+        'Declare inline method "{{ inlineMethodName }}" in a variable',
+    },
+    schema: [],
+  },
+  create(context) {
+    const importNodes = new Map();
+    const importedFromEffector = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          nodeMap: importNodes,
+          node,
+          packageName: "effector",
+        });
+      },
+      CallExpression(node) {
+        const isEffectorMethod = method.is(METHODS, {
+          node,
+          importMap: importedFromEffector,
+        });
+
+        if (!isEffectorMethod) {
+          return;
+        }
+
+        const configNode = node?.arguments?.[0];
+        const optionsNodes = configNode?.properties;
+        let inlineMethodName;
+
+        const hasInlineUnits = optionsNodes?.some((optionNode) => {
+          const isFound = method.is(UNIT_CREATORS, {
+            node: optionNode?.value,
+            importMap: importedFromEffector,
+          });
+
+          if (isFound) {
+            inlineMethodName = optionNode?.value?.callee?.name;
+          }
+
+          return isFound;
+        });
+
+        if (!hasInlineUnits) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "noInlineUnits",
+          data: { inlineMethodName },
+        });
+      },
+    };
+  },
+};

rules/no-inline-units/no-inline-units.md

@@ -0,0 +1,13 @@
+# effector/no-inline-units
+
+Disallows to use inline units in methods
+
+```ts
+// 👎 Bad
+sample({ source: $somestore, target: createEffect() });
+
+// 👍 Good
+const effectFx = createEffect();
+
+sample({ source: $somestore, target: effectFx });
+```

rules/no-inline-units/no-inline-units.test.js

@@ -0,0 +1,83 @@
+const { RuleTester } = require("eslint");
+
+const rule = require("./no-inline-units");
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: "module",
+  },
+});
+
+ruleTester.run("effector/no-inline-units.test", rule, {
+  valid: [
+    `
+      import { sample } from 'effector';
+      sample({ clock: event, target: effectFx });
+    `,
+    `
+      import { sample } from 'someLibrary';
+      sample({
+        clock: event,
+        source: $shouldExecute,
+        filter: (shouldExecute) => shouldExecute,
+        target: effectFx
+      });
+    `,
+    `
+      import { sample, attach } from 'effector';
+      sample({
+        clock: event,
+        target: attach({
+          effect: originalFx,
+          mapParams: params => {
+            return { wrapped: params }
+          },
+        })
+      });
+    `,
+  ].map((code) => ({ code })),
+  invalid: [
+    `
+      import { forward, createEffect } from 'effector';
+      forward({ from: eventOne, to: createEffect() });
+    `,
+    `
+      import { forward, createStore } from 'effector';
+      forward({ from: eventOne, to: createStore(null) });
+    `,
+    `
+      import { forward, createEvent } from 'effector';
+      forward({ from: eventOne, to: createEvent() });
+    `,
+    `
+      import { attach, createEffect } from 'effector';
+      attach({
+        effect: createEffect(),
+        mapParams: params => {
+          return {wrapped: params}
+        },
+      });
+    `,
+    `
+      import { sample, attach, createEffect } from 'effector';
+      sample({
+        clock: event,
+        target: attach({
+          effect: createEffect(),
+          mapParams: params => {
+            return {wrapped: params}
+          },
+        })
+      });
+    `,
+  ].map((code) => ({
+    code,
+    errors: [
+      {
+        messageId: "noInlineUnits",
+        type: "CallExpression",
+      },
+    ],
+  })),
+});