@openrewrite/rewrite 8.83.3 → 8.83.5

package/src/rpc/java-rpc-client.ts

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2025 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 * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import {ChildProcessWithoutNullStreams, spawn} from "node:child_process";
+import * as rpc from "vscode-jsonrpc/node";
+import {RewriteRpc} from "./rewrite-rpc";
+import {RecipeMarketplace} from "../marketplace";
+
+export interface JavaRpcOptions {
+    /** Explicit classpath override. Falls back to env var, then test-classpath.txt. */
+    classpath?: string;
+    /** JAVA_HOME to use. Falls back to process.env.JAVA_HOME, then `java` on PATH. */
+    javaHome?: string;
+    /** Optional logger forwarded to the underlying RewriteRpc instance. */
+    logger?: rpc.Logger;
+    /** Optional path to a marketplace CSV — passed via `--marketplace=` to the Java process. */
+    marketplaceCsv?: string;
+    /** Enable RPC tracing on the Java side (passed as `--trace`). */
+    trace?: boolean;
+    /**
+     * Pre-built {@link RecipeMarketplace} for the TS-side {@link RewriteRpc} instance
+     * only. Does NOT configure the Java side — for that, use {@link marketplaceCsv}.
+     */
+    marketplace?: RecipeMarketplace;
+}
+
+/**
+ * Test-only wrapper around a spawned `org.openrewrite.maven.rpc.JavaRewriteRpc` process,
+ * exposing a {@link RewriteRpc} client wired to its stdio over JSON-RPC.
+ *
+ * Typical use:
+ * ```
+ * const server = await JavaRpcTestServer.start();
+ * try {
+ *     const recipe = await server.rpc.prepareRecipe("org.openrewrite.text.FindAndReplace", {...});
+ *     const result = await server.rpc.visit(parsed, recipe.editVisitor, ctx);
+ * } finally {
+ *     await server.dispose();
+ * }
+ * ```
+ */
+export class JavaRpcTestServer {
+    private constructor(
+        private readonly child: ChildProcessWithoutNullStreams,
+        readonly rpc: RewriteRpc,
+    ) {
+    }
+
+    /** Spawn the Java RPC server and connect a {@link RewriteRpc} client to its stdio. */
+    static async start(opts: JavaRpcOptions = {}): Promise<JavaRpcTestServer> {
+        const classpath = opts.classpath ?? findTestClasspath();
+        if (!classpath) {
+            throw new Error(
+                "Java RPC test classpath not configured. " +
+                "Run `./gradlew :rewrite-javascript:generateTestClasspath`, " +
+                "or set REWRITE_JAVASCRIPT_CLASSPATH."
+            );
+        }
+
+        const javaCmd = resolveJavaCommand(opts.javaHome);
+        const args = ["-cp", classpath, "org.openrewrite.maven.rpc.JavaRewriteRpc"];
+        if (opts.marketplaceCsv) args.push(`--marketplace=${opts.marketplaceCsv}`);
+        if (opts.trace) args.push("--trace");
+
+        const child = spawn(javaCmd, args);
+
+        // Forward Java stderr line-by-line so stack traces surface in the test output.
+        // `readline` handles partial-line buffering and flushes a non-newline-terminated
+        // final line on `close` (a hand-rolled split would silently drop it).
+        readline.createInterface({input: child.stderr, crlfDelay: Infinity})
+            .on("line", line => {
+                if (line.length > 0) process.stderr.write(`[Java RPC] ${line}\n`);
+            });
+
+        // If the JVM dies before we can talk to it, surface that immediately rather
+        // than letting the first RPC request hang waiting for a response. Capture the
+        // listener so we can detach it after the race resolves — otherwise the normal
+        // exit during dispose() fires it, rejecting a Promise nobody is observing
+        // (UnhandledPromiseRejection under Node 15+).
+        let onEarlyExit!: (code: number | null, signal: NodeJS.Signals | null) => void;
+        const earlyExit = new Promise<never>((_, reject) => {
+            onEarlyExit = (code, signal) => {
+                reject(new Error(
+                    `Java RPC server exited before any request was sent ` +
+                    `(code=${code}, signal=${signal}). Check the [Java RPC] stderr above.`
+                ));
+            };
+            child.once("exit", onEarlyExit);
+        });
+
+        const connection = rpc.createMessageConnection(
+            new rpc.StreamMessageReader(child.stdout),
+            new rpc.StreamMessageWriter(child.stdin),
+            opts.logger,
+        );
+
+        // RewriteRpc's constructor calls connection.listen() — no need to call it ourselves.
+        const rewriteRpc = new RewriteRpc(connection, {
+            marketplace: opts.marketplace,
+            logger: opts.logger,
+        });
+
+        // Hand back control once we know either (a) the JVM is up and the connection is
+        // listening, or (b) the JVM died early. A trivial round-trip (GetLanguages) does both.
+        try {
+            await Promise.race([
+                rewriteRpc.languages(),
+                earlyExit,
+            ]);
+        } catch (e) {
+            child.kill("SIGKILL");
+            throw e;
+        } finally {
+            child.removeListener("exit", onEarlyExit);
+        }
+
+        return new JavaRpcTestServer(child, rewriteRpc);
+    }
+
+    /**
+     * Reset accumulated state on both the Java side and the TS-side
+     * {@link RewriteRpc} caches so the next test starts clean.
+     */
+    async reset(): Promise<void> {
+        await this.rpc.reset();
+    }
+
+    /**
+     * End the JSON-RPC connection and wait for the Java process to exit. Falls back
+     * to SIGKILL after a short grace period to ensure no orphan JVMs are left behind.
+     */
+    async dispose(): Promise<void> {
+        // Attach the exit listener BEFORE signalling shutdown so we never miss the
+        // event in a TOCTOU race between checking exitCode and registering the
+        // listener. The Promise also resolves immediately if the process is
+        // already gone — see the exitCode shortcut below.
+        const exited = new Promise<void>((resolve) => {
+            this.child.once("exit", resolve);
+        });
+
+        if (this.child.exitCode !== null) {
+            return;
+        }
+
+        // End the connection before killing the process: this triggers an EOF on the
+        // Java side's stdin reader, which lets it shut down cleanly. Killing first
+        // can race with in-flight requests and leak the connection-close handler.
+        try {
+            this.rpc.end();
+        } catch { /* ignore — already closed */ }
+
+        const grace = setTimeout(() => {
+            this.child.kill("SIGKILL");
+        }, 5_000);
+        try {
+            await exited;
+        } finally {
+            clearTimeout(grace);
+        }
+    }
+}
+
+/**
+ * Find the classpath for spawning the Java RPC server.
+ *
+ * Resolution order:
+ *  1. `REWRITE_JAVASCRIPT_CLASSPATH` environment variable.
+ *  2. `test-classpath.txt` written by the `:rewrite-javascript:generateTestClasspath`
+ *     Gradle task. Walks up from this source file (works both when running directly
+ *     via vitest and when running from `dist/`).
+ *
+ * @returns the classpath string, or `undefined` if no source is configured.
+ */
+export function findTestClasspath(): string | undefined {
+    const env = process.env.REWRITE_JAVASCRIPT_CLASSPATH;
+    if (env && env.length > 0) {
+        return env;
+    }
+
+    // From src/rpc/ (vitest source mode) or dist/rpc/ (compiled), the classpath
+    // sits two levels up at the package root. The cwd fallback handles
+    // consumer projects where this module is in node_modules but the file
+    // lives next to the consumer's package root.
+    const candidates = [
+        path.resolve(__dirname, "..", "..", "test-classpath.txt"),
+        path.resolve(process.cwd(), "test-classpath.txt"),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return fs.readFileSync(candidate, "utf8").trim();
+        }
+    }
+    return undefined;
+}
+
+function resolveJavaCommand(javaHome?: string): string {
+    const home = javaHome ?? process.env.JAVA_HOME;
+    if (home) {
+        const candidate = path.join(home, "bin", process.platform === "win32" ? "java.exe" : "java");
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return "java";
+}

package/src/rpc/rewrite-rpc.ts

@@ -108,15 +108,27 @@ export class RewriteRpc {
             }
         )
 
+        // Clears local caches. Captured here so it can close over the
+        // constructor-local `preparedRecipes` while still being callable
+        // from the public `reset()` method on the class.
+        const clearLocalState = () => {
+            this.localObjects.clear();
+            this.localObjectIds.clear();
+            this.remoteObjects.clear();
+            this.remoteRefs.clear();
+            this.localRefs.clear();
+            preparedRecipes.clear();
+            this.remoteLanguages = undefined;
+        };
+        this.clearLocalState = clearLocalState;
+
         this.connection.onRequest(
             new rpc.RequestType0<boolean, Error>("Reset"),
             async () => {
-                this.localObjects.clear();
-                this.localObjectIds.clear();
-                this.remoteObjects.clear();
-                this.remoteRefs.clear();
-                this.localRefs.clear();
-                preparedRecipes.clear();
+                // Inbound Reset only clears local state — never sends a Reset
+                // back to the originator. Mirrors the Java handler in
+                // RewriteRpc.java around line 222.
+                clearLocalState();
                 return true;
             }
         )
@@ -125,6 +137,22 @@ export class RewriteRpc {
         this.connection.listen();
     }
 
+    private readonly clearLocalState!: () => void;
+
+    /**
+     * Reset both the remote and local RPC caches. Sends a `Reset` request to the
+     * remote — which clears the remote's state without sending one back — and
+     * then clears local caches. Use this between independent operations (e.g.
+     * between tests) so accumulated objects and prepared recipes don't leak
+     * across boundaries.
+     */
+    async reset(): Promise<void> {
+        await this.connection.sendRequest(
+            new rpc.RequestType0<boolean, Error>("Reset"),
+        );
+        this.clearLocalState();
+    }
+
     static set(value: RewriteRpc) {
         this._global = value;
     }

package/src/test/java-rpc.ts

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2025 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.
+ */
+/**
+ * Vitest fixture for tests that need to drive Java recipes via a spawned
+ * `org.openrewrite.maven.rpc.JavaRewriteRpc` process. Provides a worker-scoped
+ * JVM (one process per vitest worker) wrapped in a test-scoped fixture that
+ * resets accumulated state before each test.
+ *
+ * Typical use:
+ * ```
+ * import {testJavaRpc, describeJavaRpc} from "@openrewrite/rewrite/test/java-rpc";
+ *
+ * describeJavaRpc("AddDependency", () => {
+ *     testJavaRpc("adds a dep to package.json", async ({javaRpc}) => {
+ *         const spec = new RecipeSpec();
+ *         spec.recipe = await javaRpc.rpc.prepareRecipe(
+ *             "org.openrewrite.javascript.AddDependency", {name: "lodash", version: "^4.17.21"},
+ *         );
+ *         await spec.rewriteRun(packageJson(before, after));
+ *     });
+ * });
+ * ```
+ *
+ * The classpath is resolved via {@link findTestClasspath}; the suite is skipped
+ * (via {@link describeJavaRpc}) when no classpath has been configured.
+ */
+import {describe, type SuiteAPI, test as base} from "vitest";
+import {findTestClasspath, JavaRpcTestServer} from "../rpc/java-rpc-client";
+
+export {findTestClasspath, JavaRpcTestServer} from "../rpc/java-rpc-client";
+export type {JavaRpcOptions} from "../rpc/java-rpc-client";
+
+interface JavaRpcFixtures {
+    /**
+     * Internal worker-scoped fixture holding the spawned JVM. Test code should
+     * use {@link javaRpc} instead — it depends on this fixture but adds a
+     * per-test reset.
+     */
+    _javaRpcServer: JavaRpcTestServer;
+    /**
+     * The {@link JavaRpcTestServer} for this test. State on both the Java
+     * side and the TS-side {@link RewriteRpc} is reset before the test runs,
+     * so each test gets a clean slate even though the JVM persists across
+     * tests within the same vitest worker.
+     */
+    javaRpc: JavaRpcTestServer;
+}
+
+/**
+ * Vitest test API extended with a {@link JavaRpcTestServer} fixture. The JVM
+ * is spawned once per worker; state is reset before every test.
+ */
+export const testJavaRpc = base.extend<JavaRpcFixtures>({
+    _javaRpcServer: [
+        async ({}, use) => {
+            const server = await JavaRpcTestServer.start();
+            try {
+                await use(server);
+            } finally {
+                await server.dispose();
+            }
+        },
+        {scope: "worker"},
+    ],
+    javaRpc: async ({_javaRpcServer}, use) => {
+        await _javaRpcServer.reset();
+        await use(_javaRpcServer);
+    },
+});
+
+/**
+ * `describe` wrapper that skips the suite when the Java RPC test classpath has
+ * not been configured (env var or generated file). Use in place of `describe`
+ * for any suite that uses {@link testJavaRpc}.
+ *
+ * Run `./gradlew :rewrite-javascript:generateTestClasspath` to enable, or set
+ * the `REWRITE_JAVASCRIPT_CLASSPATH` environment variable.
+ */
+export const describeJavaRpc: SuiteAPI =
+    findTestClasspath() ? describe : (describe.skip as unknown as SuiteAPI);

package/dist/javascript/recipes/add-dependency.d.ts

@@ -1,61 +0,0 @@
-import { ScanningRecipe } from "../../recipe";
-import { ExecutionContext } from "../../execution";
-import { TreeVisitor } from "../../visitor";
-import { DependencyScope, PackageManager } from "../node-resolution-result";
-import { DependencyRecipeAccumulator } from "../package-manager";
-/**
- * Information about a project that needs updating
- */
-interface ProjectUpdateInfo {
-    /** Relative path to package.json (from source root) */
-    packageJsonPath: string;
-    /** Original package.json content */
-    originalPackageJson: string;
-    /** The scope where the dependency should be added */
-    dependencyScope: DependencyScope;
-    /** Version constraint to apply */
-    newVersion: string;
-    /** The package manager used by this project */
-    packageManager: PackageManager;
-    /** Config file contents extracted from the project (e.g., .npmrc) */
-    configFiles?: Record<string, string>;
-}
-interface Accumulator extends DependencyRecipeAccumulator<ProjectUpdateInfo> {
-    /** Original lock file content, keyed by lock file path */
-    originalLockFiles: Map<string, string>;
-}
-/**
- * Adds a new dependency to package.json and updates the lock file.
- *
- * This recipe:
- * 1. Finds package.json files that don't already have the specified dependency
- * 2. Adds the dependency to the specified scope (defaults to 'dependencies')
- * 3. Runs the package manager to update the lock file
- * 4. Updates the NodeResolutionResult marker with new dependency info
- *
- * If the dependency already exists in any scope, no changes are made.
- * This matches the behavior of org.openrewrite.maven.AddDependency.
- */
-export declare class AddDependency extends ScanningRecipe<Accumulator> {
-    readonly name = "org.openrewrite.javascript.dependencies.add-dependency";
-    readonly displayName = "Add npm dependency";
-    readonly description = "Adds a new dependency to `package.json` and updates the lock file by running the package manager.";
-    packageName: string;
-    version: string;
-    scope?: DependencyScope;
-    initialValue(_ctx: ExecutionContext): Accumulator;
-    private getTargetScope;
-    scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>>;
-    editorWithData(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>>;
-    /**
-     * Runs the package manager in a temporary directory to update the lock file.
-     * All file contents are provided from in-memory sources (SourceFiles), not read from disk.
-     */
-    private runPackageManagerInstall;
-    /**
-     * Creates a modified package.json with the new dependency added.
-     */
-    private createModifiedPackageJson;
-}
-export {};
-//# sourceMappingURL=add-dependency.d.ts.map

package/dist/javascript/recipes/add-dependency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add-dependency.d.ts","sourceRoot":"","sources":["../../../src/javascript/recipes/add-dependency.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAS,cAAc,EAAC,MAAM,cAAc,CAAC;AACpD,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAK1C,OAAO,EAEH,eAAe,EAEf,cAAc,EAEjB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAGH,2BAA2B,EAQ9B,MAAM,oBAAoB,CAAC;AAI5B;;GAEG;AACH,UAAU,iBAAiB;IACvB,uDAAuD;IACvD,eAAe,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qDAAqD;IACrD,eAAe,EAAE,eAAe,CAAC;IACjC,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,cAAc,EAAE,cAAc,CAAC;IAC/B,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,UAAU,WAAY,SAAQ,2BAA2B,CAAC,iBAAiB,CAAC;IACxE,0DAA0D;IAC1D,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,SAAQ,cAAc,CAAC,WAAW,CAAC;IAC1D,QAAQ,CAAC,IAAI,4DAA4D;IACzE,QAAQ,CAAC,WAAW,wBAAwB;IAC5C,QAAQ,CAAC,WAAW,uGAAuG;IAO3H,WAAW,EAAG,MAAM,CAAC;IAOrB,OAAO,EAAG,MAAM,CAAC;IAQjB,KAAK,CAAC,EAAE,eAAe,CAAC;IAExB,YAAY,CAAC,IAAI,EAAE,gBAAgB,GAAG,WAAW;IAOjD,OAAO,CAAC,cAAc;IAIhB,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;IA2FtE,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;IA8DnF;;;OAGG;YACW,wBAAwB;IAiCtC;;OAEG;IACH,OAAO,CAAC,yBAAyB;CAcpC"}