@onrails/eslint-plugin 0.1.1 → 0.1.3

package/README.md

@@ -20,6 +20,7 @@ export default [
     rules: {
       "@onrails/no-promise-result": "warn",
       "@onrails/no-unsafe-unwrap": "warn",
+      "@onrails/no-deprecated-synonyms": "warn",
     },
   },
 ];
@@ -46,6 +47,7 @@ export default [
 |---|---|
 | `@onrails/no-promise-result` | Flags `Promise<Result<…>>` in source — public APIs should return `ResultAsync` |
 | `@onrails/no-unsafe-unwrap` | Flags `_unsafeUnwrap*` outside test files |
+| `@onrails/no-deprecated-synonyms` | Flags deprecated synonyms (`chain`, `fold`, `getOrElse`, `of`, …) and suggests the canonical names |
 
 ## Caveats (v0)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/eslint-plugin",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "ESLint rules for @onrails/result boundaries — flags Promise<Result<…>> in public APIs and _unsafeUnwrap*. Replaces unmaintained eslint-plugin-neverthrow.",
   "license": "MIT",
   "author": "Alan R. Soares",

package/src/index.js

@@ -94,11 +94,13 @@ const noUnsafeUnwrap = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "Discourage _unsafeUnwrap / _unsafeUnwrapErr outside tests.",
+      description:
+        "Discourage _unsafeUnwrap / _unsafeUnwrapErr and unwrapOk / unwrapErr / unwrap outside tests. Matching is name-based; same-named functions from other libraries are flagged too.",
     },
     schema: [],
     messages: {
-      unsafe: "Avoid _unsafeUnwrap* — use match(), resolve(), or yieldResult() in tryGen.",
+      unsafe:
+        "Avoid _unsafeUnwrap* and unwrap* outside tests — use match(), resolve(), or yieldResult() in tryGen.",
     },
   },
   create(context) {
@@ -115,6 +117,85 @@ const noUnsafeUnwrap = {
           context.report({ node, messageId: "unsafe" });
         }
       },
+      CallExpression(node) {
+        if (
+          node.callee.type === "Identifier" &&
+          (node.callee.name === "unwrapOk" ||
+            node.callee.name === "unwrapErr" ||
+            node.callee.name === "unwrap")
+        ) {
+          context.report({ node, messageId: "unsafe" });
+        }
+      },
+    };
+  },
+};
+
+/**
+ * Deprecated synonym → canonical rename tables. Hand-copied from
+ * `@onrails/codemod` `src/boundary-spec.ts` (cross-package imports are
+ * forbidden); `packages/codemod/test/boundary-conformance.spec.ts` keeps the
+ * copies in sync with the spec and the Biome `no-deprecated-synonyms.grit`.
+ */
+
+/** Flagged as `x.name(…)`. `isOk` / `isErr` map to the same-named free-function guards. */
+const DEPRECATED_METHOD_RENAMES = new Map([
+  ["chain", "flatMap"],
+  ["isOk", "isOk"],
+  ["isErr", "isErr"],
+]);
+
+/** Flagged as `name(…)`. */
+const DEPRECATED_CALL_RENAMES = new Map([
+  ["fold", "match"],
+  ["matchResult", "match"],
+  ["matchMaybe", "match"],
+  ["getOrElse", "unwrapOr"],
+  ["sequenceTupleAsync", "ResultAsync.combineTuple"],
+  ["collect", "combine"],
+  ["of", "ok"],
+]);
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noDeprecatedSynonyms = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Flag deprecated railway/maybe synonyms (chain, fold, getOrElse, of, …) and suggest the canonical onrails names. Matching is name-based; same-named functions from other libraries are flagged too.",
+    },
+    schema: [],
+    messages: {
+      rename: "{{name}}() is a deprecated onrails synonym — use {{canonical}}() instead.",
+      narrowGuard:
+        "Deprecated .{{name}}() method — await the ResultAsync and narrow with the {{name}}() free function instead.",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type === "Identifier") {
+          const canonical = DEPRECATED_CALL_RENAMES.get(callee.name);
+          if (canonical) {
+            context.report({
+              node,
+              messageId: "rename",
+              data: { name: callee.name, canonical },
+            });
+          }
+          return;
+        }
+        if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier") return;
+        const name = callee.property.name;
+        const canonical = DEPRECATED_METHOD_RENAMES.get(name);
+        if (!canonical) return;
+        context.report(
+          canonical === name
+            ? { node, messageId: "narrowGuard", data: { name } }
+            : { node, messageId: "rename", data: { name, canonical } },
+        );
+      },
     };
   },
 };
@@ -128,6 +209,7 @@ const plugin = {
   rules: {
     "no-promise-result": noPromiseResult,
     "no-unsafe-unwrap": noUnsafeUnwrap,
+    "no-deprecated-synonyms": noDeprecatedSynonyms,
   },
 };
 
@@ -141,6 +223,7 @@ export const configs = {
     rules: {
       "@onrails/result/no-promise-result": "warn",
       "@onrails/result/no-unsafe-unwrap": "warn",
+      "@onrails/result/no-deprecated-synonyms": "warn",
     },
   },
 };