Rule: prefer-serializable-value-in-store

README.md

@@ -56,6 +56,7 @@ This preset is recommended for most projects.
 - [effector/no-unnecessary-combination](rules/no-unnecessary-combination/no-unnecessary-combination.md)
 - [effector/no-duplicate-on](rules/no-duplicate-on/no-duplicate-on.md)
 - [effector/keep-options-order](rules/keep-options-order/keep-options-order.md)
+- [effector/prefer-serializable-value-in-store](rules/prefer-serializable-value-in-store/prefer-serializable-value-in-store.md)
 
 #### plugin:effector/scope
 

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/prefer-serializable-value-in-store": "warn",
   },
 };

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"),
+    "prefer-serializable-value-in-store": require("./rules/prefer-serializable-value-in-store/prefer-serializable-value-in-store"),
   },
   configs: {
     recommended: require("./config/recommended"),

rules/prefer-serializable-value-in-store/examples/correct-date-mapped.ts

@@ -0,0 +1,6 @@
+import { combine, createStore } from "effector";
+
+const $dateString = createStore(new Date().toISOString());
+
+export const $mapped = $dateString.map((s) => new Date(s));
+export const $combined = combine($dateString, (s) => new Date(s));

rules/prefer-serializable-value-in-store/examples/correct-date-serialize-ignore.ts

@@ -0,0 +1,3 @@
+import { createStore } from "effector";
+
+export const $date = createStore(new Date(), { serialize: "ignore" });

rules/prefer-serializable-value-in-store/examples/correct.ts

@@ -0,0 +1,10 @@
+import { createStore } from "effector";
+
+export const $string = createStore("");
+export const $stringOrNull = createStore<string | null>(null);
+
+export const $number = createStore(0);
+export const $numberOrNull = createStore<number | null>(null);
+
+export const $boolean = createStore(false);
+export const $booleanOrNull = createStore<boolean | null>(null);

rules/prefer-serializable-value-in-store/examples/incorrect-array-record.ts

@@ -0,0 +1,7 @@
+import { createStore } from "effector";
+
+interface User {
+  created: Date;
+}
+
+export const $users = createStore<User[]>([]);

rules/prefer-serializable-value-in-store/examples/incorrect-array.ts

@@ -0,0 +1,3 @@
+import { createStore } from "effector";
+
+export const $dates = createStore<Date[]>([]);

rules/prefer-serializable-value-in-store/examples/incorrect-date-or-null.ts

@@ -0,0 +1,3 @@
+import { createStore } from "effector";
+
+export const $dateOrNull = createStore<Date | null>(null);

rules/prefer-serializable-value-in-store/examples/incorrect-date.ts

@@ -0,0 +1,3 @@
+import { createStore } from "effector";
+
+export const $date = createStore(new Date());

rules/prefer-serializable-value-in-store/examples/incorrect-record.ts

@@ -0,0 +1,7 @@
+import { createStore } from "effector";
+
+interface User {
+  created: Date;
+}
+
+export const $user = createStore<User | null>(null);

rules/prefer-serializable-value-in-store/prefer-serializable-value-in-store.js

@@ -0,0 +1,108 @@
+const { createLinkToRule } = require("../../utils/create-link-to-rule");
+const { extractImportedFrom } = require("../../utils/extract-imported-from");
+const { is } = require("../../utils/is");
+const { extractType } = require("../../utils/extract-type");
+const { walkType } = require("../../utils/walk-type");
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Avoid unserializable values in serializable stores",
+      category: "Quality",
+      recommended: true,
+      url: createLinkToRule("prefer-serializable-value-in-store"),
+    },
+    messages: {
+      dangerousType: "Type {{typeName}} cannot be serialized.",
+    },
+    schema: [],
+  },
+  create(context) {
+    // TypeScript-way
+    const importedFromEffector = new Map();
+    return {
+      ImportDeclaration(node) {
+        extractImportedFrom({
+          importMap: importedFromEffector,
+          node,
+          packageName: "effector",
+        });
+      },
+      VariableDeclarator(node) {
+        if (is.not.store({ node, context })) {
+          return;
+        }
+
+        const useSerialization = isStoreSerializeble({ node });
+
+        const storeType = extractType({ node, context });
+        const valueType = storeType?.resolvedTypeArguments?.[0];
+
+        let dangerousType = null;
+        walkType(
+          valueType,
+          (typeItem) => {
+            if (isPrimitive(typeItem)) {
+              return;
+            }
+
+            if (isDate(typeItem)) {
+              dangerousType = typeItem;
+              return;
+            }
+          },
+          { context }
+        );
+
+        if (dangerousType && useSerialization) {
+          context.report({
+            node,
+            messageId: "dangerousType",
+            data: {
+              typeName: typeName(dangerousType) ?? "unknown",
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+// TypeCheckers
+
+function typeName(type) {
+  return type?.symbol?.escapedName ?? type?.typeName?.escapedText;
+}
+
+function isPrimitive(type) {
+  return ["boolean", "number", "string"].includes(type?.intrinsicName);
+}
+
+function isDate(type) {
+  return typeName(type) === "Date" ?? false;
+}
+
+// Arg extraction
+function isStoreSerializeble({ node }) {
+  if (node?.init?.type !== "CallExpression") {
+    return true;
+  }
+
+  if (node?.init?.callee?.name === "combine") {
+    return false;
+  }
+
+  if (node?.init?.callee?.property?.name === "map") {
+    return false;
+  }
+
+  if (node?.init?.callee?.name === "createStore") {
+    const serializeProperty = node?.init?.arguments?.[1]?.properties?.find(
+      (prop) => prop?.key?.name === "serialize"
+    );
+    return serializeProperty?.value?.value !== "ignore" ?? true;
+  }
+
+  return true;
+}

rules/prefer-serializable-value-in-store/prefer-serializable-value-in-store.md

@@ -0,0 +1 @@
+# effector/prefer-serializable-value-in-store

rules/prefer-serializable-value-in-store/prefer-serializable-value-in-store.ts.test.js

@@ -0,0 +1,48 @@
+const { RuleTester } =
+  require("@typescript-eslint/experimental-utils").ESLintUtils;
+const { join } = require("path");
+
+const { readExample } = require("../../utils/read-example");
+const rule = require("./prefer-serializable-value-in-store");
+
+const ruleTester = new RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: "module",
+    project: "./tsconfig.json",
+    tsconfigRootDir: join(__dirname, ".."),
+  },
+});
+
+const readExampleForTheRule = (name) => ({
+  code: readExample(__dirname, name),
+  filename: join(__dirname, "examples", name),
+});
+
+ruleTester.run("effector/prefer-serializable-value-in-store.ts.test", rule, {
+  valid: [
+    "correct.ts",
+    "correct-date-mapped.ts",
+    "correct-date-serialize-ignore.ts",
+  ].map(readExampleForTheRule),
+
+  invalid: [
+    "incorrect-date.ts",
+    "incorrect-date-or-null.ts",
+    "incorrect-record.ts",
+    "incorrect-array.ts",
+    "incorrect-array-record.ts",
+  ]
+    .map(readExampleForTheRule)
+    .map((result) => ({
+      ...result,
+      errors: [
+        {
+          messageId: "dangerousType",
+          type: "VariableDeclarator",
+          data: { typeName: "Date" },
+        },
+      ],
+    })),
+});

utils/extract-type.js

@@ -0,0 +1,17 @@
+function extractType({ node, context }) {
+  try {
+    const checker = context.parserServices.program.getTypeChecker();
+    const originalNode = context.parserServices.esTreeNodeToTSNodeMap.get(node);
+    const type = checker.getTypeAtLocation(
+      originalNode?.initializer ?? originalNode
+    );
+
+    return type;
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = {
+  extractType,
+};

utils/walk-type.js

@@ -0,0 +1,23 @@
+const { extractType } = require("./extract-type");
+
+function walkType(type, callback, { context }) {
+  callback(type);
+
+  // Walk around Array
+  if (type?.symbol?.escapedName === "Array") {
+    for (const typeAgrument of type?.resolvedTypeArguments) {
+      walkType(typeAgrument, callback, { context });
+    }
+    return;
+  }
+
+  // Walk around Object
+  if (type?.symbol?.members) {
+    for (const [_, member] of type.symbol.members) {
+      walkType(member?.valueDeclaration?.type, callback, { context });
+    }
+    return;
+  }
+}
+
+module.exports = { walkType };