@openrewrite/recipes-nodejs 0.52.0-20261009-102010 → 0.52.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrewrite/recipes-nodejs",
-  "version": "0.52.0-20261009-102010",
+  "version": "0.52.1",
   "license": "Moderne Proprietary",
   "description": "OpenRewrite recipes for Node.js library migrations.",
   "homepage": "https://github.com/moderneinc/rewrite-node",
@@ -25,7 +25,7 @@
     "ci:test": "jest"
   },
   "dependencies": {
-    "@openrewrite/rewrite": "^8.93.0-20261009-041902",
+    "@openrewrite/rewrite": "^8.93.11",
     "mutative": "^1.1.0",
     "semver": "^7.7.3"
   },

package/src/index.ts

@@ -62,6 +62,7 @@ import {MigrateSourceMapSupportToNative} from "./migrate/source-map-support/migr
 import {FindSourceMapSupportManualMigrations} from "./migrate/source-map-support/find-source-map-support-manual-migrations";
 import {EnableSourceMapsAtLaunch} from "./migrate/source-map-support/enable-source-maps-at-launch";
 import {ReplaceSourceMapSupportInstall} from "./migrate/source-map-support/replace-source-map-support-install";
+import {ReplaceSourceMapSupportApi} from "./migrate/source-map-support/replace-source-map-support-api";
 import {ReplaceSourceMapSupportRegisterInPackageJson} from "./migrate/source-map-support/replace-source-map-support-register-in-package-json";
 import {ReplaceSourceMapSupportRegisterInMochaConfig} from "./migrate/source-map-support/replace-source-map-support-register-in-mocha-config";
 import {RemoveUnusedSourceMapSupportDependency} from "./migrate/source-map-support/remove-unused-source-map-support-dependency";
@@ -143,6 +144,7 @@ export async function activate(marketplace: RecipeMarketplace): Promise<void> {
     await marketplace.install(SwapHpagentDependency, Hpagent);
     await marketplace.install(MigrateSourceMapSupportToNative, SourceMapSupport);
     await marketplace.install(ReplaceSourceMapSupportInstall, SourceMapSupport);
+    await marketplace.install(ReplaceSourceMapSupportApi, SourceMapSupport);
     await marketplace.install(EnableSourceMapsAtLaunch, SourceMapSupport);
     await marketplace.install(ReplaceSourceMapSupportRegisterInPackageJson, SourceMapSupport);
     await marketplace.install(ReplaceSourceMapSupportRegisterInMochaConfig, SourceMapSupport);

package/src/migrate/code-style.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+/** The conventions generated code follows where a file has no formatter to lay it out, as with eslint's `standard`. */
+export interface CodeStyle {
+    semicolons: boolean;
+    quote: string;
+    braceSpacing: boolean;
+    functionParenSpace: boolean;
+    indent: string;
+    /** Whether a member on a line of its own ends with a comma even when it is the last. */
+    trailingCommas: boolean;
+    /** The line length the file keeps to, past which a list goes one member per line, as Prettier lays it out. */
+    printWidth: number;
+}
+
+export const DEFAULT_CODE_STYLE: CodeStyle = {
+    semicolons: true, quote: "'", braceSpacing: false, functionParenSpace: false, indent: '    ',
+    trailingCommas: false, printWidth: 80
+};
+
+/** `code`, written at four spaces a level, at the file's own indent. */
+export function indented(style: CodeStyle, code: string): string {
+    return code.replace(/^(?: {4})+/gm, levels => style.indent.repeat(levels.length / 4));
+}
+
+/** The step a nested line most often indents by: a tab, or the commonest increase in leading spaces. */
+function detectIndent(source: string): string {
+    const steps = new Map<string, number>();
+    let previous = 0;
+    for (const line of source.split('\n')) {
+        if (!line.trim()) continue;
+        const leading = /^[ \t]*/.exec(line)![0];
+        if (leading.startsWith('\t')) {
+            steps.set('\t', (steps.get('\t') ?? 0) + 1);
+        } else if (leading.length > previous && leading.length - previous <= 8) {
+            const step = ' '.repeat(leading.length - previous);
+            steps.set(step, (steps.get(step) ?? 0) + 1);
+        }
+        previous = leading.startsWith('\t') ? previous : leading.length;
+    }
+    return [...steps].sort((a, b) => b[1] - a[1])[0]?.[0] ?? DEFAULT_CODE_STYLE.indent;
+}
+
+/** The narrowest common print width almost every line keeps to, since a formatter still lets strings and comments run long. */
+function detectPrintWidth(lines: string[]): number {
+    const code = lines.filter(line => line.trim());
+    for (const width of [80, 100, 120]) {
+        if (code.filter(line => line.length > width).length <= Math.max(1, code.length / 50)) return width;
+    }
+    return Infinity;
+}
+
+/** The conventions `source` is written in, by majority; a tie keeps the default. */
+export function detectCodeStyle(source: string): CodeStyle {
+    const count = (pattern: RegExp) => (source.match(pattern) ?? []).length;
+    const fallback = (yes: number, no: number, otherwise: boolean) => yes === no ? otherwise : yes > no;
+    return {
+        semicolons: fallback(count(/;[ \t]*$/gm), count(/[\w$)\]'"`][ \t]*$/gm), DEFAULT_CODE_STYLE.semicolons),
+        quote: count(/(?:from|require\(|import\()\s*"/g) > count(/(?:from|require\(|import\()\s*'/g) ? '"' : "'",
+        // `${x}` in a template literal is not a brace of the kind this asks about.
+        braceSpacing: fallback(count(/(?<!\$)\{ [\w$.]/g), count(/(?<!\$)\{[\w$.]/g), DEFAULT_CODE_STYLE.braceSpacing),
+        functionParenSpace: fallback(count(/\bfunction\s+[\w$]+\s+\(/g), count(/\bfunction\s+[\w$]+\(/g), DEFAULT_CODE_STYLE.functionParenSpace),
+        indent: detectIndent(source),
+        // The last member of a multi-line object or array, with a comma after it or without. One ending in
+        // `}` or `)` is left out of the second count, which would otherwise take every block's closing brace.
+        trailingCommas: fallback(count(/[\w$'"\])}],[ \t]*\n[ \t]*[}\]]/g), count(/[\w$'"\]][ \t]*\n[ \t]*[}\]]/g),
+            DEFAULT_CODE_STYLE.trailingCommas),
+        printWidth: detectPrintWidth(source.split('\n')),
+    };
+}
+
+/**
+ * `code`, written in the default style, restyled to `style`. The code must be written so the edits are
+ * safe: outside comments, which take whole lines, `'` appears only as a string delimiter and `"` not at
+ * all; no line starts with `(`, `[` or a template literal; a statement-ending `;` is the last character of
+ * its line; and no regular expression has a `{n}` quantifier.
+ */
+export function restyle(code: string, style: CodeStyle): string {
+    return indented(style, code).split('\n').map(line => {
+        if (/^\s*(?:\/\/|\/\*|\*)/.test(line)) return line;
+        let result = line;
+        if (!style.semicolons) result = result.replace(/;$/, '');
+        if (style.quote !== "'") result = result.replace(/'/g, style.quote);
+        if (style.braceSpacing) result = result.replace(/(?<!\$)\{([^{}]*[^{}\s])\}/g, (_, inner: string) => `{ ${inner.trim()} }`);
+        if (style.functionParenSpace) result = result.replace(/\bfunction ([\w$]+)\(/g, 'function $1 (');
+        return result;
+    }).join('\n');
+}

package/src/migrate/fs-extra/replace-fs-extra-native-methods.ts

@@ -96,8 +96,8 @@ function destructuredMembers(pattern: J): [string, string][] | undefined {
 }
 
 /**
- * `maybeRebind` won't move a destructured `require`, so one whose every member needs the same node
- * module gets its specifier swapped instead.
+ * A destructured `require` whose every member needs the same node module gets its specifier swapped
+ * in place, keeping the member order that `maybeRebind` would otherwise shuffle.
  */
 function retargetRequires(cu: JS.CompilationUnit): JS.CompilationUnit {
     let changed = false;

package/src/migrate/hpagent/find-hpagent-manual-migrations.ts

@@ -6,34 +6,24 @@
 
 import {Cursor, ExecutionContext, foundSearchResult, Recipe, TreeVisitor} from "@openrewrite/rewrite";
 import {isIdentifier, J} from "@openrewrite/rewrite/java";
-import {compilationUnitOf, JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
+import {isReference, JavaScriptVisitor, JS} from "@openrewrite/rewrite/javascript";
 import {
-    bindingsOf,
-    classifyOption,
+    constructionArgument,
+    emptyHpagentBindings,
     HPAGENT_CLASSES,
     HPAGENT_MODULES,
-    HPAGENT_TYPES,
+    hpagentBindings,
+    HpagentBindings,
     hpagentManualMigrationSteps,
-    isKnownProxyRequestOptions,
-    isModuleScoped,
-    isObjectLiteral,
-    ModuleBindings,
-    objectMembers,
+    isMockCall,
+    isValueUse,
     REASONS,
+    resolvesToBinding,
     sourcePathOf,
-    spreadIsPlainAgentOptions,
+    spiedClass,
     stringLiteral,
 } from "./hpagent-support";
 
-const MOCK_OWNERS = new Set(['vi', 'jest']);
-const MOCK_METHODS = new Set(['mock', 'doMock', 'unmock', 'unstable_mockModule']);
-
-/** Trees that hold an identifier as a declaration or import rather than a use of it. */
-const DECLARING_KINDS = new Set<string>([
-    JS.Kind.Import, JS.Kind.ImportClause, JS.Kind.ImportSpecifier, JS.Kind.Alias, JS.Kind.NamedImports,
-    JS.Kind.ExportSpecifier, JS.Kind.BindingElement, JS.Kind.ObjectBindingPattern,
-]);
-
 function isHpagentSpecifier(e: J | undefined): boolean {
     return HPAGENT_MODULES.has(stringLiteral(e) ?? '');
 }
@@ -45,18 +35,13 @@ function isDynamicHpagentImport(e: J | undefined): boolean {
     return !!fn && isIdentifier(fn) && fn.simpleName === 'import' && isHpagentSpecifier(call.arguments.elements[0]?.element);
 }
 
-function isMockCall(m: J.MethodInvocation): boolean {
-    const select = m.select?.element;
-    return !!select && isIdentifier(select) && MOCK_OWNERS.has(select.simpleName) && MOCK_METHODS.has(m.name.simpleName);
-}
-
 export class FindHpagentManualMigrations extends Recipe {
     readonly name = "org.openrewrite.node.migrate.hpagent.find-hpagent-manual-migrations";
     readonly displayName = "Find hpagent usages that need manual migration";
-    readonly description = "Marks every hpagent usage the automated migration leaves in place — a construction whose " +
-        "options aren't an object literal or set a TLS option for the destination handshake, an agent class used as a " +
-        "value, hpagent's option types, re-exports, dynamic imports and test mocks — and records each with a suggested " +
-        "replacement in the `HpagentManualMigrationSteps` data table.";
+    readonly description = "Marks every hpagent usage the automated migration leaves in place — a construction " +
+        "that doesn't pass one options object, an agent class used as a value, re-exports, dynamic imports, a " +
+        "`require` in a shape it doesn't follow, and test mocks — " +
+        "and records each with a suggested replacement in the `HpagentManualMigrationSteps` data table.";
     readonly tags = ["hpagent", "https-proxy-agent"];
 
     private readonly steps = hpagentManualMigrationSteps();
@@ -66,7 +51,7 @@ export class FindHpagentManualMigrations extends Recipe {
         const steps = this.steps;
 
         return new class extends JavaScriptVisitor<ExecutionContext> {
-            private bindings: ModuleBindings = new Map();
+            private found: HpagentBindings = emptyHpagentBindings();
             /** Rows already written for this file, so a class constructed many times reports once per reason. */
             private reported = new Set<string>();
 
@@ -85,44 +70,14 @@ export class FindHpagentManualMigrations extends Recipe {
             }
 
             protected override async visitJsCompilationUnit(cu: JS.CompilationUnit, p: ExecutionContext): Promise<J | undefined> {
-                this.bindings = bindingsOf(cu, HPAGENT_MODULES);
+                this.found = hpagentBindings(cu);
                 this.reported = new Set();
                 return super.visitJsCompilationUnit(cu, p);
             }
 
-            /** Whether `name` binds one of hpagent's agent classes at module scope. */
-            private isAgentClass(name: string): boolean {
-                const member = this.bindings.get(name);
-                return member !== undefined && HPAGENT_CLASSES.has(member) && isModuleScoped(this.cursor, name);
-            }
-
             private isWholeModule(name: string): boolean {
-                return this.bindings.has(name) && this.bindings.get(name) === undefined && isModuleScoped(this.cursor, name);
-            }
-
-            protected override async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
-                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
-                const clause = imp.importClause;
-                if (!isHpagentSpecifier(imp.moduleSpecifier?.element) || !clause) return imp;
-                const named = clause.namedBindings;
-                const specifiers = named?.kind === JS.Kind.NamedImports
-                    ? (named as JS.NamedImports).elements.elements.map(e => e.element as JS.ImportSpecifier)
-                    : [];
-                if (clause.typeOnly || specifiers.some(spec => spec.kind === JS.Kind.ImportSpecifier && spec.importType?.element)) {
-                    return this.report(imp, 'import type', REASONS.type, p);
-                }
-                // hpagent's option interfaces, imported as values in a JavaScript file or erased in TypeScript.
-                if (specifiers.some(spec => HPAGENT_TYPES.has(this.specifierMember(spec) ?? ''))) {
-                    return this.report(imp, 'options type', REASONS.type, p);
-                }
-                return clause.name?.element ? this.report(imp, 'default import', REASONS.defaultImport, p) : imp;
-            }
-
-            private specifierMember(spec: JS.ImportSpecifier): string | undefined {
-                if (spec.kind !== JS.Kind.ImportSpecifier) return undefined;
-                const specifier = spec.specifier;
-                if (isIdentifier(specifier)) return specifier.simpleName;
-                return specifier.kind === JS.Kind.Alias ? (specifier as JS.Alias).propertyName.element.simpleName : undefined;
+                return this.found.bindings.has(name) && this.found.bindings.get(name) === undefined &&
+                    resolvesToBinding(this.cursor, name, this.found);
             }
 
             protected override async visitExportDeclaration(exportDeclaration: JS.ExportDeclaration, p: ExecutionContext): Promise<J | undefined> {
@@ -146,7 +101,7 @@ export class FindHpagentManualMigrations extends Recipe {
                 if (isMockCall(m) && (isHpagentSpecifier(firstArg) || isDynamicHpagentImport(firstArg))) {
                     return this.report(m, `${(m.select!.element as J.Identifier).simpleName}.${m.name.simpleName}`, REASONS.mock, p);
                 }
-                if (!m.select && m.name.simpleName === 'require' && isHpagentSpecifier(firstArg)) {
+                if (!m.select && m.name.simpleName === 'require' && isHpagentSpecifier(firstArg) && !this.found.requires.has(method.id)) {
                     const scope = this.cursor.firstEnclosing((t: any): t is J =>
                         t?.kind === JS.Kind.CompilationUnit || t?.kind === J.Kind.Block);
                     return scope?.kind === J.Kind.Block ? this.report(m, 'require', REASONS.nestedRequire, p) : m;
@@ -156,99 +111,47 @@ export class FindHpagentManualMigrations extends Recipe {
 
             override async visitNewClass(newClass: J.NewClass, p: ExecutionContext): Promise<J | undefined> {
                 const n = await super.visitNewClass(newClass, p) as J.NewClass;
-                if (n?.kind !== J.Kind.NewClass || !n.class) return n;
-                const name = this.constructedClass(n.class);
-                if (!name) return n;
-                const reason = this.blockingReason(n);
-                return reason ? this.report(n, reason.usage, reason.reason, p) : n;
+                if (n?.kind !== J.Kind.NewClass || !n.class || !this.constructsHpagent(n.class)) return n;
+                // Any one options object goes to the two-argument form or the adapter; nothing else has a shape for either.
+                return constructionArgument(n) ? n : this.report(n, 'agent options', REASONS.arguments, p);
             }
 
-            /** The hpagent class a `new` site constructs, through a class binding or the module's own. */
-            private constructedClass(clazz: J): string | undefined {
-                if (isIdentifier(clazz)) return this.isAgentClass(clazz.simpleName) ? clazz.simpleName : undefined;
-                if (clazz.kind !== J.Kind.FieldAccess) return undefined;
-                const access = clazz as J.FieldAccess;
-                const member = access.name.element.simpleName;
-                return isIdentifier(access.target) && this.isWholeModule(access.target.simpleName) && HPAGENT_CLASSES.has(member)
-                    ? member
-                    : undefined;
-            }
-
-            /** Why `ReplaceHpagent` would leave this construction alone, or undefined where it wouldn't. */
-            private blockingReason(n: J.NewClass): {usage: string; reason: string} | undefined {
-                const args = n.arguments.elements.map(a => a.element).filter(a => a.kind !== J.Kind.Empty);
-                if (args.length !== 1 || !isObjectLiteral(args[0])) {
-                    return {usage: 'agent options', reason: REASONS.notLiteral};
-                }
-                let hasProxy = false;
-                let hasSpread = false;
-                let blocking: {usage: string; reason: string} | undefined;
-                for (const statement of objectMembers(args[0])) {
-                    const option = classifyOption(statement);
-                    if (option.kind === 'proxy') hasProxy = true;
-                    // A spread that resolves to plain agent options is migrated, so it is not reported.
-                    if (option.kind === 'spread' && !spreadIsPlainAgentOptions(compilationUnitOf(this)!, option.value)) {
-                        hasSpread = true;
-                    }
-                    if (option.kind === 'proxyRequestOptions' &&
-                        (!isObjectLiteral(option.value) || !isKnownProxyRequestOptions(option.value))) {
-                        blocking ??= {usage: 'proxyRequestOptions', reason: REASONS.notLiteral};
-                    }
-                    if (option.kind === 'unmappable') blocking ??= {usage: option.option, reason: option.reason};
+            private constructsHpagent(clazz: J): boolean {
+                if (isIdentifier(clazz)) {
+                    const member = this.found.bindings.get(clazz.simpleName);
+                    return member !== undefined && HPAGENT_CLASSES.has(member) && resolvesToBinding(this.cursor, clazz.simpleName, this.found);
                 }
-                // A named option the migration can't place is the more actionable report than the spread around it.
-                if (blocking) return blocking;
-                if (hasSpread) return {usage: '...', reason: hasProxy ? REASONS.spread : REASONS.spreadNoProxy};
-                return hasProxy ? undefined : {usage: 'agent options', reason: REASONS.noProxy};
+                if (clazz.kind !== J.Kind.FieldAccess) return false;
+                const access = clazz as J.FieldAccess;
+                return isIdentifier(access.target) && this.isWholeModule(access.target.simpleName) &&
+                    HPAGENT_CLASSES.has(access.name.element.simpleName);
             }
 
-            /**
-             * `hpagent.HttpProxyAgent` reached through a binding of the whole module, where it is not being
-             * constructed: a type annotation, an `instanceof`, or the class passed along as a value. Each keeps
-             * the hpagent import alive, so each has to be moved by hand.
-             */
+            /** `hpagent.HttpProxyAgent` handed on as a value through a binding of the whole module. */
             override async visitFieldAccess(fieldAccess: J.FieldAccess, p: ExecutionContext): Promise<J | undefined> {
                 const fa = await super.visitFieldAccess(fieldAccess, p) as J.FieldAccess;
-                const target = fa.target;
-                if (!isIdentifier(target) || !this.isWholeModule(target.simpleName)) return fa;
+                if (!isIdentifier(fa.target) || !this.isWholeModule(fa.target.simpleName) || this.found.typeOnly.has(fa.target.simpleName)) return fa;
                 const name = fa.name.element.simpleName;
-                // A construction through it is the rewrite's business, and reported there if it can't be made.
-                if (this.cursor.parentTree()?.value?.kind === J.Kind.NewClass) return fa;
-                if (HPAGENT_TYPES.has(name) || this.inTypePosition()) return this.report(fa, name, REASONS.type, p);
-                return HPAGENT_CLASSES.has(name) ? this.report(fa, name, REASONS.value, p) : fa;
+                return HPAGENT_CLASSES.has(name) && isValueUse(this.cursor) ? this.report(fa, name, REASONS.value, p) : fa;
             }
 
             override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
                 const id = await super.visitIdentifier(identifier, p) as J.Identifier;
-                if (!this.bindings.has(id.simpleName) || !isModuleScoped(this.cursor, id.simpleName)) return id;
-                if (!this.isValueUse(identifier)) return id;
-                // An option type names a type wherever it stands, including in a cast the cursor can't see into.
-                const type = HPAGENT_TYPES.has(id.simpleName) || this.inTypePosition();
-                return this.report(id, id.simpleName, type ? REASONS.type : REASONS.value, p);
-            }
-
-            /** Whether `id` stands for the value it names, not a construction, member access, declaration or import. */
-            private isValueUse(id: J.Identifier): boolean {
+                const bindings = this.found.bindings;
+                if (!bindings.has(id.simpleName) || this.found.assignmentTargets.has(identifier.id) || this.found.typeOnly.has(id.simpleName) ||
+                    !isReference(this.cursor, identifier) || !resolvesToBinding(this.cursor, id.simpleName, this.found)) {
+                    return id;
+                }
+                const member = bindings.get(id.simpleName);
+                // The adapter's types stand in for hpagent's option types.
+                if (member !== undefined && !HPAGENT_CLASSES.has(member)) return id;
+                // `jest.spyOn(hpagent, 'HttpsProxyAgent')` reads the class off by a name the new module exports too.
                 const parent = this.cursor.parentTree()?.value as J | undefined;
-                if (!parent || DECLARING_KINDS.has(parent.kind)) return false;
-                switch (parent.kind) {
-                    case J.Kind.NewClass:
-                        return (parent as J.NewClass).class !== id;
-                    case J.Kind.FieldAccess:
-                        return (parent as J.FieldAccess).target !== id;
-                    case J.Kind.MethodInvocation: {
-                        const m = parent as J.MethodInvocation;
-                        return m.select?.element !== id && m.name !== id;
-                    }
-                    case J.Kind.NamedVariable:
-                        return (parent as J.VariableDeclarations.NamedVariable).name !== id;
-                    default:
-                        return true;
+                if (member === undefined && parent?.kind === J.Kind.MethodInvocation &&
+                    spiedClass(parent as J.MethodInvocation) !== undefined) {
+                    return id;
                 }
-            }
-
-            private inTypePosition(): boolean {
-                return !!this.cursor.firstEnclosing((t: any): t is J => t?.kind === JS.Kind.TypeInfo);
+                return isValueUse(this.cursor) ? this.report(id, id.simpleName, REASONS.value, p) : id;
             }
         };
     }