feat: no-unnecessary-combination

Author: kireevmp

src/index.ts

@@ -12,6 +12,7 @@ import noForward from "./rules/no-forward/no-forward"
 import noGetState from "./rules/no-getState/no-getState"
 import noGuard from "./rules/no-guard/no-guard"
 import noPatronumDebug from "./rules/no-patronum-debug/no-patronum-debug"
+import noUnnecessaryCombination from "./rules/no-unnecessary-combination/no-unnecessary-combination"
 import noUnnecessaryDuplication from "./rules/no-unnecessary-duplication/no-unnecessary-duplication"
 import noUselessMethods from "./rules/no-useless-methods/no-useless-methods"
 import noWatch from "./rules/no-watch/no-watch"
@@ -33,6 +34,7 @@ const base = {
     "no-getState": noGetState,
     "no-guard": noGuard,
     "no-patronum-debug": noPatronumDebug,
+    "no-unnecessary-combination": noUnnecessaryCombination,
     "no-unnecessary-duplication": noUnnecessaryDuplication,
     "no-useless-methods": noUselessMethods,
     "no-watch": noWatch,

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

@@ -0,0 +1,29 @@
+---
+description: Forbid unnecessary combinations in clock and source
+---
+
+# 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, y: $store2 },
+  filter: $filter,
+})
+```

src/rules/no-unnecessary-combination/no-unnecessary-combination.test.ts

@@ -0,0 +1,194 @@
+import { RuleTester } from "@typescript-eslint/rule-tester"
+import { parser } from "typescript-eslint"
+
+import { ts } from "@/shared/tag"
+
+import rule from "./no-unnecessary-combination"
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      projectService: { allowDefaultProject: ["*.ts"], defaultProject: "tsconfig.fixture.json" },
+    },
+  },
+})
+
+ruleTester.run("no-unnecessary-combination", rule, {
+  valid: [
+    {
+      name: "no combination",
+      code: ts`
+        import { createEvent, createStore, forward, guard, sample } from "effector"
+
+        const a = createEvent()
+        const b = createEvent()
+        const $x = createStore(null)
+        const $y = createStore(null)
+
+        sample({ clock: [a, b], source: [$x, $y] })
+        sample({ clock: a, source: [$x, $y] })
+        sample({ clock: a, source: { a: $x, b: $y } })
+
+        guard({ clock: [a, b], source: $x, filter: Boolean })
+        guard({ clock: a, source: { a: $x }, filter: Boolean })
+      `,
+    },
+    {
+      name: "combine in clock",
+      code: ts`
+        import { combine, createStore, sample, guard } from "effector"
+
+        const $x = createStore(null)
+        const $y = createStore(null)
+
+        guard({ clock: combine({ $x, $y }) })
+        sample({ clock: combine($x, $y) })
+      `,
+    },
+    {
+      name: "merge/combine outside",
+      code: ts`
+        import { merge, createEvent, createStore, combine } from "effector"
+
+        const a = createEvent()
+        const b = createEvent()
+        const $x = createStore(null)
+        const $y = createStore(null)
+
+        const merged = merge([a, b])
+        const combined = combine({ a, b }, (v) => Object.values(v))
+      `,
+    },
+    {
+      name: "nested source -> clock -> combine",
+      code: ts`
+        import { combine, createStore, merge, sample, guard } from "effector"
+
+        const a = createEvent()
+
+        const $x = createStore(null)
+        const $y = createStore(null)
+
+        sample({ source: sample({ clock: combine({ $x, $y }) }) })
+      `,
+    },
+  ],
+  invalid: [
+    {
+      name: "combine in guard.source",
+      code: ts`
+        import { combine, createStore, guard } from "effector"
+
+        const $x = createStore(null)
+        const $y = createStore(null)
+
+        guard({ source: combine($x, $y), filter: Boolean })
+      `,
+      errors: [
+        {
+          messageId: "unnecessary",
+          line: 6,
+          column: 17,
+          data: { method: "combine", property: "source", operator: "guard" },
+        },
+      ],
+    },
+    {
+      name: "combine in sample.source",
+      code: ts`
+        import { combine, createStore, sample } from "effector"
+
+        const $x = createStore(null)
+        const $y = createStore(null)
+
+        sample({ source: combine({ a: $x, b: $y }), fn: (v) => v })
+      `,
+      errors: [
+        {
+          messageId: "unnecessary",
+          line: 6,
+          column: 18,
+          data: { method: "combine", property: "source", operator: "sample" },
+        },
+      ],
+    },
+    {
+      name: "merge in guard.clock",
+      code: ts`
+        import { merge, createEvent, guard } from "effector"
+
+        const a = createEvent()
+        const b = createEvent()
+
+        guard({ clock: merge([a, b]), filter: Boolean })
+      `,
+      errors: [
+        {
+          messageId: "unnecessary",
+          line: 6,
+          column: 16,
+          data: { method: "merge", property: "clock", operator: "guard" },
+        },
+      ],
+    },
+    {
+      name: "merge in sample.clock",
+      code: ts`
+        import { merge, createEvent, sample } from "effector"
+
+        const a = createEvent()
+        const b = createEvent()
+
+        sample({ clock: merge([a, b]), filter: Boolean })
+      `,
+      errors: [
+        {
+          messageId: "unnecessary",
+          line: 6,
+          column: 17,
+          data: { method: "merge", property: "clock", operator: "sample" },
+        },
+      ],
+    },
+
+    {
+      name: "merge in guard.source",
+      code: ts`
+        import { merge, createEvent, guard } from "effector"
+
+        const a = createEvent()
+        const b = createEvent()
+
+        guard({ clock: a, source: merge([a, b]), filter: Boolean })
+      `,
+      errors: [
+        {
+          messageId: "unnecessary",
+          line: 6,
+          column: 27,
+          data: { method: "merge", property: "source", operator: "guard" },
+        },
+      ],
+    },
+    {
+      name: "merge in sample.source",
+      code: ts`
+        import { merge, createEvent, sample } from "effector"
+
+        const a = createEvent()
+        const b = createEvent()
+
+        sample({ clock: a, source: merge([a, b]), fn: (v) => v })
+      `,
+      errors: [
+        {
+          messageId: "unnecessary",
+          line: 6,
+          column: 28,
+          data: { method: "merge", property: "source", operator: "sample" },
+        },
+      ],
+    },
+  ],
+})

src/rules/no-unnecessary-combination/no-unnecessary-combination.ts

@@ -0,0 +1,73 @@
+import { type TSESTree as Node, AST_NODE_TYPES as NodeType } from "@typescript-eslint/utils"
+
+import { createRule } from "@/shared/create"
+import { locate } from "@/shared/locate"
+
+type CombinatorOperator = "combine" | "merge"
+
+export default createRule({
+  name: "no-unnecessary-combination",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Forbid unnecessary combinations in `clock` and `source`.",
+    },
+    messages: {
+      unnecessary: "{{ method }} is used under the hood of {{ property }} in {{ operator }}, you can omit it.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const operators = new Set<string>()
+    const combinators = new Map<string, CombinatorOperator>()
+
+    const PACKAGE_NAME = /^effector(?:\u002Fcompat)?$/
+
+    const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME}]`
+    const operatorSelector = `ImportSpecifier[imported.name=/(sample|guard)/]`
+    const combinatorSelector = `ImportSpecifier[imported.name=/(combine|merge)/]`
+
+    const callSelector = `[callee.type="Identifier"][arguments.length=1]`
+    const argumentSelector = `ObjectExpression.arguments`
+
+    const query = { source: locate.property("source"), clock: locate.property("clock") }
+
+    type MethodCall = Node.CallExpression & { callee: Node.Identifier; arguments: [Node.ObjectExpression] }
+
+    return {
+      [`${importSelector} > ${operatorSelector}`]: (node: Node.ImportSpecifier) => operators.add(node.local.name),
+
+      [`${importSelector} > ${combinatorSelector}`]: (node: Node.ImportSpecifier & { imported: { name: string } }) =>
+        combinators.set(node.local.name, node.imported.name as CombinatorOperator),
+
+      [`CallExpression${callSelector}:has(${argumentSelector})`]: (node: MethodCall) => {
+        if (!operators.has(node.callee.name)) return
+
+        const [config] = node.arguments
+
+        const clock = query.clock(config)?.value
+        const source = query.source(config)?.value
+
+        if (clock?.type === NodeType.CallExpression && clock.callee.type === NodeType.Identifier) {
+          const method = combinators.get(clock.callee.name)
+
+          if (method === "merge") {
+            const data = { method: clock.callee.name, property: "clock", operator: node.callee.name }
+            context.report({ node: clock, messageId: "unnecessary", data })
+          }
+        }
+
+        if (source?.type === NodeType.CallExpression && source.callee.type === NodeType.Identifier) {
+          const method = combinators.get(source.callee.name)
+
+          // both "combine" and "merge" match
+          if (method) {
+            const data = { method: source.callee.name, property: "source", operator: node.callee.name }
+            context.report({ node: source, messageId: "unnecessary", data })
+          }
+        }
+      },
+    }
+  },
+})

src/rules/no-useless-methods/no-useless-methods.md

@@ -1,5 +1,5 @@
 ---
-description: Forbid useless calls of `sample` and `guard`
+description: Forbid useless calls of sample and guard
 ---
 
 # effector/no-useless-methods

src/ruleset.ts

@@ -10,7 +10,7 @@ const recommended = {
   "effector/no-getState": "error",
   "effector/no-guard": "error",
   "effector/no-patronum-debug": "warn",
-  // "effector/no-unnecessary-combination": "warn",
+  "effector/no-unnecessary-combination": "warn",
   "effector/no-unnecessary-duplication": "warn",
   "effector/no-useless-methods": "error",
   "effector/no-watch": "warn",