@openrewrite/rewrite 8.70.2 → 8.70.4

package/src/javascript/dependency-workspace.ts

@@ -49,6 +49,11 @@ interface PackageJsonWorkspaceOptions extends BaseWorkspaceOptions {
      * - `npm ci` is used instead of `npm install` (faster, deterministic)
      */
     packageLockContent?: string;
+    /**
+     * Optional workspace member package.json files.
+     * Keys are relative paths (e.g., "packages/foo/package.json"), values are content.
+     */
+    workspacePackages?: Record<string, string>;
 }
 
 /**
@@ -77,20 +82,44 @@ export class DependencyWorkspace {
         // Extract dependencies from package.json content if provided
         let dependencies: Record<string, string> | undefined = options.dependencies;
         let parsedPackageJson: Record<string, any> | undefined;
+        let workspacePackages: Record<string, string> | undefined;
+
         if (options.packageJsonContent) {
             parsedPackageJson = JSON.parse(options.packageJsonContent);
             dependencies = {
                 ...parsedPackageJson?.dependencies,
                 ...parsedPackageJson?.devDependencies
             };
+            workspacePackages = options.workspacePackages;
+
+            // For workspaces, also collect dependencies from workspace members
+            if (workspacePackages) {
+                for (const content of Object.values(workspacePackages)) {
+                    const memberPkg = JSON.parse(content);
+                    dependencies = {
+                        ...dependencies,
+                        ...memberPkg?.dependencies,
+                        ...memberPkg?.devDependencies
+                    };
+                }
+            }
         }
 
-        if (!dependencies || Object.keys(dependencies).length === 0) {
+        // For workspaces without explicit dependencies in root, we still need to run install
+        const hasWorkspaces = parsedPackageJson?.workspaces && Array.isArray(parsedPackageJson.workspaces);
+        if ((!dependencies || Object.keys(dependencies).length === 0) && !hasWorkspaces) {
             throw new Error('No dependencies provided');
         }
 
         // Use the refactored internal method
-        return this.createWorkspace(dependencies, parsedPackageJson, options.packageJsonContent, options.packageLockContent, options.targetDir);
+        return this.createWorkspace(
+            dependencies || {},
+            parsedPackageJson,
+            options.packageJsonContent,
+            options.packageLockContent,
+            options.targetDir,
+            workspacePackages
+        );
     }
 
     /**
@@ -101,14 +130,23 @@ export class DependencyWorkspace {
         parsedPackageJson: Record<string, any> | undefined,
         packageJsonContent: string | undefined,
         packageLockContent: string | undefined,
-        targetDir: string | undefined
+        targetDir: string | undefined,
+        workspacePackages?: Record<string, string>
     ): Promise<string> {
         // Determine hash based on lock file (most precise) or dependencies
         // Note: We always hash dependencies (not packageJsonContent) because whitespace/formatting
         // differences in package.json shouldn't create different workspaces
-        const hash = packageLockContent
-            ? this.hashContent(packageLockContent)
-            : this.hashDependencies(dependencies);
+        // For workspaces, include workspace package paths in the hash
+        let hash: string;
+        if (packageLockContent) {
+            hash = this.hashContent(packageLockContent);
+        } else if (workspacePackages) {
+            // Include workspace package paths in hash for workspace setups
+            const workspacePaths = Object.keys(workspacePackages).sort().join(',');
+            hash = this.hashContent(this.hashDependencies(dependencies) + ':' + workspacePaths);
+        } else {
+            hash = this.hashDependencies(dependencies);
+        }
 
         // Determine npm command: use `npm ci` when lock file is provided (faster, deterministic)
         const npmCommand = packageLockContent ? 'npm ci --silent' : 'npm install --silent';
@@ -134,11 +172,26 @@ export class DependencyWorkspace {
             if (packageLockContent) {
                 fs.writeFileSync(path.join(dir, 'package-lock.json'), packageLockContent);
             }
+
+            // Write workspace member package.json files
+            if (workspacePackages) {
+                for (const [relativePath, content] of Object.entries(workspacePackages)) {
+                    const fullPath = path.join(dir, relativePath);
+                    const memberDir = path.dirname(fullPath);
+                    if (!fs.existsSync(memberDir)) {
+                        fs.mkdirSync(memberDir, {recursive: true});
+                    }
+                    fs.writeFileSync(fullPath, content);
+                }
+            }
         };
 
+        // For workspaces, skip dependency validation (combined deps don't match root package.json)
+        const depsForValidation = workspacePackages ? undefined : dependencies;
+
         if (targetDir) {
             // Use provided directory - check if it's already valid
-            if (this.isWorkspaceValid(targetDir, dependencies)) {
+            if (this.isWorkspaceValid(targetDir, depsForValidation)) {
                 return targetDir;
             }
 
@@ -149,7 +202,7 @@ export class DependencyWorkspace {
             const cachedWorkspaceDir = path.join(this.WORKSPACE_BASE, hash);
             const cachedNodeModules = path.join(cachedWorkspaceDir, 'node_modules');
 
-            if (fs.existsSync(cachedNodeModules) && this.isWorkspaceValid(cachedWorkspaceDir, dependencies)) {
+            if (fs.existsSync(cachedNodeModules) && this.isWorkspaceValid(cachedWorkspaceDir, depsForValidation)) {
                 // Symlink node_modules from cached workspace
                 try {
                     const targetNodeModules = path.join(targetDir, 'node_modules');
@@ -190,7 +243,7 @@ export class DependencyWorkspace {
 
         // Check cache
         const cached = this.cache.get(hash);
-        if (cached && fs.existsSync(cached) && this.isWorkspaceValid(cached, dependencies)) {
+        if (cached && fs.existsSync(cached) && this.isWorkspaceValid(cached, depsForValidation)) {
             return cached;
         }
 
@@ -198,7 +251,7 @@ export class DependencyWorkspace {
         const workspaceDir = path.join(this.WORKSPACE_BASE, hash);
 
         // Check if valid workspace already exists on disk (cross-VM reuse)
-        if (fs.existsSync(workspaceDir) && this.isWorkspaceValid(workspaceDir, dependencies)) {
+        if (fs.existsSync(workspaceDir) && this.isWorkspaceValid(workspaceDir, depsForValidation)) {
             this.cache.set(hash, workspaceDir);
             return workspaceDir;
         }
@@ -241,7 +294,7 @@ export class DependencyWorkspace {
                     if (error.code === 'EEXIST' || error.code === 'ENOTEMPTY' || error.code === 'EISDIR' ||
                         (error.code === 'EPERM' && fs.existsSync(workspaceDir))) {
                         // Target exists - check if it's valid
-                        if (this.isWorkspaceValid(workspaceDir, dependencies)) {
+                        if (this.isWorkspaceValid(workspaceDir, depsForValidation)) {
                             // Another process created a valid workspace - use theirs
                             moved = true; // Don't try again
                         } else {
@@ -261,7 +314,7 @@ export class DependencyWorkspace {
                             moved = true;
                         } catch (copyError) {
                             // Check if another process created it while we were copying
-                            if (this.isWorkspaceValid(workspaceDir, dependencies)) {
+                            if (this.isWorkspaceValid(workspaceDir, depsForValidation)) {
                                 moved = true;
                             } else {
                                 throw error;
@@ -284,7 +337,7 @@ export class DependencyWorkspace {
             }
 
             // Verify final workspace is valid (might be from another process)
-            if (!this.isWorkspaceValid(workspaceDir, dependencies)) {
+            if (!this.isWorkspaceValid(workspaceDir, depsForValidation)) {
                 throw new Error('Failed to create valid workspace due to concurrent modifications');
             }
 

package/src/javascript/package-json-parser.ts

@@ -29,6 +29,8 @@ import * as fsp from "fs/promises";
 import * as path from "path";
 import * as YAML from "yaml";
 import {getLockFileDetectionConfig, runList} from "./package-manager";
+import picomatch from "picomatch";
+import {DEFAULT_DIR_EXCLUSIONS, walkDirs} from "../path-utils";
 
 /**
  * Bun.lock package entry metadata.
@@ -140,52 +142,42 @@ export class PackageJsonParser extends Parser {
     }
 
     async *parse(...inputs: ParserInput[]): AsyncGenerator<SourceFile> {
-        // Group inputs by directory to share NodeResolutionResult markers
-        const inputsByDir = new Map<string, ParserInput[]>();
+        // Cache markers by directory to share NodeResolutionResult markers
+        // but maintain input order for output
+        const markersByDir = new Map<string, NodeResolutionResult | null>();
 
+        // Process each input in order, caching markers per directory
         for (const input of inputs) {
             const filePath = parserInputFile(input);
             const dir = path.dirname(filePath);
 
-            if (!inputsByDir.has(dir)) {
-                inputsByDir.set(dir, []);
-            }
-            inputsByDir.get(dir)!.push(input);
-        }
-
-        // Process each directory's package.json files
-        for (const [dir, dirInputs] of inputsByDir) {
-            // Create a shared marker for this directory
-            let marker: NodeResolutionResult | null = null;
-
-            for (const input of dirInputs) {
-                // Parse as JSON first
-                const jsonGenerator = this.jsonParser.parse(input);
-                const jsonResult = await jsonGenerator.next();
-
-                if (jsonResult.done || !jsonResult.value) {
-                    continue;
-                }
+            // Parse as JSON first
+            const jsonGenerator = this.jsonParser.parse(input);
+            const jsonResult = await jsonGenerator.next();
 
-                const jsonDoc = jsonResult.value as Json.Document;
+            if (jsonResult.done || !jsonResult.value) {
+                continue;
+            }
 
-                // Create NodeResolutionResult marker if not already created for this directory
-                if (!marker) {
-                    marker = await this.createMarker(input, dir);
-                }
+            const jsonDoc = jsonResult.value as Json.Document;
 
-                // Attach the marker to the JSON document
-                if (marker) {
-                    yield {
-                        ...jsonDoc,
-                        markers: {
-                            ...jsonDoc.markers,
-                            markers: [...jsonDoc.markers.markers, marker]
-                        }
-                    };
-                } else {
-                    yield jsonDoc;
-                }
+            // Create NodeResolutionResult marker if not already created for this directory
+            if (!markersByDir.has(dir)) {
+                markersByDir.set(dir, await this.createMarker(input, dir));
+            }
+            const marker = markersByDir.get(dir)!;
+
+            // Attach the marker to the JSON document
+            if (marker) {
+                yield {
+                    ...jsonDoc,
+                    markers: {
+                        ...jsonDoc.markers,
+                        markers: [...jsonDoc.markers.markers, marker]
+                    }
+                };
+            } else {
+                yield jsonDoc;
             }
         }
     }
@@ -222,11 +214,24 @@ export class PackageJsonParser extends Parser {
             const projectDir = this.relativeTo || dir;
             const npmrcConfigs = await readNpmrcConfigs(projectDir);
 
+            // Detect workspace member paths if this is a workspace root
+            let workspacePackagePaths: string[] | undefined;
+            if (packageJson.workspaces) {
+                const absoluteDir = this.relativeTo && !path.isAbsolute(dir)
+                    ? path.resolve(this.relativeTo, dir)
+                    : dir;
+                workspacePackagePaths = await this.resolveWorkspacePackagePaths(
+                    packageJson.workspaces,
+                    absoluteDir,
+                    this.relativeTo
+                );
+            }
+
             return createNodeResolutionResultMarker(
                 relativePath,
                 packageJson,
                 lockContent,
-                undefined,
+                workspacePackagePaths,
                 packageManager,
                 npmrcConfigs.length > 0 ? npmrcConfigs : undefined
             );
@@ -236,6 +241,131 @@ export class PackageJsonParser extends Parser {
         }
     }
 
+    /**
+     * Resolves workspace glob patterns to actual package.json paths.
+     *
+     * Workspaces can be specified as:
+     * - Array of globs: ["packages/*", "apps/*", "packages/**", "{apps,libs}/*"]
+     * - Object with packages array: { packages: ["packages/*"] }
+     * - Negation patterns: ["packages/*", "!packages/internal"]
+     *
+     * @param workspaces The workspaces field from package.json
+     * @param projectDir The absolute path to the project directory
+     * @param relativeTo Optional base path for creating relative paths
+     * @returns Array of relative paths to workspace member package.json files
+     */
+    private async resolveWorkspacePackagePaths(
+        workspaces: string[] | { packages?: string[] },
+        projectDir: string,
+        relativeTo?: string
+    ): Promise<string[] | undefined> {
+        // Normalize workspaces to array format
+        const patterns = Array.isArray(workspaces)
+            ? workspaces
+            : workspaces.packages;
+
+        if (!patterns || patterns.length === 0) {
+            return undefined;
+        }
+
+        // Separate include and exclude patterns
+        const includePatterns = patterns.filter(p => !p.startsWith('!'));
+        const excludePatterns = patterns.filter(p => p.startsWith('!')).map(p => p.slice(1));
+
+        // Create picomatch matchers
+        const isIncluded = includePatterns.length > 0
+            ? picomatch(includePatterns, { dot: false })
+            : () => false;
+        const isExcluded = excludePatterns.length > 0
+            ? picomatch(excludePatterns, { dot: false })
+            : () => false;
+
+        // Collect all candidate directories by walking the project
+        const candidateDirs = await this.collectCandidateWorkspaceDirs(projectDir, includePatterns);
+
+        const memberPaths: string[] = [];
+        const basePath = relativeTo || projectDir;
+
+        for (const candidateDir of candidateDirs) {
+            // Get relative path from project root for pattern matching
+            const relativeDir = path.relative(projectDir, candidateDir);
+
+            // Check if directory matches include patterns and not exclude patterns
+            if (isIncluded(relativeDir) && !isExcluded(relativeDir)) {
+                const packageJsonPath = path.join(candidateDir, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    const relativePath = path.relative(basePath, packageJsonPath);
+                    memberPaths.push(relativePath);
+                }
+            }
+        }
+
+        return memberPaths.length > 0 ? memberPaths : undefined;
+    }
+
+    /**
+     * Collects candidate directories that might match workspace patterns.
+     * Uses the patterns to determine how deep to scan.
+     */
+    private async collectCandidateWorkspaceDirs(
+        projectDir: string,
+        patterns: string[]
+    ): Promise<string[]> {
+        const candidates: string[] = [];
+
+        // Determine the maximum depth we need to scan based on patterns
+        // "packages/*" -> depth 1 under packages/
+        // "packages/**" -> unlimited depth under packages/
+        // "{apps,libs}/*" -> depth 1 under apps/ and libs/
+
+        for (const pattern of patterns) {
+            // Extract base directories from pattern (before any wildcards)
+            const baseDirs = this.extractBaseDirs(pattern);
+            const hasRecursive = pattern.includes('**');
+
+            for (const baseDir of baseDirs) {
+                const absoluteBaseDir = path.join(projectDir, baseDir);
+
+                if (!fs.existsSync(absoluteBaseDir)) {
+                    continue;
+                }
+
+                // Use walkDirs with appropriate depth limit
+                const dirs = await walkDirs(absoluteBaseDir, {
+                    maxDepth: hasRecursive ? undefined : 0,
+                    excludeDirs: DEFAULT_DIR_EXCLUSIONS
+                });
+
+                candidates.push(...dirs);
+            }
+        }
+
+        return candidates;
+    }
+
+    /**
+     * Extracts base directory paths from a glob pattern.
+     * Handles brace expansion like "{apps,libs}/*" -> ["apps", "libs"]
+     */
+    private extractBaseDirs(pattern: string): string[] {
+        // Find the first wildcard character
+        const wildcardIndex = pattern.search(/[*?]/);
+        const beforeWildcard = wildcardIndex >= 0 ? pattern.slice(0, wildcardIndex) : pattern;
+
+        // Remove trailing slash if present
+        const basePath = beforeWildcard.replace(/\/$/, '');
+
+        // Handle brace expansion at the end of basePath: "dir/{a,b}" or "{a,b}"
+        const braceMatch = basePath.match(/^(.*?)(?:\{([^}]+)\})?$/);
+        if (braceMatch && braceMatch[2]) {
+            const prefix = braceMatch[1];
+            const options = braceMatch[2].split(',').map(s => s.trim());
+            return options.map(opt => prefix + opt);
+        }
+
+        return basePath ? [basePath] : ['.'];
+    }
+
     /**
      * Attempts to find and read a lock file by walking up the directory tree.
      * Starts from the directory containing the package.json and walks up toward
@@ -412,12 +542,21 @@ export class PackageJsonParser extends Parser {
             }
 
             // Parse name@version from directory name
+            // pnpm directory format: <name>@<version> or <name>@<version>_<peer-deps-context>
             // Handle scoped packages: @scope+name@version
-            const atIndex = entry.name.lastIndexOf('@');
+            // Example: @babel+helper-module-transforms@7.28.3_@babel+core@7.28.5
+            //   -> name: @babel/helper-module-transforms, version: 7.28.3
+
+            // First, strip peer dependency context (everything after first _)
+            const underscoreIndex = entry.name.indexOf('_');
+            const mainPart = underscoreIndex > 0 ? entry.name.substring(0, underscoreIndex) : entry.name;
+
+            // Now parse name@version from the main part
+            const atIndex = mainPart.lastIndexOf('@');
             if (atIndex <= 0) return;
 
-            let name = entry.name.substring(0, atIndex);
-            const version = entry.name.substring(atIndex + 1);
+            let name = mainPart.substring(0, atIndex);
+            const version = mainPart.substring(atIndex + 1);
 
             // pnpm encodes @ as + in scoped packages: @scope+name -> @scope/name
             if (name.startsWith('@') && name.includes('+')) {