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

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,10 @@ 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-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.163",
   "license": "MIT",
   "repository": {
     "type": "git",

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