@next/codemod 16.0.0-canary.4 → 16.0.0-canary.5

package/package.json

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

package/transforms/middleware-to-proxy.js

@@ -4,20 +4,257 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = transformer;
-const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const utils_1 = require("./lib/utils");
 const parser_1 = require("../lib/parser");
+// Middleware config properties that need to be renamed to proxy equivalents
+const CONFIG_PROPERTY_MAP = {
+    middlewarePrefetch: 'proxyPrefetch',
+    middlewareClientMaxBodySize: 'proxyClientMaxBodySize',
+    externalMiddlewareRewritesResolve: 'externalProxyRewritesResolve',
+    skipMiddlewareUrlNormalize: 'skipProxyUrlNormalize',
+};
+// Type imports from 'next/server' that need to be transformed
+const MIDDLEWARE_TYPE_IMPORT_MAP = {
+    NextMiddleware: 'NextProxy',
+    MiddlewareConfig: 'ProxyConfig',
+};
 function transformer(file) {
-    if (!/(^|[/\\])middleware\.|[/\\]src[/\\]middleware\./.test(file.path) &&
-        // fixtures have unique basenames in test
-        process.env.NODE_ENV !== 'test') {
-        return file.source;
-    }
     const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
     if (!root.length) {
         return file.source;
     }
+    const isNextConfig = (0, utils_1.isNextConfigFile)(file) ||
+        (process.env.NODE_ENV === 'test' && /next-config-/.test(file.path));
+    const isMiddlewareFile = /(^|[/\\])middleware\.|[/\\]src[/\\]middleware\./.test(file.path) ||
+        (process.env.NODE_ENV === 'test' && !isNextConfig);
+    const hasMiddlewareTypeImports = checkForNextServerTypeImports(root, j);
+    // In test mode, process all files. Otherwise, only process relevant files
+    if (process.env.NODE_ENV !== 'test') {
+        if (!isMiddlewareFile && !isNextConfig && !hasMiddlewareTypeImports) {
+            return file.source;
+        }
+    }
+    let hasChanges = false;
+    if (hasMiddlewareTypeImports) {
+        const typeImportChanges = transformMiddlewareTypeImports(root, j);
+        hasChanges = hasChanges || typeImportChanges;
+    }
+    if (isMiddlewareFile) {
+        const middlewareChanges = transformMiddlewareFunction(root, j);
+        hasChanges = hasChanges || middlewareChanges.hasChanges;
+    }
+    if (isNextConfig) {
+        const { hasConfigChanges } = transformNextConfig(root, j);
+        hasChanges = hasChanges || hasConfigChanges;
+    }
+    if (!hasChanges) {
+        return file.source;
+    }
+    const source = root.toSource();
+    // Need to write proxy file and unlink the original middleware file.
+    if (isMiddlewareFile) {
+        return handleMiddlewareFileRename(file, source);
+    }
+    return source;
+}
+function checkForNextServerTypeImports(root, j) {
+    return (root
+        .find(j.ImportDeclaration, {
+        source: { value: 'next/server' },
+    })
+        .find(j.ImportSpecifier)
+        .filter((path) => MIDDLEWARE_TYPE_IMPORT_MAP[path.node.imported.name]).length > 0);
+}
+function transformMiddlewareTypeImports(root, j) {
+    let hasChanges = false;
+    // Transform type imports from 'next/server'
+    root
+        .find(j.ImportDeclaration, {
+        source: { value: 'next/server' },
+    })
+        .forEach((importPath) => {
+        const specifiers = importPath.node.specifiers;
+        if (!specifiers)
+            return;
+        specifiers.forEach((specifier) => {
+            if (j.ImportSpecifier.check(specifier) &&
+                specifier.imported &&
+                MIDDLEWARE_TYPE_IMPORT_MAP[specifier.imported.name]) {
+                const oldImportName = specifier.imported.name;
+                const newImportName = MIDDLEWARE_TYPE_IMPORT_MAP[oldImportName];
+                // Update the local name if it matches the original imported name
+                if (specifier.local && specifier.local.name === oldImportName) {
+                    specifier.local.name = newImportName;
+                }
+                // Transform the import name
+                specifier.imported.name = newImportName;
+                hasChanges = true;
+            }
+        });
+    });
+    // Also transform any type annotations using the old types
+    Object.keys(MIDDLEWARE_TYPE_IMPORT_MAP).forEach((oldType) => {
+        root
+            .find(j.TSTypeReference)
+            .filter((path) => {
+            return (path.node.typeName &&
+                path.node.typeName.type === 'Identifier' &&
+                path.node.typeName.name === oldType);
+        })
+            .forEach((path) => {
+            path.node.typeName.name = MIDDLEWARE_TYPE_IMPORT_MAP[oldType];
+            hasChanges = true;
+        });
+    });
+    return hasChanges;
+}
+function transformNextConfig(root, j) {
+    let hasConfigChanges = false;
+    // Collect config-related object expressions instead of processing all
+    const configObjects = findNextConfigObjects(root, j);
+    configObjects.forEach((objPath) => {
+        const result = processConfigObject(objPath.value);
+        hasConfigChanges = hasConfigChanges || result.hasChanges;
+    });
+    // Process function configurations that are likely to be Next.js config
+    const configFunctions = findNextConfigFunctions(root, j);
+    configFunctions.forEach((path) => {
+        const result = processFunctionConfig(path, j);
+        hasConfigChanges = hasConfigChanges || result.hasChanges;
+    });
+    // Process arrow function configurations that are likely to be Next.js config
+    const configArrowFunctions = findNextConfigArrowFunctions(root, j);
+    configArrowFunctions.forEach((path) => {
+        const result = processArrowFunctionConfig(path, j);
+        hasConfigChanges = hasConfigChanges || result.hasChanges;
+    });
+    // Process direct property assignments: config.experimental.middlewarePrefetch = value
+    Object.keys(CONFIG_PROPERTY_MAP).forEach((oldProp) => {
+        const newProp = CONFIG_PROPERTY_MAP[oldProp];
+        // Handle experimental.* properties
+        if (oldProp.startsWith('middleware') &&
+            oldProp !== 'skipMiddlewareUrlNormalize') {
+            root
+                .find(j.AssignmentExpression, {
+                left: {
+                    type: 'MemberExpression',
+                    object: {
+                        type: 'MemberExpression',
+                        property: { name: 'experimental' },
+                    },
+                    property: { name: oldProp },
+                },
+            })
+                .forEach((path) => {
+                path.node.left.property.name = newProp;
+                hasConfigChanges = true;
+            });
+        }
+        else {
+            // Handle top-level properties like skipMiddlewareUrlNormalize
+            root
+                .find(j.AssignmentExpression, {
+                left: {
+                    type: 'MemberExpression',
+                    property: { name: oldProp },
+                },
+            })
+                .forEach((path) => {
+                path.node.left.property.name = newProp;
+                hasConfigChanges = true;
+            });
+        }
+    });
+    return { hasConfigChanges };
+}
+function processConfigObject(configObj) {
+    let hasChanges = false;
+    // Check for experimental property
+    const experimentalProp = configObj.properties.find((prop) => isStaticProperty(prop) &&
+        prop.key &&
+        prop.key.type === 'Identifier' &&
+        prop.key.name === 'experimental');
+    if (experimentalProp && isStaticProperty(experimentalProp)) {
+        const experimentalObj = experimentalProp.value;
+        if (experimentalObj.type === 'ObjectExpression') {
+            // Transform properties in experimental object
+            experimentalObj.properties.forEach((prop) => {
+                if (isStaticProperty(prop) &&
+                    prop.key &&
+                    prop.key.type === 'Identifier' &&
+                    CONFIG_PROPERTY_MAP[prop.key.name] &&
+                    prop.key.name !== 'skipMiddlewareUrlNormalize' // This is top-level
+                ) {
+                    prop.key.name = CONFIG_PROPERTY_MAP[prop.key.name];
+                    hasChanges = true;
+                }
+            });
+        }
+    }
+    // Transform top-level properties
+    configObj.properties.forEach((prop) => {
+        if (isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'skipMiddlewareUrlNormalize') {
+            prop.key.name = CONFIG_PROPERTY_MAP[prop.key.name];
+            hasChanges = true;
+        }
+    });
+    // Also transform any top-level middleware properties (for spread scenarios)
+    configObj.properties.forEach((prop) => {
+        if (isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            CONFIG_PROPERTY_MAP[prop.key.name] &&
+            prop.key.name !== 'skipMiddlewareUrlNormalize' // Already handled above
+        ) {
+            prop.key.name = CONFIG_PROPERTY_MAP[prop.key.name];
+            hasChanges = true;
+        }
+    });
+    return { hasChanges };
+}
+function processFunctionConfig(path, j) {
+    let hasChanges = false;
+    // Look for return statements with object expressions
+    j(path)
+        .find(j.ReturnStatement)
+        .forEach((returnPath) => {
+        if (returnPath.node.argument &&
+            returnPath.node.argument.type === 'ObjectExpression') {
+            const result = processConfigObject(returnPath.node.argument);
+            hasChanges = hasChanges || result.hasChanges;
+        }
+    });
+    return { hasChanges };
+}
+function processArrowFunctionConfig(path, j) {
+    let hasChanges = false;
+    const body = path.node.body;
+    // Handle: () => ({ ... })
+    if (body && body.type === 'ObjectExpression') {
+        const result = processConfigObject(body);
+        hasChanges = hasChanges || result.hasChanges;
+    }
+    // Handle: () => { return { ... } }
+    if (body && body.type === 'BlockStatement') {
+        j(path)
+            .find(j.ReturnStatement)
+            .forEach((returnPath) => {
+            if (returnPath.node.argument &&
+                returnPath.node.argument.type === 'ObjectExpression') {
+                const result = processConfigObject(returnPath.node.argument);
+                hasChanges = hasChanges || result.hasChanges;
+            }
+        });
+    }
+    return { hasChanges };
+}
+function transformMiddlewareFunction(root, j) {
     const proxyIdentifier = generateUniqueIdentifier(root, j, 'proxy');
     const needsAlias = proxyIdentifier !== 'proxy';
     let hasChanges = false;
@@ -125,9 +362,6 @@ function transformer(file) {
             astPath.node.name = proxyIdentifier;
         });
     }
-    if (!hasChanges) {
-        return file.source;
-    }
     // If we used a unique identifier AND we exported `as proxy`, add an export alias
     // This handles cases where the export was part of the declaration itself:
     //   export function middleware() {} -> export function _proxy1() {} (needs alias)
@@ -158,23 +392,30 @@ function transformer(file) {
             }
         }
     }
-    const source = root.toSource();
+    return { hasChanges };
+}
+function handleMiddlewareFileRename(file, source) {
     // We will not modify the original file in real world,
     // so return the source here for testing.
     if (process.env.NODE_ENV === 'test') {
         return source;
     }
-    const { dir, ext } = path_1.default.parse(file.path);
-    const newFilePath = path_1.default.join(dir, 'proxy' + ext);
+    const { dir, ext } = (0, path_1.parse)(file.path);
+    const newFilePath = (0, path_1.join)(dir, 'proxy' + ext);
     try {
         fs_1.default.writeFileSync(newFilePath, source);
         fs_1.default.unlinkSync(file.path);
+        // Return empty string to indicate successful file replacement.
+        return '';
     }
     catch (cause) {
         console.error(`Failed to write "${newFilePath}" and delete "${file.path}".\n${JSON.stringify({ cause })}`);
         return file.source;
     }
 }
+function isStaticProperty(prop) {
+    return prop.type === 'Property' || prop.type === 'ObjectProperty';
+}
 function generateUniqueIdentifier(root, j, baseName) {
     // First check if baseName itself is available
     if (!hasIdentifierInScope(root, j, baseName)) {
@@ -206,4 +447,159 @@ function hasIdentifierInScope(root, j, name) {
         astPath.value.local.name === name).length > 0;
     return hasVariableDeclaration || hasFunctionDeclaration || hasImportSpecifier;
 }
+function findNextConfigObjects(root, j) {
+    const configObjects = [];
+    // Find identifiers that are exported as default or assigned to module.exports
+    const exportedNames = new Set();
+    // Handle: export default nextConfig or export default wrappedFunction(nextConfig)
+    root.find(j.ExportDefaultDeclaration).forEach((path) => {
+        if (j.Identifier.check(path.node.declaration)) {
+            exportedNames.add(path.node.declaration.name);
+        }
+        else if (j.ObjectExpression.check(path.node.declaration)) {
+            // Direct object export: export default { ... }
+            configObjects.push(path.get('declaration'));
+        }
+        else if (j.CallExpression.check(path.node.declaration)) {
+            // Handle wrapped exports: export default wrapper(config)
+            extractObjectsFromCallExpression(path.node.declaration, configObjects, exportedNames, j);
+        }
+    });
+    // Handle: module.exports = nextConfig or module.exports = wrappedFunction(nextConfig)
+    root
+        .find(j.AssignmentExpression, {
+        left: {
+            type: 'MemberExpression',
+            object: { name: 'module' },
+            property: { name: 'exports' },
+        },
+    })
+        .forEach((path) => {
+        if (j.Identifier.check(path.node.right)) {
+            exportedNames.add(path.node.right.name);
+        }
+        else if (j.ObjectExpression.check(path.node.right)) {
+            // Direct object assignment: module.exports = { ... }
+            configObjects.push(path.get('right'));
+        }
+        else if (j.CallExpression.check(path.node.right)) {
+            // Handle wrapped assignments: module.exports = wrapper(config)
+            extractObjectsFromCallExpression(path.node.right, configObjects, exportedNames, j);
+        }
+    });
+    // Find variable declarations for exported names
+    exportedNames.forEach((name) => {
+        root
+            .find(j.VariableDeclarator, { id: { name } })
+            .forEach((path) => {
+            if (j.ObjectExpression.check(path.node.init)) {
+                configObjects.push(path.get('init'));
+            }
+        });
+    });
+    return configObjects;
+}
+function findNextConfigFunctions(root, j) {
+    const configFunctions = [];
+    const exportedNames = new Set();
+    // Handle: export default function or export default functionName
+    root.find(j.ExportDefaultDeclaration).forEach((path) => {
+        if (j.FunctionDeclaration.check(path.node.declaration)) {
+            // export default function configFunction() { ... }
+            configFunctions.push(path.get('declaration'));
+        }
+        else if (j.Identifier.check(path.node.declaration)) {
+            exportedNames.add(path.node.declaration.name);
+        }
+    });
+    // Handle: module.exports = function
+    root
+        .find(j.AssignmentExpression, {
+        left: {
+            type: 'MemberExpression',
+            object: { name: 'module' },
+            property: { name: 'exports' },
+        },
+    })
+        .forEach((path) => {
+        if (j.FunctionExpression.check(path.node.right)) {
+            // module.exports = function() { ... }
+            configFunctions.push(path.get('right'));
+        }
+        else if (j.Identifier.check(path.node.right)) {
+            exportedNames.add(path.node.right.name);
+        }
+    });
+    // Find function declarations for exported names
+    exportedNames.forEach((name) => {
+        root
+            .find(j.FunctionDeclaration, { id: { name } })
+            .forEach((path) => {
+            configFunctions.push(path);
+        });
+    });
+    return configFunctions;
+}
+function findNextConfigArrowFunctions(root, j) {
+    const configArrowFunctions = [];
+    const exportedNames = new Set();
+    // Handle: export default arrowFunction
+    root.find(j.ExportDefaultDeclaration).forEach((path) => {
+        if (j.ArrowFunctionExpression.check(path.node.declaration)) {
+            // export default () => { ... }
+            configArrowFunctions.push(path.get('declaration'));
+        }
+        else if (j.Identifier.check(path.node.declaration)) {
+            exportedNames.add(path.node.declaration.name);
+        }
+    });
+    // Handle: module.exports = arrowFunction
+    root
+        .find(j.AssignmentExpression, {
+        left: {
+            type: 'MemberExpression',
+            object: { name: 'module' },
+            property: { name: 'exports' },
+        },
+    })
+        .forEach((path) => {
+        if (j.ArrowFunctionExpression.check(path.node.right)) {
+            // module.exports = () => { ... }
+            configArrowFunctions.push(path.get('right'));
+        }
+        else if (j.Identifier.check(path.node.right)) {
+            exportedNames.add(path.node.right.name);
+        }
+    });
+    // Find variable declarations with arrow functions for exported names
+    exportedNames.forEach((name) => {
+        root
+            .find(j.VariableDeclarator, { id: { name } })
+            .forEach((path) => {
+            if (j.ArrowFunctionExpression.check(path.node.init)) {
+                configArrowFunctions.push(path.get('init'));
+            }
+        });
+    });
+    return configArrowFunctions;
+}
+function extractObjectsFromCallExpression(callExpr, configObjects, exportedNames, j) {
+    // Recursively extract arguments from call expressions
+    // E.g., wrapper(anotherWrapper(config)) or wrapper(config)
+    if (callExpr.arguments) {
+        callExpr.arguments.forEach((arg) => {
+            if (j.Identifier.check(arg)) {
+                exportedNames.add(arg.name);
+            }
+            else if (j.ObjectExpression.check(arg)) {
+                // This would be unusual but handle direct object arguments
+                // We don't have the path here, so we'll skip this case
+                // It would be handled by the direct export case anyway
+            }
+            else if (j.CallExpression.check(arg)) {
+                extractObjectsFromCallExpression(arg, configObjects, exportedNames, j);
+            }
+        });
+    }
+}
 //# sourceMappingURL=middleware-to-proxy.js.map