@onrails/codemod 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/codemod",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Codemods for migrating onto @onrails/result (neverthrow → compat shim, and beyond)",
   "license": "MIT",
   "author": "Alan R. Soares",

package/src/ast.ts

@@ -1,4 +1,4 @@
-import { fromNullable, type Maybe, match as matchMaybe, none, some } from "@onrails/maybe";
+import { fromNullable, type Maybe, match, none, some } from "@onrails/maybe";
 import ts from "typescript";
 import { TYPE_ONLY_NATIVE } from "./constants.js";
 import type { Edit } from "./types.js";
@@ -11,7 +11,7 @@ export const edit = (text: string, imports: readonly string[] = []): Edit => ({
 });
 
 export const lookupMap = <K, V, R>(m: Map<K, V>, k: K, f: (v: V) => R): Maybe<R> =>
-  matchMaybe(fromNullable(m.get(k)), (v) => some(f(v)), none);
+  match(fromNullable(m.get(k)), (v) => some(f(v)), none);
 
 export const concatCollectors =
   <T, R>(...fns: Array<(t: T) => readonly R[]>) =>

package/src/chains.ts

@@ -1,4 +1,4 @@
-import { compactMap, isSome, type Maybe, none, some } from "@onrails/maybe";
+import { compactMap, isSome, type Maybe, map, none, some } from "@onrails/maybe";
 import ts from "typescript";
 import { argsToText, edit, lookupMap, spanEdit, walkSource } from "./ast.js";
 import {
@@ -22,10 +22,81 @@ export function isSupportedChainCall(node: ts.Node): node is ts.CallExpression {
   return CHAIN_METHODS.has(method) || TERMINAL_METHODS.has(method);
 }
 
-export function helperCallToNative(node: ts.CallExpression): Maybe<Edit> {
-  if (ts.isIdentifier(node.expression) && node.arguments.length === 0) {
-    return lookupMap(ZERO_ARG_HELPERS, node.expression.text, (text) => edit(text));
+function identifierCallToNative(node: ts.CallExpression): Maybe<Edit> {
+  if (!ts.isIdentifier(node.expression)) return none();
+  const name = node.expression.text;
+  if (node.arguments.length === 0) {
+    const zero = lookupMap(ZERO_ARG_HELPERS, name, (text) => edit(text));
+    if (isSome(zero)) return zero;
+  }
+
+  if (name === "sequenceTupleAsync") {
+    return some(edit(`ResultAsync.combineTuple(${argsToText(node.arguments)})`, ["ResultAsync"]));
+  }
+  if (name === "getOrElse") {
+    return some(edit(`unwrapOr(${argsToText(node.arguments)})`, ["unwrapOr"]));
+  }
+  if (name === "collect") {
+    return some(edit(`combine(${argsToText(node.arguments)})`, ["combine"]));
+  }
+  if (name === "matchResult" || name === "matchMaybe") {
+    return some(edit(`match(${argsToText(node.arguments)})`, ["match"]));
   }
+  if (name === "fold") {
+    return map(foldHandlerTexts(node.arguments[0]), ({ okText, errText }) =>
+      edit(`match(${okText}, ${errText})`, ["match"]),
+    );
+  }
+  return none();
+}
+
+type FoldHandlerTexts = { okText: string; errText: string };
+
+// Bails (none) unless both `ok` and `err` handlers are plain or shorthand
+// properties — spread/computed handlers can't be rewritten textually.
+function foldHandlerTexts(objArg: ts.Expression | undefined): Maybe<FoldHandlerTexts> {
+  if (!objArg || !ts.isObjectLiteralExpression(objArg)) return none();
+  let okText: string | undefined;
+  let errText: string | undefined;
+  for (const prop of objArg.properties) {
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      if (prop.name.text === "ok") {
+        okText = prop.initializer.getText();
+      } else if (prop.name.text === "err") {
+        errText = prop.initializer.getText();
+      }
+    } else if (ts.isShorthandPropertyAssignment(prop)) {
+      if (prop.name.text === "ok") {
+        okText = "ok";
+      } else if (prop.name.text === "err") {
+        errText = "err";
+      }
+    }
+  }
+  return okText !== undefined && errText !== undefined ? some({ okText, errText }) : none();
+}
+
+function curriedFoldToNative(node: ts.CallExpression): Maybe<Edit> {
+  if (
+    !ts.isCallExpression(node.expression) ||
+    !ts.isIdentifier(node.expression.expression) ||
+    node.expression.expression.text !== "fold"
+  ) {
+    return none();
+  }
+  const receiver = node.arguments[0];
+  if (!receiver) return none();
+  return map(foldHandlerTexts(node.expression.arguments[0]), ({ okText, errText }) =>
+    edit(`match(${okText}, ${errText})(${receiver.getText()})`, ["match"]),
+  );
+}
+
+export function helperCallToNative(node: ts.CallExpression): Maybe<Edit> {
+  const ident = identifierCallToNative(node);
+  if (isSome(ident)) return ident;
+
+  const curried = curriedFoldToNative(node);
+  if (isSome(curried)) return curried;
 
   if (!ts.isPropertyAccessExpression(node.expression)) return none();
   const method = node.expression.name.text;

package/src/cli.ts

@@ -1,5 +1,5 @@
 import { relative, resolve } from "node:path";
-import { type Maybe, match as matchMaybe, none, some, tap } from "@onrails/maybe";
+import * as Maybe from "@onrails/maybe";
 import { match } from "@onrails/pattern";
 import { err, isErr, ok, type Result, ResultAsync } from "@onrails/result";
 import { Glob } from "bun";
@@ -61,25 +61,25 @@ const rewriteCode = (
   path: string,
   dry: boolean,
   mode: Mode,
-): ResultAsync<Maybe<FileChange>, Error> =>
+): ResultAsync<Maybe.Maybe<FileChange>, Error> =>
   readFileText(path).flatMap((src) =>
-    matchMaybe(
+    Maybe.match(
       computeFileChange(src, mode),
       (c) => {
         const change = toFileChange(path, c);
         return c.changed && !dry
-          ? writeFileText(path, c.next).map(() => some(change))
-          : ResultAsync.ok<Maybe<FileChange>, Error>(some(change));
+          ? writeFileText(path, c.next).map(() => Maybe.some(change))
+          : ResultAsync.ok<Maybe.Maybe<FileChange>, Error>(Maybe.some(change));
       },
-      () => ResultAsync.ok<Maybe<FileChange>, Error>(none()),
+      () => ResultAsync.ok<Maybe.Maybe<FileChange>, Error>(Maybe.none()),
     ),
   );
 
 const collectInto =
   <T>(into: T[], file: string) =>
-  (r: ResultAsync<Maybe<T>, Error>): Promise<void> =>
+  (r: ResultAsync<Maybe.Maybe<T>, Error>): Promise<void> =>
     r.match(
-      (m) => void tap(m, (c) => into.push(c)),
+      (m) => void Maybe.tap(m, (c) => into.push(c)),
       (e) => console.error(`error processing ${file}:`, e.message),
     );
 

package/src/imports.ts

@@ -1,18 +1,39 @@
 import { isTypeOnlyNative, isValueImport, splitImportNames, stripInlineType } from "./ast.js";
 import { COMPAT_SPEC, NATIVE_SPEC } from "./constants.js";
 
+// Every entry must have a matching call-site rewrite in chains.ts, or the
+// renamed import strands the old name at call sites. `of` is intentionally
+// absent: bare `of(...)` calls collide with other libraries (e.g. RxJS) and
+// the canonical target differs per carrier (result `ok` vs maybe `some`) —
+// the native package still exports the deprecated alias, so imports of `of`
+// pass through unchanged and the lint rules flag them for manual migration.
+const IMPORT_RENAMES = new Map([
+  ["sequenceTupleAsync", "ResultAsync"],
+  ["getOrElse", "unwrapOr"],
+  ["collect", "combine"],
+  ["matchResult", "match"],
+  ["matchMaybe", "match"],
+  ["fold", "match"],
+]);
+
 export function toNativeImport(full: string, specifiers: string, quote: string): string {
   const imports = splitImportNames(specifiers);
   const typeNames = imports.filter(isTypeOnlyNative).map(stripInlineType);
-  const valueNames = imports.filter(isValueImport);
+  const rawValueNames = imports.filter(isValueImport);
+  const valueNames = rawValueNames.map((name) => IMPORT_RENAMES.get(name) ?? name);
+
+  const uniqueValueNames = [...new Set(valueNames)];
+  const uniqueTypeNames = [...new Set(typeNames)];
   const chunks: string[] = [];
 
-  if (valueNames.length > 0) {
-    chunks.push(`import { ${valueNames.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`);
+  if (uniqueValueNames.length > 0) {
+    chunks.push(`import { ${uniqueValueNames.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`);
   }
 
-  if (typeNames.length > 0) {
-    chunks.push(`import type { ${typeNames.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`);
+  if (uniqueTypeNames.length > 0) {
+    chunks.push(
+      `import type { ${uniqueTypeNames.join(", ")} } from ${quote}${NATIVE_SPEC}${quote};`,
+    );
   }
 
   return chunks.length > 0 ? chunks.join("\n") : full;

package/src/pkg.ts

@@ -1,5 +1,5 @@
 import { relative } from "node:path";
-import { type Maybe, match as matchMaybe, none, some } from "@onrails/maybe";
+import { type Maybe, match, none, some } from "@onrails/maybe";
 import { type Result, ResultAsync, trySync } from "@onrails/result";
 import { DEP_KEYS } from "./constants.js";
 import { readFileText, toError, writeFileText } from "./io.js";
@@ -49,7 +49,7 @@ export const rewritePkg = (
   readFileText(path)
     .flatMap((raw) => ResultAsync.fromResult(parsePackageJson(raw)))
     .flatMap((json) =>
-      matchMaybe(
+      match(
         computePkgRewrite(json, path, onrailsAbs),
         (c) => {
           const change = toPkgChange(path, c);