@netlify/plugin-nextjs 4.26.0 → 4.27.1

package/lib/helpers/analysis.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractConfigFromFile = exports.validateConfigValue = void 0;
+const fs_1 = __importStar(require("fs"));
+const pathe_1 = require("pathe");
+const validateConfigValue = (config, apiFilePath) => {
+    if (config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */) {
+        if (!config.schedule) {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: schedule is required when type is "${"experimental-scheduled" /* ApiRouteType.SCHEDULED */}"`);
+            return false;
+        }
+        if (config.runtime === 'experimental-edge') {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: edge runtime is not supported for scheduled functions`);
+            return false;
+        }
+        return true;
+    }
+    if (!config.type || config.type === "experimental-background" /* ApiRouteType.BACKGROUND */) {
+        if (config.schedule) {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: schedule is not allowed unless type is "${"experimental-scheduled" /* ApiRouteType.SCHEDULED */}"`);
+            return false;
+        }
+        if (config.type && config.runtime === 'experimental-edge') {
+            console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: edge runtime is not supported for background functions`);
+            return false;
+        }
+        return true;
+    }
+    console.error(`Invalid config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}: type ${config.type} is not supported`);
+    return false;
+};
+exports.validateConfigValue = validateConfigValue;
+let extractConstValue;
+let parseModule;
+let hasWarnedAboutNextVersion = false;
+/**
+ * Uses Next's swc static analysis to extract the config values from a file.
+ */
+const extractConfigFromFile = async (apiFilePath) => {
+    if (!apiFilePath || !(0, fs_1.existsSync)(apiFilePath)) {
+        return {};
+    }
+    try {
+        if (!extractConstValue) {
+            extractConstValue = require('next/dist/build/analysis/extract-const-value');
+        }
+        if (!parseModule) {
+            // eslint-disable-next-line prefer-destructuring, @typescript-eslint/no-var-requires
+            parseModule = require('next/dist/build/analysis/parse-module').parseModule;
+        }
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            if (!hasWarnedAboutNextVersion) {
+                console.log("This version of Next.js doesn't support advanced API routes. Skipping...");
+                hasWarnedAboutNextVersion = true;
+            }
+            // Old Next.js version
+            return {};
+        }
+        throw error;
+    }
+    const { extractExportedConstValue, UnsupportedValueError } = extractConstValue;
+    const fileContent = await fs_1.default.promises.readFile(apiFilePath, 'utf8');
+    // No need to parse if there's no "config"
+    if (!fileContent.includes('config')) {
+        return {};
+    }
+    const ast = await parseModule(apiFilePath, fileContent);
+    let config;
+    try {
+        config = extractExportedConstValue(ast, 'config');
+    }
+    catch (error) {
+        if (UnsupportedValueError && error instanceof UnsupportedValueError) {
+            console.warn(`Unsupported config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}`);
+        }
+        return {};
+    }
+    if ((0, exports.validateConfigValue)(config, apiFilePath)) {
+        return config;
+    }
+    throw new Error(`Unsupported config value in ${(0, pathe_1.relative)(process.cwd(), apiFilePath)}`);
+};
+exports.extractConfigFromFile = extractConfigFromFile;

package/lib/helpers/config.js

@@ -69,7 +69,7 @@ const configureHandlerFunctions = async ({ netlifyConfig, publish, ignore = [] }
     }
     /* eslint-enable no-underscore-dangle */
     ;
-    [constants_1.HANDLER_FUNCTION_NAME, constants_1.ODB_FUNCTION_NAME].forEach((functionName) => {
+    [constants_1.HANDLER_FUNCTION_NAME, constants_1.ODB_FUNCTION_NAME, '_api_*'].forEach((functionName) => {
         var _a, _b;
         (_a = netlifyConfig.functions)[functionName] || (_a[functionName] = { included_files: [], external_node_modules: [] });
         netlifyConfig.functions[functionName].node_bundler = 'nft';

package/lib/helpers/edge.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enableEdgeInNextConfig = exports.writeEdgeFunctions = exports.writeDevEdgeFunction = exports.cleanupEdgeFunctions = exports.loadMiddlewareManifest = void 0;
+exports.writeEdgeFunctions = exports.writeDevEdgeFunction = exports.cleanupEdgeFunctions = exports.loadMiddlewareManifest = void 0;
 /* eslint-disable max-lines */
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -181,10 +181,4 @@ const writeEdgeFunctions = async (netlifyConfig) => {
     await (0, fs_extra_1.writeJson)((0, path_1.join)(edgeFunctionRoot, 'manifest.json'), manifest);
 };
 exports.writeEdgeFunctions = writeEdgeFunctions;
-const enableEdgeInNextConfig = async (publish) => {
-    const configFile = (0, path_1.join)(publish, 'required-server-files.json');
-    const config = await (0, fs_extra_1.readJSON)(configFile);
-    await (0, fs_extra_1.writeJSON)(configFile, config);
-};
-exports.enableEdgeInNextConfig = enableEdgeInNextConfig;
 /* eslint-enable max-lines */

package/lib/helpers/files.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.movePublicFiles = exports.unpatchNextFiles = exports.unpatchFile = exports.patchNextFiles = exports.moveStaticPages = exports.getMiddleware = exports.matchesRewrite = exports.matchesRedirect = exports.matchMiddleware = exports.stripLocale = exports.isDynamicRoute = void 0;
+exports.movePublicFiles = exports.unpatchNextFiles = exports.unpatchFile = exports.patchNextFiles = exports.getDependenciesOfFile = exports.getSourceFileForPage = exports.moveStaticPages = exports.getMiddleware = exports.matchesRewrite = exports.matchesRedirect = exports.matchMiddleware = exports.stripLocale = exports.isDynamicRoute = void 0;
 /* eslint-disable max-lines */
 const os_1 = require("os");
 const chalk_1 = require("chalk");
@@ -16,6 +16,7 @@ const slash_1 = __importDefault(require("slash"));
 const constants_1 = require("../constants");
 const utils_1 = require("./utils");
 const TEST_ROUTE = /(|\/)\[[^/]+?](\/|\.html|$)/;
+const SOURCE_FILE_EXTENSIONS = ['js', 'jsx', 'ts', 'tsx'];
 const isDynamicRoute = (route) => TEST_ROUTE.test(route);
 exports.isDynamicRoute = isDynamicRoute;
 const stripLocale = (rawPath, locales = []) => {
@@ -270,6 +271,31 @@ const getServerFile = (root, includeBase = true) => {
     }
     return (0, utils_1.findModuleFromBase)({ candidates, paths: [root] });
 };
+/**
+ * Find the source file for a given page route
+ */
+const getSourceFileForPage = (page, root) => {
+    for (const extension of SOURCE_FILE_EXTENSIONS) {
+        const file = (0, pathe_1.join)(root, `${page}.${extension}`);
+        if ((0, fs_extra_1.existsSync)(file)) {
+            return file;
+        }
+    }
+    console.log('Could not find source file for page', page);
+};
+exports.getSourceFileForPage = getSourceFileForPage;
+/**
+ * Reads the node file trace file for a given file, and resolves the dependencies
+ */
+const getDependenciesOfFile = async (file) => {
+    const nft = `${file}.nft.json`;
+    if (!(0, fs_extra_1.existsSync)(nft)) {
+        return [];
+    }
+    const dependencies = await (0, fs_extra_1.readJson)(nft, 'utf8');
+    return dependencies.files.map((dep) => (0, pathe_1.resolve)(file, dep));
+};
+exports.getDependenciesOfFile = getDependenciesOfFile;
 const baseServerReplacements = [
     // force manual revalidate during cache fetches
     [

package/lib/helpers/functions.js

@@ -3,24 +3,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
+exports.warnOnApiRoutes = exports.getApiRouteConfigs = exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
 const node_bridge_1 = __importDefault(require("@vercel/node-bridge"));
+const chalk_1 = __importDefault(require("chalk"));
 const destr_1 = __importDefault(require("destr"));
 const fs_extra_1 = require("fs-extra");
+const outdent_1 = require("outdent");
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
+const getApiHandler_1 = require("../templates/getApiHandler");
 const getHandler_1 = require("../templates/getHandler");
 const getPageResolver_1 = require("../templates/getPageResolver");
-const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir) => {
-    const functionsDir = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
-    const functionDir = (0, pathe_1.join)(process.cwd(), functionsDir, constants_1.HANDLER_FUNCTION_NAME);
-    const publishDir = (0, pathe_1.relative)(functionDir, (0, pathe_1.resolve)(PUBLISH_DIR));
-    const writeHandler = async (func, isODB) => {
+const analysis_1 = require("./analysis");
+const files_1 = require("./files");
+const utils_1 = require("./utils");
+const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir, apiRoutes) => {
+    const publish = (0, pathe_1.resolve)(PUBLISH_DIR);
+    const functionsDir = (0, pathe_1.resolve)(INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC);
+    console.log({ functionsDir });
+    const functionDir = (0, pathe_1.join)(functionsDir, constants_1.HANDLER_FUNCTION_NAME);
+    const publishDir = (0, pathe_1.relative)(functionDir, publish);
+    for (const { route, config, compiled } of apiRoutes) {
+        const apiHandlerSource = await (0, getApiHandler_1.getApiHandler)({
+            page: route,
+            config,
+        });
+        const functionName = (0, utils_1.getFunctionNameForPage)(route, config.type === "experimental-background" /* ApiRouteType.BACKGROUND */);
+        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, functionName));
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, `${functionName}.js`), apiHandlerSource);
+        await (0, fs_extra_1.copyFile)(node_bridge_1.default, (0, pathe_1.join)(functionsDir, functionName, 'bridge.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, functionName, 'handlerUtils.js'));
+        const resolverSource = await (0, getPageResolver_1.getSinglePageResolver)({
+            functionsDir,
+            sourceFile: (0, pathe_1.join)(publish, 'server', compiled),
+        });
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, 'pages.js'), resolverSource);
+    }
+    const writeHandler = async (functionName, isODB) => {
         const handlerSource = await (0, getHandler_1.getHandler)({ isODB, publishDir, appDir: (0, pathe_1.relative)(functionDir, appDir) });
-        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, func));
-        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, func, `${func}.js`), handlerSource);
-        await (0, fs_extra_1.copyFile)(node_bridge_1.default, (0, pathe_1.join)(functionsDir, func, 'bridge.js'));
-        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, func, 'handlerUtils.js'));
+        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, functionName));
+        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, functionName, `${functionName}.js`), handlerSource);
+        await (0, fs_extra_1.copyFile)(node_bridge_1.default, (0, pathe_1.join)(functionsDir, functionName, 'bridge.js'));
+        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, functionName, 'handlerUtils.js'));
     };
     await writeHandler(constants_1.HANDLER_FUNCTION_NAME, false);
     await writeHandler(constants_1.ODB_FUNCTION_NAME, true);
@@ -92,3 +116,42 @@ const setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIO
     }
 };
 exports.setupImageFunction = setupImageFunction;
+/**
+ * Look for API routes, and extract the config from the source file.
+ */
+const getApiRouteConfigs = async (publish, baseDir) => {
+    const pages = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(publish, 'server', 'pages-manifest.json'));
+    const apiRoutes = Object.keys(pages).filter((page) => page.startsWith('/api/'));
+    const pagesDir = (0, pathe_1.join)(baseDir, 'pages');
+    return Promise.all(apiRoutes.map(async (apiRoute) => {
+        const filePath = (0, files_1.getSourceFileForPage)(apiRoute, pagesDir);
+        return { route: apiRoute, config: await (0, analysis_1.extractConfigFromFile)(filePath), compiled: pages[apiRoute] };
+    }));
+};
+exports.getApiRouteConfigs = getApiRouteConfigs;
+/**
+ * Warn the user of the caveats if they're using background or scheduled API routes
+ */
+const warnOnApiRoutes = async ({ FUNCTIONS_DIST, }) => {
+    const functionsManifestPath = (0, pathe_1.join)(FUNCTIONS_DIST, 'manifest.json');
+    if (!(0, fs_extra_1.existsSync)(functionsManifestPath)) {
+        return;
+    }
+    const { functions } = await (0, fs_extra_1.readJSON)(functionsManifestPath);
+    if (functions.some((func) => func.name.endsWith('-background'))) {
+        console.warn((0, outdent_1.outdent) `
+        ${chalk_1.default.yellowBright `Using background API routes`}
+        If your account type does not support background functions, the deploy will fail.
+        During local development, background API routes will run as regular API routes, but in production they will immediately return an empty "202 Accepted" response.
+      `);
+    }
+    if (functions.some((func) => func.schedule)) {
+        console.warn((0, outdent_1.outdent) `
+        ${chalk_1.default.yellowBright `Using scheduled API routes`} 
+        These are run on a schedule when deployed to production.
+        You can test them locally by loading them in your browser but this will not be available when deployed, and any returned value is ignored.
+      `);
+    }
+};
+exports.warnOnApiRoutes = warnOnApiRoutes;
+/* eslint-enable max-lines */

package/lib/helpers/redirects.js

@@ -152,7 +152,7 @@ const generateDynamicRewrites = ({ dynamicRoutes, prerenderedDynamicRoutes, midd
         dynamicRewrites,
     };
 };
-const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, }) => {
+const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, buildId, apiRoutes, }) => {
     const { dynamicRoutes: prerenderedDynamicRoutes, routes: prerenderedStaticRoutes } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(netlifyConfig.build.publish, 'prerender-manifest.json'));
     const { dynamicRoutes, staticRoutes } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(netlifyConfig.build.publish, 'routes-manifest.json'));
     netlifyConfig.redirects.push(...generateHiddenPathRedirects({ basePath }));
@@ -162,7 +162,7 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     // This is only used in prod, so dev uses `next dev` directly
     netlifyConfig.redirects.push(
     // API routes always need to be served from the regular function
-    ...(0, utils_1.getApiRewrites)(basePath), 
+    ...(0, utils_1.getApiRewrites)(basePath, apiRoutes), 
     // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
     ...(await (0, utils_1.getPreviewRewrites)({ basePath, appDir })));
     const middleware = await (0, files_1.getMiddleware)(netlifyConfig.build.publish);

package/lib/helpers/utils.js

@@ -3,10 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRemotePatterns = exports.isBundleSizeCheckDisabled = exports.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.is404Route = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = void 0;
+exports.getRemotePatterns = exports.isBundleSizeCheckDisabled = exports.getCustomImageResponseHeaders = exports.isNextAuthInstalled = exports.findModuleFromBase = exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.is404Route = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = exports.getFunctionNameForPage = void 0;
 const globby_1 = __importDefault(require("globby"));
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
+const RESERVED_FILENAME = /[^\w_-]/g;
+/**
+ * Given a Next route, generates a valid Netlify function name.
+ * If "background" is true then the function name will have `-background`
+ * appended to it, meaning that it is executed as a background function.
+ */
+const getFunctionNameForPage = (page, background = false) => `${page
+    .replace(constants_1.CATCH_ALL_REGEX, '_$1-SPLAT')
+    .replace(constants_1.OPTIONAL_CATCH_ALL_REGEX, '-SPLAT')
+    .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '_$1-PARAM')
+    .replace(RESERVED_FILENAME, '_')}-${background ? 'background' : 'handler'}`;
+exports.getFunctionNameForPage = getFunctionNameForPage;
 const toNetlifyRoute = (nextRoute) => {
     const netlifyRoutes = [nextRoute];
     // If the route is an optional catch-all route, we need to add a second
@@ -79,18 +91,28 @@ const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status
     force,
 }));
 exports.redirectsForNextRouteWithData = redirectsForNextRouteWithData;
-const getApiRewrites = (basePath) => [
-    {
-        from: `${basePath}/api`,
-        to: constants_1.HANDLER_FUNCTION_PATH,
-        status: 200,
-    },
-    {
-        from: `${basePath}/api/*`,
-        to: constants_1.HANDLER_FUNCTION_PATH,
-        status: 200,
-    },
-];
+const getApiRewrites = (basePath, apiRoutes) => {
+    const apiRewrites = apiRoutes.map((apiRoute) => {
+        const [from] = (0, exports.toNetlifyRoute)(`${basePath}${apiRoute.route}`);
+        // Scheduled functions can't be invoked directly, so we 404 them.
+        if (apiRoute.config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */) {
+            return { from, to: '/404.html', status: 404 };
+        }
+        return {
+            from,
+            to: `/.netlify/functions/${(0, exports.getFunctionNameForPage)(apiRoute.route, apiRoute.config.type === "experimental-background" /* ApiRouteType.BACKGROUND */)}`,
+            status: 200,
+        };
+    });
+    return [
+        ...apiRewrites,
+        {
+            from: `${basePath}/api/*`,
+            to: constants_1.HANDLER_FUNCTION_PATH,
+            status: 200,
+        },
+    ];
+};
 exports.getApiRewrites = getApiRewrites;
 const getPreviewRewrites = async ({ basePath, appDir }) => {
     const publicFiles = await (0, globby_1.default)('**/*', { cwd: (0, pathe_1.join)(appDir, 'public') });

package/lib/index.js

@@ -90,10 +90,11 @@ const plugin = {
         }
         const buildId = (0, fs_extra_1.readFileSync)((0, path_1.join)(publish, 'BUILD_ID'), 'utf8').trim();
         await (0, config_1.configureHandlerFunctions)({ netlifyConfig, ignore, publish: (0, path_1.relative)(process.cwd(), publish) });
-        await (0, functions_1.generateFunctions)(constants, appDir);
+        const apiRoutes = await (0, functions_1.getApiRouteConfigs)(publish, appDir);
+        await (0, functions_1.generateFunctions)(constants, appDir, apiRoutes);
         await (0, functions_1.generatePagesResolver)({ target, constants });
         await (0, files_1.movePublicFiles)({ appDir, outdir, publish });
-        await (0, files_1.patchNextFiles)(basePath);
+        await (0, files_1.patchNextFiles)(appDir);
         if (!(0, destr_1.default)(process.env.SERVE_STATIC_FILES_FROM_ORIGIN)) {
             await (0, files_1.moveStaticPages)({ target, netlifyConfig, i18n, basePath });
         }
@@ -113,6 +114,7 @@ const plugin = {
             netlifyConfig,
             nextConfig: { basePath, i18n, trailingSlash, appDir },
             buildId,
+            apiRoutes,
         });
         await (0, edge_1.writeEdgeFunctions)(netlifyConfig);
     },
@@ -134,6 +136,7 @@ const plugin = {
         (0, config_1.generateCustomHeaders)(nextConfig, headers);
         (0, verification_1.warnForProblematicUserRewrites)({ basePath, redirects });
         (0, verification_1.warnForRootRedirects)({ appDir });
+        await (0, functions_1.warnOnApiRoutes)({ FUNCTIONS_DIST });
     },
 };
 // The types haven't been updated yet

package/lib/templates/getApiHandler.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiHandler = void 0;
+// Aliasing like this means the editor may be able to syntax-highlight the string
+const outdent_1 = require("outdent");
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { Server } = require('http');
+const path = require('path');
+// eslint-disable-next-line n/prefer-global/url, n/prefer-global/url-search-params
+const { URLSearchParams, URL } = require('url');
+const { Bridge } = require('@vercel/node-bridge/bridge');
+const { getMultiValueHeaders, getNextServer } = require('./handlerUtils');
+// We return a function and then call `toString()` on it to serialise it as the launcher function
+const makeHandler = (conf, app, pageRoot, page) => {
+    var _a;
+    // Change working directory into the site root, unless using Nx, which moves the
+    // dist directory and handles this itself
+    const dir = path.resolve(__dirname, app);
+    if (pageRoot.startsWith(dir)) {
+        process.chdir(dir);
+    }
+    // This is just so nft knows about the page entrypoints. It's not actually used
+    try {
+        // eslint-disable-next-line n/no-missing-require
+        require.resolve('./pages.js');
+    }
+    catch { }
+    // React assumes you want development mode if NODE_ENV is unset.
+    ;
+    (_a = process.env).NODE_ENV || (_a.NODE_ENV = 'production');
+    // We don't want to write ISR files to disk in the lambda environment
+    conf.experimental.isrFlushToDisk = false;
+    // This is our flag that we use when patching the source
+    // eslint-disable-next-line no-underscore-dangle
+    process.env._BYPASS_SSG = 'true';
+    for (const [key, value] of Object.entries(conf.env)) {
+        process.env[key] = String(value);
+    }
+    // We memoize this because it can be shared between requests, but don't instantiate it until
+    // the first request because we need the host and port.
+    let bridge;
+    const getBridge = (event) => {
+        if (bridge) {
+            return bridge;
+        }
+        // Scheduled functions don't have a URL, but we need to give one so Next knows the route to serve
+        const url = event.rawUrl ? new URL(event.rawUrl) : new URL(path, process.env.URL || 'http://n');
+        const port = Number.parseInt(url.port) || 80;
+        const NextServer = getNextServer();
+        const nextServer = new NextServer({
+            // We know we're just an API route, so can enable minimal mode
+            minimalMode: true,
+            conf,
+            dir,
+            customServer: false,
+            hostname: url.hostname,
+            port,
+        });
+        const requestHandler = nextServer.getRequestHandler();
+        const server = new Server(async (req, res) => {
+            try {
+                await requestHandler(req, res);
+            }
+            catch (error) {
+                console.error(error);
+                throw new Error('Error handling request. See function logs for details.');
+            }
+        });
+        bridge = new Bridge(server);
+        bridge.listen();
+        return bridge;
+    };
+    return async function handler(event, context) {
+        // Ensure that paths are encoded - but don't double-encode them
+        event.path = event.rawUrl ? new URL(event.rawUrl).pathname : page;
+        // Next expects to be able to parse the query from the URL
+        const query = new URLSearchParams(event.queryStringParameters).toString();
+        event.path = query ? `${event.path}?${query}` : event.path;
+        // We know the page
+        event.headers['x-matched-path'] = page;
+        const { headers, ...result } = await getBridge(event).launcher(event, context);
+        // Convert all headers to multiValueHeaders
+        const multiValueHeaders = getMultiValueHeaders(headers);
+        multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
+        console.log(`[${event.httpMethod}] ${event.path} (API)`);
+        return {
+            ...result,
+            multiValueHeaders,
+            isBase64Encoded: result.encoding === 'base64',
+        };
+    };
+};
+/**
+ * Handlers for API routes are simpler than page routes, but they each have a separate one
+ */
+const getApiHandler = ({ page, config, publishDir = '../../../.next', appDir = '../../..', }) => 
+// This is a string, but if you have the right editor plugin it should format as js
+(0, outdent_1.outdent /* javascript */) `
+  const { Server } = require("http");
+  // We copy the file here rather than requiring from the node module
+  const { Bridge } = require("./bridge");
+  const { getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
+
+  ${config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? `const { schedule } = require("@netlify/functions")` : ''}
+
+
+  const { config }  = require("${publishDir}/required-server-files.json")
+  let staticManifest
+  const path = require("path");
+  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", "serverless", "pages"));
+  const handler = (${makeHandler.toString()})(config, "${appDir}", pageRoot, ${JSON.stringify(page)})
+  exports.handler = ${config.type === "experimental-scheduled" /* ApiRouteType.SCHEDULED */ ? `schedule(${JSON.stringify(config.schedule)}, handler);` : 'handler'}
+`;
+exports.getApiHandler = getApiHandler;

package/lib/templates/getHandler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHandler = void 0;
+// Aliasing like this means the editor may be able to syntax-highlight the string
 const outdent_1 = require("outdent");
 /* eslint-disable @typescript-eslint/no-var-requires */
 const { promises } = require('fs');
@@ -127,14 +128,14 @@ const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') =>
 };
 const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }) => 
 // This is a string, but if you have the right editor plugin it should format as js
-(0, outdent_1.outdent) `
+(0, outdent_1.outdent /* javascript */) `
   const { Server } = require("http");
   const { promises } = require("fs");
   // We copy the file here rather than requiring from the node module
   const { Bridge } = require("./bridge");
   const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
 
-  const { builder } = require("@netlify/functions");
+  ${isODB ? `const { builder } = require("@netlify/functions")` : ''}
   const { config }  = require("${publishDir}/required-server-files.json")
   let staticManifest
   try {

package/lib/templates/getPageResolver.js

@@ -3,12 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageResolver = void 0;
+exports.getSinglePageResolver = exports.getPageResolver = void 0;
 const path_1 = require("path");
 const outdent_1 = require("outdent");
+const pathe_1 = require("pathe");
 const slash_1 = __importDefault(require("slash"));
 const tiny_glob_1 = __importDefault(require("tiny-glob"));
 const constants_1 = require("../constants");
+const files_1 = require("../helpers/files");
 // Generate a file full of require.resolve() calls for all the pages in the
 // build. This is used by the nft bundler to find all the pages.
 const getPageResolver = async ({ publish, target }) => {
@@ -31,3 +33,22 @@ const getPageResolver = async ({ publish, target }) => {
   `;
 };
 exports.getPageResolver = getPageResolver;
+/**
+ * API routes only need the dependencies for a single entrypoint, so we use the
+ * NFT trace file to get the dependencies.
+ */
+const getSinglePageResolver = async ({ functionsDir, sourceFile, }) => {
+    const dependencies = await (0, files_1.getDependenciesOfFile)(sourceFile);
+    // We don't need the actual name, just the relative path.
+    const functionDir = (0, pathe_1.resolve)(functionsDir, 'functionName');
+    const pageFiles = [sourceFile, ...dependencies]
+        .map((file) => `require.resolve('${(0, pathe_1.relative)(functionDir, file)}')`)
+        .sort();
+    return (0, outdent_1.outdent /* javascript */) `
+    // This file is purely to allow nft to know about these pages. 
+      try {
+          ${pageFiles.join('\n        ')}
+      } catch {}
+  `;
+};
+exports.getSinglePageResolver = getSinglePageResolver;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.26.0",
+  "version": "4.27.1",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "index.js",
   "files": [