@onrails/codemod 0.1.1 → 0.1.3

package/src/pkg.ts

@@ -0,0 +1,62 @@
+import { relative } from "node:path";
+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";
+import type { ComputedPkg, PkgChange, PkgUpdate } from "./types.js";
+
+const reorderDeps = (deps: Record<string, string>): Record<string, string> =>
+  Object.fromEntries(Object.entries(deps).sort(([a], [b]) => a.localeCompare(b)));
+
+export const parsePackageJson = (raw: string): Result<Record<string, unknown>, Error> =>
+  trySync(() => JSON.parse(raw) as Record<string, unknown>, toError)();
+
+const applyDepRewrite =
+  (fileSpec: string) =>
+  (acc: PkgUpdate, key: string): PkgUpdate => {
+    const deps = acc.json[key] as Record<string, string> | undefined;
+    if (!deps || typeof deps !== "object" || !("neverthrow" in deps)) return acc;
+    const { neverthrow: _drop, ...rest } = deps;
+    return {
+      json: { ...acc.json, [key]: reorderDeps({ ...rest, "@onrails/result": fileSpec }) },
+      removed: [...acc.removed, key],
+    };
+  };
+
+export const computePkgRewrite = (
+  json: Record<string, unknown>,
+  path: string,
+  onrailsAbs: string,
+): Maybe<ComputedPkg> => {
+  const fileSpec = `file:${relative(path.replace(/\/package\.json$/, ""), onrailsAbs)}`;
+  const updated = DEP_KEYS.reduce(applyDepRewrite(fileSpec), { json, removed: [] } as PkgUpdate);
+  return updated.removed.length === 0
+    ? none()
+    : some({ json: updated.json, removed: updated.removed, fileSpec });
+};
+
+const toPkgChange = (path: string, c: ComputedPkg): PkgChange => ({
+  path,
+  removed: [...c.removed],
+  addedAs: c.fileSpec,
+});
+
+export const rewritePkg = (
+  path: string,
+  onrailsAbs: string,
+  dry: boolean,
+): ResultAsync<Maybe<PkgChange>, Error> =>
+  readFileText(path)
+    .flatMap((raw) => ResultAsync.fromResult(parsePackageJson(raw)))
+    .flatMap((json) =>
+      match(
+        computePkgRewrite(json, path, onrailsAbs),
+        (c) => {
+          const change = toPkgChange(path, c);
+          return dry
+            ? ResultAsync.ok<Maybe<PkgChange>, Error>(some(change))
+            : writeFileText(path, `${JSON.stringify(c.json, null, 2)}\n`).map(() => some(change));
+        },
+        () => ResultAsync.ok<Maybe<PkgChange>, Error>(none()),
+      ),
+    );

package/src/types.ts

@@ -0,0 +1,46 @@
+export type Mode = "compat" | "native";
+export type Args = { target: string; dry: boolean; onrails: string; mode: Mode };
+
+export type Warning = { line: number; label: string; text: string };
+export type FileChange = {
+  path: string;
+  before: number;
+  after: number;
+  changed: boolean;
+  warnings: readonly Warning[];
+};
+export type Edit = { start: number; end: number; text: string; imports: readonly string[] };
+export type ChainStep = { method: string; argsText: string; argCount: number };
+export type PipelinePart = { importName: string; text: string };
+
+export type ComputedChange = {
+  next: string;
+  before: number;
+  after: number;
+  changed: boolean;
+  warnings: readonly Warning[];
+};
+
+export type ModeStrategy = {
+  countBefore: (src: string) => number;
+  earlyExit: (src: string, before: number) => boolean;
+  transform: (src: string) => string;
+  warnings: (next: string) => readonly Warning[];
+  countAfter: (next: string) => number;
+};
+
+export type PkgChange = { path: string; removed: string[]; addedAs: string };
+export type PkgUpdate = { json: Record<string, unknown>; removed: readonly string[] };
+export type ComputedPkg = {
+  json: Record<string, unknown>;
+  removed: readonly string[];
+  fileSpec: string;
+};
+
+export type ArgState = {
+  positional: readonly string[];
+  dry: boolean;
+  mode: Mode;
+  onrails: string;
+};
+export type EditAcc = { src: string; imports: Set<string> };

package/src/warnings.ts

@@ -0,0 +1,61 @@
+import ts from "typescript";
+import { concatCollectors, walkSource } from "./ast.js";
+import { COMPAT_ONLY_PATTERNS, COMPAT_SPEC } from "./constants.js";
+import type { Warning } from "./types.js";
+
+export const collectRegexLineWarnings = (src: string): readonly Warning[] =>
+  src
+    .split(/\r?\n/)
+    .flatMap((line, i) =>
+      COMPAT_ONLY_PATTERNS.flatMap(({ pattern, label }) =>
+        pattern.test(line) ? [{ line: i + 1, label, text: line.trim() }] : [],
+      ),
+    );
+
+export const collectAstCompatWarnings = (src: string): readonly Warning[] => {
+  const warnings: Warning[] = [];
+  const lines = src.split(/\r?\n/);
+  const lineTextAt = (sf: ts.SourceFile, node: ts.Node) => {
+    const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    return { line, text: lines[line - 1]?.trim() ?? node.getText(sf) };
+  };
+
+  walkSource(src, (node, sf) => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const method = node.expression.name.text;
+      if (method === "isOk" || method === "isErr") {
+        warnings.push({ ...lineTextAt(sf, node), label: "compat predicate method" });
+      }
+    }
+
+    if (ts.isPropertyAccessExpression(node)) {
+      const property = node.name.text;
+      if (property === "value" || property === "error") {
+        const receiver = node.expression.getText(sf);
+        if (/result$/i.test(receiver) || /^result$/i.test(receiver)) {
+          warnings.push({ ...lineTextAt(sf, node), label: "compat value/error property" });
+        }
+      }
+    }
+  });
+
+  return warnings;
+};
+
+export const collectNativeMigrationWarnings = concatCollectors(
+  collectRegexLineWarnings,
+  collectAstCompatWarnings,
+);
+
+export const collectUnsupportedCompatImportWarnings = (src: string): readonly Warning[] =>
+  src.split(/\r?\n/).flatMap((line, i) =>
+    line.includes(COMPAT_SPEC)
+      ? [
+          {
+            line: i + 1,
+            label: "unsupported compat import",
+            text: line.trim(),
+          },
+        ]
+      : [],
+  );