@openrewrite/recipes-nodejs 0.47.0 → 0.47.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrewrite/recipes-nodejs",
-  "version": "0.47.0",
+  "version": "0.47.3",
   "license": "Moderne Proprietary",
   "description": "OpenRewrite recipes for Node.js library migrations.",
   "homepage": "https://github.com/moderneinc/rewrite-node",
@@ -17,15 +17,15 @@
     "access": "public"
   },
   "scripts": {
-    "prebuild": "bun -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "build": "tsc --build tsconfig.build.json",
-    "postbuild": "bun -e \"const fse=require('fs-extra'); fse.existsSync('resources') && fse.copySync('resources','dist/resources',{dereference:true})\"",
+    "postbuild": "node -e \"const fse=require('fs-extra'); fse.existsSync('resources') && fse.copySync('resources','dist/resources',{dereference:true})\"",
     "dev": "tsc --watch -p tsconfig.json",
     "test": "npm run build && jest",
     "ci:test": "jest"
   },
   "dependencies": {
-    "@openrewrite/rewrite": "^8.86.0-20260701-020557",
+    "@openrewrite/rewrite": "^8.88.0-20260729-151827",
     "mutative": "^1.1.0",
     "semver": "^7.7.3"
   },
@@ -33,7 +33,6 @@
     "@types/jest": "^29.5.13",
     "@types/node": "^22.5.4",
     "@types/semver": "^7.7.1",
-    "bun": "^1.3.5",
     "fs-extra": "^11.3.3",
     "jest": "^29.7.0",
     "jest-junit": "^17.0.0",

package/src/migrate/increase-node-engine-version.ts

@@ -11,7 +11,10 @@ import * as semver from "semver";
 export class IncreaseNodeEngineVersion extends Recipe {
     readonly name = "org.openrewrite.node.migrate.increase-node-engine-version";
     readonly displayName = "Increase Node.js engine version";
-    readonly description = "Increases the upper bound of the `engines.node` version range in package.json to allow the specified Node.js version.";
+    readonly description = "Raises the lower bound of the `engines.node` version range in package.json to the specified " +
+        "Node.js version, performing a hard cutover that drops support for older, end-of-life versions " +
+        "(`22.x` → `24.x`, `>= 22` → `>= 24`). The original constraint style is preserved where possible and the " +
+        "version is never lowered.";
 
     @Option({
         displayName: "Version",
@@ -48,13 +51,18 @@ export class IncreaseNodeEngineVersion extends Recipe {
                     return doc;
                 }
 
-                const updatedRange = increaseUpperBound(nodeRange, targetVersion);
+                const updatedRange = raiseMinimumVersion(nodeRange, targetVersion);
                 if (updatedRange === nodeRange) {
                     return doc;
                 }
 
-                packageJson.engines.node = updatedRange;
-                const modifiedContent = JSON.stringify(packageJson, null, 2);
+                // Targeted replacement preserves the file's original formatting (indentation,
+                // trailing newline, key order) instead of round-tripping through JSON.stringify.
+                const nodeMemberRegex = /("engines"\s*:\s*\{[\s\S]*?"node"\s*:\s*)"([^"]+)"/;
+                const modifiedContent = content.replace(nodeMemberRegex, `$1${JSON.stringify(updatedRange)}`);
+                if (modifiedContent === content) {
+                    return doc;
+                }
 
                 const parsed = await new JsonParser({}).parseOne({
                     text: modifiedContent,
@@ -71,67 +79,64 @@ export class IncreaseNodeEngineVersion extends Recipe {
     }
 }
 
-export function increaseUpperBound(range: string, targetVersion: number): string {
+export function raiseMinimumVersion(range: string, targetVersion: number): string {
+    const trimmed = range.trim();
+
+    let minVersion: semver.SemVer | null = null;
     try {
-        if (semver.satisfies(`${targetVersion}.0.0`, range)) {
-            return range;
-        }
+        minVersion = semver.minVersion(trimmed);
     } catch {
-        // fall through to string manipulation
+        // unparseable range: fall through to string manipulation
     }
-
-    // Hyphen range: "14 - 18" or "14.0.0 - 18.0.0"
-    const hyphenMatch = range.match(/^(.+\s+-\s+)(\d+)(\.0\.0)?$/);
-    if (hyphenMatch) {
-        return `${hyphenMatch[1]}${targetVersion}${hyphenMatch[3] || ''}`;
+    if (minVersion && minVersion.major >= targetVersion) {
+        return range;
     }
 
-    // Simple OR ranges (no < or > comparators): "14 || 16 || 18", "^14 || ^16", "14.x || 16.x"
-    if (range.includes('||') && !/[<>]/.test(range)) {
-        const separatorMatch = range.match(/(\s*\|\|\s*)/);
-        const separator = separatorMatch ? separatorMatch[1] : ' || ';
-        const lastPart = range.split(/\s*\|\|\s*/).pop()!.trim();
-
-        let newPart: string;
-        if (lastPart.startsWith('^')) {
-            newPart = `^${targetVersion}`;
-        } else if (lastPart.startsWith('~')) {
-            newPart = `~${targetVersion}`;
-        } else if (lastPart.endsWith('.x')) {
-            newPart = `${targetVersion}.x`;
-        } else {
-            newPart = `${targetVersion}`;
+    // OR union with no comparators: drop terms below the target, floor the rest.
+    // "20.x || 22.x" -> "24.x"; "^26 || ^22" -> "^26" (preserves out-of-order terms already ≥ target).
+    if (trimmed.includes('||') && !/[<>]/.test(trimmed)) {
+        const parts = trimmed.split(/\s*\|\|\s*/).map(p => p.trim());
+        const kept = parts.filter(p => {
+            try {
+                const m = semver.minVersion(p);
+                return m !== null && m.major >= targetVersion;
+            } catch {
+                return false;
+            }
+        });
+        if (kept.length > 0) {
+            return kept.join(' || ');
         }
-
-        return `${range}${separator}${newPart}`;
+        return floorTerm(parts[parts.length - 1], targetVersion);
     }
 
-    // Upper bound with < or <= (not preceded by >, to avoid matching >=)
-    const upperBoundRegex = /(?<!>)(<=?)(\d+)(\.0\.0)?(?=[^<]*$)/;
-    const upperMatch = range.match(upperBoundRegex);
-    if (upperMatch) {
-        const op = upperMatch[1];
-        const suffix = upperMatch[3] || '';
-        const newMajor = op === '<' ? targetVersion + 1 : targetVersion;
-        return range.replace(upperBoundRegex, `${op}${newMajor}${suffix}`);
-    }
-
-    // Single caret: "^18" or "^18.0.0"
-    const caretMatch = range.match(/^\^(\d+)(\.0\.0)?$/);
-    if (caretMatch) {
-        return `${range} || ^${targetVersion}${caretMatch[2] || ''}`;
+    // Hyphen range: "18 - 20" or "18.0.0 - 20.0.0".
+    const hyphenMatch = trimmed.match(/^(.+?)\s+-\s+(.+)$/);
+    if (hyphenMatch) {
+        const upper = hyphenMatch[2].trim();
+        const upperMajor = parseInt(upper, 10);
+        if (!Number.isNaN(upperMajor) && upperMajor < targetVersion) {
+            return `>=${targetVersion}`;
+        }
+        return `${targetVersion} - ${upper}`;
     }
 
-    // Single tilde: "~18" or "~18.0.0"
-    const tildeMatch = range.match(/^~(\d+)(\.0\.0)?$/);
-    if (tildeMatch) {
-        return `${range} || ~${targetVersion}${tildeMatch[2] || ''}`;
+    // Two-sided comparator range: raise the lower bound, keep the upper bound only if it still admits the target.
+    if (/</.test(trimmed)) {
+        const upperMatch = trimmed.match(/(<=?)\s*(\d+)(?:\.\d+)*/);
+        let upper = '';
+        if (upperMatch) {
+            const op = upperMatch[1];
+            const upperMajor = parseInt(upperMatch[2], 10);
+            const admitsTarget = op === '<=' ? upperMajor >= targetVersion : upperMajor > targetVersion;
+            upper = admitsTarget ? ` ${op}${upperMatch[2]}` : '';
+        }
+        return `>=${targetVersion}${upper}`;
     }
 
-    // Single x-range: "18.x"
-    if (/^\d+\.x$/.test(range)) {
-        return `${range} || ${targetVersion}.x`;
-    }
+    return floorTerm(trimmed, targetVersion);
+}
 
-    return range;
+function floorTerm(part: string, targetVersion: number): string {
+    return part.replace(/\d+/, String(targetVersion));
 }