@openrewrite/rewrite 8.63.2 → 8.63.4

package/src/javascript/type-mapping.ts

@@ -196,7 +196,7 @@ export class JavaScriptTypeMapping {
     private wrapperType(declaringType: (Type.FullyQualified & Type.Primitive) | Type.FullyQualified) {
         if (declaringType == Type.Primitive.String && this.stringWrapperType) {
             return this.getType(this.stringWrapperType) as Type.FullyQualified;
-        } else if ((declaringType == Type.Primitive.Double || declaringType == Type.Primitive.Long) && this.numberWrapperType) {
+        } else if ((declaringType == Type.Primitive.Double || declaringType == Type.Primitive.BigInt) && this.numberWrapperType) {
             return this.getType(this.numberWrapperType) as Type.FullyQualified;
         } else if (declaringType == Type.Primitive.Boolean && this.booleanWrapperType) {
             return this.getType(this.booleanWrapperType) as Type.FullyQualified;
@@ -808,7 +808,7 @@ export class JavaScriptTypeMapping {
             type.flags === ts.TypeFlags.BigIntLiteral ||
             type.flags === ts.TypeFlags.BigIntLike
         ) {
-            return Type.Primitive.Long;
+            return Type.Primitive.BigInt;
         } else if (
             (type.symbol !== undefined && type.symbol === this.regExpSymbol) ||
             this.checker.typeToString(type) === "RegExp"

package/src/rpc/queue.ts

@@ -150,7 +150,8 @@ export class RpcSendQueue {
         return saveTrace(this.trace, async () => {
             if (before === after) {
                 this.put({state: RpcObjectState.NO_CHANGE});
-            } else if (before === undefined) {
+            } else if (before === undefined || (after !== undefined && this.typesAreDifferent(after, before))) {
+                // Treat as ADD when before is undefined OR types differ (it's a new object, not a change)
                 await this.add(after, onChange);
             } else if (after === undefined) {
                 this.put({state: RpcObjectState.DELETE});
@@ -182,6 +183,9 @@ export class RpcSendQueue {
                     const aBefore = before ? before[beforePos] : undefined;
                     if (aBefore === anAfter) {
                         this.put({state: RpcObjectState.NO_CHANGE});
+                    } else if (anAfter !== undefined && this.typesAreDifferent(anAfter, aBefore)) {
+                        // Type changed - treat as ADD
+                        await this.add(anAfter, onChangeRun);
                     } else {
                         this.put({state: RpcObjectState.CHANGE});
                         await this.doChange(anAfter, aBefore, onChangeRun, RpcCodecs.forInstance(anAfter, this.sourceFileType));
@@ -248,6 +252,12 @@ export class RpcSendQueue {
         }
     }
 
+    private typesAreDifferent(after: any, before: any): boolean {
+        const afterKind = after !== undefined && after !== null && typeof after === "object" ? after["kind"] : undefined;
+        const beforeKind = before !== undefined && before !== null && typeof before === "object" ? before["kind"] : undefined;
+        return afterKind !== undefined && beforeKind !== undefined && afterKind !== beforeKind;
+    }
+
     private getValueType(after?: any): string | undefined {
         if (after !== undefined && after !== null && typeof after === "object" && "kind" in after) {
             return after["kind"];

package/src/rpc/request/install-recipes.ts

@@ -118,7 +118,11 @@ export class InstallRecipes {
 
                     let recipeModule;
                     try {
-                        setupSharedDependencies(resolvedPath);
+                        // Pre-load core modules that are used by recipes but loaded lazily
+                        // This ensures they're in require.cache before setupSharedDependencies runs
+                        preloadCoreModules(logger);
+
+                        setupSharedDependencies(resolvedPath, logger);
                         recipeModule = require(resolvedPath);
                     } catch (e: any) {
                         throw new Error(`Failed to load recipe module from ${resolvedPath}: ${e.stack}`);
@@ -142,38 +146,137 @@ export class InstallRecipes {
     }
 }
 
+/**
+ * Pre-loads core modules that are typically loaded lazily by recipes.
+ * This ensures they're in require.cache before setupSharedDependencies runs,
+ * so they can be properly mapped to avoid instanceof failures.
+ */
+function preloadCoreModules(logger?: rpc.Logger) {
+    const modulesToPreload = [
+        '../..',
+        '../../java',
+        '../../javascript',
+        '../../json',
+        '../../rpc',
+        '../../search',
+        '../../text',
+    ];
+
+    modulesToPreload.forEach(modulePath => {
+        try {
+            require(modulePath);
+            if (logger) {
+                logger.info(`[preloadCoreModules] Loaded ${modulePath}`);
+            }
+        } catch (e) {
+            if (logger) {
+                logger.warn(`[preloadCoreModules] Failed to load ${modulePath}: ${e}`);
+            }
+        }
+    });
+}
+
 /**
  * Ensures dynamically loaded modules share the same class instances as the host
  * by mapping require.cache entries. This prevents instanceof failures when the
  * same package is installed in multiple node_modules directories.
  */
-function setupSharedDependencies(targetModulePath: string) {
+function setupSharedDependencies(targetModulePath: string, logger?: rpc.Logger) {
     const sharedDeps = ['@openrewrite/rewrite', 'vscode-jsonrpc'];
     const targetDir = path.dirname(targetModulePath);
 
     sharedDeps.forEach(depName => {
-        const depPattern = path.sep + 'node_modules' + path.sep + depName.replace('/', path.sep);
-
-        for (const cachedPath of Object.keys(require.cache)) {
-            if (!cachedPath.includes(depPattern)) continue;
-
-            try {
-                // Extract subpath: /path/node_modules/@pkg/dist/tree.js -> dist/tree.js
-                const pkgIndex = cachedPath.indexOf(depPattern);
-                let subpath = cachedPath.substring(pkgIndex + depPattern.length)
-                    .replace(/^[/\\]/, '')           // Remove leading slash
-                    .replace(/\.(js|ts)$/, '')        // Remove extension
-                    .replace(/^dist[/\\]/, '')        // Remove dist/ prefix if present
-                    .replace(/[/\\]index$/, '');      // Remove /index suffix
-
-                // Build require path: @pkg or @pkg/subpath
-                const requirePath = subpath ? `${depName}/${subpath}` : depName;
-
-                // Resolve from target's perspective and map cache
-                const targetDepPath = require.resolve(requirePath, {paths: [targetDir]});
-                require.cache[targetDepPath] = require.cache[cachedPath];
-            } catch (e) {
-                // Target can't resolve this path, skip
+        try {
+            // Step 1: Find where this package is currently loaded from (host)
+            const hostPackageEntry = require.resolve(depName);
+
+            // Step 2: Find the package root by looking for package.json
+            let hostPackageRoot = path.dirname(hostPackageEntry);
+            while (hostPackageRoot !== path.dirname(hostPackageRoot)) {
+                const packageJsonPath = path.join(hostPackageRoot, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    try {
+                        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                        if (pkg.name === depName) {
+                            break; // Found the package root
+                        }
+                    } catch (e) {
+                        // Not a valid package.json, continue
+                    }
+                }
+                hostPackageRoot = path.dirname(hostPackageRoot);
+            }
+
+            if (logger) {
+                logger.info(`[setupSharedDependencies] Host package root for ${depName}: ${hostPackageRoot}`);
+            }
+
+            // Step 3: Find where the target's node_modules has this package
+            // We explicitly look in node_modules to avoid finding npm-linked global packages
+            let targetPackageRoot: string | undefined;
+
+            // Walk up from targetDir looking for node_modules containing this package
+            let searchDir = targetDir;
+            while (searchDir !== path.dirname(searchDir)) {
+                const nodeModulesPath = path.join(searchDir, 'node_modules', ...depName.split('/'));
+                if (fs.existsSync(nodeModulesPath)) {
+                    const packageJsonPath = path.join(nodeModulesPath, 'package.json');
+                    if (fs.existsSync(packageJsonPath)) {
+                        try {
+                            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                            if (pkg.name === depName) {
+                                targetPackageRoot = nodeModulesPath;
+                                break;
+                            }
+                        } catch (e) {
+                            // Not a valid package.json, continue
+                        }
+                    }
+                }
+                searchDir = path.dirname(searchDir);
+            }
+
+            if (!targetPackageRoot) {
+                if (logger) {
+                    logger.warn(`[setupSharedDependencies] Could not find ${depName} in target's node_modules`);
+                }
+                return; // Can't map this package
+            }
+
+            if (logger) {
+                logger.info(`[setupSharedDependencies] Target package root for ${depName}: ${targetPackageRoot}`);
+            }
+
+            // If they're the same, no mapping needed
+            if (hostPackageRoot === targetPackageRoot) {
+                if (logger) {
+                    logger.info(`[setupSharedDependencies] Same package root, no mapping needed for ${depName}`);
+                }
+                return;
+            }
+
+            // Step 4: Map all cached modules from host package to target package
+            const hostPrefix = hostPackageRoot + path.sep;
+
+            let mappedCount = 0;
+            for (const cachedPath of Object.keys(require.cache)) {
+                if (cachedPath.startsWith(hostPrefix)) {
+                    // This module belongs to the host package
+                    const relativePath = cachedPath.substring(hostPrefix.length);
+                    const targetPath = path.join(targetPackageRoot, relativePath);
+
+                    // Map the target path to use the host's cached module
+                    require.cache[targetPath] = require.cache[cachedPath];
+                    mappedCount++;
+                }
+            }
+
+            if (logger) {
+                logger.info(`[setupSharedDependencies] Mapped ${mappedCount} modules for ${depName}`);
+            }
+        } catch (e) {
+            if (logger) {
+                logger.error(`[setupSharedDependencies] Failed to setup ${depName}: ${e}`);
             }
         }
     });

package/src/rpc/server.ts

@@ -19,6 +19,7 @@ import {RewriteRpc} from "./rewrite-rpc";
 import * as fs from "fs";
 import {Command} from 'commander';
 import {dir} from 'tmp-promise';
+import {DependencyWorkspace} from "../javascript/dependency-workspace";
 
 // Include all languages you want this server to support.
 import "../text";
@@ -66,6 +67,8 @@ async function main() {
             if (recipeCleanup) {
                 await recipeCleanup();
             }
+            // Clean up old dependency workspaces (older than 24 hours)
+            DependencyWorkspace.cleanupOldWorkspaces();
             process.exit(0);
         });
 
@@ -73,6 +76,8 @@ async function main() {
             if (recipeCleanup) {
                 await recipeCleanup();
             }
+            // Clean up old dependency workspaces (older than 24 hours)
+            DependencyWorkspace.cleanupOldWorkspaces();
             process.exit(0);
         });
 

package/src/test/rewrite-test.ts

@@ -61,13 +61,21 @@ export class RecipeSpec {
         this.dataTableAssertions[name] = allRows;
     }
 
-    async rewriteRun(...sourceSpecs: (SourceSpec<any> | Generator<SourceSpec<any>, void, unknown>)[]): Promise<void> {
+    async rewriteRun(...sourceSpecs: (SourceSpec<any> | Generator<SourceSpec<any>, void, unknown> | AsyncGenerator<SourceSpec<any>, void, unknown>)[]): Promise<void> {
         // Flatten generators into a list of sourceSpecs
         const flattenedSpecs: SourceSpec<any>[] = [];
         for (const specOrGenerator of sourceSpecs) {
             if (specOrGenerator && typeof (specOrGenerator as any).next === 'function') {
-                for (const spec of specOrGenerator as Generator<SourceSpec<any>, void, unknown>) {
-                    flattenedSpecs.push(spec);
+                // Check if it's an async generator
+                if (typeof (specOrGenerator as any)[Symbol.asyncIterator] === 'function') {
+                    for await (const spec of specOrGenerator as AsyncGenerator<SourceSpec<any>, void, unknown>) {
+                        flattenedSpecs.push(spec);
+                    }
+                } else {
+                    // Sync generator
+                    for (const spec of specOrGenerator as Generator<SourceSpec<any>, void, unknown>) {
+                        flattenedSpecs.push(spec);
+                    }
                 }
             } else {
                 flattenedSpecs.push(specOrGenerator as SourceSpec<any>);