@netlify/plugin-nextjs 4.1.1 → 4.2.1

package/lib/helpers/utils.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldSkip = exports.netlifyRoutesForNextRoute = void 0;
+exports.shouldSkip = exports.getPreviewRewrites = exports.getApiRewrites = exports.redirectsForNextRouteWithData = exports.redirectsForNextRoute = exports.targetForFallback = exports.isApiRoute = exports.routeToDataRoute = exports.netlifyRoutesForNextRouteWithData = exports.toNetlifyRoute = void 0;
+const globby_1 = __importDefault(require("globby"));
+const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
-const netlifyRoutesForNextRoute = (nextRoute) => {
+const toNetlifyRoute = (nextRoute) => {
     const netlifyRoutes = [nextRoute];
     // If the route is an optional catch-all route, we need to add a second
     // Netlify route for the base path (when no parameters are present).
@@ -29,7 +34,93 @@ const netlifyRoutesForNextRoute = (nextRoute) => {
         // Replace dynamic parameters, e.g., [id]
         .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '/:$1'));
 };
-exports.netlifyRoutesForNextRoute = netlifyRoutesForNextRoute;
+exports.toNetlifyRoute = toNetlifyRoute;
+const netlifyRoutesForNextRouteWithData = ({ route, dataRoute }) => [
+    ...(0, exports.toNetlifyRoute)(dataRoute),
+    ...(0, exports.toNetlifyRoute)(route),
+];
+exports.netlifyRoutesForNextRouteWithData = netlifyRoutesForNextRouteWithData;
+const routeToDataRoute = (route, buildId, locale) => `/_next/data/${buildId}${locale ? `/${locale}` : ''}${route === '/' ? '/index' : route}.json`;
+exports.routeToDataRoute = routeToDataRoute;
+const netlifyRoutesForNextRoute = (route, buildId, i18n) => {
+    var _a;
+    if (!((_a = i18n === null || i18n === void 0 ? void 0 : i18n.locales) === null || _a === void 0 ? void 0 : _a.length)) {
+        return (0, exports.netlifyRoutesForNextRouteWithData)({ route, dataRoute: (0, exports.routeToDataRoute)(route, buildId) });
+    }
+    const { locales, defaultLocale } = i18n;
+    const routes = [];
+    locales.forEach((locale) => {
+        // Data route is always localized
+        const dataRoute = (0, exports.routeToDataRoute)(route, buildId, locale);
+        routes.push(
+        // Default locale is served from root, not localized
+        ...(0, exports.netlifyRoutesForNextRouteWithData)({
+            route: locale === defaultLocale ? route : `/${locale}${route}`,
+            dataRoute,
+        }));
+    });
+    return routes;
+};
+const isApiRoute = (route) => route.startsWith('/api/') || route === '/api';
+exports.isApiRoute = isApiRoute;
+const targetForFallback = (fallback) => {
+    if (fallback === null || fallback === false) {
+        // fallback = null mean "blocking", which uses ODB. For fallback=false then anything prerendered should 404.
+        // However i18n pages may not have been prerendered, so we still need to hit the origin
+        return { to: constants_1.ODB_FUNCTION_PATH, status: 200 };
+    }
+    // fallback = true is also ODB
+    return { to: constants_1.ODB_FUNCTION_PATH, status: 200 };
+};
+exports.targetForFallback = targetForFallback;
+const redirectsForNextRoute = ({ route, buildId, basePath, to, i18n, status = 200, force = false, }) => netlifyRoutesForNextRoute(route, buildId, i18n).map((redirect) => ({
+    from: `${basePath}${redirect}`,
+    to,
+    status,
+    force,
+}));
+exports.redirectsForNextRoute = redirectsForNextRoute;
+const redirectsForNextRouteWithData = ({ route, dataRoute, basePath, to, status = 200, force = false, }) => (0, exports.netlifyRoutesForNextRouteWithData)({ route, dataRoute }).map((redirect) => ({
+    from: `${basePath}${redirect}`,
+    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,
+    },
+];
+exports.getApiRewrites = getApiRewrites;
+const getPreviewRewrites = async ({ basePath, appDir }) => {
+    const publicFiles = await (0, globby_1.default)('**/*', { cwd: (0, pathe_1.join)(appDir, 'public') });
+    // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
+    return [
+        ...publicFiles.map((file) => ({
+            from: `${basePath}/${file}`,
+            // This is a no-op, but we do it to stop it matching the following rule
+            to: `${basePath}/${file}`,
+            conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+            status: 200,
+        })),
+        {
+            from: `${basePath}/*`,
+            to: constants_1.HANDLER_FUNCTION_PATH,
+            status: 200,
+            conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+            force: true,
+        },
+    ];
+};
+exports.getPreviewRewrites = getPreviewRewrites;
 const shouldSkip = () => process.env.NEXT_PLUGIN_FORCE_RUN === 'false' ||
     process.env.NEXT_PLUGIN_FORCE_RUN === '0' ||
     process.env.NETLIFY_NEXT_PLUGIN_SKIP === 'true' ||

package/lib/helpers/verification.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnForProblematicUserRewrites = exports.getProblematicUserRewrites = exports.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
+exports.warnForRootRedirects = exports.warnForProblematicUserRewrites = exports.getProblematicUserRewrites = exports.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
 /* eslint-disable max-lines */
 const fs_1 = require("fs");
 const path_1 = __importStar(require("path"));
@@ -36,8 +36,8 @@ const constants_1 = require("../constants");
 const REQUIRED_BUILD_VERSION = '>=18.16.0';
 const verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild, }) => {
     // We check for build version because that's what's available to us, but prompt about the cli because that's what they can upgrade
-    if (IS_LOCAL && !semver_1.satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
-        return failBuild(outdent_1.outdent `
+    if (IS_LOCAL && !(0, semver_1.satisfies)(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
+        return failBuild((0, outdent_1.outdent) `
       This version of the Essential Next.js plugin requires netlify-cli@6.12.4 or higher. Please upgrade and try again.
       You can do this by running: "npm install -g netlify-cli@latest" or "yarn global add netlify-cli@latest"
     `);
@@ -48,31 +48,31 @@ const checkForOldFunctions = async ({ functions }) => {
     const allOldFunctions = await functions.list();
     const oldFunctions = allOldFunctions.filter(({ name }) => name.startsWith('next_'));
     if (oldFunctions.length !== 0) {
-        console.log(chalk_1.yellowBright(outdent_1.outdent `
+        console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
         We have found the following functions in your site that seem to be left over from the old Next.js plugin (v3). We have guessed this because the name starts with "next_".
 
-        ${chalk_1.reset(oldFunctions.map(({ name }) => `- ${name}`).join('\n'))}
+        ${(0, chalk_1.reset)(oldFunctions.map(({ name }) => `- ${name}`).join('\n'))}
 
         If they were created by the old plugin, these functions are likely to cause errors so should be removed. You can do this by deleting the following directories:
 
-        ${chalk_1.reset(oldFunctions.map(({ mainFile }) => `- ${path_1.default.relative(process.cwd(), path_1.default.dirname(mainFile))}`).join('\n'))}
+        ${(0, chalk_1.reset)(oldFunctions.map(({ mainFile }) => `- ${path_1.default.relative(process.cwd(), path_1.default.dirname(mainFile))}`).join('\n'))}
       `));
     }
 };
 exports.checkForOldFunctions = checkForOldFunctions;
 const checkNextSiteHasBuilt = ({ publish, failBuild, }) => {
-    if (!fs_1.existsSync(path_1.default.join(publish, 'BUILD_ID'))) {
+    if (!(0, fs_1.existsSync)(path_1.default.join(publish, 'BUILD_ID'))) {
         const outWarning = path_1.default.basename(publish) === 'out'
             ? `Your publish directory is set to "out", but in most cases it should be ".next".`
             : `In most cases it should be set to ".next", unless you have chosen a custom "distDir" in your Next config.`;
-        return failBuild(outdent_1.outdent `
+        return failBuild((0, outdent_1.outdent) `
       The directory "${path_1.default.relative(process.cwd(), publish)}" does not contain a Next.js production build. Perhaps the build command was not run, or you specified the wrong publish directory.
       ${outWarning}
       If you are using "next export" then you should set the environment variable NETLIFY_NEXT_PLUGIN_SKIP to "true".
     `);
     }
-    if (fs_1.existsSync(path_1.default.join(publish, 'export-detail.json'))) {
-        failBuild(outdent_1.outdent `
+    if ((0, fs_1.existsSync)(path_1.default.join(publish, 'export-detail.json'))) {
+        failBuild((0, outdent_1.outdent) `
       Detected that "next export" was run, but site is incorrectly publishing the ".next" directory.
       The publish directory should be set to "out", and you should set the environment variable NETLIFY_NEXT_PLUGIN_SKIP to "true".
     `);
@@ -81,7 +81,7 @@ const checkNextSiteHasBuilt = ({ publish, failBuild, }) => {
 exports.checkNextSiteHasBuilt = checkNextSiteHasBuilt;
 const checkForRootPublish = ({ publish, failBuild, }) => {
     if (path_1.default.resolve(publish) === path_1.default.resolve('.')) {
-        failBuild(outdent_1.outdent `
+        failBuild((0, outdent_1.outdent) `
       Your publish directory is pointing to the base directory of your site. This is not supported for Next.js sites, and is probably a mistake. 
       In most cases it should be set to ".next", unless you have chosen a custom "distDir" in your Next config, or the Next site is in a subdirectory.
     `);
@@ -89,7 +89,7 @@ const checkForRootPublish = ({ publish, failBuild, }) => {
 };
 exports.checkForRootPublish = checkForRootPublish;
 const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
-    if (!fs_1.existsSync(file)) {
+    if (!(0, fs_1.existsSync)(file)) {
         console.warn(`Could not check zip size because ${file} does not exist`);
         return;
     }
@@ -98,8 +98,8 @@ const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
         return;
     }
     // We don't fail the build, because the actual hard max size is larger so it might still succeed
-    console.log(chalk_1.redBright(outdent_1.outdent `
-      The function zip ${chalk_1.yellowBright(path_1.relative(process.cwd(), file))} size is ${pretty_bytes_1.default(fileSize)}, which is larger than the maximum supported size of ${pretty_bytes_1.default(maxSize)}.
+    console.log((0, chalk_1.redBright)((0, outdent_1.outdent) `
+      The function zip ${(0, chalk_1.yellowBright)((0, path_1.relative)(process.cwd(), file))} size is ${(0, pretty_bytes_1.default)(fileSize)}, which is larger than the maximum supported size of ${(0, pretty_bytes_1.default)(maxSize)}.
       There are a few reasons this could happen. You may have accidentally bundled a large dependency, or you might have a
       large number of pre-rendered pages included.
     `));
@@ -110,13 +110,13 @@ const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
     for (let i = 0; i < 10 && i < sortedFiles.length; i++) {
         largest[`${i + 1}`] = {
             File: sortedFiles[i].name,
-            'Compressed Size': pretty_bytes_1.default(sortedFiles[i].compressedSize),
-            'Uncompressed Size': pretty_bytes_1.default(sortedFiles[i].size),
+            'Compressed Size': (0, pretty_bytes_1.default)(sortedFiles[i].compressedSize),
+            'Uncompressed Size': (0, pretty_bytes_1.default)(sortedFiles[i].size),
         };
     }
-    console.log(chalk_1.yellowBright `\n\nThese are the largest files in the zip:`);
+    console.log((0, chalk_1.yellowBright) `\n\nThese are the largest files in the zip:`);
     console.table(largest);
-    console.log(chalk_1.greenBright `\n\nFor more information on fixing this, see ${chalk_1.blueBright `https://ntl.fyi/large-next-functions`}`);
+    console.log((0, chalk_1.greenBright) `\n\nFor more information on fixing this, see ${(0, chalk_1.blueBright) `https://ntl.fyi/large-next-functions`}`);
 };
 exports.checkZipSize = checkZipSize;
 const getProblematicUserRewrites = ({ redirects, basePath, }) => {
@@ -140,17 +140,23 @@ const getProblematicUserRewrites = ({ redirects, basePath, }) => {
 };
 exports.getProblematicUserRewrites = getProblematicUserRewrites;
 const warnForProblematicUserRewrites = ({ redirects, basePath, }) => {
-    const userRewrites = exports.getProblematicUserRewrites({ redirects, basePath });
+    const userRewrites = (0, exports.getProblematicUserRewrites)({ redirects, basePath });
     if (userRewrites.length === 0) {
         return;
     }
-    console.log(chalk_1.yellowBright(outdent_1.outdent `
+    console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
       You have the following Netlify rewrite${userRewrites.length === 1 ? '' : 's'} that might cause conflicts with the Next.js plugin:
 
-      ${chalk_1.reset(userRewrites.map(({ from, to, status }) => `- ${from} ${to} ${status}`).join('\n'))}
+      ${(0, chalk_1.reset)(userRewrites.map(({ from, to, status }) => `- ${from} ${to} ${status}`).join('\n'))}
 
       For more information, see https://ntl.fyi/next-rewrites
     `));
 };
 exports.warnForProblematicUserRewrites = warnForProblematicUserRewrites;
+const warnForRootRedirects = ({ appDir }) => {
+    if ((0, fs_1.existsSync)((0, path_1.join)(appDir, '_redirects'))) {
+        console.log((0, chalk_1.yellowBright)(`You have a "_redirects" file in your root directory, which is not deployed and will be ignored. If you want it to be used, please move it into "public".`));
+    }
+};
+exports.warnForRootRedirects = warnForRootRedirects;
 /* eslint-enable max-lines */

package/lib/index.js

@@ -14,55 +14,57 @@ const plugin = {
     async onPreBuild({ constants, netlifyConfig, utils: { build: { failBuild }, cache, }, }) {
         var _a;
         const { publish } = netlifyConfig.build;
-        if (utils_1.shouldSkip()) {
-            await cache_1.restoreCache({ cache, publish });
+        if ((0, utils_1.shouldSkip)()) {
+            await (0, cache_1.restoreCache)({ cache, publish });
             console.log('Not running Essential Next.js plugin');
-            if (fs_extra_1.existsSync(path_1.join(constants.INTERNAL_FUNCTIONS_SRC, constants_1.HANDLER_FUNCTION_NAME))) {
+            if ((0, fs_extra_1.existsSync)((0, path_1.join)(constants.INTERNAL_FUNCTIONS_SRC, constants_1.HANDLER_FUNCTION_NAME))) {
                 console.log(`Please ensure you remove any generated functions from ${constants.INTERNAL_FUNCTIONS_SRC}`);
             }
             return;
         }
-        verification_1.checkForRootPublish({ publish, failBuild });
-        verification_1.verifyNetlifyBuildVersion({ failBuild, ...constants });
-        await cache_1.restoreCache({ cache, publish });
+        (0, verification_1.checkForRootPublish)({ publish, failBuild });
+        (0, verification_1.verifyNetlifyBuildVersion)({ failBuild, ...constants });
+        await (0, cache_1.restoreCache)({ cache, publish });
         (_a = netlifyConfig.build).environment || (_a.environment = {});
         // eslint-disable-next-line unicorn/consistent-destructuring
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
     async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
-        if (utils_1.shouldSkip()) {
+        if ((0, utils_1.shouldSkip)()) {
             return;
         }
         const { publish } = netlifyConfig.build;
-        verification_1.checkNextSiteHasBuilt({ publish, failBuild });
-        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await config_1.getNextConfig({
+        (0, verification_1.checkNextSiteHasBuilt)({ publish, failBuild });
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await (0, config_1.getNextConfig)({
             publish,
             failBuild,
         });
-        config_1.configureHandlerFunctions({ netlifyConfig, ignore, publish: path_1.relative(process.cwd(), publish) });
-        await functions_1.generateFunctions(constants, appDir);
-        await functions_1.generatePagesResolver({ target, constants });
-        await files_1.movePublicFiles({ appDir, outdir, publish });
-        await files_1.patchNextFiles(basePath);
+        const buildId = (0, fs_extra_1.readFileSync)((0, path_1.join)(publish, 'BUILD_ID'), 'utf8').trim();
+        (0, config_1.configureHandlerFunctions)({ netlifyConfig, ignore, publish: (0, path_1.relative)(process.cwd(), publish) });
+        await (0, functions_1.generateFunctions)(constants, appDir);
+        await (0, functions_1.generatePagesResolver)({ target, constants });
+        await (0, files_1.movePublicFiles)({ appDir, outdir, publish });
+        await (0, files_1.patchNextFiles)(basePath);
         if (process.env.EXPERIMENTAL_MOVE_STATIC_PAGES) {
             console.log("The flag 'EXPERIMENTAL_MOVE_STATIC_PAGES' is no longer required, as it is now the default. To disable this behavior, set the env var 'SERVE_STATIC_FILES_FROM_ORIGIN' to 'true'");
         }
         if (!process.env.SERVE_STATIC_FILES_FROM_ORIGIN) {
-            await files_1.moveStaticPages({ target, netlifyConfig, i18n });
+            await (0, files_1.moveStaticPages)({ target, netlifyConfig, i18n });
         }
-        await redirects_1.generateStaticRedirects({
+        await (0, redirects_1.generateStaticRedirects)({
             netlifyConfig,
             nextConfig: { basePath, i18n },
         });
-        await functions_1.setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
-        await redirects_1.generateRedirects({
+        await (0, functions_1.setupImageFunction)({ constants, imageconfig: images, netlifyConfig, basePath });
+        await (0, redirects_1.generateRedirects)({
             netlifyConfig,
             nextConfig: { basePath, i18n, trailingSlash, appDir },
+            buildId,
         });
     },
     async onPostBuild({ netlifyConfig: { build: { publish }, redirects, }, utils: { status, cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
-        await cache_1.saveCache({ cache, publish });
-        if (utils_1.shouldSkip()) {
+        await (0, cache_1.saveCache)({ cache, publish });
+        if ((0, utils_1.shouldSkip)()) {
             status.show({
                 title: 'Essential Next.js plugin did not run',
                 summary: `Next cache was stored, but all other functions were skipped because ${process.env.NETLIFY_NEXT_PLUGIN_SKIP
@@ -71,11 +73,12 @@ const plugin = {
             });
             return;
         }
-        await verification_1.checkForOldFunctions({ functions });
-        await verification_1.checkZipSize(path_1.join(FUNCTIONS_DIST, `${constants_1.ODB_FUNCTION_NAME}.zip`));
-        const { basePath } = await config_1.getNextConfig({ publish, failBuild });
-        verification_1.warnForProblematicUserRewrites({ basePath, redirects });
-        await files_1.unpatchNextFiles(basePath);
+        await (0, verification_1.checkForOldFunctions)({ functions });
+        await (0, verification_1.checkZipSize)((0, path_1.join)(FUNCTIONS_DIST, `${constants_1.ODB_FUNCTION_NAME}.zip`));
+        const { basePath, appDir } = await (0, config_1.getNextConfig)({ publish, failBuild });
+        (0, verification_1.warnForProblematicUserRewrites)({ basePath, redirects });
+        (0, verification_1.warnForRootRedirects)({ appDir });
+        await (0, files_1.unpatchNextFiles)(basePath);
     },
 };
 module.exports = plugin;

package/lib/templates/getHandler.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHandler = void 0;
+const outdent_1 = require("outdent");
+/* eslint-disable @typescript-eslint/no-var-requires */
 const { promises } = require('fs');
 const { Server } = require('http');
 const path = require('path');
 // eslint-disable-next-line node/prefer-global/url, node/prefer-global/url-search-params
 const { URLSearchParams, URL } = require('url');
-const { Bridge } = require('@vercel/node/dist/bridge');
+const { Bridge } = require('@vercel/node-bridge/bridge');
 const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils');
-const makeHandler = () => 
 // We return a function and then call `toString()` on it to serialise it as the launcher function
 // eslint-disable-next-line max-params
-(conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
+const makeHandler = (conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
     var _a;
     // This is just so nft knows about the page entrypoints. It's not actually used
     try {
@@ -23,30 +24,47 @@ const makeHandler = () =>
     (_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';
     // Set during the request as it needs the host header. Hoisted so we can define the function once
     let base;
     augmentFsModule({ promises, staticManifest, pageRoot, getBase: () => base });
-    const NextServer = getNextServer();
-    const nextServer = new NextServer({
-        conf,
-        dir: path.resolve(__dirname, app),
-        customServer: false,
-    });
-    const requestHandler = nextServer.getRequestHandler();
-    const server = new Server(async (req, res) => {
-        try {
-            await requestHandler(req, res);
+    // 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;
         }
-        catch (error) {
-            console.error(error);
-            throw new Error('server function error');
-        }
-    });
-    const bridge = new Bridge(server);
-    bridge.listen();
-    return async (event, context) => {
+        const url = new URL(event.rawUrl);
+        const port = Number.parseInt(url.port) || 80;
+        const { host } = event.headers;
+        const protocol = event.headers['x-forwarded-proto'] || 'http';
+        base = `${protocol}://${host}`;
+        const NextServer = getNextServer();
+        const nextServer = new NextServer({
+            conf,
+            dir: path.resolve(__dirname, app),
+            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) {
         var _a, _b, _c;
         let requestMode = mode;
         // Ensure that paths are encoded - but don't double-encode them
@@ -54,13 +72,7 @@ const makeHandler = () =>
         // 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;
-        // Only needed if we're intercepting static files
-        if (staticManifest.length !== 0) {
-            const { host } = event.headers;
-            const protocol = event.headers['x-forwarded-proto'] || 'http';
-            base = `${protocol}://${host}`;
-        }
-        const { headers, ...result } = await bridge.launcher(event, context);
+        const { headers, ...result } = await getBridge(event).launcher(event, context);
         // Convert all headers to multiValueHeaders
         const multiValueHeaders = getMultiValueHeaders(headers);
         if ((_b = (_a = multiValueHeaders['set-cookie']) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.includes('__prerender_bypass')) {
@@ -71,17 +83,17 @@ const makeHandler = () =>
         const cacheHeader = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0];
         if (cacheHeader === null || cacheHeader === void 0 ? void 0 : cacheHeader.includes('stale-while-revalidate')) {
             if (requestMode === 'odb') {
-                requestMode = 'isr';
                 const ttl = getMaxAge(cacheHeader);
-                // Long-expiry TTL is basically no TTL
+                // Long-expiry TTL is basically no TTL, so we'll skip it
                 if (ttl > 0 && ttl < ONE_YEAR_IN_SECONDS) {
                     result.ttl = ttl;
+                    requestMode = 'isr';
                 }
-                multiValueHeaders['x-rendered-at'] = [new Date().toISOString()];
             }
             multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
         }
         multiValueHeaders['x-render-mode'] = [requestMode];
+        console.log(`[${event.httpMethod}] ${event.path} (${requestMode === null || requestMode === void 0 ? void 0 : requestMode.toUpperCase()})`);
         return {
             ...result,
             multiValueHeaders,
@@ -89,24 +101,25 @@ const makeHandler = () =>
         };
     };
 };
-const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }) => `
-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 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) `
+  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");
-const { config }  = require("${publishDir}/required-server-files.json")
-let staticManifest 
-try {
-  staticManifest = require("${publishDir}/static-manifest.json")
-} catch {}
-const path = require("path");
-const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", config.target === "server" ? "server" : "serverless", "pages"));
-exports.handler = ${isODB
-    ? `builder((${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'odb'));`
-    : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}
+  const { builder } = require("@netlify/functions");
+  const { config }  = require("${publishDir}/required-server-files.json")
+  let staticManifest 
+  try {
+    staticManifest = require("${publishDir}/static-manifest.json")
+  } catch {}
+  const path = require("path");
+  const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", config.target === "server" ? "server" : "serverless", "pages"));
+  exports.handler = ${isODB
+    ? `builder((${makeHandler.toString()})(config, "${appDir}", pageRoot, staticManifest, 'odb'));`
+    : `(${makeHandler.toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}
 `;
 exports.getHandler = getHandler;
-/* eslint-enable @typescript-eslint/no-var-requires */

package/lib/templates/getPageResolver.js

@@ -13,15 +13,15 @@ const constants_1 = require("../constants");
 // build. This is used by the nft bundler to find all the pages.
 const getPageResolver = async ({ publish, target }) => {
     const functionDir = path_1.posix.resolve(path_1.posix.join('.netlify', 'functions', constants_1.HANDLER_FUNCTION_NAME));
-    const root = path_1.posix.resolve(slash_1.default(publish), target === 'server' ? 'server' : 'serverless', 'pages');
-    const pages = await tiny_glob_1.default('**/*.js', {
+    const root = path_1.posix.resolve((0, slash_1.default)(publish), target === 'server' ? 'server' : 'serverless', 'pages');
+    const pages = await (0, tiny_glob_1.default)('**/*.js', {
         cwd: root,
         dot: true,
     });
     const pageFiles = pages
-        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, slash_1.default(page)))}')`)
+        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, (0, slash_1.default)(page)))}')`)
         .sort();
-    return outdent_1.outdent `
+    return (0, outdent_1.outdent) `
     // This file is purely to allow nft to know about these pages. It should be temporary.
     exports.resolvePages = () => {
         try {

package/lib/templates/handlerUtils.js

@@ -11,7 +11,11 @@ const os_1 = require("os");
 const path_1 = __importDefault(require("path"));
 const stream_1 = require("stream");
 const util_1 = require("util");
-const streamPipeline = util_1.promisify(stream_1.pipeline);
+const streamPipeline = (0, util_1.promisify)(stream_1.pipeline);
+/**
+ * Downloads a file from the CDN to the local aliased filesystem. This is a fallback, because in most cases we'd expect
+ * files required at runtime to not be sent to the CDN.
+ */
 const downloadFile = async (url, destination) => {
     console.log(`Downloading ${url} to ${destination}`);
     const httpx = url.startsWith('https') ? https_1.default : http_1.default;
@@ -21,7 +25,7 @@ const downloadFile = async (url, destination) => {
                 reject(new Error(`Failed to download ${url}: ${response.statusCode} ${response.statusMessage || ''}`));
                 return;
             }
-            const fileStream = fs_1.createWriteStream(destination);
+            const fileStream = (0, fs_1.createWriteStream)(destination);
             streamPipeline(response, fileStream)
                 .then(resolve)
                 .catch((error) => {
@@ -36,6 +40,9 @@ const downloadFile = async (url, destination) => {
     });
 };
 exports.downloadFile = downloadFile;
+/**
+ * Parse maxage from a cache-control header
+ */
 const getMaxAge = (header) => {
     const parts = header.split(',');
     let maxAge;
@@ -66,6 +73,9 @@ const getMultiValueHeaders = (headers) => {
     return multiValueHeaders;
 };
 exports.getMultiValueHeaders = getMultiValueHeaders;
+/**
+ * Monkey-patch the fs module to download missing files from the CDN
+ */
 const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     // Only do this if we have some static files moved to the CDN
     if (staticManifest.length === 0) {
@@ -78,7 +88,7 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     const staticFiles = new Map(staticManifest);
     const downloadPromises = new Map();
     // Yes, you can cache stuff locally in a Lambda
-    const cacheDir = path_1.default.join(os_1.tmpdir(), 'next-static-cache');
+    const cacheDir = path_1.default.join((0, os_1.tmpdir)(), 'next-static-cache');
     // Grab the real fs.promises.readFile...
     const readfileOrig = promises.readFile;
     const statsOrig = promises.stat;
@@ -90,7 +100,7 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
             // We only want the part after `pages/`
             const filePath = file.slice(pageRoot.length + 1);
             // Is it in the CDN and not local?
-            if (staticFiles.has(filePath) && !fs_1.existsSync(file)) {
+            if (staticFiles.has(filePath) && !(0, fs_1.existsSync)(file)) {
                 // This name is safe to use, because it's one that was already created by Next
                 const cacheFile = path_1.default.join(cacheDir, filePath);
                 const url = `${base}/${staticFiles.get(filePath)}`;
@@ -99,11 +109,11 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
                     await downloadPromises.get(url);
                 }
                 // Have we already cached it? We download every time if running locally to avoid staleness
-                if ((!fs_1.existsSync(cacheFile) || process.env.NETLIFY_DEV) && base) {
+                if ((!(0, fs_1.existsSync)(cacheFile) || process.env.NETLIFY_DEV) && base) {
                     await promises.mkdir(path_1.default.dirname(cacheFile), { recursive: true });
                     try {
                         // Append the path to our host and we can load it like a regular page
-                        const downloadPromise = exports.downloadFile(url, cacheFile);
+                        const downloadPromise = (0, exports.downloadFile)(url, cacheFile);
                         downloadPromises.set(url, downloadPromise);
                         await downloadPromise;
                     }
@@ -122,7 +132,7 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
         if (file.startsWith(pageRoot)) {
             // We only want the part after `pages/`
             const cacheFile = path_1.default.join(cacheDir, file.slice(pageRoot.length + 1));
-            if (fs_1.existsSync(cacheFile)) {
+            if ((0, fs_1.existsSync)(cacheFile)) {
                 return statsOrig(cacheFile, options);
             }
         }
@@ -130,6 +140,9 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     });
 };
 exports.augmentFsModule = augmentFsModule;
+/**
+ * Next.js has an annoying habit of needing deep imports, but then moving those in patch releases. This is our abstraction.
+ */
 const getNextServer = () => {
     let NextServer;
     try {
@@ -142,7 +155,7 @@ const getNextServer = () => {
             // A different error, so rethrow it
             throw error;
         }
-        // Probably an old version of next
+        // Probably an old version of next, so fall through and find it elsewhere.
     }
     if (!NextServer) {
         try {

package/lib/templates/ipx.js

@@ -5,7 +5,7 @@ exports.handler = void 0;
 const ipx_1 = require("@netlify/ipx");
 // @ts-ignore Injected at build time
 const imageconfig_json_1 = require("./imageconfig.json");
-exports.handler = ipx_1.createIPXHandler({
+exports.handler = (0, ipx_1.createIPXHandler)({
     basePath: imageconfig_json_1.basePath,
     domains: imageconfig_json_1.domains,
 });