eslint-plugin-effector 0.4.2 → 0.6.0

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

@@ -1,10 +1,10 @@
-const {
-  extractImportedFromEffector,
-} = require("../../utils/extract-imported-from-effector");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
 const {
   traverseNestedObjectNode,
 } = require("../../utils/traverse-nested-object-node");
 const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { method } = require("../../utils/method");
+const { replaceForwardBySample } = require("../../utils/replace-by-sample");
 
 module.exports = {
   meta: {
@@ -20,24 +20,31 @@ module.exports = {
         "Instead of `forward` with `{{ eventName }}.map` you can use `sample`",
       overPrepend:
         "Instead of `forward` with `{{ eventName }}.prepend` you can use `sample`",
+      replaceWithSample: "Repalce `forward` with `sample`.",
     },
     schema: [],
+    hasSuggestions: true,
   },
   create(context) {
+    const importNodes = new Map();
     const importedFromEffector = new Map();
 
     return {
       ImportDeclaration(node) {
-        extractImportedFromEffector(importedFromEffector, node);
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          nodeMap: importNodes,
+          node,
+          packageName: "effector",
+        });
       },
       CallExpression(node) {
-        const localMethod = importedFromEffector.get("forward");
-        if (!localMethod) {
-          return;
-        }
-
-        const isEffectorMethod = node?.callee?.name === localMethod;
-        if (!isEffectorMethod) {
+        if (
+          method.isNot("forward", {
+            node,
+            importMap: importedFromEffector,
+          })
+        ) {
           return;
         }
 
@@ -70,14 +77,25 @@ module.exports = {
             return;
           }
 
-          // console.log(eventName);
-
           context.report({
             node,
             messageId,
             data: {
               eventName,
             },
+            suggest: [
+              {
+                messageId: "replaceWithSample",
+                *fix(fixer) {
+                  yield* replaceForwardBySample(forwardConfig, {
+                    fixer,
+                    node,
+                    context,
+                    importNodes,
+                  });
+                },
+              },
+            ],
           });
         }
 

package/rules/strict-effect-handlers/strict-effect-handlers.js

@@ -0,0 +1,76 @@
+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) {
+      const functionBody = node.body?.body;
+
+      if (!Array.isArray(functionBody)) {
+        return;
+      }
+
+      const calledNodes = functionBody
+        .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/utils/builders.js

@@ -0,0 +1,19 @@
+const buildObjectInText = {
+  fromArrayOfNodes({ properties, context }) {
+    const content = properties
+      .map((property) => context.getSourceCode().getText(property))
+      .join(", ");
+
+    return `{ ${content} }`;
+  },
+  fromMapOfNodes({ properties, context }) {
+    const content = Object.entries(properties)
+      .filter(([_, node]) => Boolean(node))
+      .map(([key, node]) => `${key}: ${context.getSourceCode().getText(node)}`)
+      .join(", ");
+
+    return `{ ${content} }`;
+  },
+};
+
+module.exports = { buildObjectInText };

package/utils/extract-imported-from.js

@@ -0,0 +1,10 @@
+function extractImportedFrom({ importMap, nodeMap, node, packageName }) {
+  if (node.source.value === packageName) {
+    for (const s of node.specifiers) {
+      importMap.set(s.imported.name, s.local.name);
+      nodeMap?.set(s.imported.name, s);
+    }
+  }
+}
+
+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/method.js

@@ -0,0 +1,23 @@
+function isSomeMethod(methodName, { node, importMap }) {
+  const normalizedMethodNames = Array.isArray(methodName)
+    ? methodName
+    : [methodName];
+
+  return normalizedMethodNames.some((method) => {
+    const localMethod = importMap.get(method);
+    if (!localMethod) {
+      return false;
+    }
+
+    const isEffectorMethod = node?.callee?.name === localMethod;
+
+    return isEffectorMethod;
+  });
+}
+
+const method = {
+  is: (...args) => isSomeMethod(...args),
+  isNot: (...args) => !isSomeMethod(...args),
+};
+
+module.exports = { method };

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,59 @@
+function hasType({ node, possibleTypes, context, from }) {
+  try {
+    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))
+    );
+  } catch (e) {
+    return false;
+  }
+}
+
+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/replace-by-sample.js

@@ -0,0 +1,66 @@
+const { buildObjectInText } = require("./builders");
+
+function* replaceForwardBySample(
+  forwardConfig,
+  { fixer, node, context, importNodes }
+) {
+  let mapperFunctionNode = null;
+
+  let clockMapperUsed = false;
+  let targetMapperUsed = false;
+
+  let clockNode = forwardConfig.from.value;
+  let targetNode = forwardConfig.to.value;
+
+  if (
+    clockNode.type === "CallExpression" &&
+    clockNode?.callee?.property?.name === "map"
+  ) {
+    mapperFunctionNode = clockNode?.arguments?.[0];
+    clockNode = clockNode.callee.object;
+    clockMapperUsed = true;
+  }
+
+  if (
+    targetNode.type === "CallExpression" &&
+    targetNode?.callee?.property?.name === "prepend"
+  ) {
+    mapperFunctionNode = targetNode?.arguments?.[0];
+    targetNode = targetNode.callee.object;
+    targetMapperUsed = true;
+  }
+
+  // We cannot apply two mappers in one sample
+  // Let's revert mappers and use .map + .prepend
+  if (clockMapperUsed && targetMapperUsed) {
+    mapperFunctionNode = null;
+    clockNode = forwardConfig.from.value;
+    targetNode = forwardConfig.to.value;
+  }
+
+  yield* replaceBySample(
+    { clockNode, targetNode, mapperFunctionNode },
+    { node, fixer, context, importNodes, methodName: "forward" }
+  );
+}
+
+function* replaceBySample(
+  { clockNode, targetNode, mapperFunctionNode },
+  { node, fixer, context, importNodes, methodName }
+) {
+  yield fixer.replaceText(
+    node,
+    `sample(${buildObjectInText.fromMapOfNodes({
+      properties: {
+        clock: clockNode,
+        fn: mapperFunctionNode,
+        target: targetNode,
+      },
+      context,
+    })})`
+  );
+
+  yield fixer.replaceText(importNodes.get(methodName), "sample");
+}
+
+module.exports = { replaceForwardBySample };

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/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.md

@@ -1,11 +0,0 @@
-# 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.md

@@ -1,44 +0,0 @@
-# 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. 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 = createStore(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.md

@@ -1,12 +0,0 @@
-# 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.md

@@ -1,20 +0,0 @@
-# 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-combination/no-unnecessary-combination.md

@@ -1,14 +0,0 @@
-# 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, x: $store2}), filter: $filter });
-```
-

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

@@ -1,32 +0,0 @@
-# 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.
-
-```ts
-const $data = createStore(null);
-
-// 👎 can be simplified
-const target1 = sample({
-  source: $data,
-  clock: $data,
-  fn(data) {
-    return data.length;
-  },
-});
-
-// 👍 better
-const target2 = sample({
-  source: $data,
-  fn(data) {
-    return data.length;
-  },
-});
-
-// 👍 also nice solution
-const target3 = sample({
-  clock: $data,
-  fn(data) {
-    return data.length;
-  },
-});
-```

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

@@ -1,14 +0,0 @@
-# effector/no-useless-methods
-
-Call of `gaurd`/`sample` without `target` or variable assignment is useless. It can be omitted from source code.
-
-```ts
-// 👎 can be omitted
-guard({ clock: trigger, filter: Boolean });
-
-// 👍 makes sense
-const target1 = guard({ clock: trigger, filter: Boolean });
-
-// 👍 make sense too
-guard({ clock: trigger, filter: Boolean, target: target2 });
-```