@next/codemod 15.0.0-rc.1 → 15.0.0

package/bin/upgrade.js

@@ -1,12 +1,35 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runUpgrade = runUpgrade;
+const os = __importStar(require("os"));
 const prompts_1 = __importDefault(require("prompts"));
 const fs_1 = __importDefault(require("fs"));
-const semver_1 = __importDefault(require("semver"));
 const compare_1 = __importDefault(require("semver/functions/compare"));
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
@@ -15,6 +38,22 @@ const handle_package_1 = require("../lib/handle-package");
 const transform_1 = require("./transform");
 const utils_1 = require("../lib/utils");
 const shared_1 = require("./shared");
+const optionalNextjsPackages = [
+    'create-next-app',
+    'eslint-config-next',
+    '@next/bundle-analyzer',
+    '@next/codemod',
+    '@next/env',
+    '@next/eslint-plugin-next',
+    '@next/font',
+    '@next/mdx',
+    '@next/plugin-storybook',
+    '@next/polyfill-module',
+    '@next/polyfill-nomodule',
+    '@next/swc',
+    '@next/react-refresh-utils',
+    '@next/third-parties',
+];
 /**
  * @param query
  * @example loadHighestNPMVersionMatching("react@^18.3.0 || ^19.0.0") === Promise<"19.0.0">
@@ -71,6 +110,10 @@ async function runUpgrade(revision, options) {
     console.log(`  - React: v${installedReactVersion}`);
     console.log(`  - Next.js: v${installedNextVersion}`);
     let shouldStayOnReact18 = false;
+    const usesAppDir = isUsingAppDir(process.cwd());
+    const usesPagesDir = isUsingPagesDir(process.cwd());
+    const isPureAppRouter = usesAppDir && !usesPagesDir;
+    const isMixedApp = usesPagesDir && usesAppDir;
     if (
     // From release v14.3.0-canary.45, Next.js expects the React version to be 19.0.0-beta.0
     // If the user is on a version higher than this but is still on React 18, we ask them
@@ -79,12 +122,19 @@ async function runUpgrade(revision, options) {
     // we should only let the user stay on React 18 if they are using pure Pages Router.
     // x-ref(PR): https://github.com/vercel/next.js/pull/65058
     // x-ref(release): https://github.com/vercel/next.js/releases/tag/v14.3.0-canary.45
-    (0, compare_1.default)(installedNextVersion, '14.3.0-canary.45') >= 0 &&
-        installedReactVersion.startsWith('18')) {
+    (0, compare_1.default)(targetNextVersion, '14.3.0-canary.45') >= 0 &&
+        installedReactVersion.startsWith('18') &&
+        // Pure App Router always uses React 19
+        // The mixed case is tricky to handle from a types perspective.
+        // We'll recommend to upgrade in the prompt but users can decide to try 18.
+        !isPureAppRouter) {
         const shouldStayOnReact18Res = await (0, prompts_1.default)({
             type: 'confirm',
             name: 'shouldStayOnReact18',
-            message: `Are you using ${picocolors_1.default.underline('only the Pages Router')} (no App Router) and prefer to stay on React 18?`,
+            message: `Do you prefer to stay on React 18?` +
+                (isMixedApp
+                    ? " Since you're using both pages/ and app/, we recommend upgrading React to use a consistent version throughout your app."
+                    : ''),
             initial: false,
             active: 'Yes',
             inactive: 'No',
@@ -109,7 +159,8 @@ async function runUpgrade(revision, options) {
     let execCommand = 'npx';
     // The following React codemods are for React 19
     if (!shouldStayOnReact18 &&
-        (0, compare_1.default)(targetReactVersion, '19.0.0-beta.0') >= 0) {
+        (0, compare_1.default)(targetReactVersion, '19.0.0-0') >= 0 &&
+        (0, compare_1.default)(installedReactVersion, '19.0.0-0') < 0) {
         shouldRunReactCodemods = await suggestReactCodemods();
         shouldRunReactTypesCodemods = await suggestReactTypesCodemods();
         const execCommandMap = {
@@ -133,6 +184,12 @@ async function runUpgrade(revision, options) {
         'react-dom': { version: targetReactVersion, required: true },
         'react-is': { version: targetReactVersion, required: false },
     };
+    for (const optionalNextjsPackage of optionalNextjsPackages) {
+        versionMapping[optionalNextjsPackage] = {
+            version: targetNextVersion,
+            required: false,
+        };
+    }
     if (targetReactVersion.startsWith('19.0.0-canary') ||
         targetReactVersion.startsWith('19.0.0-beta') ||
         targetReactVersion.startsWith('19.0.0-rc')) {
@@ -196,7 +253,9 @@ async function runUpgrade(revision, options) {
     for (const [dep, version] of devDependenciesToInstall) {
         (0, handle_package_1.addPackageDependency)(appPackageJson, dep, version, true);
     }
-    fs_1.default.writeFileSync(appPackageJsonPath, JSON.stringify(appPackageJson, null, 2));
+    fs_1.default.writeFileSync(appPackageJsonPath, JSON.stringify(appPackageJson, null, 2) +
+        // Common IDE formatters would add a newline as well.
+        os.EOL);
     (0, handle_package_1.runInstallation)(packageManager);
     for (const codemod of codemods) {
         await (0, transform_1.runTransform)(codemod, process.cwd(), { force: true, verbose });
@@ -248,6 +307,14 @@ function getInstalledReactVersion() {
         });
     }
 }
+function isUsingPagesDir(projectPath) {
+    return (fs_1.default.existsSync(path_1.default.resolve(projectPath, 'pages')) ||
+        fs_1.default.existsSync(path_1.default.resolve(projectPath, 'src/pages')));
+}
+function isUsingAppDir(projectPath) {
+    return (fs_1.default.existsSync(path_1.default.resolve(projectPath, 'app')) ||
+        fs_1.default.existsSync(path_1.default.resolve(projectPath, 'src/app')));
+}
 /*
  * Heuristics are used to determine whether to Turbopack is enabled or not and
  * to determine how to update the dev script.
@@ -287,25 +354,21 @@ async function suggestTurbopack(packageJson) {
         responseCustomDevScript.customDevScript || devScript;
 }
 async function suggestCodemods(initialNextVersion, targetNextVersion) {
-    // Here we suggest pre-released codemods by their "stable" version.
-    // It is because if we suggest by the version range (installed ~ target),
-    // pre-released codemods for the target version are not suggested when upgrading.
-    // Let's say we have a codemod for v15.0.0-canary.x, and we're upgrading from
-    // v15.x -> v15.x. Our initial version is higher than the codemod's version,
-    // so the codemod will not be suggested.
-    // This is not ideal as the codemods for pre-releases are also targeting the major version.
-    // Also, when the user attempts to run the upgrade command twice, and have installed the
-    // target version, the behavior must be idempotent and suggest the codemods including the
-    // pre-releases of the target version.
-    const initial = semver_1.default.parse(initialNextVersion);
-    const initialVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((versionCodemods) => {
-        const codemod = semver_1.default.parse(versionCodemods.version);
-        return ((0, compare_1.default)(`${codemod.major}.${codemod.minor}.${codemod.patch}`, `${initial.major}.${initial.minor}.${initial.patch}`) >= 0);
+    // example:
+    // codemod version: 15.0.0-canary.45
+    // 14.3             -> 15.0.0-canary.45: apply
+    // 14.3             -> 15.0.0-canary.44: don't apply
+    // 15.0.0-canary.44 -> 15.0.0-canary.45: apply
+    // 15.0.0-canary.45 -> 15.0.0-canary.46: don't apply
+    // 15.0.0-canary.45 -> 15.0.0          : don't apply
+    // 15.0.0-canary.44 -> 15.0.0          : apply
+    const initialVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((codemod) => {
+        return (0, compare_1.default)(codemod.version, initialNextVersion) > 0;
     });
     if (initialVersionIndex === -1) {
         return [];
     }
-    let targetVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((versionCodemods) => (0, compare_1.default)(versionCodemods.version, targetNextVersion) > 0);
+    let targetVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((codemod) => (0, compare_1.default)(codemod.version, targetNextVersion) > 0);
     if (targetVersionIndex === -1) {
         targetVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.length;
     }
@@ -330,39 +393,41 @@ async function suggestCodemods(initialNextVersion, targetNextVersion) {
 }
 async function suggestReactCodemods() {
     const { runReactCodemod } = await (0, prompts_1.default)({
-        type: 'toggle',
+        type: 'confirm',
         name: 'runReactCodemod',
         message: 'Would you like to run the React 19 upgrade codemod?',
         initial: true,
-        active: 'Yes',
-        inactive: 'No',
     }, { onCancel: utils_1.onCancel });
     return runReactCodemod;
 }
 async function suggestReactTypesCodemods() {
     const { runReactTypesCodemod } = await (0, prompts_1.default)({
-        type: 'toggle',
+        type: 'confirm',
         name: 'runReactTypesCodemod',
         message: 'Would you like to run the React 19 Types upgrade codemod?',
         initial: true,
-        active: 'Yes',
-        inactive: 'No',
     }, { onCancel: utils_1.onCancel });
     return runReactTypesCodemod;
 }
 function writeOverridesField(packageJson, packageManager, overrides) {
-    if (packageManager === 'bun' || packageManager === 'npm') {
+    const entries = Object.entries(overrides);
+    // Avoids writing an empty overrides field into package.json
+    // which would be an unnecessary diff.
+    if (entries.length === 0) {
+        return;
+    }
+    if (packageManager === 'npm') {
         if (!packageJson.overrides) {
             packageJson.overrides = {};
         }
-        for (const [key, value] of Object.entries(overrides)) {
+        for (const [key, value] of entries) {
             packageJson.overrides[key] = value;
         }
     }
     else if (packageManager === 'pnpm') {
         // pnpm supports pnpm.overrides and pnpm.resolutions
         if (packageJson.resolutions) {
-            for (const [key, value] of Object.entries(overrides)) {
+            for (const [key, value] of entries) {
                 packageJson.resolutions[key] = value;
             }
         }
@@ -373,7 +438,7 @@ function writeOverridesField(packageJson, packageManager, overrides) {
             if (!packageJson.pnpm.overrides) {
                 packageJson.pnpm.overrides = {};
             }
-            for (const [key, value] of Object.entries(overrides)) {
+            for (const [key, value] of entries) {
                 packageJson.pnpm.overrides[key] = value;
             }
         }
@@ -382,9 +447,27 @@ function writeOverridesField(packageJson, packageManager, overrides) {
         if (!packageJson.resolutions) {
             packageJson.resolutions = {};
         }
-        for (const [key, value] of Object.entries(overrides)) {
+        for (const [key, value] of entries) {
             packageJson.resolutions[key] = value;
         }
     }
+    else if (packageManager === 'bun') {
+        // bun supports both overrides and resolutions
+        // x-ref: https://bun.sh/docs/install/overrides
+        if (packageJson.resolutions) {
+            for (const [key, value] of entries) {
+                packageJson.resolutions[key] = value;
+            }
+        }
+        else {
+            // add overrides field if it's missing and add overrides
+            if (!packageJson.overrides) {
+                packageJson.overrides = {};
+            }
+            for (const [key, value] of entries) {
+                packageJson.overrides[key] = value;
+            }
+        }
+    }
 }
 //# sourceMappingURL=upgrade.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "15.0.0-rc.1",
+  "version": "15.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,7 +30,8 @@
     "build": "pnpm tsc -d -p tsconfig.json",
     "prepublishOnly": "cd ../../ && turbo run build",
     "dev": "pnpm tsc -d -w -p tsconfig.json",
-    "test": "jest"
+    "test": "jest",
+    "test:upgrade-fixture": "./scripts/test-upgrade-fixture.sh"
   },
   "bin": "./bin/next-codemod.js",
   "devDependencies": {

package/transforms/lib/async-request-api/next-async-dynamic-api.js

@@ -108,10 +108,10 @@ function transformDynamicAPI(source, _api, filePath) {
                 // check if current path is under the default export function
                 if (isEntryFileExport) {
                     // if default export function is not async, convert it to async, and await the api call
-                    if (!isCallAwaited) {
+                    if (!isCallAwaited && (0, utils_1.isFunctionType)(exportFunctionNode.type)) {
+                        const hasReactHooksUsage = (0, utils_1.containsReactHooksCallExpressions)(closetScopePath, j);
                         // If the scoped function is async function
-                        if ((0, utils_1.isFunctionType)(exportFunctionNode.type) &&
-                            exportFunctionNode.async === false) {
+                        if (exportFunctionNode.async === false && !hasReactHooksUsage) {
                             canConvertToAsync = true;
                             exportFunctionNode.async = true;
                         }
@@ -121,15 +121,25 @@ function transformDynamicAPI(source, _api, filePath) {
                             (0, utils_1.turnFunctionReturnTypeToAsync)(closetScopePath.node, j);
                             modified = true;
                         }
+                        else {
+                            // If it's still sync function that cannot be converted to async, wrap the api call with 'use()' if needed
+                            if (!(0, utils_1.isParentUseCallExpression)(path, j)) {
+                                j(path).replaceWith(j.callExpression(j.identifier('use'), [
+                                    j.callExpression(j.identifier(asyncRequestApiName), []),
+                                ]));
+                                needsReactUseImport = true;
+                                modified = true;
+                            }
+                        }
                     }
                 }
                 else {
                     // if parent is function and it's a hook, which starts with 'use', wrap the api call with 'use()'
                     const parentFunction = (0, utils_1.findClosetParentFunctionScope)(path, j);
                     if (parentFunction) {
-                        const parentFunctionName = parentFunction.get().node.id?.name;
-                        const isParentFunctionHook = parentFunctionName?.startsWith('use');
-                        if (isParentFunctionHook) {
+                        const parentFunctionName = parentFunction.get().node.id?.name || '';
+                        const isParentFunctionHook = (0, utils_1.isReactHookName)(parentFunctionName);
+                        if (isParentFunctionHook && !(0, utils_1.isParentUseCallExpression)(path, j)) {
                             j(path).replaceWith(j.callExpression(j.identifier('use'), [
                                 j.callExpression(j.identifier(asyncRequestApiName), []),
                             ]));

package/transforms/lib/async-request-api/next-async-dynamic-prop.js

@@ -4,16 +4,9 @@ exports.transformDynamicProps = transformDynamicProps;
 const utils_1 = require("./utils");
 const parser_1 = require("../../../lib/parser");
 const PAGE_PROPS = 'props';
-function findFunctionBody(path) {
-    let functionBody = path.node.body;
-    if (functionBody && functionBody.type === 'BlockStatement') {
-        return functionBody.body;
-    }
-    return null;
-}
 function awaitMemberAccessOfProp(propIdName, path, j) {
     // search the member access of the prop
-    const functionBody = findFunctionBody(path);
+    const functionBody = (0, utils_1.findFunctionBody)(path);
     const memberAccess = j(functionBody).find(j.MemberExpression, {
         object: {
             type: 'Identifier',
@@ -30,7 +23,7 @@ function awaitMemberAccessOfProp(propIdName, path, j) {
         if (!isAccessingMatchedProperty) {
             return;
         }
-        if (isParentPromiseAllCallExpression(memberAccessPath, j)) {
+        if ((0, utils_1.isParentPromiseAllCallExpression)(memberAccessPath, j)) {
             return;
         }
         // check if it's already awaited
@@ -42,44 +35,16 @@ function awaitMemberAccessOfProp(propIdName, path, j) {
         memberAccessPath.replace(awaitMemberAccess);
         hasAwaited = true;
     });
+    const hasReactHooksUsage = (0, utils_1.containsReactHooksCallExpressions)(path.get('body'), j);
     // If there's any awaited member access, we need to make the function async
     if (hasAwaited) {
-        if (!path.value.async) {
-            if ('async' in path.value) {
-                path.value.async = true;
-                (0, utils_1.turnFunctionReturnTypeToAsync)(path.value, j);
-            }
+        if (path.value.async === false && !hasReactHooksUsage) {
+            path.value.async = true;
+            (0, utils_1.turnFunctionReturnTypeToAsync)(path.value, j);
         }
     }
     return hasAwaited;
 }
-function isParentUseCallExpression(path, j) {
-    if (
-    // member access parentPath is argument
-    j.CallExpression.check(path.parent.value) &&
-        // member access is first argument
-        path.parent.value.arguments[0] === path.value &&
-        // function name is `use`
-        j.Identifier.check(path.parent.value.callee) &&
-        path.parent.value.callee.name === 'use') {
-        return true;
-    }
-    return false;
-}
-function isParentPromiseAllCallExpression(path, j) {
-    const argsParent = path.parent;
-    const callParent = argsParent?.parent;
-    if (j.ArrayExpression.check(argsParent.value) &&
-        j.CallExpression.check(callParent.value) &&
-        j.MemberExpression.check(callParent.value.callee) &&
-        j.Identifier.check(callParent.value.callee.object) &&
-        callParent.value.callee.object.name === 'Promise' &&
-        j.Identifier.check(callParent.value.callee.property) &&
-        callParent.value.callee.property.name === 'all') {
-        return true;
-    }
-    return false;
-}
 function applyUseAndRenameAccessedProp(propIdName, path, j) {
     // search the member access of the prop, and rename the member access to the member value
     // e.g.
@@ -87,7 +52,7 @@ function applyUseAndRenameAccessedProp(propIdName, path, j) {
     // props.params.foo => params.foo
     // props.searchParams.search => searchParams.search
     let modified = false;
-    const functionBody = findFunctionBody(path);
+    const functionBody = (0, utils_1.findFunctionBody)(path);
     const memberAccess = j(functionBody).find(j.MemberExpression, {
         object: {
             type: 'Identifier',
@@ -98,7 +63,7 @@ function applyUseAndRenameAccessedProp(propIdName, path, j) {
     // rename each member access
     memberAccess.forEach((memberAccessPath) => {
         // If the member access expression is first argument of `use()`, we skip
-        if (isParentUseCallExpression(memberAccessPath, j)) {
+        if ((0, utils_1.isParentUseCallExpression)(memberAccessPath, j)) {
             return;
         }
         const member = memberAccessPath.value;
@@ -190,7 +155,6 @@ function modifyTypes(paramTypeAnnotation, propsIdentifier, root, j) {
                         member.typeAnnotation.typeAnnotation &&
                         j.TSType.check(member.typeAnnotation.typeAnnotation)) {
                         member.typeAnnotation.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
-                            // @ts-ignore
                             member.typeAnnotation.typeAnnotation,
                         ]));
                         modified = true;
@@ -238,6 +202,42 @@ function modifyTypes(paramTypeAnnotation, propsIdentifier, root, j) {
                         });
                     }
                 }
+                // Deal with type aliases
+                if (foundTypes.typeAliases.length > 0) {
+                    const typeAliasDeclaration = foundTypes.typeAliases[0];
+                    if (j.TSTypeAliasDeclaration.check(typeAliasDeclaration)) {
+                        const typeAlias = typeAliasDeclaration.typeAnnotation;
+                        if (j.TSTypeLiteral.check(typeAlias) &&
+                            typeAlias.members.length > 0) {
+                            const typeLiteral = typeAlias;
+                            typeLiteral.members.forEach((member) => {
+                                if (j.TSPropertySignature.check(member) &&
+                                    j.Identifier.check(member.key) &&
+                                    utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
+                                    // if it's already a Promise, don't wrap it again, return
+                                    if (member.typeAnnotation &&
+                                        member.typeAnnotation.typeAnnotation &&
+                                        member.typeAnnotation.typeAnnotation.type ===
+                                            'TSTypeReference' &&
+                                        member.typeAnnotation.typeAnnotation.typeName.type ===
+                                            'Identifier' &&
+                                        member.typeAnnotation.typeAnnotation.typeName.name ===
+                                            'Promise') {
+                                        return;
+                                    }
+                                    // Wrap the prop type in Promise<>
+                                    if (member.typeAnnotation &&
+                                        j.TSTypeLiteral.check(member.typeAnnotation.typeAnnotation)) {
+                                        member.typeAnnotation.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
+                                            member.typeAnnotation.typeAnnotation,
+                                        ]));
+                                        modified = true;
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
             }
         }
         propsIdentifier.typeAnnotation = paramTypeAnnotation;
@@ -338,6 +338,7 @@ function transformDynamicProps(source, _api, filePath) {
                     const awaited = awaitMemberAccessOfProp(argName, path, j);
                     modified ||= awaited;
                 }
+                modified ||= modifyTypes(currentParam.typeAnnotation, propsIdentifier, root, j);
                 // cases of passing down `props` into any function
                 // Page(props) { callback(props) }
                 // search for all the argument of CallExpression, where currentParam is one of the arguments
@@ -391,11 +392,10 @@ function transformDynamicProps(source, _api, filePath) {
             const node = path.value;
             // If it's sync default export, and it's also server component, make the function async
             if (isDefaultExport && !isClientComponent) {
-                if (!node.async) {
-                    if ('async' in node) {
-                        node.async = true;
-                        (0, utils_1.turnFunctionReturnTypeToAsync)(node, j);
-                    }
+                const hasReactHooksUsage = (0, utils_1.containsReactHooksCallExpressions)(path.get('body'), j);
+                if (node.async === false && !hasReactHooksUsage) {
+                    node.async = true;
+                    (0, utils_1.turnFunctionReturnTypeToAsync)(node, j);
                 }
             }
             // If it's arrow function and function body is not block statement, check if the properties are used there
@@ -421,7 +421,9 @@ function transformDynamicProps(source, _api, filePath) {
             }
             const isAsyncFunc = !!node.async;
             const functionName = path.value.id?.name || 'default';
-            const functionBody = findFunctionBody(path);
+            const functionBody = (0, utils_1.findFunctionBody)(path);
+            const functionBodyPath = path.get('body');
+            const hasReactHooksUsage = (0, utils_1.containsReactHooksCallExpressions)(functionBodyPath, j);
             const hasOtherProperties = allProperties.length > propertiesMap.size;
             function createDestructuringDeclaration(properties, destructPropsIdentifierName) {
                 const propsToKeep = [];
@@ -491,7 +493,7 @@ function transformDynamicProps(source, _api, filePath) {
                         name: matchedPropName,
                     });
                     for (const propPath of propPaths.paths()) {
-                        if (isParentUseCallExpression(propPath, j)) {
+                        if ((0, utils_1.isParentUseCallExpression)(propPath, j)) {
                             // Skip transformation
                             shouldSkip = true;
                             break;
@@ -507,7 +509,6 @@ function transformDynamicProps(source, _api, filePath) {
                 const paramPropertyName = paramsPropertyName || matchedPropName;
                 // if propName is not used in lower scope, and it stars with unused prefix `_`,
                 // also skip the transformation
-                const functionBodyPath = path.get('body');
                 const hasUsedInBody = j(functionBodyPath)
                     .find(j.Identifier, {
                     name: paramPropertyName,
@@ -526,7 +527,7 @@ function transformDynamicProps(source, _api, filePath) {
                     propUsages.forEach((propUsage) => {
                         // If the parent is not AwaitExpression, it's not awaited
                         const isAwaited = propUsage.parentPath?.value.type === 'AwaitExpression';
-                        const isAwaitedByUse = isParentUseCallExpression(propUsage, j);
+                        const isAwaitedByUse = (0, utils_1.isParentUseCallExpression)(propUsage, j);
                         if (!isAwaited && !isAwaitedByUse) {
                             hasMissingAwaited = true;
                             return;
@@ -575,22 +576,19 @@ function transformDynamicProps(source, _api, filePath) {
                     }
                 }
                 else {
-                    // const isFromExport = true
-                    if (!isClientComponent) {
+                    if (!isClientComponent &&
+                        (0, utils_1.isFunctionType)(node.type) &&
+                        !hasReactHooksUsage) {
                         // If it's export function, populate the function to async
-                        if ((0, utils_1.isFunctionType)(node.type) &&
-                            // Make TS happy
-                            'async' in node) {
-                            node.async = true;
-                            (0, utils_1.turnFunctionReturnTypeToAsync)(node, j);
-                            // Insert `const <propName> = await props.<propName>;` at the beginning of the function body
-                            const paramAssignment = j.variableDeclaration('const', [
-                                j.variableDeclarator(j.identifier(paramPropertyName), j.awaitExpression(accessedPropIdExpr)),
-                            ]);
-                            if (!insertedRenamedPropFunctionNames.has(uid) && functionBody) {
-                                functionBody.unshift(paramAssignment);
-                                insertedRenamedPropFunctionNames.add(uid);
-                            }
+                        node.async = true;
+                        (0, utils_1.turnFunctionReturnTypeToAsync)(node, j);
+                        // Insert `const <propName> = await props.<propName>;` at the beginning of the function body
+                        const paramAssignment = j.variableDeclaration('const', [
+                            j.variableDeclarator(j.identifier(paramPropertyName), j.awaitExpression(accessedPropIdExpr)),
+                        ]);
+                        if (!insertedRenamedPropFunctionNames.has(uid) && functionBody) {
+                            functionBody.unshift(paramAssignment);
+                            insertedRenamedPropFunctionNames.add(uid);
                         }
                     }
                     else {
@@ -691,7 +689,7 @@ function findAllTypes(root, j, typeName) {
 }
 function commentSpreadProps(path, propsIdentifierName, j) {
     let modified = false;
-    const functionBody = findFunctionBody(path);
+    const functionBody = (0, utils_1.findFunctionBody)(path);
     const functionBodyCollection = j(functionBody);
     // Find all the usage of spreading properties of `props`
     const jsxSpreadProperties = functionBodyCollection.find(j.JSXSpreadAttribute, { argument: { name: propsIdentifierName } });

package/transforms/lib/async-request-api/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TARGET_PROP_NAMES = exports.TARGET_NAMED_EXPORTS = exports.TARGET_ROUTE_EXPORTS = exports.NEXT_CODEMOD_ERROR_PREFIX = exports.NEXTJS_ENTRY_FILES = void 0;
+exports.isReactHookName = exports.TARGET_PROP_NAMES = exports.TARGET_NAMED_EXPORTS = exports.TARGET_ROUTE_EXPORTS = exports.NEXT_CODEMOD_ERROR_PREFIX = exports.NEXTJS_ENTRY_FILES = void 0;
 exports.isFunctionType = isFunctionType;
 exports.isMatchedFunctionExported = isMatchedFunctionExported;
 exports.determineClientDirective = determineClientDirective;
@@ -14,6 +14,10 @@ exports.getFunctionPathFromExportPath = getFunctionPathFromExportPath;
 exports.wrapParentheseIfNeeded = wrapParentheseIfNeeded;
 exports.insertCommentOnce = insertCommentOnce;
 exports.getVariableDeclaratorId = getVariableDeclaratorId;
+exports.findFunctionBody = findFunctionBody;
+exports.containsReactHooksCallExpressions = containsReactHooksCallExpressions;
+exports.isParentUseCallExpression = isParentUseCallExpression;
+exports.isParentPromiseAllCallExpression = isParentPromiseAllCallExpression;
 exports.NEXTJS_ENTRY_FILES = /([\\/]|^)(page|layout|route|default)\.(t|j)sx?$/;
 exports.NEXT_CODEMOD_ERROR_PREFIX = '@next-codemod-error';
 const NEXT_CODEMOD_IGNORE_ERROR_PREFIX = '@next-codemod-ignore';
@@ -371,4 +375,99 @@ function getVariableDeclaratorId(path, j) {
     }
     return undefined;
 }
+function findFunctionBody(path) {
+    let functionBody = path.node.body;
+    if (functionBody && functionBody.type === 'BlockStatement') {
+        return functionBody.body;
+    }
+    return null;
+}
+const isPascalCase = (s) => /^[A-Z][a-z0-9]*$/.test(s);
+const isReactHookName = (name) => 
+// function name is `use`
+name === 'use' ||
+    // function name is `useX*`
+    (name.startsWith('use') && name[3] === name[3].toUpperCase());
+exports.isReactHookName = isReactHookName;
+// Determine a path of function contains any React hooks call expressions.
+// e.g. if there's any of those call expressions in the function body:
+// use() => true
+// React.use() => false
+// useXxxx() => true
+// Foo.use() => true
+// Foo.useXxxx() => true
+function containsReactHooksCallExpressions(path, j) {
+    const hasReactHooks = j(path)
+        .find(j.CallExpression)
+        .filter((callPath) => {
+        // It's matching:
+        // - use(<callPath>) => true
+        // - useX*(<callPath>) => true
+        const isUseHookOrReactHookCall = j.Identifier.check(callPath.value.callee) &&
+            (0, exports.isReactHookName)(callPath.value.callee.name);
+        // It's matching member access:
+        // - React.use(<callPath>) => true
+        // - Foo.useFoo(<callPath>) => true
+        // - foo.useFoo(<callPath>) => false
+        // - foo.use(<callPath>) => false
+        const isReactUseCall = j.MemberExpression.check(callPath.value.callee) &&
+            j.Identifier.check(callPath.value.callee.object) &&
+            j.Identifier.check(callPath.value.callee.property) &&
+            isPascalCase(callPath.value.callee.object.name) &&
+            (0, exports.isReactHookName)(callPath.value.callee.property.name);
+        return isUseHookOrReactHookCall || isReactUseCall;
+    })
+        .size() > 0;
+    return hasReactHooks;
+}
+// Capture the parent of the current path is wrapped by `use()` call expression
+// e.g.
+// use(<path>) => true
+// use2(<path>) => false
+// React.use(<path>) => true
+// Robust.use(<path>) => false
+function isParentUseCallExpression(path, j) {
+    const isParentUseCall = 
+    // member access parentPath is argument
+    j.CallExpression.check(path.parent.value) &&
+        // member access is first argument
+        path.parent.value.arguments[0] === path.value &&
+        path.parent.value.arguments.length === 1 &&
+        // function name is `use`
+        j.Identifier.check(path.parent.value.callee) &&
+        path.parent.value.callee.name === 'use';
+    const isParentReactUseCall = 
+    // member access parentPath is argument
+    j.CallExpression.check(path.parent.value) &&
+        // member access is first argument
+        path.parent.value.arguments[0] === path.value &&
+        path.parent.value.arguments.length === 1 &&
+        // function name is `use`
+        j.MemberExpression.check(path.parent.value.callee) &&
+        j.Identifier.check(path.parent.value.callee.object) &&
+        path.parent.value.callee.object.name === 'React' &&
+        j.Identifier.check(path.parent.value.callee.property) &&
+        path.parent.value.callee.property.name === 'use';
+    return isParentUseCall || isParentReactUseCall;
+}
+// Determine if a path is wrapped by `Promise.all()`
+// e.g.
+// Promise.all(<path>) => true
+// Promise.allSettled(<path>) => false
+function isParentPromiseAllCallExpression(path, j) {
+    const argsParent = path.parent;
+    const callParent = argsParent?.parent;
+    if (argsParent &&
+        callParent &&
+        j.ArrayExpression.check(argsParent.value) &&
+        j.CallExpression.check(callParent.value) &&
+        j.MemberExpression.check(callParent.value.callee) &&
+        j.Identifier.check(callParent.value.callee.object) &&
+        callParent.value.callee.object.name === 'Promise' &&
+        j.Identifier.check(callParent.value.callee.property) &&
+        callParent.value.callee.property.name === 'all') {
+        return true;
+    }
+    return false;
+}
 //# sourceMappingURL=utils.js.map