@openrewrite/rewrite 8.75.2 → 8.75.4

package/src/javascript/recipes/remove-dependency.ts

@@ -0,0 +1,345 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {Option, ScanningRecipe} from "../../recipe";
+import {ExecutionContext} from "../../execution";
+import {TreeVisitor} from "../../visitor";
+import {Tree} from "../../tree";
+import {getMemberKeyName, isJson, isObject, Json, JsonVisitor} from "../../json";
+import {isDocuments, isYaml, Yaml} from "../../yaml";
+import {isPlainText, PlainText} from "../../text";
+import {
+    allDependencyScopes,
+    DependencyScope,
+    findNodeResolutionResult,
+    PackageManager,
+    serializeNpmrcConfigs
+} from "../node-resolution-result";
+import {markupWarn} from "../../markers";
+import {TreePrinters} from "../../print";
+import {
+    createDependencyRecipeAccumulator,
+    createLockFileEditor,
+    DependencyRecipeAccumulator,
+    getAllLockFileNames,
+    getLockFileName,
+    parseLockFileContent,
+    runInstallIfNeeded,
+    runInstallInTempDir,
+    storeInstallResult,
+    updateNodeResolutionMarker
+} from "../package-manager";
+import * as path from "path";
+
+interface ProjectUpdateInfo {
+    packageJsonPath: string;
+    originalPackageJson: string;
+    dependencyScopes: DependencyScope[];
+    packageManager: PackageManager;
+    configFiles?: Record<string, string>;
+}
+
+interface Accumulator extends DependencyRecipeAccumulator<ProjectUpdateInfo> {
+    originalLockFiles: Map<string, string>;
+}
+
+export class RemoveDependency extends ScanningRecipe<Accumulator> {
+    readonly name = "org.openrewrite.javascript.dependencies.remove-dependency";
+    readonly displayName = "Remove npm dependency";
+    readonly description = "Removes a dependency from `package.json` and updates the lock file by running the package manager.";
+
+    @Option({
+        displayName: "Package name",
+        description: "The name of the npm package to remove (e.g., `lodash`, `@types/node`)",
+        example: "lodash"
+    })
+    packageName!: string;
+
+    @Option({
+        displayName: "Scope",
+        description: "The dependency scope to remove from. If not specified, the dependency is removed from all scopes where it is found.",
+        example: "dependencies",
+        required: false
+    })
+    scope?: DependencyScope;
+
+    initialValue(_ctx: ExecutionContext): Accumulator {
+        return {
+            ...createDependencyRecipeAccumulator<ProjectUpdateInfo>(),
+            originalLockFiles: new Map()
+        };
+    }
+
+    async scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        const recipe = this;
+        const LOCK_FILE_NAMES = getAllLockFileNames();
+
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            protected async accept(tree: Tree, ctx: ExecutionContext): Promise<Tree | undefined> {
+                if (isJson(tree) && tree.kind === Json.Kind.Document) {
+                    return this.handleJsonDocument(tree as Json.Document, ctx);
+                }
+                if (isYaml(tree) && isDocuments(tree)) {
+                    return this.handleYamlDocument(tree, ctx);
+                }
+                if (isPlainText(tree)) {
+                    return this.handlePlainTextDocument(tree as PlainText, ctx);
+                }
+                return tree;
+            }
+
+            private async handleJsonDocument(doc: Json.Document, _ctx: ExecutionContext): Promise<Json | undefined> {
+                const basename = path.basename(doc.sourcePath);
+
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(doc.sourcePath, await TreePrinters.print(doc));
+                    return doc;
+                }
+
+                if (!doc.sourcePath.endsWith('package.json')) {
+                    return doc;
+                }
+
+                const marker = findNodeResolutionResult(doc);
+                if (!marker) {
+                    return doc;
+                }
+
+                const scopesToCheck = recipe.scope ? [recipe.scope] : allDependencyScopes;
+                const foundScopes: DependencyScope[] = [];
+
+                for (const scope of scopesToCheck) {
+                    const deps = marker[scope];
+                    if (deps?.some(d => d.name === recipe.packageName)) {
+                        foundScopes.push(scope);
+                    }
+                }
+
+                if (foundScopes.length === 0) {
+                    return doc;
+                }
+
+                const pm = marker.packageManager ?? PackageManager.Npm;
+
+                const configFiles: Record<string, string> = {};
+                const npmrcContent = serializeNpmrcConfigs(marker.npmrcConfigs);
+                if (npmrcContent) {
+                    configFiles['.npmrc'] = npmrcContent;
+                }
+
+                acc.projectsToUpdate.set(doc.sourcePath, {
+                    packageJsonPath: doc.sourcePath,
+                    originalPackageJson: await TreePrinters.print(doc),
+                    dependencyScopes: foundScopes,
+                    packageManager: pm,
+                    configFiles: Object.keys(configFiles).length > 0 ? configFiles : undefined
+                });
+
+                return doc;
+            }
+
+            private async handleYamlDocument(docs: Yaml.Documents, _ctx: ExecutionContext): Promise<Yaml.Documents | undefined> {
+                const basename = path.basename(docs.sourcePath);
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(docs.sourcePath, await TreePrinters.print(docs));
+                }
+                return docs;
+            }
+
+            private async handlePlainTextDocument(text: PlainText, _ctx: ExecutionContext): Promise<PlainText | undefined> {
+                const basename = path.basename(text.sourcePath);
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(text.sourcePath, await TreePrinters.print(text));
+                }
+                return text;
+            }
+        };
+    }
+
+    async editorWithData(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        const recipe = this;
+
+        const jsonEditor = new class extends JsonVisitor<ExecutionContext> {
+            protected async visitDocument(doc: Json.Document, ctx: ExecutionContext): Promise<Json | undefined> {
+                const sourcePath = doc.sourcePath;
+
+                if (sourcePath.endsWith('package.json')) {
+                    const updateInfo = acc.projectsToUpdate.get(sourcePath);
+                    if (!updateInfo) {
+                        return doc;
+                    }
+
+                    const failureMessage = await runInstallIfNeeded(sourcePath, acc, () =>
+                        recipe.runPackageManagerInstall(acc, updateInfo, ctx)
+                    );
+                    if (failureMessage) {
+                        return markupWarn(
+                            doc,
+                            `Failed to remove ${recipe.packageName}`,
+                            failureMessage
+                        );
+                    }
+
+                    const modifiedDoc = removeDependencyFromJson(
+                        doc,
+                        recipe.packageName,
+                        updateInfo.dependencyScopes
+                    );
+
+                    return updateNodeResolutionMarker(modifiedDoc, updateInfo, acc);
+                }
+
+                const lockFileName = path.basename(sourcePath);
+                if (getAllLockFileNames().includes(lockFileName)) {
+                    const updatedLockContent = acc.updatedLockFiles.get(sourcePath);
+                    if (updatedLockContent) {
+                        const parsed = await parseLockFileContent(updatedLockContent, sourcePath, lockFileName) as Json.Document;
+                        return {
+                            ...doc,
+                            value: parsed.value,
+                            eof: parsed.eof
+                        } as Json.Document;
+                    }
+                }
+
+                return doc;
+            }
+        };
+
+        return createLockFileEditor(jsonEditor, acc);
+    }
+
+    private async runPackageManagerInstall(
+        acc: Accumulator,
+        updateInfo: ProjectUpdateInfo,
+        _ctx: ExecutionContext
+    ): Promise<void> {
+        const modifiedPackageJson = this.createModifiedPackageJson(
+            updateInfo.originalPackageJson,
+            updateInfo.dependencyScopes
+        );
+
+        const lockFileName = getLockFileName(updateInfo.packageManager);
+        const packageJsonDir = path.dirname(updateInfo.packageJsonPath);
+        const lockFilePath = packageJsonDir === '.'
+            ? lockFileName
+            : path.join(packageJsonDir, lockFileName);
+
+        const originalLockFileContent = acc.originalLockFiles.get(lockFilePath);
+
+        const result = await runInstallInTempDir(
+            updateInfo.packageManager,
+            modifiedPackageJson,
+            {
+                originalLockFileContent,
+                configFiles: updateInfo.configFiles
+            }
+        );
+
+        storeInstallResult(result, acc, updateInfo, modifiedPackageJson);
+    }
+
+    private createModifiedPackageJson(
+        originalContent: string,
+        scopes: DependencyScope[]
+    ): string {
+        const packageJson = JSON.parse(originalContent);
+
+        for (const scope of scopes) {
+            if (packageJson[scope] && packageJson[scope][this.packageName]) {
+                delete packageJson[scope][this.packageName];
+
+                if (Object.keys(packageJson[scope]).length === 0) {
+                    delete packageJson[scope];
+                }
+            }
+        }
+
+        return JSON.stringify(packageJson, null, 2);
+    }
+}
+
+function removeDependencyFromJson(
+    doc: Json.Document,
+    packageName: string,
+    scopes: DependencyScope[]
+): Json.Document {
+    if (!isObject(doc.value)) {
+        return doc;
+    }
+
+    const targetScopes = new Set<string>(scopes);
+    const rootObj = doc.value;
+    let changed = false;
+    const result: Json.RightPadded<Json>[] = [];
+
+    for (const rp of rootObj.members) {
+        const member = rp.element as Json.Member;
+        const keyName = getMemberKeyName(member);
+
+        if (!keyName || !targetScopes.has(keyName) || !isObject(member.value)) {
+            result.push(rp);
+            continue;
+        }
+
+        const scopeObj = member.value;
+        const filtered = scopeObj.members.filter(depRp =>
+            getMemberKeyName(depRp.element as Json.Member) !== packageName
+        );
+
+        if (filtered.length === scopeObj.members.length) {
+            result.push(rp);
+            continue;
+        }
+
+        changed = true;
+
+        if (filtered.length === 0) {
+            continue;
+        }
+
+        const lastOriginalAfter = scopeObj.members[scopeObj.members.length - 1].after;
+        filtered[filtered.length - 1] = {
+            ...filtered[filtered.length - 1],
+            after: lastOriginalAfter
+        };
+
+        result.push({
+            ...rp,
+            element: {
+                ...member,
+                value: {...scopeObj, members: filtered} as Json.Object
+            }
+        } as Json.RightPadded<Json>);
+    }
+
+    if (!changed) {
+        return doc;
+    }
+
+    if (result.length > 0 && result.length < rootObj.members.length) {
+        const originalLastAfter = rootObj.members[rootObj.members.length - 1].after;
+        result[result.length - 1] = {
+            ...result[result.length - 1],
+            after: originalLastAfter
+        };
+    }
+
+    return {
+        ...doc,
+        value: {...rootObj, members: result} as Json.Object
+    };
+}

package/src/javascript/remove-import.ts

@@ -1,7 +1,7 @@
 import {JavaScriptVisitor} from "./visitor";
 import {J} from "../java";
 import {JS, JSX} from "./tree";
-import {mapAsync} from "../util";
+import {mapAsync, updateIfChanged} from "../util";
 import {ElementRemovalFormatter} from "../java";
 
 /**
@@ -146,7 +146,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         return this.produceJavaScript(compilationUnit, p, async draft => {
             const formatter = new ElementRemovalFormatter<J>(true); // Preserve file headers from first import
 
-            draft.statements = await mapAsync(compilationUnit.statements, async (stmt) => {
+            const newStatements = await mapAsync(compilationUnit.statements, async (stmt) => {
                 const statement = stmt.element;
 
                 // Handle ES6 imports
@@ -159,7 +159,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                     }
 
                     const finalResult = formatter.processKept(result) as JS.Import;
-                    return {...stmt, element: finalResult};
+                    return updateIfChanged(stmt, {element: finalResult});
                 }
 
                 // Handle CommonJS require statements
@@ -174,7 +174,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                     }
 
                     const finalResult = formatter.processKept(result) as J.VariableDeclarations;
-                    return {...stmt, element: finalResult};
+                    return updateIfChanged(stmt, {element: finalResult});
                 }
 
                 // Handle JS.ScopedVariableDeclarations (multi-variable var/let/const)
@@ -194,7 +194,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                                 varFormatter.markRemoved(varDecl);
                             } else {
                                 const formattedVarDecl = varFormatter.processKept(result as J.VariableDeclarations);
-                                filteredVariables.push({...v, element: formattedVarDecl});
+                                filteredVariables.push(updateIfChanged(v, {element: formattedVarDecl}));
                             }
                         } else {
                             filteredVariables.push(v);
@@ -210,20 +210,21 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                         ? formatter.processKept({...scopedVarDecl, variables: filteredVariables})
                         : formatter.processKept(statement);
 
-                    return {...stmt, element: finalElement};
+                    return updateIfChanged(stmt, {element: finalElement});
                 }
 
                 // For any other statement type, apply prefix from removed elements
                 if (statement) {
                     const finalStatement = formatter.processKept(statement);
-                    return {...stmt, element: finalStatement};
+                    return updateIfChanged(stmt, {element: finalStatement});
                 }
 
                 return stmt;
             });
 
-            // Filter out undefined (removed) statements
-            draft.statements = draft.statements.filter(s => s !== undefined);
+            draft.statements = newStatements.some(s => s === undefined)
+                ? newStatements.filter(s => s !== undefined)
+                : newStatements;
             draft.eof = await this.visitSpace(compilationUnit.eof, p);
         });
     }

package/src/rpc/request/prepare-recipe.ts

@@ -58,6 +58,8 @@ export class PrepareRecipe {
 
                     preparedRecipes.set(id, recipe);
 
+                    await this.installSubRecipes(recipe, marketplace);
+
                     const result = {
                         id: id,
                         descriptor: await recipe.descriptor(),
@@ -73,6 +75,15 @@ export class PrepareRecipe {
         );
     }
 
+    private static async installSubRecipes(recipe: Recipe, marketplace: RecipeMarketplace) {
+        for (const subRecipe of await recipe.recipeList()) {
+            if (!marketplace.findRecipe(subRecipe.name)) {
+                await marketplace.install(subRecipe.constructor as any, []);
+                await this.installSubRecipes(subRecipe, marketplace);
+            }
+        }
+    }
+
     /**
      * For preconditions that can be evaluated on the remote peer, let the remote peer
      * evaluate them and know that we will only have to do the visit work if the
@@ -110,22 +121,22 @@ export class PrepareRecipe {
                         }
                 )
             }
-            this.visitorTypePrecondition(preconditions, visitor.v);
+            await this.visitorTypePrecondition(preconditions, visitor.v);
         } else {
-            this.visitorTypePrecondition(preconditions, visitor!);
+            await this.visitorTypePrecondition(preconditions, visitor!);
         }
         return recipe;
     }
 
-    private static visitorTypePrecondition(preconditions: Precondition[], v: TreeVisitor<any, ExecutionContext>): Precondition[] {
+    private static async visitorTypePrecondition(preconditions: Precondition[], v: TreeVisitor<any, ExecutionContext>): Promise<Precondition[]> {
         let treeType: string | undefined;
 
-        // Use CommonJS require to defer loading and avoid circular dependencies
-        const {JsonVisitor} = require("../../json");
-        const {JavaScriptVisitor} = require("../../javascript");
-        const {JavaVisitor} = require("../../java");
-        const {PlainTextVisitor} = require("../../text");
-        const {YamlVisitor} = require("../../yaml");
+        // Use dynamic import to defer loading and avoid circular dependencies
+        const {JsonVisitor} = await import("../../json/index.js");
+        const {JavaScriptVisitor} = await import("../../javascript/index.js");
+        const {JavaVisitor} = await import("../../java/index.js");
+        const {PlainTextVisitor} = await import("../../text/index.js");
+        const {YamlVisitor} = await import("../../yaml/index.js");
 
         if (v instanceof JsonVisitor) {
             treeType = "org.openrewrite.json.tree.Json";

package/src/test/rewrite-test.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {expect} from "vitest";
 import {Recipe} from "../recipe";
 import {ExecutionContext} from "../execution";
 import {noopVisitor, TreeVisitor} from "../visitor";
@@ -40,6 +41,7 @@ export interface SourceSpec<T extends SourceFile> {
 
 export class RecipeSpec {
     checkParsePrintIdempotence: boolean = true
+    allowEmptyDiff: boolean = false
 
     recipe: Recipe = new NoopRecipe()
 
@@ -162,9 +164,21 @@ export class RecipeSpec {
 
             if (!spec.after) {
                 if (after && after !== result?.before) {
-                    expect(await TreePrinters.print(after)).toEqual(dedent(spec.before!));
-                    // TODO: Consider throwing an error, as there should typically have been no change to the LST
-                    // fail("Expected after to be undefined.");
+                    const actual = await TreePrinters.print(after);
+                    const expected = dedent(spec.before!);
+                    if (actual === expected) {
+                        if (!this.allowEmptyDiff) {
+                            throw new Error(
+                                "An empty diff was generated. The recipe incorrectly " +
+                                "changed the AST without changing the printed output."
+                            );
+                        }
+                    } else {
+                        throw new Error(
+                            "Expected no change but recipe modified the file.\n" +
+                            `Expected:\n${expected}\n\nActual:\n${actual}`
+                        );
+                    }
                 }
                 if (spec.afterRecipe) {
                     await spec.afterRecipe(matchingSpec![1]);

package/src/visitor.ts

@@ -145,13 +145,18 @@ export abstract class TreeVisitor<T extends Tree, P> {
         const newMarkers = await this.visitMarkers(before.markers, p);
 
         if (recipe) {
-            // Remove markers before Mutative drafting to avoid cycles, then restore after
+            // Remove markers before Mutative drafting to avoid cycles, then restore after.
+            // The spread cost is paid unconditionally, but it enables the identity check below.
             const withoutMarkers = { ...before, markers: emptyMarkers };
             const result = await produceAsync(withoutMarkers, recipe);
             if (result === undefined) {
                 return undefined;
             }
-            // Restore markers (use newMarkers since we visited them)
+            // Mutative's produceAsync returns the same reference when no draft mutations occurred
+            // (structural sharing), so reference equality is a reliable no-change check.
+            if (result === withoutMarkers && newMarkers === before.markers) {
+                return before;
+            }
             return { ...result, markers: newMarkers } as T;
         }