@openrewrite/rewrite 8.69.0-20251207-160255 → 8.69.0-20251207-214914

package/dist/javascript/recipes/async-callback-in-sync-array-method.d.ts

@@ -0,0 +1,40 @@
+import { Recipe } from "../../recipe";
+import { ExecutionContext } from "../../execution";
+import { TreeVisitor } from "../../visitor";
+/**
+ * Detects async callbacks passed to synchronous array methods.
+ *
+ * This is a common bug pattern in JavaScript/TypeScript where async functions
+ * are passed to array methods like `.some()`, `.every()`, `.find()`, etc.
+ * These methods don't await the promises returned by async callbacks, leading
+ * to bugs where Promise objects are treated as truthy values.
+ *
+ * Example of buggy code:
+ * ```typescript
+ * // BUG: .some() doesn't await, so any Promise is truthy
+ * const hasAdmin = users.some(async user => {
+ *     return await checkPermission(user, 'admin');
+ * });
+ * // hasAdmin is ALWAYS true because Promise objects are truthy!
+ *
+ * // CORRECT: Use a for loop with await
+ * let hasAdmin = false;
+ * for (const user of users) {
+ *     if (await checkPermission(user, 'admin')) {
+ *         hasAdmin = true;
+ *         break;
+ *     }
+ * }
+ * ```
+ *
+ * This recipe reports occurrences but doesn't auto-fix because the correct
+ * fix depends on the context (could use for...of loop, Promise.all, etc.).
+ */
+export declare class AsyncCallbackInSyncArrayMethod extends Recipe {
+    readonly name = "org.openrewrite.javascript.cleanup.async-callback-in-sync-array-method";
+    readonly displayName: string;
+    readonly description: string;
+    readonly tags: string[];
+    editor(): Promise<TreeVisitor<any, ExecutionContext>>;
+}
+//# sourceMappingURL=async-callback-in-sync-array-method.d.ts.map

package/dist/javascript/recipes/async-callback-in-sync-array-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-callback-in-sync-array-method.d.ts","sourceRoot":"","sources":["../../../src/javascript/recipes/async-callback-in-sync-array-method.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAC,MAAM,EAAC,MAAM,cAAc,CAAC;AACpC,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AA0J1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,8BAA+B,SAAQ,MAAM;IACtD,QAAQ,CAAC,IAAI,4EAA4E;IACzF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAyD;IACrF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAiL;IAC7M,QAAQ,CAAC,IAAI,WAA2D;IAElE,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;CA6B9D"}

package/dist/javascript/recipes/async-callback-in-sync-array-method.js

@@ -0,0 +1,232 @@
+"use strict";
+/*
+ * 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncCallbackInSyncArrayMethod = void 0;
+const recipe_1 = require("../../recipe");
+const visitor_1 = require("../visitor");
+const java_1 = require("../../java");
+const tree_1 = require("../tree");
+const java_2 = require("../../java");
+const markers_1 = require("../../markers");
+/**
+ * Array methods that don't await async callbacks.
+ * When an async function is passed as a callback to these methods,
+ * the returned Promise is not awaited, leading to bugs.
+ */
+const SYNC_ARRAY_METHODS = new Set([
+    'some', // Returns first truthy value, but Promise is always truthy
+    'every', // Returns first falsy value, but Promise is always truthy
+    'find', // Returns first truthy value, but Promise is always truthy
+    'findIndex', // Returns first truthy value, but Promise is always truthy
+    'filter', // Filters based on truthy values, but Promise is always truthy
+    'forEach', // Ignores return values entirely, async callbacks won't be awaited
+]);
+/**
+ * Check if a type is a Promise type.
+ * Looks for types like Promise<T>, PromiseLike<T>, or the Promise class itself.
+ */
+function isPromiseType(type) {
+    if (!type)
+        return false;
+    // Check for Class type with Promise name
+    if (java_2.Type.isClass(type)) {
+        const fqn = type.fullyQualifiedName;
+        return fqn === 'Promise' ||
+            fqn === 'PromiseLike' ||
+            fqn.endsWith('.Promise') ||
+            fqn.endsWith('.PromiseLike');
+    }
+    // Check for Parameterized type (e.g., Promise<boolean>)
+    if (java_2.Type.isParameterized(type)) {
+        return isPromiseType(type.type);
+    }
+    // Check for Union type (e.g., Promise<T> | undefined)
+    if (java_2.Type.isUnion(type)) {
+        return type.bounds.some(b => isPromiseType(b));
+    }
+    return false;
+}
+/**
+ * Check if an arrow function has an async modifier.
+ * In JavaScript, async is represented as a LanguageExtension modifier with keyword="async"
+ */
+function hasAsyncModifier(arrowFunc) {
+    return arrowFunc.modifiers.some(m => m.type === java_1.J.ModifierType.Async ||
+        (m.type === java_1.J.ModifierType.LanguageExtension && m.keyword === 'async'));
+}
+/**
+ * Check if a function type returns a Promise.
+ */
+function functionTypeReturnsPromise(funcType) {
+    if (!java_2.Type.isFunctionType(funcType))
+        return false;
+    const clazz = funcType;
+    if (clazz.typeParameters && clazz.typeParameters.length > 0) {
+        // First type parameter is typically R (return type) in TypeScript function types
+        // It's a GenericTypeVariable with bounds containing the actual type
+        const returnTypeParam = clazz.typeParameters[0];
+        // Check if it's directly a Promise type
+        if (isPromiseType(returnTypeParam)) {
+            return true;
+        }
+        // Check if it's a GenericTypeVariable with bounds
+        if (java_2.Type.isGenericTypeVariable(returnTypeParam)) {
+            const bounds = returnTypeParam.bounds;
+            if (bounds && bounds.some(b => isPromiseType(b))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if a callback argument returns a Promise.
+ * This checks:
+ * 1. Explicit async modifier on arrow functions
+ * 2. Type annotation indicating Promise return type
+ * 3. Function references whose type indicates Promise return
+ */
+function callbackReturnsPromise(arg) {
+    var _a;
+    // Handle RightPadded wrapper
+    const element = (_a = arg === null || arg === void 0 ? void 0 : arg.element) !== null && _a !== void 0 ? _a : arg;
+    if (!element)
+        return false;
+    // Check if it's an arrow function
+    if (element.kind === tree_1.JS.Kind.ArrowFunction) {
+        const arrowFunc = element;
+        // Check for async modifier
+        if (hasAsyncModifier(arrowFunc)) {
+            return true;
+        }
+        // Check if return type expression indicates Promise
+        const returnType = arrowFunc.returnTypeExpression;
+        if (returnType) {
+            // Check if the return type expression is an identifier named Promise
+            if (returnType.kind === java_1.J.Kind.Identifier) {
+                const id = returnType;
+                if (id.simpleName === 'Promise' || id.simpleName === 'PromiseLike') {
+                    return true;
+                }
+            }
+            // Check if it's a parameterized type like Promise<boolean>
+            if (returnType.kind === java_1.J.Kind.ParameterizedType) {
+                const pt = returnType;
+                // ParameterizedType has 'clazz' property which is the base type
+                const baseType = pt.clazz;
+                if ((baseType === null || baseType === void 0 ? void 0 : baseType.kind) === java_1.J.Kind.Identifier) {
+                    const clazz = baseType;
+                    if (clazz.simpleName === 'Promise' || clazz.simpleName === 'PromiseLike') {
+                        return true;
+                    }
+                }
+            }
+        }
+        // Check type attribution if available
+        const funcType = arrowFunc.type;
+        if (funcType && functionTypeReturnsPromise(funcType)) {
+            return true;
+        }
+    }
+    // Check if it's a function reference (Identifier) with type attribution
+    if (element.kind === java_1.J.Kind.Identifier) {
+        const identifier = element;
+        const funcType = identifier.type;
+        if (funcType && functionTypeReturnsPromise(funcType)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Detects async callbacks passed to synchronous array methods.
+ *
+ * This is a common bug pattern in JavaScript/TypeScript where async functions
+ * are passed to array methods like `.some()`, `.every()`, `.find()`, etc.
+ * These methods don't await the promises returned by async callbacks, leading
+ * to bugs where Promise objects are treated as truthy values.
+ *
+ * Example of buggy code:
+ * ```typescript
+ * // BUG: .some() doesn't await, so any Promise is truthy
+ * const hasAdmin = users.some(async user => {
+ *     return await checkPermission(user, 'admin');
+ * });
+ * // hasAdmin is ALWAYS true because Promise objects are truthy!
+ *
+ * // CORRECT: Use a for loop with await
+ * let hasAdmin = false;
+ * for (const user of users) {
+ *     if (await checkPermission(user, 'admin')) {
+ *         hasAdmin = true;
+ *         break;
+ *     }
+ * }
+ * ```
+ *
+ * This recipe reports occurrences but doesn't auto-fix because the correct
+ * fix depends on the context (could use for...of loop, Promise.all, etc.).
+ */
+class AsyncCallbackInSyncArrayMethod extends recipe_1.Recipe {
+    constructor() {
+        super(...arguments);
+        this.name = "org.openrewrite.javascript.cleanup.async-callback-in-sync-array-method";
+        this.displayName = "Detect async callbacks in synchronous array methods";
+        this.description = "Detects async callbacks passed to array methods like .some(), .every(), .filter() which don't await promises. This is a common bug where Promise objects are always truthy.";
+        this.tags = ["javascript", "typescript", "async", "bug", "cleanup"];
+    }
+    editor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new class extends visitor_1.JavaScriptVisitor {
+                visitMethodInvocation(method, ctx) {
+                    const _super = Object.create(null, {
+                        visitMethodInvocation: { get: () => super.visitMethodInvocation }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        let m = yield _super.visitMethodInvocation.call(this, method, ctx);
+                        const methodName = (_a = m.name) === null || _a === void 0 ? void 0 : _a.simpleName;
+                        if (!methodName || !SYNC_ARRAY_METHODS.has(methodName)) {
+                            return m;
+                        }
+                        // Check the arguments for async callbacks
+                        const args = (_b = m.arguments) === null || _b === void 0 ? void 0 : _b.elements;
+                        if (!args || args.length === 0) {
+                            return m;
+                        }
+                        const firstArg = args[0];
+                        if (callbackReturnsPromise(firstArg)) {
+                            return (0, markers_1.markupWarn)(m, `Async callback passed to .${methodName}()`, `Array methods like .${methodName}() don't await async callbacks, so Promises are treated as truthy values. Consider using a for...of loop with await instead.`);
+                        }
+                        return m;
+                    });
+                }
+            }();
+        });
+    }
+}
+exports.AsyncCallbackInSyncArrayMethod = AsyncCallbackInSyncArrayMethod;
+//# sourceMappingURL=async-callback-in-sync-array-method.js.map

package/dist/javascript/recipes/async-callback-in-sync-array-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-callback-in-sync-array-method.js","sourceRoot":"","sources":["../../../src/javascript/recipes/async-callback-in-sync-array-method.ts"],"names":[],"mappings":"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"}

package/dist/javascript/recipes/change-import.d.ts

@@ -0,0 +1,51 @@
+import { Recipe } from "../../recipe";
+import { TreeVisitor } from "../../visitor";
+import { ExecutionContext } from "../../execution";
+/**
+ * Changes an import from one module to another, updating all type attributions.
+ *
+ * This recipe is useful for:
+ * - Library migrations (e.g., moving `act` from `react-dom/test-utils` to `react`)
+ * - Module restructuring (e.g., split packages)
+ * - Renaming exported members
+ *
+ * @example
+ * // Migrate act import from react-dom/test-utils to react
+ * const recipe = new ChangeImport({
+ *     oldModule: "react-dom/test-utils",
+ *     oldMember: "act",
+ *     newModule: "react"
+ * });
+ * // Before: import { act } from 'react-dom/test-utils';
+ * // After:  import { act } from 'react';
+ *
+ * @example
+ * // Change a named import to a different name
+ * const recipe = new ChangeImport({
+ *     oldModule: "lodash",
+ *     oldMember: "extend",
+ *     newModule: "lodash",
+ *     newMember: "assign"
+ * });
+ * // Before: import { extend } from 'lodash';
+ * // After:  import { assign } from 'lodash';
+ */
+export declare class ChangeImport extends Recipe {
+    readonly name = "org.openrewrite.javascript.change-import";
+    readonly displayName = "Change import";
+    readonly description = "Changes an import from one module/member to another, updating all type attributions.";
+    oldModule: string;
+    oldMember: string;
+    newModule: string;
+    newMember?: string;
+    newAlias?: string;
+    constructor(options?: {
+        oldModule?: string;
+        oldMember?: string;
+        newModule?: string;
+        newMember?: string;
+        newAlias?: string;
+    });
+    editor(): Promise<TreeVisitor<any, ExecutionContext>>;
+}
+//# sourceMappingURL=change-import.d.ts.map

package/dist/javascript/recipes/change-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-import.d.ts","sourceRoot":"","sources":["../../../src/javascript/recipes/change-import.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAS,MAAM,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAMjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,YAAa,SAAQ,MAAM;IACpC,QAAQ,CAAC,IAAI,8CAA8C;IAC3D,QAAQ,CAAC,WAAW,mBAAmB;IACvC,QAAQ,CAAC,WAAW,0FAA0F;IAO9G,SAAS,EAAG,MAAM,CAAC;IAOnB,SAAS,EAAG,MAAM,CAAC;IAOnB,SAAS,EAAG,MAAM,CAAC;IAQnB,SAAS,CAAC,EAAE,MAAM,CAAC;IAOnB,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAEN,OAAO,CAAC,EAAE;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrB;IAIK,MAAM,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;CAmlB9D"}