@openrewrite/rewrite 8.69.0-20251210-214835 → 8.69.0-20251211-110844

package/src/cli/rewrite.ts

@@ -21,6 +21,7 @@ import * as path from 'path';
 import {spawn} from 'child_process';
 import {Recipe, RecipeRegistry} from '../recipe';
 import {ExecutionContext} from '../execution';
+import {CsvDataTableStore, DATA_TABLE_STORE} from '../data-table';
 import {ProgressCallback, scheduleRunStreaming} from '../run';
 import {TreePrinters} from '../print';
 import {activate} from '../index';
@@ -145,6 +146,8 @@ interface CliOptions {
     option: string[];
     verbose: boolean;
     debug: boolean;
+    dataTables?: string;
+    dataTablesOnly: boolean;
 }
 
 /**
@@ -184,6 +187,8 @@ async function main() {
         .option('-o, --option <option...>', 'Recipe options in format "key=value"', [])
         .option('-v, --verbose', 'Enable verbose output', false)
         .option('--debug', 'Start with Node.js debugger (--inspect-brk)', false)
+        .option('--data-tables <dir>', 'Export data tables as CSV files to this directory')
+        .option('--data-tables-only', 'Only output data tables, skip source file diffs', false)
         .parse();
 
     const recipeArg = program.args[0];
@@ -377,8 +382,18 @@ async function main() {
     // Run the recipe with streaming output - for non-scanning recipes,
     // parsing and processing happen concurrently without collecting all files first
     const ctx = new ExecutionContext();
+
+    // Set up data table store if requested
+    let csvDataTableStore: CsvDataTableStore | undefined;
+    if (opts.dataTables) {
+        csvDataTableStore = new CsvDataTableStore(opts.dataTables);
+        csvDataTableStore.acceptRows(true);
+        ctx.messages[DATA_TABLE_STORE] = csvDataTableStore;
+    }
+
     let changeCount = 0;
     let processedCount = 0;
+    const skipSourceOutput = opts.dataTablesOnly;
 
     // Progress callback for spinner updates during all phases (disabled in verbose mode)
     const onProgress: ProgressCallback | undefined = opts.verbose ? undefined : (phase, current, total, sourcePath) => {
@@ -414,23 +429,27 @@ async function main() {
                 await fsp.writeFile(filePath, content);
 
                 changeCount++;
-                if (!opts.verbose) spinner.stop();
-                const displayPath = toCwdRelative(result.after.sourcePath, projectRoot);
-                if (result.before) {
-                    console.log(`  Modified: ${displayPath}`);
-                } else {
-                    console.log(`  Created: ${displayPath}`);
+                if (!skipSourceOutput) {
+                    if (!opts.verbose) spinner.stop();
+                    const displayPath = toCwdRelative(result.after.sourcePath, projectRoot);
+                    if (result.before) {
+                        console.log(`  Modified: ${displayPath}`);
+                    } else {
+                        console.log(`  Created: ${displayPath}`);
+                    }
+                    if (!opts.verbose) spinner.start(statusMsg);
                 }
-                if (!opts.verbose) spinner.start(statusMsg);
             } else if (result.before) {
                 const filePath = path.join(projectRoot, result.before.sourcePath);
                 await fsp.unlink(filePath);
                 changeCount++;
-                if (!opts.verbose) spinner.stop();
-                console.log(`  Deleted: ${toCwdRelative(result.before.sourcePath, projectRoot)}`);
-                if (!opts.verbose) spinner.start(statusMsg);
+                if (!skipSourceOutput) {
+                    if (!opts.verbose) spinner.stop();
+                    console.log(`  Deleted: ${toCwdRelative(result.before.sourcePath, projectRoot)}`);
+                    if (!opts.verbose) spinner.start(statusMsg);
+                }
             }
-        } else {
+        } else if (!skipSourceOutput) {
             // Dry-run mode: show diff or just list paths
             const diff = await result.diff();
             const hasChanges = diff.split('\n').some(line =>
@@ -466,12 +485,29 @@ async function main() {
         process.exit(recipe.hasErrors ? 1 : 0);
     }
 
-    if (changeCount === 0) {
-        console.log('No changes to make.');
-    } else if (opts.apply) {
-        console.log(`\n${changeCount} file(s) changed.`);
-    } else if (!opts.list) {
-        console.log(`\n${changeCount} file(s) would be changed. Run with --apply to apply changes.`);
+    // Report on data tables if any were written
+    if (csvDataTableStore) {
+        const tableNames = csvDataTableStore.tableNames;
+        const rowCounts = csvDataTableStore.rowCounts;
+        if (tableNames.length > 0) {
+            console.log(`\nData tables written to ${opts.dataTables}:`);
+            for (const name of tableNames) {
+                console.log(`  ${name}.csv (${rowCounts[name]} rows)`);
+            }
+        } else if (opts.dataTablesOnly) {
+            console.log('No data tables produced.');
+        }
+    }
+
+    // Report on source file changes (unless --data-tables-only)
+    if (!skipSourceOutput) {
+        if (changeCount === 0) {
+            console.log('No changes to make.');
+        } else if (opts.apply) {
+            console.log(`\n${changeCount} file(s) changed.`);
+        } else if (!opts.list) {
+            console.log(`\n${changeCount} file(s) would be changed. Run with --apply to apply changes.`);
+        }
     }
 }
 

package/src/data-table.ts

@@ -13,11 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as fs from 'fs';
+import * as path from 'path';
 import {ExecutionContext} from "./execution";
 import {OptionDescriptor} from "./recipe";
 
-const DATA_TABLE_STORE = Symbol("org.openrewrite.dataTables.store");
-const COLUMNS_KEY = Symbol("org.openrewrite.dataTables.columns");
+export const DATA_TABLE_STORE = Symbol.for("org.openrewrite.dataTables.store");
+const COLUMNS_KEY = Symbol.for("org.openrewrite.dataTables.columns");
 
 export function Column(descriptor: ColumnDescriptor) {
     return function (target: any, propertyKey: string) {
@@ -103,3 +105,82 @@ export interface ColumnDescriptor {
     displayName: string,
     description: string
 }
+
+/**
+ * Escape a value for CSV output following RFC 4180.
+ * Quotes the value if it contains commas, quotes, or newlines.
+ */
+function escapeCsv(value: unknown): string {
+    if (value === null || value === undefined) {
+        return '""';
+    }
+    const str = String(value);
+    // If the value contains comma, quote, or newline, wrap in quotes and escape internal quotes
+    if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+
+/**
+ * A DataTableStore that writes rows directly to CSV files as they are inserted.
+ */
+export class CsvDataTableStore implements DataTableStore {
+    private _acceptRows = false;
+    private readonly _initializedTables = new Set<string>();
+    private readonly _rowCounts: { [dataTable: string]: number } = {};
+
+    constructor(private readonly outputDir: string) {
+        // Ensure output directory exists
+        fs.mkdirSync(outputDir, {recursive: true});
+    }
+
+    insertRow<Row>(dataTable: DataTable<Row>, _ctx: ExecutionContext, row: Row): void {
+        if (!this._acceptRows) {
+            return;
+        }
+
+        const descriptor = dataTable.descriptor;
+        const tableName = descriptor.name;
+        const csvPath = path.join(this.outputDir, tableName + '.csv');
+
+        // Write header rows on first insert for this table
+        if (!this._initializedTables.has(tableName)) {
+            this._initializedTables.add(tableName);
+            this._rowCounts[tableName] = 0;
+
+            const columns = descriptor.columns;
+            const headerRow = columns.map(col => escapeCsv(col.displayName)).join(',');
+            const descriptionRow = columns.map(col => escapeCsv(col.description)).join(',');
+
+            fs.writeFileSync(csvPath, headerRow + '\n' + descriptionRow + '\n');
+        }
+
+        // Write the data row
+        const columns = descriptor.columns;
+        const rowValues = columns.map(col => {
+            const value = (row as any)[col.name];
+            return escapeCsv(value);
+        });
+        fs.appendFileSync(csvPath, rowValues.join(',') + '\n');
+        this._rowCounts[tableName]++;
+    }
+
+    acceptRows(accept: boolean): void {
+        this._acceptRows = accept;
+    }
+
+    /**
+     * Get the number of rows written for each data table.
+     */
+    get rowCounts(): { [dataTable: string]: number } {
+        return {...this._rowCounts};
+    }
+
+    /**
+     * Get the names of all data tables that have been written to.
+     */
+    get tableNames(): string[] {
+        return [...this._initializedTables];
+    }
+}

package/src/index.ts

@@ -38,9 +38,10 @@ export async function activate(registry: RecipeRegistry): Promise<void> {
     const {ModernizeOctalEscapeSequences, ModernizeOctalLiterals, RemoveDuplicateObjectKeys} = await import("./javascript/migrate/es6/index.js");
     const {ExportAssignmentToExportDefault} = await import("./javascript/migrate/typescript/index.js");
     const {UseObjectPropertyShorthand, PreferOptionalChain, AddParseIntRadix} = await import("./javascript/cleanup/index.js");
-    const {AsyncCallbackInSyncArrayMethod, AutoFormat, UpgradeDependencyVersion, UpgradeTransitiveDependencyVersion, OrderImports, ChangeImport} = await import("./javascript/recipes/index.js");
+    const {AddDependency, AsyncCallbackInSyncArrayMethod, AutoFormat, UpgradeDependencyVersion, UpgradeTransitiveDependencyVersion, OrderImports, ChangeImport} = await import("./javascript/recipes/index.js");
     const {FindDependency} = await import("./javascript/search/index.js");
 
+    registry.register(AddDependency);
     registry.register(ExportAssignmentToExportDefault);
     registry.register(FindDependency);
     registry.register(OrderImports);

package/src/javascript/node-resolution-result.ts

@@ -89,6 +89,22 @@ export const enum NpmrcScope {
     Project = 'Project',     // .npmrc in project root
 }
 
+/**
+ * Represents a dependency scope in package.json that uses object structure {name: version}.
+ * Note: `bundledDependencies` is excluded because it's a string[] of package names, not a version map.
+ */
+export type DependencyScope = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
+
+/**
+ * All dependency scopes in package.json that use object structure {name: version}.
+ */
+export const allDependencyScopes: readonly DependencyScope[] = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+] as const;
+
 export const NpmrcKind = "org.openrewrite.javascript.marker.NodeResolutionResult$Npmrc" as const;
 
 /**

package/src/javascript/package-manager.ts

@@ -14,7 +14,16 @@
  * limitations under the License.
  */
 
-import {PackageManager} from "./node-resolution-result";
+import {
+    createNodeResolutionResultMarker,
+    findNodeResolutionResult,
+    PackageJsonContent,
+    PackageLockContent,
+    PackageManager,
+    readNpmrcConfigs
+} from "./node-resolution-result";
+import {replaceMarkerByKind} from "../markers";
+import {Json} from "../json";
 import * as fs from "fs";
 import * as fsp from "fs/promises";
 import * as path from "path";
@@ -108,7 +117,7 @@ const LOCK_FILE_DETECTION: ReadonlyArray<LockFileDetectionConfig> = [
 /**
  * Result of running a package manager command.
  */
-export interface PackageManagerResult {
+interface PackageManagerResult {
     success: boolean;
     stdout?: string;
     stderr?: string;
@@ -118,7 +127,7 @@ export interface PackageManagerResult {
 /**
  * Options for running package manager install.
  */
-export interface InstallOptions {
+interface InstallOptions {
     /** Working directory */
     cwd: string;
 
@@ -164,13 +173,6 @@ export function getLockFileDetectionConfig(): ReadonlyArray<LockFileDetectionCon
     return LOCK_FILE_DETECTION;
 }
 
-/**
- * Gets the configuration for a package manager.
- */
-export function getPackageManagerConfig(pm: PackageManager): PackageManagerConfig {
-    return PACKAGE_MANAGER_CONFIGS[pm];
-}
-
 /**
  * Gets the lock file name for a package manager.
  */
@@ -185,22 +187,10 @@ export function getAllLockFileNames(): string[] {
     return LOCK_FILE_DETECTION.map(c => c.filename);
 }
 
-/**
- * Checks if a file path is a lock file.
- */
-export function isLockFile(filePath: string): boolean {
-    const fileName = path.basename(filePath);
-    return getAllLockFileNames().includes(fileName);
-}
-
 /**
  * Runs the package manager install command.
- *
- * @param pm The package manager to use
- * @param options Install options
- * @returns Result of the install command
  */
-export function runInstall(pm: PackageManager, options: InstallOptions): PackageManagerResult {
+function runInstall(pm: PackageManager, options: InstallOptions): PackageManagerResult {
     const config = PACKAGE_MANAGER_CONFIGS[pm];
     const command = options.lockOnly ? config.installLockOnlyCommand : config.installCommand;
     const [cmd, ...args] = command;
@@ -244,121 +234,6 @@ export function runInstall(pm: PackageManager, options: InstallOptions): Package
     }
 }
 
-/**
- * Options for adding/upgrading a package.
- */
-export interface AddPackageOptions {
-    /** Working directory */
-    cwd: string;
-
-    /** Package name to add/upgrade */
-    packageName: string;
-
-    /** Version constraint (e.g., "^5.0.0") */
-    version: string;
-
-    /** If true, only update lock file without installing to node_modules */
-    lockOnly?: boolean;
-
-    /** Timeout in milliseconds (default: 120000 = 2 minutes) */
-    timeout?: number;
-
-    /** Additional environment variables */
-    env?: Record<string, string>;
-}
-
-/**
- * Runs a package manager command to add or upgrade a package.
- * This updates both package.json and the lock file.
- *
- * @param pm The package manager to use
- * @param options Add package options
- * @returns Result of the command
- */
-export function runAddPackage(pm: PackageManager, options: AddPackageOptions): PackageManagerResult {
-    const packageSpec = `${options.packageName}@${options.version}`;
-
-    // Build command based on package manager
-    let cmd: string;
-    let args: string[];
-
-    switch (pm) {
-        case PackageManager.Npm:
-            cmd = 'npm';
-            args = ['install', packageSpec];
-            if (options.lockOnly) {
-                args.push('--package-lock-only');
-            }
-            break;
-        case PackageManager.YarnClassic:
-            cmd = 'yarn';
-            args = ['add', packageSpec];
-            if (options.lockOnly) {
-                args.push('--ignore-scripts');
-            }
-            break;
-        case PackageManager.YarnBerry:
-            cmd = 'yarn';
-            args = ['add', packageSpec];
-            if (options.lockOnly) {
-                args.push('--mode', 'skip-build');
-            }
-            break;
-        case PackageManager.Pnpm:
-            cmd = 'pnpm';
-            args = ['add', packageSpec];
-            if (options.lockOnly) {
-                args.push('--lockfile-only');
-            }
-            break;
-        case PackageManager.Bun:
-            cmd = 'bun';
-            args = ['add', packageSpec];
-            if (options.lockOnly) {
-                args.push('--ignore-scripts');
-            }
-            break;
-    }
-
-    try {
-        const result = spawnSync(cmd, args, {
-            cwd: options.cwd,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            timeout: options.timeout ?? 120000,
-            env: options.env ? {...process.env, ...options.env} : process.env,
-        });
-
-        if (result.error) {
-            return {
-                success: false,
-                error: result.error.message,
-                stderr: result.stderr,
-            };
-        }
-
-        if (result.status !== 0) {
-            return {
-                success: false,
-                stdout: result.stdout,
-                stderr: result.stderr,
-                error: `Command exited with code ${result.status}`,
-            };
-        }
-
-        return {
-            success: true,
-            stdout: result.stdout,
-            stderr: result.stderr,
-        };
-    } catch (error: any) {
-        return {
-            success: false,
-            error: error.message,
-        };
-    }
-}
-
 /**
  * Runs a package manager list command to get dependency information.
  *
@@ -390,55 +265,203 @@ export function runList(pm: PackageManager, cwd: string, timeout: number = 30000
 }
 
 /**
- * Checks if a package manager is available on the system.
+ * Result of running install in a temporary directory.
+ */
+export interface TempInstallResult {
+    /** Whether the install succeeded */
+    success: boolean;
+    /** The updated lock file content (if successful and lock file exists) */
+    lockFileContent?: string;
+    /** Error message (if failed) */
+    error?: string;
+}
+
+/**
+ * Generic accumulator for dependency recipes that run package manager operations.
+ * Used by scanning recipes to track state across scanning and editing phases.
  *
- * @param pm The package manager to check
- * @returns True if the package manager is available
+ * @typeParam T The recipe-specific project update info type
  */
-export function isPackageManagerAvailable(pm: PackageManager): boolean {
-    const config = PACKAGE_MANAGER_CONFIGS[pm];
-    const cmd = config.installCommand[0];
+export interface DependencyRecipeAccumulator<T> {
+    /** Projects that need updating: packageJsonPath -> update info */
+    projectsToUpdate: Map<string, T>;
 
-    try {
-        const result = spawnSync(cmd, ['--version'], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            timeout: 5000,
-        });
-        return result.status === 0;
-    } catch {
-        return false;
+    /** After running package manager, store the updated lock file content */
+    updatedLockFiles: Map<string, string>;
+
+    /** Updated package.json content (after npm install may have modified it) */
+    updatedPackageJsons: Map<string, string>;
+
+    /** Track which projects have been processed (npm install has run) */
+    processedProjects: Set<string>;
+
+    /** Track projects where npm install failed: packageJsonPath -> error message */
+    failedProjects: Map<string, string>;
+}
+
+/**
+ * Creates a new empty accumulator for dependency recipes.
+ */
+export function createDependencyRecipeAccumulator<T>(): DependencyRecipeAccumulator<T> {
+    return {
+        projectsToUpdate: new Map(),
+        updatedLockFiles: new Map(),
+        updatedPackageJsons: new Map(),
+        processedProjects: new Set(),
+        failedProjects: new Map()
+    };
+}
+
+/**
+ * Checks if a source path is a lock file and returns the updated content if available.
+ * This is a helper for dependency recipes that need to update lock files.
+ *
+ * @param sourcePath The source path to check
+ * @param acc The recipe accumulator containing updated lock file content
+ * @returns The updated lock file content if this is a lock file that was updated, undefined otherwise
+ */
+export function getUpdatedLockFileContent<T>(
+    sourcePath: string,
+    acc: DependencyRecipeAccumulator<T>
+): string | undefined {
+    for (const lockFileName of getAllLockFileNames()) {
+        if (sourcePath.endsWith(lockFileName)) {
+            // Find the corresponding package.json path
+            const packageJsonPath = sourcePath.replace(lockFileName, 'package.json');
+            const updateInfo = acc.projectsToUpdate.get(packageJsonPath);
+
+            if (updateInfo && acc.updatedLockFiles.has(sourcePath)) {
+                return acc.updatedLockFiles.get(sourcePath);
+            }
+            break;
+        }
     }
+    return undefined;
+}
+
+/**
+ * Base interface for project update info used by dependency recipes.
+ * Recipes extend this with additional fields specific to their needs.
+ */
+export interface BaseProjectUpdateInfo {
+    /** Absolute path to the project directory */
+    projectDir: string;
+    /** Relative path to package.json (from source root) */
+    packageJsonPath: string;
+    /** The package manager used by this project */
+    packageManager: PackageManager;
 }
 
 /**
- * Gets a human-readable name for a package manager.
+ * Stores the result of a package manager install into the accumulator.
+ * This handles the common pattern of storing updated lock files and tracking failures.
+ *
+ * @param result The result from runInstallInTempDir
+ * @param acc The recipe accumulator
+ * @param updateInfo The project update info (must have packageJsonPath and packageManager)
+ * @param modifiedPackageJson The modified package.json content that was used for install
  */
-export function getPackageManagerDisplayName(pm: PackageManager): string {
-    switch (pm) {
-        case PackageManager.Npm:
-            return 'npm';
-        case PackageManager.YarnClassic:
-            return 'Yarn Classic';
-        case PackageManager.YarnBerry:
-            return 'Yarn Berry';
-        case PackageManager.Pnpm:
-            return 'pnpm';
-        case PackageManager.Bun:
-            return 'Bun';
+export function storeInstallResult<T extends BaseProjectUpdateInfo>(
+    result: TempInstallResult,
+    acc: DependencyRecipeAccumulator<T>,
+    updateInfo: T,
+    modifiedPackageJson: string
+): void {
+    if (result.success) {
+        acc.updatedPackageJsons.set(updateInfo.packageJsonPath, modifiedPackageJson);
+
+        if (result.lockFileContent) {
+            const lockFileName = getLockFileName(updateInfo.packageManager);
+            const lockFilePath = updateInfo.packageJsonPath.replace('package.json', lockFileName);
+            acc.updatedLockFiles.set(lockFilePath, result.lockFileContent);
+        }
+    } else {
+        acc.failedProjects.set(updateInfo.packageJsonPath, result.error || 'Unknown error');
     }
 }
 
 /**
- * Result of running install in a temporary directory.
+ * Runs the package manager install for a project if it hasn't been processed yet.
+ * Updates the accumulator's processedProjects set after running.
+ *
+ * @param sourcePath The source path (package.json path) being processed
+ * @param acc The recipe accumulator
+ * @param runInstall Function that performs the actual install (recipe-specific)
+ * @returns The failure message if install failed, undefined otherwise
  */
-export interface TempInstallResult {
-    /** Whether the install succeeded */
-    success: boolean;
-    /** The updated lock file content (if successful and lock file exists) */
-    lockFileContent?: string;
-    /** Error message (if failed) */
-    error?: string;
+export async function runInstallIfNeeded<T>(
+    sourcePath: string,
+    acc: DependencyRecipeAccumulator<T>,
+    runInstall: () => Promise<void>
+): Promise<string | undefined> {
+    if (!acc.processedProjects.has(sourcePath)) {
+        await runInstall();
+        acc.processedProjects.add(sourcePath);
+    }
+    return acc.failedProjects.get(sourcePath);
+}
+
+/**
+ * Updates the NodeResolutionResult marker on a JSON document after a package manager operation.
+ * This recreates the marker based on the updated package.json and lock file content.
+ *
+ * @param doc The JSON document containing the marker
+ * @param updateInfo Project update info with paths and package manager
+ * @param acc The recipe accumulator containing updated content
+ * @returns The document with the updated marker, or unchanged if no existing marker
+ */
+export async function updateNodeResolutionMarker<T extends BaseProjectUpdateInfo>(
+    doc: Json.Document,
+    updateInfo: T & { originalPackageJson: string },
+    acc: DependencyRecipeAccumulator<T>
+): Promise<Json.Document> {
+    const existingMarker = findNodeResolutionResult(doc);
+    if (!existingMarker) {
+        return doc;
+    }
+
+    // Parse the updated package.json and lock file to create new marker
+    const updatedPackageJson = acc.updatedPackageJsons.get(updateInfo.packageJsonPath);
+    const lockFileName = getLockFileName(updateInfo.packageManager);
+    const updatedLockFile = acc.updatedLockFiles.get(
+        updateInfo.packageJsonPath.replace('package.json', lockFileName)
+    );
+
+    let packageJsonContent: PackageJsonContent;
+    let lockContent: PackageLockContent | undefined;
+
+    try {
+        packageJsonContent = JSON.parse(updatedPackageJson || updateInfo.originalPackageJson);
+    } catch {
+        return doc; // Failed to parse, keep original marker
+    }
+
+    if (updatedLockFile) {
+        try {
+            lockContent = JSON.parse(updatedLockFile);
+        } catch {
+            // Continue without lock file content
+        }
+    }
+
+    // Read npmrc configs from the project directory
+    const npmrcConfigs = await readNpmrcConfigs(updateInfo.projectDir);
+
+    // Create new marker
+    const newMarker = createNodeResolutionResultMarker(
+        existingMarker.path,
+        packageJsonContent,
+        lockContent,
+        existingMarker.workspacePackagePaths,
+        existingMarker.packageManager,
+        npmrcConfigs.length > 0 ? npmrcConfigs : undefined
+    );
+
+    // Replace the marker in the document
+    return {
+        ...doc,
+        markers: replaceMarkerByKind(doc.markers, newMarker)
+    };
 }
 
 /**