@next/codemod 15.0.0-canary.162 → 15.0.0-canary.164

package/bin/cli.js

@@ -23,7 +23,7 @@ const path_1 = __importDefault(require("path"));
 const execa_1 = __importDefault(require("execa"));
 const picocolors_1 = require("picocolors");
 const is_git_clean_1 = __importDefault(require("is-git-clean"));
-const uninstall_package_1 = require("../lib/uninstall-package");
+const handle_package_1 = require("../lib/handle-package");
 exports.jscodeshiftExecutable = require.resolve('.bin/jscodeshift');
 exports.transformerDirectory = path_1.default.join(__dirname, '../', 'transforms');
 function checkGitStatus(force) {
@@ -87,12 +87,16 @@ function runTransform({ files, flags, transformer }) {
     if (!dry && transformer === 'built-in-next-font') {
         console.log('Uninstalling `@next/font`');
         try {
-            (0, uninstall_package_1.uninstallPackage)('@next/font');
+            (0, handle_package_1.uninstallPackage)('@next/font');
         }
         catch (_a) {
             console.error("Couldn't uninstall `@next/font`, please uninstall it manually");
         }
     }
+    if (!dry && transformer === 'next-request-geo-ip') {
+        console.log('Installing `@vercel/functions`...');
+        (0, handle_package_1.installPackage)('@vercel/functions');
+    }
 }
 const TRANSFORMER_INQUIRER_CHOICES = [
     {
@@ -143,6 +147,14 @@ const TRANSFORMER_INQUIRER_CHOICES = [
         name: 'built-in-next-font: Uninstall `@next/font` and transform imports to `next/font`',
         value: 'built-in-next-font',
     },
+    {
+        name: 'next-async-request-api: Transforms usage of Next.js async Request APIs',
+        value: 'next-async-request-api',
+    },
+    {
+        name: 'next-request-geo-ip: Install `@vercel/functions` to replace `geo` and `ip` properties on `NextRequest`',
+        value: 'next-request-geo-ip',
+    },
 ];
 function expandFilePathsIfNeeded(filesBeforeExpansion) {
     const shouldExpandFiles = filesBeforeExpansion.some((file) => file.includes('*'));

package/lib/{uninstall-package.js → handle-package.js}

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uninstallPackage = uninstallPackage;
+exports.installPackage = installPackage;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const execa_1 = __importDefault(require("execa"));
@@ -28,4 +29,15 @@ function uninstallPackage(packageToUninstall) {
     }
     execa_1.default.sync(pkgManager, [command, packageToUninstall], { stdio: 'inherit' });
 }
-//# sourceMappingURL=uninstall-package.js.map
+function installPackage(packageToInstall) {
+    const pkgManager = getPkgManager(process.cwd());
+    if (!pkgManager)
+        throw new Error('Failed to find package manager');
+    try {
+        execa_1.default.sync(pkgManager, ['add', packageToInstall], { stdio: 'inherit' });
+    }
+    catch (error) {
+        throw new Error(`Failed to install "${packageToInstall}". Please install it manually.`, { cause: error });
+    }
+}
+//# sourceMappingURL=handle-package.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "15.0.0-canary.162",
+  "version": "15.0.0-canary.164",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,6 +19,7 @@
   },
   "files": [
     "transforms/*.js",
+    "transforms/lib/**/*.js",
     "bin/*.js",
     "lib/**/*.js",
     "lib/cra-to-next/gitignore"

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transform;
+const next_async_dynamic_prop_1 = require("./next-async-dynamic-prop");
+const next_async_dynamic_api_1 = require("./next-async-dynamic-api");
+function transform(file, api) {
+    const filePath = file.path;
+    // if it's node_modules or types file, skip
+    if (/node_modules/.test(filePath) || /\.d\.(m|c)?ts$/.test(filePath)) {
+        return file.source;
+    }
+    const transforms = [next_async_dynamic_prop_1.transformDynamicProps, next_async_dynamic_api_1.transformDynamicAPI];
+    return transforms.reduce((source, transformFn) => {
+        const result = transformFn(source, api, file.path);
+        if (!result) {
+            return source;
+        }
+        return result;
+    }, file.source);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDynamicAPI = transformDynamicAPI;
+const utils_1 = require("./utils");
+function wrapParathnessIfNeeded(hasChainAccess, j, expression) {
+    return hasChainAccess ? j.parenthesizedExpression(expression) : expression;
+}
+function transformDynamicAPI(source, api, filePath) {
+    const j = api.jscodeshift.withParser('tsx');
+    const root = j(source);
+    let modified = false;
+    // Check if 'use' from 'react' needs to be imported
+    let needsReactUseImport = false;
+    const insertedTypes = new Set();
+    function isImportedInModule(path, functionName) {
+        const closestDef = j(path)
+            .closestScope()
+            .findVariableDeclarators(functionName);
+        return closestDef.size() === 0;
+    }
+    function processAsyncApiCalls(asyncRequestApiName, originRequestApiName) {
+        // Process each call to cookies() or headers()
+        root
+            .find(j.CallExpression, {
+            callee: {
+                type: 'Identifier',
+                name: asyncRequestApiName,
+            },
+        })
+            .forEach((path) => {
+            var _a, _b, _c;
+            const isImportedTopLevel = isImportedInModule(path, asyncRequestApiName);
+            if (!isImportedTopLevel) {
+                return;
+            }
+            const closetScope = j(path).closestScope();
+            // First search the closed function of the current path
+            let closestFunction;
+            closestFunction = j(path).closest(j.FunctionDeclaration);
+            if (closestFunction.size() === 0) {
+                closestFunction = j(path).closest(j.FunctionExpression);
+            }
+            if (closestFunction.size() === 0) {
+                closestFunction = j(path).closest(j.ArrowFunctionExpression);
+            }
+            const isAsyncFunction = closestFunction
+                .nodes()
+                .some((node) => node.async);
+            const isCallAwaited = ((_b = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.node) === null || _b === void 0 ? void 0 : _b.type) === 'AwaitExpression';
+            const hasChainAccess = path.parentPath.value.type === 'MemberExpression' &&
+                path.parentPath.value.object === path.node;
+            // For cookies/headers API, only transform server and shared components
+            if (isAsyncFunction) {
+                if (!isCallAwaited) {
+                    // Add 'await' in front of cookies() call
+                    const expr = j.awaitExpression(
+                    // add parentheses to wrap the function call
+                    j.callExpression(j.identifier(asyncRequestApiName), []));
+                    j(path).replaceWith(wrapParathnessIfNeeded(hasChainAccess, j, expr));
+                    modified = true;
+                }
+            }
+            else {
+                // Determine if the function is an export
+                const closetScopePath = closetScope.get();
+                const isFromExport = (0, utils_1.isMatchedFunctionExported)(closetScopePath, j);
+                const closestFunctionNode = closetScope.size()
+                    ? closetScopePath.node
+                    : null;
+                // If it's exporting a function directly, exportFunctionNode is same as exportNode
+                // e.g. export default function MyComponent() {}
+                // If it's exporting a variable declaration, exportFunctionNode is the function declaration
+                // e.g. export const MyComponent = function() {}
+                let exportFunctionNode;
+                if (isFromExport) {
+                    if (closestFunctionNode &&
+                        (0, utils_1.isFunctionType)(closestFunctionNode.type)) {
+                        exportFunctionNode = closestFunctionNode;
+                    }
+                }
+                else {
+                    // Is normal async function
+                    exportFunctionNode = closestFunctionNode;
+                }
+                let canConvertToAsync = false;
+                // check if current path is under the default export function
+                if (isFromExport) {
+                    // if default export function is not async, convert it to async, and await the api call
+                    if (!isCallAwaited) {
+                        // If the scoped function is async function
+                        if ((0, utils_1.isFunctionType)(exportFunctionNode.type) &&
+                            exportFunctionNode.async === false) {
+                            canConvertToAsync = true;
+                            exportFunctionNode.async = true;
+                        }
+                        if (canConvertToAsync) {
+                            const expr = j.awaitExpression(j.callExpression(j.identifier(asyncRequestApiName), []));
+                            j(path).replaceWith(wrapParathnessIfNeeded(hasChainAccess, j, expr));
+                            (0, utils_1.turnFunctionReturnTypeToAsync)(closetScopePath.node, j);
+                            modified = true;
+                        }
+                    }
+                }
+                else {
+                    // if parent is function and it's a hook, which starts with 'use', wrap the api call with 'use()'
+                    const parentFunction = j(path).closest(j.FunctionDeclaration) ||
+                        j(path).closest(j.FunctionExpression) ||
+                        j(path).closest(j.ArrowFunctionExpression);
+                    if (parentFunction.size() > 0) {
+                        const parentFunctionName = (_c = parentFunction.get().node.id) === null || _c === void 0 ? void 0 : _c.name;
+                        const isParentFunctionHook = parentFunctionName === null || parentFunctionName === void 0 ? void 0 : parentFunctionName.startsWith('use');
+                        if (isParentFunctionHook) {
+                            j(path).replaceWith(j.callExpression(j.identifier('use'), [
+                                j.callExpression(j.identifier(asyncRequestApiName), []),
+                            ]));
+                            needsReactUseImport = true;
+                        }
+                        else {
+                            castTypesOrAddComment(j, path, originRequestApiName, root, filePath, insertedTypes);
+                        }
+                    }
+                    else {
+                        castTypesOrAddComment(j, path, originRequestApiName, root, filePath, insertedTypes);
+                    }
+                    modified = true;
+                }
+            }
+        });
+    }
+    const isClientComponent = (0, utils_1.determineClientDirective)(root, j, source);
+    const importedNextAsyncRequestApisMapping = findImportMappingFromNextHeaders(root, j);
+    // Only transform the valid calls in server or shared components
+    if (!isClientComponent) {
+        for (const originName in importedNextAsyncRequestApisMapping) {
+            const aliasName = importedNextAsyncRequestApisMapping[originName];
+            processAsyncApiCalls(aliasName, originName);
+        }
+        // Add import { use } from 'react' if needed and not already imported
+        if (needsReactUseImport) {
+            (0, utils_1.insertReactUseImport)(root, j);
+        }
+    }
+    return modified ? root.toSource() : null;
+}
+// cast to unknown first, then the specific type
+const API_CAST_TYPE_MAP = {
+    cookies: 'UnsafeUnwrappedCookies',
+    headers: 'UnsafeUnwrappedHeaders',
+    draftMode: 'UnsafeUnwrappedDraftMode',
+};
+function castTypesOrAddComment(j, path, originRequestApiName, root, filePath, insertedTypes) {
+    const isTsFile = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+    if (isTsFile) {
+        /* Do type cast for headers, cookies, draftMode
+          import {
+            type UnsafeUnwrappedHeaders,
+            type UnsafeUnwrappedCookies,
+            type UnsafeUnwrappedDraftMode
+          } from 'next/headers'
+          
+          cookies() as unknown as UnsafeUnwrappedCookies
+          headers() as unknown as UnsafeUnwrappedHeaders
+          draftMode() as unknown as UnsafeUnwrappedDraftMode
+          
+          e.g. `<path>` is cookies(), convert it to `(<path> as unknown as UnsafeUnwrappedCookies)`
+        */
+        const targetType = API_CAST_TYPE_MAP[originRequestApiName];
+        const newCastExpression = j.tsAsExpression(j.tsAsExpression(path.node, j.tsUnknownKeyword()), j.tsTypeReference(j.identifier(targetType)));
+        // Replace the original expression with the new cast expression,
+        // also wrap () around the new cast expression.
+        j(path).replaceWith(j.parenthesizedExpression(newCastExpression));
+        // If cast types are not imported, add them to the import list
+        const importDeclaration = root.find(j.ImportDeclaration, {
+            source: { value: 'next/headers' },
+        });
+        if (importDeclaration.size() > 0) {
+            const hasImportedType = importDeclaration
+                .find(j.TSTypeAliasDeclaration, {
+                id: { name: targetType },
+            })
+                .size() > 0 ||
+                importDeclaration
+                    .find(j.ImportSpecifier, {
+                    imported: { name: targetType },
+                })
+                    .size() > 0;
+            if (!hasImportedType && !insertedTypes.has(targetType)) {
+                importDeclaration
+                    .get()
+                    .node.specifiers.push(j.importSpecifier(j.identifier(`type ${targetType}`)));
+                insertedTypes.add(targetType);
+            }
+        }
+    }
+    else {
+        // Otherwise for JS file, leave a message to the user to manually handle the transformation
+        path.node.comments = [
+            j.commentBlock(' TODO: please manually await this call, codemod cannot transform due to undetermined async scope '),
+            ...(path.node.comments || []),
+        ];
+    }
+}
+function findImportMappingFromNextHeaders(root, j) {
+    const mappings = {};
+    // Find the import declaration from 'next/headers'
+    root
+        .find(j.ImportDeclaration, { source: { value: 'next/headers' } })
+        .forEach((importPath) => {
+        const importDeclaration = importPath.node;
+        // Iterate over the specifiers and build the mappings
+        importDeclaration.specifiers.forEach((specifier) => {
+            if (j.ImportSpecifier.check(specifier)) {
+                const importedName = specifier.imported.name; // Original name (e.g., cookies)
+                const localName = specifier.local.name; // Local name (e.g., myCookies or same as importedName)
+                // Add to the mappings
+                mappings[importedName] = localName;
+            }
+        });
+    });
+    return mappings;
+}
+//# sourceMappingURL=next-async-dynamic-api.js.map

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

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDynamicProps = transformDynamicProps;
+const utils_1 = require("./utils");
+const PAGE_PROPS = 'props';
+function isAsyncFunctionDeclaration(path) {
+    const decl = path.value.declaration;
+    const isAsyncFunction = (decl.type === 'FunctionDeclaration' ||
+        decl.type === 'FunctionExpression' ||
+        decl.type === 'ArrowFunctionExpression') &&
+        decl.async;
+    return isAsyncFunction;
+}
+function transformDynamicProps(source, api, _filePath) {
+    let modified = false;
+    const j = api.jscodeshift.withParser('tsx');
+    const root = j(source);
+    // Check if 'use' from 'react' needs to be imported
+    let needsReactUseImport = false;
+    // Based on the prop names
+    // e.g. destruct `params` { slug } = params
+    // e.g. destruct `searchParams `{ search } = searchParams
+    let insertedDestructPropNames = new Set();
+    // Rename props to `prop` argument for the function
+    let insertedRenamedPropFunctionNames = new Set();
+    function processAsyncPropOfEntryFile(isClientComponent) {
+        // find `params` and `searchParams` in file, and transform the access to them
+        function renameAsyncPropIfExisted(path) {
+            var _a;
+            const decl = path.value.declaration;
+            if (decl.type !== 'FunctionDeclaration' &&
+                decl.type !== 'FunctionExpression' &&
+                decl.type !== 'ArrowFunctionExpression') {
+                return;
+            }
+            const params = decl.params;
+            const propertiesMap = new Map();
+            // If there's no first param, return
+            if (params.length !== 1) {
+                return;
+            }
+            const propsIdentifier = (0, utils_1.generateUniqueIdentifier)(PAGE_PROPS, path, j);
+            const currentParam = params[0];
+            // Argument destructuring case
+            if (currentParam.type === 'ObjectPattern') {
+                // Validate if the properties are not `params` and `searchParams`,
+                // if they are, quit the transformation
+                for (const prop of currentParam.properties) {
+                    if ('key' in prop && prop.key.type === 'Identifier') {
+                        const propName = prop.key.name;
+                        if (!utils_1.TARGET_PROP_NAMES.has(propName)) {
+                            return;
+                        }
+                    }
+                }
+                currentParam.properties.forEach((prop) => {
+                    if (
+                    // Could be `Property` or `ObjectProperty`
+                    'key' in prop &&
+                        prop.key.type === 'Identifier') {
+                        const value = 'value' in prop ? prop.value : null;
+                        propertiesMap.set(prop.key.name, value);
+                    }
+                });
+                const paramTypeAnnotation = currentParam.typeAnnotation;
+                if (paramTypeAnnotation && paramTypeAnnotation.typeAnnotation) {
+                    const typeAnnotation = paramTypeAnnotation.typeAnnotation;
+                    if (typeAnnotation.type === 'TSTypeLiteral') {
+                        const typeLiteral = typeAnnotation;
+                        // Find the type property for `params`
+                        typeLiteral.members.forEach((member) => {
+                            if (member.type === 'TSPropertySignature' &&
+                                member.key.type === 'Identifier' &&
+                                propertiesMap.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 `params` type in Promise<>
+                                if (member.typeAnnotation &&
+                                    member.typeAnnotation.typeAnnotation &&
+                                    j.TSType.check(member.typeAnnotation.typeAnnotation)) {
+                                    member.typeAnnotation.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
+                                        // @ts-ignore
+                                        member.typeAnnotation.typeAnnotation,
+                                    ]));
+                                }
+                            }
+                        });
+                    }
+                    else if (typeAnnotation.type === 'TSTypeReference') {
+                        // If typeAnnotation is a type or interface, change the properties to Promise<type of property>
+                        // e.g. interface PageProps { params: { slug: string } } => interface PageProps { params: Promise<{ slug: string }> }
+                        const typeReference = typeAnnotation;
+                        if (typeReference.typeName.type === 'Identifier') {
+                            // Find the actual type of the type reference
+                            const foundTypes = findAllTypes(root, j, typeReference.typeName.name);
+                            // Deal with interfaces
+                            if (foundTypes.interfaces.length > 0) {
+                                const interfaceDeclaration = foundTypes.interfaces[0];
+                                if (interfaceDeclaration.type === 'TSInterfaceDeclaration' &&
+                                    ((_a = interfaceDeclaration.body) === null || _a === void 0 ? void 0 : _a.type) === 'TSInterfaceBody') {
+                                    const typeBody = interfaceDeclaration.body.body;
+                                    // if it's already a Promise, don't wrap it again, return
+                                    // traverse the typeReference's properties, if any is in propNames, wrap it in Promise<> if needed
+                                    typeBody.forEach((member) => {
+                                        var _a, _b, _c;
+                                        if (member.type === 'TSPropertySignature' &&
+                                            member.key.type === 'Identifier' &&
+                                            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 &&
+                                                ((_c = (_b = (_a = member.typeAnnotation) === null || _a === void 0 ? void 0 : _a.typeAnnotation) === null || _b === void 0 ? void 0 : _b.typeName) === null || _c === void 0 ? void 0 : _c.name) === 'Promise') {
+                                                return;
+                                            }
+                                            // Wrap the prop type in Promise<>
+                                            if (member.typeAnnotation &&
+                                                member.typeAnnotation.typeAnnotation &&
+                                                // check if member name is in propNames
+                                                utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
+                                                member.typeAnnotation.typeAnnotation =
+                                                    j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
+                                                        member.typeAnnotation.typeAnnotation,
+                                                    ]));
+                                            }
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    propsIdentifier.typeAnnotation = paramTypeAnnotation;
+                }
+                // Override the first param to `props`
+                params[0] = propsIdentifier;
+                modified = true;
+            }
+            if (modified) {
+                resolveAsyncProp(path, propertiesMap, propsIdentifier.name);
+            }
+        }
+        function getBodyOfFunctionDeclaration(path) {
+            const decl = path.value.declaration;
+            let functionBody;
+            if (decl.type === 'FunctionDeclaration' ||
+                decl.type === 'FunctionExpression' ||
+                decl.type === 'ArrowFunctionExpression') {
+                if (decl.body && decl.body.type === 'BlockStatement') {
+                    functionBody = decl.body.body;
+                }
+            }
+            return functionBody;
+        }
+        // Helper function to insert `const params = await asyncParams;` at the beginning of the function body
+        function resolveAsyncProp(path, propertiesMap, propsIdentifierName) {
+            var _a;
+            const isDefaultExport = path.value.type === 'ExportDefaultDeclaration';
+            // If it's sync default export, and it's also server component, make the function async
+            if (isDefaultExport &&
+                !isClientComponent &&
+                !isAsyncFunctionDeclaration(path)) {
+                if ('async' in path.value.declaration) {
+                    path.value.declaration.async = true;
+                    (0, utils_1.turnFunctionReturnTypeToAsync)(path.value.declaration, j);
+                }
+            }
+            const isAsyncFunc = isAsyncFunctionDeclaration(path);
+            // @ts-ignore quick way to check if it's a function and it has a name
+            const functionName = ((_a = path.value.declaration.id) === null || _a === void 0 ? void 0 : _a.name) || 'default';
+            const functionBody = getBodyOfFunctionDeclaration(path);
+            for (const [propName, paramsProperty] of propertiesMap) {
+                const propNameIdentifier = j.identifier(propName);
+                const propsIdentifier = j.identifier(propsIdentifierName);
+                const accessedPropId = j.memberExpression(propsIdentifier, propNameIdentifier);
+                // Check param property value, if it's destructed, we need to destruct it as well
+                // e.g.
+                // input: Page({ params: { slug } })
+                // output: const { slug } = await props.params; rather than const props = await props.params;
+                const uid = functionName + ':' + propName;
+                if ((paramsProperty === null || paramsProperty === void 0 ? void 0 : paramsProperty.type) === 'ObjectPattern') {
+                    const objectPattern = paramsProperty;
+                    const objectPatternProperties = objectPattern.properties;
+                    // destruct the object pattern, e.g. { slug } => const { slug } = params;
+                    const destructedObjectPattern = j.variableDeclaration('const', [
+                        j.variableDeclarator(j.objectPattern(objectPatternProperties.map((prop) => {
+                            if (prop.type === 'Property' &&
+                                prop.key.type === 'Identifier') {
+                                return j.objectProperty(j.identifier(prop.key.name), j.identifier(prop.key.name));
+                            }
+                            return prop;
+                        })), propNameIdentifier),
+                    ]);
+                    if (!insertedDestructPropNames.has(uid) && functionBody) {
+                        functionBody.unshift(destructedObjectPattern);
+                        insertedDestructPropNames.add(uid);
+                    }
+                }
+                if (isAsyncFunc) {
+                    // If it's async function, add await to the async props.<propName>
+                    const paramAssignment = j.variableDeclaration('const', [
+                        j.variableDeclarator(j.identifier(propName), j.awaitExpression(accessedPropId)),
+                    ]);
+                    if (!insertedRenamedPropFunctionNames.has(uid) && functionBody) {
+                        functionBody.unshift(paramAssignment);
+                        insertedRenamedPropFunctionNames.add(uid);
+                    }
+                }
+                else {
+                    const isFromExport = path.value.type === 'ExportNamedDeclaration';
+                    if (isFromExport) {
+                        // If it's export function, populate the function to async
+                        if ((0, utils_1.isFunctionType)(path.value.declaration.type) &&
+                            // Make TS happy
+                            'async' in path.value.declaration) {
+                            path.value.declaration.async = true;
+                            (0, utils_1.turnFunctionReturnTypeToAsync)(path.value.declaration, j);
+                            // Insert `const <propName> = await props.<propName>;` at the beginning of the function body
+                            const paramAssignment = j.variableDeclaration('const', [
+                                j.variableDeclarator(j.identifier(propName), j.awaitExpression(accessedPropId)),
+                            ]);
+                            if (!insertedRenamedPropFunctionNames.has(uid) && functionBody) {
+                                functionBody.unshift(paramAssignment);
+                                insertedRenamedPropFunctionNames.add(uid);
+                            }
+                        }
+                    }
+                    else {
+                        const paramAssignment = j.variableDeclaration('const', [
+                            j.variableDeclarator(j.identifier(propName), j.callExpression(j.identifier('use'), [accessedPropId])),
+                        ]);
+                        if (!insertedRenamedPropFunctionNames.has(uid) && functionBody) {
+                            needsReactUseImport = true;
+                            functionBody.unshift(paramAssignment);
+                            insertedRenamedPropFunctionNames.add(uid);
+                        }
+                    }
+                }
+            }
+        }
+        // Process Function Declarations
+        // Matching: default export function XXX(...) { ... }
+        const defaultExportFunctionDeclarations = root.find(j.ExportDefaultDeclaration, {
+            declaration: {
+                type: (type) => type === 'FunctionDeclaration' ||
+                    type === 'FunctionExpression' ||
+                    type === 'ArrowFunctionExpression',
+            },
+        });
+        defaultExportFunctionDeclarations.forEach((path) => {
+            renameAsyncPropIfExisted(path);
+        });
+        // Matching Next.js functional named export of route entry:
+        // - export function <named>(...) { ... }
+        // - export const <named> = ...
+        const targetNamedExportDeclarations = root.find(j.ExportNamedDeclaration, 
+        // Filter the name is in TARGET_NAMED_EXPORTS
+        {
+            declaration: {
+                id: {
+                    name: (idName) => {
+                        return utils_1.TARGET_NAMED_EXPORTS.has(idName);
+                    },
+                },
+            },
+        });
+        targetNamedExportDeclarations.forEach((path) => {
+            renameAsyncPropIfExisted(path);
+        });
+        // TDOO: handle targetNamedDeclarators
+        // const targetNamedDeclarators = root.find(
+        //   j.VariableDeclarator,
+        //   (node) =>
+        //     node.id.type === 'Identifier' &&
+        //     TARGET_NAMED_EXPORTS.has(node.id.name)
+        // )
+    }
+    const isClientComponent = (0, utils_1.determineClientDirective)(root, j, source);
+    // Apply to `params` and `searchParams`
+    processAsyncPropOfEntryFile(isClientComponent);
+    // Add import { use } from 'react' if needed and not already imported
+    if (needsReactUseImport) {
+        (0, utils_1.insertReactUseImport)(root, j);
+    }
+    return modified ? root.toSource() : null;
+}
+function findAllTypes(root, j, typeName) {
+    const types = {
+        interfaces: [],
+        typeAliases: [],
+        imports: [],
+        references: [],
+    };
+    // Step 1: Find all interface declarations with the specified name
+    root
+        .find(j.TSInterfaceDeclaration, {
+        id: {
+            type: 'Identifier',
+            name: typeName,
+        },
+    })
+        .forEach((path) => {
+        types.interfaces.push(path.node);
+    });
+    // Step 2: Find all type alias declarations with the specified name
+    root
+        .find(j.TSTypeAliasDeclaration, {
+        id: {
+            type: 'Identifier',
+            name: typeName,
+        },
+    })
+        .forEach((path) => {
+        types.typeAliases.push(path.node);
+    });
+    // Step 3: Find all imported types with the specified name
+    root
+        .find(j.ImportSpecifier, {
+        imported: {
+            type: 'Identifier',
+            name: typeName,
+        },
+    })
+        .forEach((path) => {
+        types.imports.push(path.node);
+    });
+    // Step 4: Find all references to the specified type
+    root
+        .find(j.TSTypeReference, {
+        typeName: {
+            type: 'Identifier',
+            name: typeName,
+        },
+    })
+        .forEach((path) => {
+        types.references.push(path.node);
+    });
+    return types;
+}
+//# sourceMappingURL=next-async-dynamic-prop.js.map

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

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TARGET_PROP_NAMES = exports.TARGET_NAMED_EXPORTS = void 0;
+exports.isFunctionType = isFunctionType;
+exports.isMatchedFunctionExported = isMatchedFunctionExported;
+exports.determineClientDirective = determineClientDirective;
+exports.isPromiseType = isPromiseType;
+exports.turnFunctionReturnTypeToAsync = turnFunctionReturnTypeToAsync;
+exports.insertReactUseImport = insertReactUseImport;
+exports.generateUniqueIdentifier = generateUniqueIdentifier;
+exports.TARGET_NAMED_EXPORTS = new Set([
+    // For custom route
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'OPTIONS',
+    // For page and layout
+    'generateMetadata',
+]);
+exports.TARGET_PROP_NAMES = new Set(['params', 'searchParams']);
+function isFunctionType(type) {
+    return (type === 'FunctionDeclaration' ||
+        type === 'FunctionExpression' ||
+        type === 'ArrowFunctionExpression');
+}
+function isMatchedFunctionExported(path, j) {
+    const matchedFunctionNameFilter = (idName) => exports.TARGET_NAMED_EXPORTS.has(idName);
+    const directNamedExport = j(path).closest(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'FunctionDeclaration',
+            id: {
+                name: matchedFunctionNameFilter,
+            },
+        },
+    });
+    if (directNamedExport.size() > 0) {
+        return true;
+    }
+    // Check for default export (`export default function() {}`)
+    const isDefaultExport = j(path).closest(j.ExportDefaultDeclaration).size() > 0;
+    if (isDefaultExport) {
+        return true;
+    }
+    // Look for named export elsewhere in the file (`export { <named> }`)
+    const root = j(path).closestScope().closest(j.Program);
+    const isNamedExport = root
+        .find(j.ExportNamedDeclaration, {
+        specifiers: [
+            {
+                type: 'ExportSpecifier',
+                exported: {
+                    name: matchedFunctionNameFilter,
+                },
+            },
+        ],
+    })
+        .size() > 0;
+    // Look for variable export but still function, e.g. `export const <named> = function() {}`,
+    // also check if variable is a function or arrow function
+    const isVariableExport = root
+        .find(j.ExportNamedDeclaration, {
+        declaration: {
+            declarations: [
+                {
+                    type: 'VariableDeclarator',
+                    id: {
+                        type: 'Identifier',
+                        name: matchedFunctionNameFilter,
+                    },
+                    init: {
+                        type: isFunctionType,
+                    },
+                },
+            ],
+        },
+    })
+        .size() > 0;
+    if (isVariableExport)
+        return true;
+    return isNamedExport;
+}
+function determineClientDirective(root, j, source) {
+    const hasStringDirective = root
+        .find(j.Literal)
+        .filter((path) => {
+        const expr = path.node;
+        return (expr.value === 'use client' && path.parentPath.node.type === 'Program');
+    })
+        .size() > 0;
+    // 'use client';
+    const hasStringDirectiveWithSemicolon = root
+        .find(j.StringLiteral)
+        .filter((path) => {
+        const expr = path.node;
+        return (expr.type === 'StringLiteral' &&
+            expr.value === 'use client' &&
+            path.parentPath.node.type === 'Program');
+    })
+        .size() > 0;
+    if (hasStringDirective || hasStringDirectiveWithSemicolon)
+        return true;
+    // Since the client detection is not reliable with AST in jscodeshift,
+    // determine if 'use client' or "use client" is leading in the source code.
+    const trimmedSource = source.trim();
+    const containsClientDirective = /^'use client'/.test(trimmedSource) || /^"use client"/g.test(trimmedSource);
+    return containsClientDirective;
+}
+function isPromiseType(typeAnnotation) {
+    return (typeAnnotation.type === 'TSTypeReference' &&
+        typeAnnotation.typeName.name === 'Promise');
+}
+function turnFunctionReturnTypeToAsync(node, j) {
+    if (j.FunctionDeclaration.check(node) ||
+        j.FunctionExpression.check(node) ||
+        j.ArrowFunctionExpression.check(node)) {
+        if (node.returnType) {
+            const returnTypeAnnotation = node.returnType.typeAnnotation;
+            const isReturnTypePromise = isPromiseType(returnTypeAnnotation);
+            // Turn <return type> to Promise<return type>
+            // e.g. () => { slug: string } to () => Promise<{ slug: string }>
+            // e.g. Anything to Promise<Anything>
+            if (!isReturnTypePromise) {
+                if (node.returnType &&
+                    j.TSTypeAnnotation.check(node.returnType) &&
+                    (j.TSTypeReference.check(node.returnType.typeAnnotation) ||
+                        j.TSUnionType.check(node.returnType.typeAnnotation) ||
+                        j.TSTypePredicate.check(node.returnType.typeAnnotation))) {
+                    // Change the return type to Promise<void>
+                    node.returnType.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), 
+                    // @ts-ignore ignore the super strict type checking on the type annotation
+                    j.tsTypeParameterInstantiation([returnTypeAnnotation]));
+                }
+            }
+        }
+    }
+}
+function insertReactUseImport(root, j) {
+    const hasReactUseImport = root
+        .find(j.ImportSpecifier, {
+        imported: {
+            type: 'Identifier',
+            name: 'use',
+        },
+    })
+        .size() > 0;
+    if (!hasReactUseImport) {
+        const reactImportDeclaration = root.find(j.ImportDeclaration, {
+            source: {
+                type: 'Literal',
+                value: 'react',
+            },
+        });
+        if (reactImportDeclaration.size() > 0) {
+            // Add 'use' to existing 'react' import declaration
+            reactImportDeclaration
+                .get()
+                .node.specifiers.push(j.importSpecifier(j.identifier('use')));
+        }
+        else {
+            // Final all type imports to 'react'
+            const reactImport = root.find(j.ImportDeclaration, {
+                source: {
+                    type: 'Literal',
+                    value: 'react',
+                },
+            });
+            if (reactImport.size() > 0) {
+                reactImport
+                    .get()
+                    .node.specifiers.push(j.importSpecifier(j.identifier('use')));
+            }
+            else {
+                // Add new import declaration for 'react' and 'use'
+                root
+                    .get()
+                    .node.program.body.unshift(j.importDeclaration([j.importSpecifier(j.identifier('use'))], j.literal('react')));
+            }
+        }
+    }
+}
+function findSubScopeArgumentIdentifier(path, j, argName) {
+    const defCount = j(path).find(j.Identifier, { name: argName }).size();
+    return defCount > 0;
+}
+function generateUniqueIdentifier(defaultIdName, path, j) {
+    let idName = defaultIdName;
+    let idNameSuffix = 0;
+    while (findSubScopeArgumentIdentifier(path, j, idName)) {
+        idName = defaultIdName + idNameSuffix;
+        idNameSuffix++;
+    }
+    const propsIdentifier = j.identifier(idName);
+    return propsIdentifier;
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var index_1 = require("./lib/async-request-api/index");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_1).default; } });
+//# sourceMappingURL=next-async-request-api.js.map

package/transforms/next-request-geo-ip.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const GEO = 'geo';
+const IP = 'ip';
+const GEOLOCATION = 'geolocation';
+const IP_ADDRESS = 'ipAddress';
+const GEO_TYPE = 'Geo';
+function default_1(fileInfo, api) {
+    const j = api.jscodeshift.withParser('tsx');
+    const root = j(fileInfo.source);
+    if (!root.length) {
+        return fileInfo.source;
+    }
+    const nextReqType = root
+        .find(j.FunctionDeclaration)
+        .find(j.Identifier, (id) => {
+        var _a;
+        if (((_a = id.typeAnnotation) === null || _a === void 0 ? void 0 : _a.type) !== 'TSTypeAnnotation') {
+            return false;
+        }
+        const typeAnn = id.typeAnnotation.typeAnnotation;
+        return (typeAnn.type === 'TSTypeReference' &&
+            typeAnn.typeName.type === 'Identifier' &&
+            typeAnn.typeName.name === 'NextRequest');
+    });
+    const vercelFuncImports = root.find(j.ImportDeclaration, {
+        source: {
+            value: '@vercel/functions',
+        },
+    });
+    const vercelFuncImportSpecifiers = vercelFuncImports
+        .find(j.ImportSpecifier)
+        .nodes();
+    const vercelFuncImportNames = new Set(vercelFuncImportSpecifiers.map((node) => node.imported.name));
+    const hasGeolocation = vercelFuncImportNames.has(GEOLOCATION);
+    const hasIpAddress = vercelFuncImportNames.has(IP_ADDRESS);
+    const hasGeoType = vercelFuncImportNames.has(GEO_TYPE);
+    let identifierNames = new Set();
+    // if all identifiers are already imported, we don't need to create
+    // a unique identifier for them, therefore we don't look for all
+    // identifier names in the file
+    if (!hasGeolocation || !hasIpAddress || !hasGeoType) {
+        const allIdentifiers = root.find(j.Identifier).nodes();
+        identifierNames = new Set(allIdentifiers.map((node) => node.name));
+    }
+    let geoIdentifier = hasGeolocation
+        ? getExistingIdentifier(vercelFuncImportSpecifiers, GEOLOCATION)
+        : getUniqueIdentifier(identifierNames, GEOLOCATION);
+    let ipIdentifier = hasIpAddress
+        ? getExistingIdentifier(vercelFuncImportSpecifiers, IP_ADDRESS)
+        : getUniqueIdentifier(identifierNames, IP_ADDRESS);
+    let geoTypeIdentifier = hasGeoType
+        ? getExistingIdentifier(vercelFuncImportSpecifiers, GEO_TYPE)
+        : getUniqueIdentifier(identifierNames, GEO_TYPE);
+    let { needImportGeolocation, needImportIpAddress } = replaceGeoIpValues(j, nextReqType, geoIdentifier, ipIdentifier);
+    let { needImportGeoType, hasChangedIpType } = replaceGeoIpTypes(j, root, geoTypeIdentifier);
+    let needChanges = needImportGeolocation ||
+        needImportIpAddress ||
+        needImportGeoType ||
+        hasChangedIpType;
+    if (!needChanges) {
+        return fileInfo.source;
+    }
+    // Even if there was a change above, if there's an existing import,
+    // we don't need to import them again.
+    needImportGeolocation = !hasGeolocation && needImportGeolocation;
+    needImportIpAddress = !hasIpAddress && needImportIpAddress;
+    needImportGeoType = !hasGeoType && needImportGeoType;
+    insertImportDeclarations(j, root, vercelFuncImports, needImportGeolocation, needImportIpAddress, needImportGeoType, geoIdentifier, ipIdentifier, geoTypeIdentifier);
+    return root.toSource();
+}
+/**
+ * Returns an existing identifier from the Vercel functions import declaration.
+ */
+function getExistingIdentifier(vercelFuncImportSpecifiers, identifier) {
+    var _a;
+    const existingIdentifier = vercelFuncImportSpecifiers.find((node) => node.imported.name === identifier);
+    return (((_a = existingIdentifier === null || existingIdentifier === void 0 ? void 0 : existingIdentifier.local) === null || _a === void 0 ? void 0 : _a.name) ||
+        existingIdentifier.imported.name ||
+        identifier);
+}
+/**
+ * Returns a unique identifier by adding a suffix to the original identifier
+ * if it already exists in the set.
+ */
+function getUniqueIdentifier(identifierNames, identifier) {
+    let suffix = 1;
+    let uniqueIdentifier = identifier;
+    while (identifierNames.has(uniqueIdentifier)) {
+        uniqueIdentifier = `${identifier}${suffix}`;
+        suffix++;
+    }
+    return uniqueIdentifier;
+}
+/**
+ * Replaces accessors `geo` and `ip` of NextRequest with corresponding
+ * function calls from `@vercel/functions`.
+ *
+ * Creates new variable declarations for destructuring assignments.
+ */
+function replaceGeoIpValues(j, nextReqType, geoIdentifier, ipIdentifier) {
+    let needImportGeolocation = false;
+    let needImportIpAddress = false;
+    for (const nextReqPath of nextReqType.paths()) {
+        const fnPath = nextReqPath.parentPath.parentPath;
+        const fn = j(fnPath);
+        const blockStatement = fn.find(j.BlockStatement);
+        const varDeclarators = fn.find(j.VariableDeclarator);
+        // req.geo, req.ip
+        const geoAccesses = blockStatement.find(j.MemberExpression, (me) => me.object.type === 'Identifier' &&
+            me.object.name === nextReqPath.node.name &&
+            me.property.type === 'Identifier' &&
+            me.property.name === GEO);
+        const ipAccesses = blockStatement.find(j.MemberExpression, (me) => me.object.type === 'Identifier' &&
+            me.object.name === nextReqPath.node.name &&
+            me.property.type === 'Identifier' &&
+            me.property.name === IP);
+        // var { geo, ip } = req
+        const geoDestructuring = varDeclarators.filter((path) => path.node.id.type === 'ObjectPattern' &&
+            path.node.id.properties.some((prop) => prop.type === 'ObjectProperty' &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === GEO));
+        const ipDestructuring = varDeclarators.filter((path) => path.node.id.type === 'ObjectPattern' &&
+            path.node.id.properties.some((prop) => prop.type === 'ObjectProperty' &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === IP));
+        // geolocation(req), ipAddress(req)
+        const geoCall = j.callExpression(j.identifier(geoIdentifier), [
+            Object.assign(Object.assign({}, nextReqPath.node), { typeAnnotation: null }),
+        ]);
+        const ipCall = j.callExpression(j.identifier(ipIdentifier), [
+            Object.assign(Object.assign({}, nextReqPath.node), { typeAnnotation: null }),
+        ]);
+        geoAccesses.replaceWith(geoCall);
+        ipAccesses.replaceWith(ipCall);
+        /**
+         * For each destructuring assignment, we create a new variable
+         * declaration and insert it after the current block statement.
+         *
+         * Before:
+         *
+         * ```
+         * const { buildId, geo, ip } = req;
+         * ```
+         *
+         * After:
+         *
+         * ```
+         * const { buildId } = req;
+         * const geo = geolocation(req);
+         * const ip = ipAddress(req);
+         * ```
+         */
+        geoDestructuring.forEach((path) => {
+            if (path.node.id.type === 'ObjectPattern') {
+                const properties = path.node.id.properties;
+                const geoProperty = properties.find((prop) => prop.type === 'ObjectProperty' &&
+                    prop.key.type === 'Identifier' &&
+                    prop.key.name === GEO);
+                const otherProperties = properties.filter((prop) => prop !== geoProperty);
+                const geoDeclaration = j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier(
+                    // Use alias from destructuring (if present) to retain references:
+                    // const { geo: geoAlias } = req; -> const geoAlias = geolocation(req);
+                    // This prevents errors from undeclared variables.
+                    geoProperty.type === 'ObjectProperty' &&
+                        geoProperty.value.type === 'Identifier'
+                        ? geoProperty.value.name
+                        : GEO), geoCall),
+                ]);
+                path.node.id.properties = otherProperties;
+                path.parent.insertAfter(geoDeclaration);
+            }
+        });
+        ipDestructuring.forEach((path) => {
+            if (path.node.id.type === 'ObjectPattern') {
+                const properties = path.node.id.properties;
+                const ipProperty = properties.find((prop) => prop.type === 'ObjectProperty' &&
+                    prop.key.type === 'Identifier' &&
+                    prop.key.name === IP);
+                const otherProperties = properties.filter((prop) => prop !== ipProperty);
+                const ipDeclaration = j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier(
+                    // Use alias from destructuring (if present) to retain references:
+                    // const { ip: ipAlias } = req; -> const ipAlias = ipAddress(req);
+                    // This prevents errors from undeclared variables.
+                    ipProperty.type === 'ObjectProperty' &&
+                        ipProperty.value.type === 'Identifier'
+                        ? ipProperty.value.name
+                        : IP), ipCall),
+                ]);
+                path.node.id.properties = otherProperties;
+                path.parent.insertAfter(ipDeclaration);
+            }
+        });
+        needImportGeolocation =
+            needImportGeolocation ||
+                geoAccesses.length > 0 ||
+                geoDestructuring.length > 0;
+        needImportIpAddress =
+            needImportIpAddress || ipAccesses.length > 0 || ipDestructuring.length > 0;
+    }
+    return {
+        needImportGeolocation,
+        needImportIpAddress,
+    };
+}
+/**
+ * Replaces the types of `NextRequest["geo"]` and `NextRequest["ip"]` with
+ * corresponding types from `@vercel/functions`.
+ */
+function replaceGeoIpTypes(j, root, geoTypeIdentifier) {
+    let needImportGeoType = false;
+    let hasChangedIpType = false;
+    // get the type of NextRequest that has accessed for ip and geo
+    // NextRequest['geo'], NextRequest['ip']
+    const nextReqGeoType = root.find(j.TSIndexedAccessType, (tsIndexedAccessType) => {
+        return (tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
+            tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
+            tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
+            tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
+            tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
+            tsIndexedAccessType.indexType.literal.value === GEO);
+    });
+    const nextReqIpType = root.find(j.TSIndexedAccessType, (tsIndexedAccessType) => {
+        return (tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
+            tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
+            tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
+            tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
+            tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
+            tsIndexedAccessType.indexType.literal.value === IP);
+    });
+    if (nextReqGeoType.length > 0) {
+        needImportGeoType = true;
+        // replace with type Geo
+        nextReqGeoType.replaceWith(j.identifier(geoTypeIdentifier));
+    }
+    if (nextReqIpType.length > 0) {
+        hasChangedIpType = true;
+        // replace with type string | undefined
+        nextReqIpType.replaceWith(j.tsUnionType([j.tsStringKeyword(), j.tsUndefinedKeyword()]));
+    }
+    return {
+        needImportGeoType,
+        hasChangedIpType,
+    };
+}
+/**
+ * Inserts import declarations from `"@vercel/functions"`.
+ *
+ * For the `Geo` type that needs to be imported to replace `NextRequest["geo"]`,
+ * if it is the only import needed, we import it as a type.
+ *
+ * ```ts
+ * import type { Geo } from "@vercel/functions";
+ * ```
+ *
+ * Otherwise, we import it as an inline type import.
+ *
+ * ```ts
+ * import { type Geo, ... } from "@vercel/functions";
+ * ```
+ */
+function insertImportDeclarations(j, root, vercelFuncImports, needImportGeolocation, needImportIpAddress, needImportGeoType, geoIdentifier, ipIdentifier, geoTypeIdentifier) {
+    // No need inserting import.
+    if (!needImportGeolocation && !needImportIpAddress && !needImportGeoType) {
+        return;
+    }
+    // As we run this only when `NextRequest` is imported, there should be
+    // a "next/server" import.
+    const firstNextServerImport = root
+        .find(j.ImportDeclaration, { source: { value: 'next/server' } })
+        .at(0);
+    const firstVercelFuncImport = vercelFuncImports.at(0);
+    const hasVercelFuncImport = firstVercelFuncImport.length > 0;
+    // If there's no "@vercel/functions" import, and we only need to import
+    // `Geo` type, we create a type import to avoid side effect with
+    // `verbatimModuleSyntax`.
+    // x-ref: https://typescript-eslint.io/rules/no-import-type-side-effects
+    if (!hasVercelFuncImport &&
+        !needImportGeolocation &&
+        !needImportIpAddress &&
+        needImportGeoType) {
+        const geoTypeImportDeclaration = j.importDeclaration([
+            needImportGeoType
+                ? j.importSpecifier(j.identifier(GEO_TYPE), j.identifier(geoTypeIdentifier))
+                : null,
+        ].filter(Boolean), j.literal('@vercel/functions'), 
+        // import type { Geo } ...
+        'type');
+        firstNextServerImport.insertAfter(geoTypeImportDeclaration);
+        return;
+    }
+    const importDeclaration = j.importDeclaration([
+        // If there was a duplicate identifier, we add an
+        // incremental number suffix to it and we use alias:
+        // `import { geolocation as geolocation1 } from ...`
+        needImportGeolocation
+            ? j.importSpecifier(j.identifier(GEOLOCATION), j.identifier(geoIdentifier))
+            : null,
+        needImportIpAddress
+            ? j.importSpecifier(j.identifier(IP_ADDRESS), j.identifier(ipIdentifier))
+            : null,
+        needImportGeoType
+            ? j.importSpecifier(j.identifier(GEO_TYPE), j.identifier(geoTypeIdentifier))
+            : null,
+    ].filter(Boolean), j.literal('@vercel/functions'));
+    if (hasVercelFuncImport) {
+        firstVercelFuncImport
+            .get()
+            .node.specifiers.push(...importDeclaration.specifiers);
+        if (needImportGeoType) {
+            const targetGeo = firstVercelFuncImport
+                .get()
+                .node.specifiers.find((specifier) => specifier.imported.name === GEO_TYPE);
+            if (targetGeo) {
+                targetGeo.importKind = 'type';
+            }
+        }
+    }
+    else {
+        if (needImportGeoType) {
+            const targetGeo = importDeclaration.specifiers.find((specifier) => specifier.type === 'ImportSpecifier' &&
+                specifier.imported.name === GEO_TYPE);
+            if (targetGeo) {
+                // @ts-expect-error -- Missing types in jscodeshift.
+                targetGeo.importKind = 'type';
+            }
+        }
+        firstNextServerImport.insertAfter(importDeclaration);
+    }
+}
+//# sourceMappingURL=next-request-geo-ip.js.map