@next/codemod 15.0.3-canary.5 → 15.0.3-canary.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "15.0.3-canary.5",
+  "version": "15.0.3-canary.7",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -4,6 +4,9 @@ exports.transformDynamicProps = transformDynamicProps;
 const utils_1 = require("./utils");
 const parser_1 = require("../../../lib/parser");
 const PAGE_PROPS = 'props';
+// Find all the member access of the prop, and await them
+// e.g. If there's argument `props`, find all the member access of props.<name>.
+// If the member access can be awaited, await them.
 function awaitMemberAccessOfProp(propIdName, path, j) {
     // search the member access of the prop
     const functionBody = (0, utils_1.findFunctionBody)(path);
@@ -30,6 +33,17 @@ function awaitMemberAccessOfProp(propIdName, path, j) {
         if (memberAccessPath.parentPath?.value.type === 'AwaitExpression') {
             return;
         }
+        const parentScopeOfMemberAccess = (0, utils_1.findClosetParentFunctionScope)(memberAccessPath, j);
+        // When the parent scope is sync, and it's also not the function itself, which means it's not able to convert to async.
+        if (parentScopeOfMemberAccess &&
+            !parentScopeOfMemberAccess.value?.async &&
+            parentScopeOfMemberAccess.node !== path.node) {
+            // If it's not able to convert, add a comment to the prop access to warn the user
+            // e.g. the parent scope is sync, await keyword can't be applied
+            const comment = ` ${utils_1.NEXT_CODEMOD_ERROR_PREFIX} '${propIdName}.${memberProperty.name}' is accessed without awaiting.`;
+            (0, utils_1.insertCommentOnce)(member, j, comment);
+            return;
+        }
         const awaitedExpr = j.awaitExpression(member);
         const awaitMemberAccess = (0, utils_1.wrapParentheseIfNeeded)(true, j, awaitedExpr);
         memberAccessPath.replace(awaitMemberAccess);
@@ -238,6 +252,43 @@ function modifyTypes(paramTypeAnnotation, propsIdentifier, root, j) {
                         }
                     }
                 }
+                if (foundTypes.imports.length > 0) {
+                    // console.log('typeReference.typeName.name', typeReference.typeName.name, foundTypes)
+                    // If it's React PropsWithChildren
+                    if (typeReference.typeName.name === 'PropsWithChildren') {
+                        const propType = typeReference.typeParameters?.params[0];
+                        if (propType &&
+                            j.TSTypeLiteral.check(propType) &&
+                            propType.members.length > 0) {
+                            const typeLiteral = propType;
+                            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;
@@ -335,6 +386,9 @@ function transformDynamicProps(source, _api, filePath) {
                     }
                 }
                 else {
+                    // If it's (props.params).<name>, await the member access
+                    // const pathOfCurrentParam = path.get('params', propsArgumentIndex)
+                    // const paramScope = findClosetParentFunctionScope(pathOfCurrentParam, j)
                     const awaited = awaitMemberAccessOfProp(argName, path, j);
                     modified ||= awaited;
                 }

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

@@ -199,6 +199,8 @@ function isFunctionScope(path, j) {
         j.ArrowFunctionExpression.check(node));
 }
 function findClosetParentFunctionScope(path, j) {
+    if (!path.scope)
+        return null;
     let parentFunctionPath = path.scope.path;
     while (parentFunctionPath && !isFunctionScope(parentFunctionPath, j)) {
         parentFunctionPath = parentFunctionPath.parent;